diff --git a/.github/workflows/buildcache.yml b/.github/workflows/buildcache.yml
index 10c921f0cb2..42eb1767ed3 100644
--- a/.github/workflows/buildcache.yml
+++ b/.github/workflows/buildcache.yml
@@ -25,13 +25,14 @@ jobs:
     name: '${{ matrix.os }}, ${{ matrix.jdk }} seed build cache'
     runs-on: ${{ matrix.os }}-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
           fetch-depth: 50
       - name: 'Set up JDK ${{ matrix.jdk }}'
         uses: actions/setup-java@v1
         with:
           java-version: ${{ matrix.jdk }}
+          distribution: 'zulu'
       - uses: burrunan/gradle-cache-action@v1
         name: Build Calcite
         env:
diff --git a/.github/workflows/gradle-wrapper-validation.yml b/.github/workflows/gradle-wrapper-validation.yml
index 405a2b30659..8bfd0dcf51f 100644
--- a/.github/workflows/gradle-wrapper-validation.yml
+++ b/.github/workflows/gradle-wrapper-validation.yml
@@ -6,5 +6,5 @@ jobs:
     name: "Validation"
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: gradle/wrapper-validation-action@v1
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index ac12876aa85..fd397a24052 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -47,18 +47,19 @@ env:
   _JAVA_OPTIONS: '-XX:GCTimeLimit=90 -XX:GCHeapFreeLimit=35'
 
 jobs:
-  windows:
+  windows-jdk8:
     if: github.event.action != 'labeled'
     name: 'Windows (JDK 8)'
     runs-on: windows-latest
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
       with:
         fetch-depth: 50
     - name: 'Set up JDK 8'
-      uses: actions/setup-java@v1
+      uses: actions/setup-java@v2
       with:
         java-version: 8
+        distribution: 'zulu'
     - uses: burrunan/gradle-cache-action@v1
       name: Test
       env:
@@ -79,15 +80,150 @@ jobs:
         echo sqlsh
         call sqlsh.bat -o headers "select count(*) commits, author from (select substring(author, 1, position(' <' in author)-1) author from git_commits) group by author order by count(*) desc, author limit 20"
 
+  windows-jdk17:
+    if: github.event.action != 'labeled'
+    name: 'Windows (JDK 17)'
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 50
+      - name: 'Set up JDK 17'
+        uses: actions/setup-java@v2
+        with:
+          java-version: 17
+          distribution: 'zulu'
+      - uses: burrunan/gradle-cache-action@v1
+        name: Test
+        env:
+          S3_BUILD_CACHE_ACCESS_KEY_ID: ${{ secrets.S3_BUILD_CACHE_ACCESS_KEY_ID }}
+          S3_BUILD_CACHE_SECRET_KEY: ${{ secrets.S3_BUILD_CACHE_SECRET_KEY }}
+        with:
+          job-id: jdk${{ matrix.jdk }}
+          remote-build-cache-proxy-enabled: false
+          arguments: --scan --no-parallel --no-daemon build
+      - name: 'sqlline and sqllsh'
+        shell: cmd
+        run: |
+          call sqlline.bat -e '!quit'
+          echo.
+          echo Sqlline example/csv
+          call example/csv/sqlline.bat --verbose -u jdbc:calcite:model=example/csv/src/test/resources/model.json -n admin -p admin -f example/csv/src/test/resources/smoke_test.sql
+          echo.
+          echo sqlsh
+          call sqlsh.bat -o headers "select count(*) commits, author from (select substring(author, 1, position(' <' in author)-1) author from git_commits) group by author order by count(*) desc, author limit 20"
+
+  linux-jdk8-oldest-guava-tz:
+    if: github.event.action != 'labeled'
+    name: 'Linux (JDK 8), Oldest Guava, America/New_York Timezone'
+    runs-on: ubuntu-latest
+    env:
+      TZ: 'America/New_York' # flips between −05:00 and −04:00
+      GUAVA: '16.0.1' # oldest supported Guava version
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 50
+      - name: 'Set up JDK 8'
+        uses: actions/setup-java@v2
+        with:
+          java-version: 8
+          distribution: 'zulu'
+      - uses: burrunan/gradle-cache-action@v1
+        name: Test
+        env:
+          S3_BUILD_CACHE_ACCESS_KEY_ID: ${{ secrets.S3_BUILD_CACHE_ACCESS_KEY_ID }}
+          S3_BUILD_CACHE_SECRET_KEY: ${{ secrets.S3_BUILD_CACHE_SECRET_KEY }}
+        with:
+          job-id: jdk${{ matrix.jdk }}
+          remote-build-cache-proxy-enabled: false
+          arguments: --scan --no-parallel --no-daemon -Pguava.version=${{ env.GUAVA }} build
+
+  linux-jdk11-tz:
+    if: github.event.action != 'labeled'
+    name: 'Linux (JDK 11), Pacific/Chatham Timezone'
+    runs-on: ubuntu-latest
+    env:
+      TZ: 'Pacific/Chatham' # flips between +12:45 and +13:45
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 50
+      - name: 'Set up JDK 11'
+        uses: actions/setup-java@v2
+        with:
+          java-version: 11
+          distribution: 'zulu'
+      - uses: burrunan/gradle-cache-action@v1
+        name: Test
+        env:
+          S3_BUILD_CACHE_ACCESS_KEY_ID: ${{ secrets.S3_BUILD_CACHE_ACCESS_KEY_ID }}
+          S3_BUILD_CACHE_SECRET_KEY: ${{ secrets.S3_BUILD_CACHE_SECRET_KEY }}
+        with:
+          job-id: jdk${{ matrix.jdk }}
+          remote-build-cache-proxy-enabled: false
+          arguments: --scan --no-parallel --no-daemon build
+
+  linux-jdk17:  # LTS JDK version, don't remove until EOL
+    if: github.event.action != 'labeled'
+    name: 'Linux (JDK 17)'
+    runs-on: ubuntu-latest
+    env:
+      GUAVA: '31.1-jre'
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 50
+      - name: 'Set up JDK 17'
+        uses: actions/setup-java@v2
+        with:
+          java-version: 17
+          distribution: 'zulu'
+      - uses: burrunan/gradle-cache-action@v1
+        name: Test
+        env:
+          S3_BUILD_CACHE_ACCESS_KEY_ID: ${{ secrets.S3_BUILD_CACHE_ACCESS_KEY_ID }}
+          S3_BUILD_CACHE_SECRET_KEY: ${{ secrets.S3_BUILD_CACHE_SECRET_KEY }}
+        with:
+          job-id: jdk${{ matrix.jdk }}
+          remote-build-cache-proxy-enabled: false
+          arguments: --scan --no-parallel --no-daemon -Pguava.version=${{ env.GUAVA }} build
+
+  linux-jdk18: # latest JDK version supported by ForbiddenAPIs plugin, keep this updated (see https://jdk.java.net/)
+    if: github.event.action != 'labeled'
+    name: 'Linux (JDK 18)'
+    runs-on: ubuntu-latest
+    env:
+      GUAVA: '31.1-jre'
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 50
+      - name: 'Set up JDK 18'
+        uses: actions/setup-java@v2
+        with:
+          java-version: 18
+          distribution: 'zulu'
+      - uses: burrunan/gradle-cache-action@v1
+        name: Test
+        env:
+          S3_BUILD_CACHE_ACCESS_KEY_ID: ${{ secrets.S3_BUILD_CACHE_ACCESS_KEY_ID }}
+          S3_BUILD_CACHE_SECRET_KEY: ${{ secrets.S3_BUILD_CACHE_SECRET_KEY }}
+        with:
+          job-id: jdk${{ matrix.jdk }}
+          remote-build-cache-proxy-enabled: false
+          arguments: --scan --no-parallel --no-daemon -Pguava.version=${{ env.GUAVA }} build
+
   linux-avatica:
     if: github.event.action != 'labeled'
     name: 'Linux (JDK 11), Avatica main'
     runs-on: ubuntu-latest
     steps:
     - name: 'Set up JDK 11'
-      uses: actions/setup-java@v1
+      uses: actions/setup-java@v2
       with:
         java-version: 11
+        distribution: 'zulu'
     - name: 'Clone Avatica to Maven Local repository'
       run: |
         git clone --branch main --depth 100 https://github.com/apache/calcite-avatica.git ../calcite-avatica
@@ -104,7 +240,7 @@ jobs:
         properties: |
           calcite.avatica.version=1.0.0-dev-main
           skipJavadoc=
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
       with:
         fetch-depth: 50
     - uses: burrunan/gradle-cache-action@v1
@@ -121,29 +257,28 @@ jobs:
           calcite.avatica.version=1.0.0-dev-main-SNAPSHOT
           enableMavenLocal=
 
-  linux-openj9:
+  mac:
     if: github.event.action != 'labeled'
-    name: 'Linux (OpenJ9 8)'
+    name: 'macOS (JDK 18)'
     runs-on: macos-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
           fetch-depth: 50
-      - uses: AdoptOpenJDK/install-jdk@v1
+      - name: 'Set up JDK 18'
+        uses: actions/setup-java@v2
         with:
-          impl: openj9
-          version: '8'
-          architecture: x64
+          java-version: 18
+          distribution: 'zulu'
       - uses: burrunan/gradle-cache-action@v1
         name: Test
         env:
           S3_BUILD_CACHE_ACCESS_KEY_ID: ${{ secrets.S3_BUILD_CACHE_ACCESS_KEY_ID }}
           S3_BUILD_CACHE_SECRET_KEY: ${{ secrets.S3_BUILD_CACHE_SECRET_KEY }}
         with:
-          job-id: jdk8-openj9
+          job-id: jdk18
           remote-build-cache-proxy-enabled: false
-          # Temporarily disable hadoop related tests due to https://github.com/eclipse-openj9/openj9/issues/14950
-          arguments: --scan --no-parallel --no-daemon -x :piglet:test -x :spark:test build javadoc
+          arguments: --scan --no-parallel --no-daemon build javadoc
       - name: 'sqlline and sqllsh'
         run: |
           ./sqlline -e '!quit'
@@ -154,49 +289,44 @@ jobs:
           echo sqlsh
           ./sqlsh -o headers "select count(*) commits, author from (select substring(author, 1, position(' <' in author)-1) author from git_commits) group by author order by count(*) desc, author limit 20"
 
-  mac:
+  errorprone:
     if: github.event.action != 'labeled'
-    name: 'macOS (JDK 18)'
-    runs-on: macos-latest
+    name: 'Error Prone (JDK 11)'
+    runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
           fetch-depth: 50
-      - name: 'Set up JDK 18'
-        uses: actions/setup-java@v1
+      - name: 'Set up JDK 11'
+        uses: actions/setup-java@v2
         with:
-          java-version: 18
+          java-version: 11
+          distribution: 'zulu'
       - uses: burrunan/gradle-cache-action@v1
         name: Test
         env:
           S3_BUILD_CACHE_ACCESS_KEY_ID: ${{ secrets.S3_BUILD_CACHE_ACCESS_KEY_ID }}
           S3_BUILD_CACHE_SECRET_KEY: ${{ secrets.S3_BUILD_CACHE_SECRET_KEY }}
         with:
-          job-id: jdk18
+          job-id: errprone
           remote-build-cache-proxy-enabled: false
-          arguments: --scan --no-parallel --no-daemon build javadoc
-      - name: 'sqlline and sqllsh'
-        run: |
-          ./sqlline -e '!quit'
-          echo
-          echo Sqlline example/csv
-          ./example/csv/sqlline --verbose -u jdbc:calcite:model=example/csv/src/test/resources/model.json -n admin -p admin -f example/csv/src/test/resources/smoke_test.sql
-          echo
-          echo sqlsh
-          ./sqlsh -o headers "select count(*) commits, author from (select substring(author, 1, position(' <' in author)-1) author from git_commits) group by author order by count(*) desc, author limit 20"
+          arguments: --scan --no-parallel --no-daemon -PenableErrorprone classes
 
-  errorprone:
+  errorprone-guava31:  # LTS JDK version, don't remove until EOL
     if: github.event.action != 'labeled'
-    name: 'Error Prone (JDK 11)'
+    name: 'Error Prone (JDK 11), Guava 31'
     runs-on: ubuntu-latest
+    env:
+      GUAVA: '31.1-jre' # ErrorProne checks for Beta APIs, so use the newest supported Guava version
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
           fetch-depth: 50
       - name: 'Set up JDK 11'
-        uses: actions/setup-java@v1
+        uses: actions/setup-java@v2
         with:
           java-version: 11
+          distribution: 'zulu'
       - uses: burrunan/gradle-cache-action@v1
         name: Test
         env:
@@ -205,19 +335,20 @@ jobs:
         with:
           job-id: errprone
           remote-build-cache-proxy-enabled: false
-          arguments: --scan --no-parallel --no-daemon -PenableErrorprone classes
+          arguments: --scan --no-parallel --no-daemon -Pguava.version=${{ env.GUAVA }} -PenableErrorprone classes
 
   linux-checkerframework:
     name: 'CheckerFramework (JDK 11)'
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
           fetch-depth: 50
       - name: 'Set up JDK 11'
-        uses: actions/setup-java@v1
+        uses: actions/setup-java@v2
         with:
           java-version: 11
+          distribution: 'zulu'
       - name: 'Run CheckerFramework'
         uses: burrunan/gradle-cache-action@v1
         env:
@@ -228,6 +359,30 @@ jobs:
           remote-build-cache-proxy-enabled: false
           arguments: --scan --no-parallel --no-daemon -PenableCheckerframework :linq4j:classes :core:classes
 
+  linux-checkerframework-guava29:
+    name: 'CheckerFramework (JDK 11), Guava 29'
+    runs-on: ubuntu-latest
+    env:
+      GUAVA: '29.0-jre'
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 50
+      - name: 'Set up JDK 11'
+        uses: actions/setup-java@v2
+        with:
+          java-version: 11
+          distribution: 'zulu'
+      - name: 'Run CheckerFramework'
+        uses: burrunan/gradle-cache-action@v1
+        env:
+          S3_BUILD_CACHE_ACCESS_KEY_ID: ${{ secrets.S3_BUILD_CACHE_ACCESS_KEY_ID }}
+          S3_BUILD_CACHE_SECRET_KEY: ${{ secrets.S3_BUILD_CACHE_SECRET_KEY }}
+        with:
+          job-id: checkerframework-jdk11
+          remote-build-cache-proxy-enabled: false
+          arguments: --scan --no-parallel --no-daemon -Pguava.version=${{ env.GUAVA }} -PenableCheckerframework :linq4j:classes :core:classes
+
   linux-slow:
     # Run slow tests when the commit is on main or it is requested explicitly by adding an
     # appropriate label in the PR
@@ -235,13 +390,14 @@ jobs:
     name: 'Linux (JDK 8) Slow Tests'
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
         with:
           fetch-depth: 50
       - name: 'Set up JDK 8'
-        uses: actions/setup-java@v1
+        uses: actions/setup-java@v2
         with:
           java-version: 8
+          distribution: 'zulu'
       - uses: burrunan/gradle-cache-action@v1
         name: Test
         env:
@@ -254,13 +410,14 @@ jobs:
 
   linux-druid:
     if: github.event.action != 'labeled'
-    name: 'Linux (JDK 8) Druid Tests'
+    name: 'Druid Tests'
     runs-on: ubuntu-latest
     steps:
-    - name: 'Set up JDK 8'
-      uses: actions/setup-java@v1
+    - name: 'Set up JDK 17'
+      uses: actions/setup-java@v2
       with:
-        java-version: 8
+        java-version: 17
+        distribution: 'zulu'
     - name: 'Checkout Druid dataset'
       uses: actions/checkout@v3
       with:
@@ -282,7 +439,7 @@ jobs:
     - name: 'Index Foodmart/Wikipedia datasets'
       working-directory: ./druid-dataset
       run: ./index.sh 30s
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
       with:
         fetch-depth: 1
         path: calcite
diff --git a/.gitignore b/.gitignore
index 0602bdcdd14..9425771f747 100644
--- a/.gitignore
+++ b/.gitignore
@@ -26,6 +26,12 @@
 /buildSrc/subprojects/*/build
 /site/.jekyll-cache
 
+# VSCode Java plugin
+/example/*/bin
+/*/bin
+/bin
+/.vscode/*
+
 # IDEA
 /out
 /*/out/
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index 36cea90b63c..00000000000
--- a/.travis.yml
+++ /dev/null
@@ -1,77 +0,0 @@
-#
-# 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.
-#
-
-# Configuration file for Travis continuous integration.
-# See https://travis-ci.com/github/apache/calcite
-language: java
-matrix:
-  fast_finish: true
-  include:
-    - jdk: openjdk8
-      env:
-        - TZ=America/New_York # flips between −05:00 and −04:00
-        - GUAVA=19.0 # oldest supported Guava version
-    - jdk: openjdk11
-      env:
-        - CHECKERFRAMEWORK=Y
-      script:
-        - export _JAVA_OPTIONS="-XX:GCTimeLimit=90 -XX:GCHeapFreeLimit=35"
-        - travis_wait ./gradlew --no-parallel --no-daemon --scan -Pguava.version=${GUAVA:-29.0-jre} -PenableCheckerframework :linq4j:classes :core:classes
-    - jdk: openjdk11
-      env:
-        - ERRORPRONE=Y
-        - GUAVA=31.1-jre # ErrorProne checks for Beta APIs, so use newest supported Guava version
-      script:
-        - export _JAVA_OPTIONS="-XX:GCTimeLimit=90 -XX:GCHeapFreeLimit=35"
-        - ./gradlew --no-parallel --no-daemon --scan -Pguava.version=${GUAVA:-29.0-jre} -PenableErrorprone classes
-    - jdk: openjdk11
-      env:
-        - TZ=Pacific/Chatham # flips between +12:45 and +13:45
-    - jdk: openjdk15
-      env:
-        - GUAVA=31.1-jre # newest supported Guava version
-    - jdk: openjdk16
-      env:
-        - GUAVA=31.1-jre
-    - jdk: openjdk17
-      env:
-        - GUAVA=31.1-jre
-    - jdk: openjdk18
-      env:
-        - GUAVA=31.1-jre
-branches:
-  only:
-    - main
-    - javadoc
-    - /^branch-.*$/
-    - /^[0-9]+-.*$/
-install: true
-script:
-  # Throw OutOfMemoryError in case less than 35% is free after full GC
-  # This avoids never-ending GC trashing if memory gets too low in case of a memory leak
-  - export _JAVA_OPTIONS="-XX:GCTimeLimit=90 -XX:GCHeapFreeLimit=35"
-  - ./gradlew --no-daemon -Pguava.version=${GUAVA:-29.0-jre} build
-git:
-  depth: 100
-cache:
-  directories:
-    - $HOME/.gradle/caches/
-    - $HOME/.gradle/wrapper/
-
-before_cache:
-  - ./gradlew --stop
-  - F=CleanupGradleCache sh -x -c 'curl -O https://raw.githubusercontent.com/vlsi/cleanup-gradle-cache/v1.x/$F.java && javac -J-Xmx128m $F.java && java -Xmx128m $F'
diff --git a/Jenkinsfile b/Jenkinsfile
new file mode 100644
index 00000000000..53cc1e6f31f
--- /dev/null
+++ b/Jenkinsfile
@@ -0,0 +1,57 @@
+/*
+ * 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.
+ */
+
+node('ubuntu') {
+  def JAVA_JDK_17=tool name: 'jdk_17_latest', type: 'hudson.model.JDK'
+  stage('Checkout') {
+    if(env.CHANGE_ID) {
+      // By default checkout on PRs will fetch only that branch and nothing else. However, in order for the Sonar plugin
+      // to function properly we need to fetch also the target branch ${CHANGE_TARGET} so we need to customize the
+      // refspec. If the target branch of the PR is not present warnings like the following may appear:
+      // Could not find ref 'main' in refs/heads, refs/remotes/upstream or refs/remotes/origin
+      checkout([
+        $class: 'GitSCM',
+        branches: scm.branches,
+        doGenerateSubmoduleConfigurations: scm.doGenerateSubmoduleConfigurations,
+        extensions: scm.extensions,
+        userRemoteConfigs: scm.userRemoteConfigs + [[
+          name: 'origin',
+          refspec: scm.userRemoteConfigs[0].refspec+ " +refs/heads/${CHANGE_TARGET}:refs/remotes/origin/${CHANGE_TARGET}",
+          url: scm.userRemoteConfigs[0].url,
+          credentialsId: scm.userRemoteConfigs[0].credentialsId
+        ]],
+      ])
+    } else {
+      checkout scm
+    }
+  }
+  stage('Code Quality') {
+    timeout(time: 1, unit: 'HOURS') {
+      withEnv(["Path+JDK=$JAVA_JDK_17/bin","JAVA_HOME=$JAVA_JDK_17"]) {
+        withCredentials([string(credentialsId: 'SONARCLOUD_TOKEN', variable: 'SONAR_TOKEN')]) {
+          if ( env.BRANCH_NAME.startsWith("PR-") ) {
+            sh './gradlew --no-parallel --no-daemon jacocoAggregateTestReport sonar -PenableJacoco -Dsonar.pullrequest.branch=${CHANGE_BRANCH} -Dsonar.pullrequest.base=${CHANGE_TARGET} -Dsonar.pullrequest.key=${CHANGE_ID} -Dsonar.login=${SONAR_TOKEN}'
+          } else {
+            sh './gradlew --no-parallel --no-daemon jacocoAggregateTestReport sonar -PenableJacoco -Dsonar.branch.name=${BRANCH_NAME} -Dsonar.login=${SONAR_TOKEN}'
+          }
+        }
+      }
+    }
+  }
+  cleanWs()
+}
+
diff --git a/NOTICE b/NOTICE
index fb342f9c909..f4562f0e62a 100644
--- a/NOTICE
+++ b/NOTICE
@@ -1,5 +1,5 @@
 Apache Calcite
-Copyright 2012-2022 The Apache Software Foundation
+Copyright 2012-2023 The Apache Software Foundation
 
 This product includes software developed at
 The Apache Software Foundation (http://www.apache.org/).
diff --git a/README b/README
index 3365c5e341e..87c004816e5 100644
--- a/README
+++ b/README
@@ -1,4 +1,4 @@
-Apache Calcite release 1.30.0
+Apache Calcite release 1.34.0
 
 This is a source or binary distribution of Apache Calcite.
 
diff --git a/README.md b/README.md
index d9277043703..af6a60e2dab 100644
--- a/README.md
+++ b/README.md
@@ -18,9 +18,7 @@ limitations under the License.
 -->
 
 [![Maven Central](https://maven-badges.herokuapp.com/maven-central/org.apache.calcite/calcite-core/badge.svg)](https://maven-badges.herokuapp.com/maven-central/org.apache.calcite/calcite-core)
-[![Travis Build Status](https://app.travis-ci.com/apache/calcite.svg?branch=main)](https://app.travis-ci.com/github/apache/calcite)
 [![CI Status](https://github.com/apache/calcite/workflows/CI/badge.svg?branch=main)](https://github.com/apache/calcite/actions?query=branch%3Amain)
-[![AppVeyor Build Status](https://ci.appveyor.com/api/projects/status/github/apache/calcite?svg=true&branch=main)](https://ci.appveyor.com/project/ApacheSoftwareFoundation/calcite)
 
 # Apache Calcite
 
@@ -37,3 +35,6 @@ Elasticsearch, MongoDB, Kafka, and others, with minimal
 configuration.
 
 For more details, see the [home page](http://calcite.apache.org).
+
+The project uses [JIRA](https://issues.apache.org/jira/browse/CALCITE)
+for issue tracking. For further information, please see the [JIRA accounts guide](https://calcite.apache.org/develop/#jira-accounts).
diff --git a/babel/src/main/codegen/config.fmpp b/babel/src/main/codegen/config.fmpp
index f75631e739a..a61dee55e29 100644
--- a/babel/src/main/codegen/config.fmpp
+++ b/babel/src/main/codegen/config.fmpp
@@ -30,14 +30,25 @@ data: {
       "org.apache.calcite.sql.SqlCreate",
       "org.apache.calcite.sql.babel.SqlBabelCreateTable",
       "org.apache.calcite.sql.babel.TableCollectionType",
+      "org.apache.calcite.sql.babel.postgresql.AndChain",
+      "org.apache.calcite.sql.babel.postgresql.SqlBegin",
+      "org.apache.calcite.sql.babel.postgresql.SqlCommit",
+      "org.apache.calcite.sql.babel.postgresql.SqlDiscard",
+      "org.apache.calcite.sql.babel.postgresql.SqlRollback",
+      "org.apache.calcite.sql.babel.postgresql.SqlShow",
       "org.apache.calcite.sql.ddl.SqlDdlNodes",
     ]
 
     # List of new keywords. Example: "DATABASES", "TABLES". If the keyword is
     # not a reserved keyword, add it to the 'nonReservedKeywords' section.
     keywords: [
+      "DISCARD"
       "IF"
+      "PLANS"
+      "SEED"
       "SEMI"
+      "SEQUENCES"
+      "TEMP"
       "VOLATILE"
     ]
 
@@ -45,7 +56,13 @@ data: {
     # items in this list become non-reserved
     nonReservedKeywordsToAdd: [
       # not in core, added in babel
+      "DISCARD"
+      "IF"
+      "PLANS"
+      "SEED"
       "SEMI"
+      "SEQUENCES"
+      "TEMP"
 
       # The following keywords are reserved in core Calcite,
       # are reserved in some version of SQL,
@@ -156,6 +173,7 @@ data: {
       "CYCLE"
       "DATA"
 #     "DATE"
+      "DATETIME_DIFF"
       "DAY"
       "DEALLOCATE"
       "DEC"
@@ -236,7 +254,6 @@ data: {
       "HOLD"
       "HOUR"
       "IDENTITY"
-#     "IF" # not a keyword in Calcite
       "ILIKE"
       "IMMEDIATE"
       "IMMEDIATELY"
@@ -463,7 +480,11 @@ data: {
       "TEMPORARY"
 #     "THEN"
 #     "TIME"
+      "TIME_DIFF"
+      "TIME_TRUNC"
 #     "TIMESTAMP"
+      "TIMESTAMP_DIFF"
+      "TIMESTAMP_TRUNC"
       "TIMEZONE_HOUR"
       "TIMEZONE_MINUTE"
       "TINYINT"
@@ -528,9 +549,8 @@ data: {
 
     # List of methods for parsing builtin function calls.
     # Return type of method implementation should be "SqlNode".
-    # Example: "DateFunctionCall()".
+    # Example: "DateaddFunctionCall()".
     builtinFunctionCallMethods: [
-       "DateFunctionCall()"
        "DateaddFunctionCall()"
     ]
 
@@ -540,6 +560,15 @@ data: {
     createStatementParserMethods: [
       "SqlCreateTable"
     ]
+    
+    statementParserMethods: [
+      "PostgresqlSqlShow()",
+      "PostgresqlSqlSetOption()",
+      "PostgresqlSqlBegin()",
+      "PostgresqlSqlDiscard()",
+      "PostgresqlSqlCommit()",
+      "PostgresqlSqlRollback()"
+    ]
 
     # Binary operators tokens.
     # Example: "< INFIX_CAST: \"::\" >".
@@ -562,9 +591,11 @@ data: {
     # Example: "parserImpls.ftl".
     implementationFiles: [
       "parserImpls.ftl"
+      "parserPostgresqlImpls.ftl"
     ]
 
     includePosixOperators: true
+    includeParsingStringLiteralAsArrayLiteral: true
   }
 }
 
diff --git a/babel/src/main/codegen/includes/parserImpls.ftl b/babel/src/main/codegen/includes/parserImpls.ftl
index 2e9134750d6..fb169fe1e8e 100644
--- a/babel/src/main/codegen/includes/parserImpls.ftl
+++ b/babel/src/main/codegen/includes/parserImpls.ftl
@@ -22,42 +22,23 @@ JoinType LeftSemiJoin() :
     <LEFT> <SEMI> <JOIN> { return JoinType.LEFT_SEMI_JOIN; }
 }
 
-SqlNode DateFunctionCall() :
-{
-    final SqlFunctionCategory funcType = SqlFunctionCategory.USER_DEFINED_FUNCTION;
-    final SqlIdentifier qualifiedName;
-    final Span s;
-    final SqlLiteral quantifier;
-    final List<? extends SqlNode> args;
-}
-{
-    <DATE> {
-        s = span();
-        qualifiedName = new SqlIdentifier(unquotedIdentifier(), getPos());
-    }
-    args = FunctionParameterList(ExprContext.ACCEPT_SUB_QUERY) {
-        quantifier = (SqlLiteral) args.get(0);
-        args.remove(0);
-        return createCall(qualifiedName, s.end(this), funcType, quantifier, args);
-    }
-}
-
 SqlNode DateaddFunctionCall() :
 {
-    final SqlFunctionCategory funcType = SqlFunctionCategory.USER_DEFINED_FUNCTION;
     final Span s;
-    final SqlIdentifier qualifiedName;
-    final TimeUnit unit;
+    final SqlOperator op;
+    final SqlIntervalQualifier unit;
     final List<SqlNode> args;
     SqlNode e;
 }
 {
-    ( <DATEADD> | <DATEDIFF> | <DATE_PART> ) {
-        s = span();
-        qualifiedName = new SqlIdentifier(unquotedIdentifier(), getPos());
-    }
-    <LPAREN> unit = TimeUnit() {
-        args = startList(new SqlIntervalQualifier(unit, null, getPos()));
+    (   <DATE_PART>  { op = SqlLibraryOperators.DATE_PART; }
+    |   <DATEADD> { op = SqlLibraryOperators.DATEADD; }
+    |   <DATEDIFF> { op = SqlLibraryOperators.DATEDIFF; }
+    |   <DATEPART>  { op = SqlLibraryOperators.DATEPART; }
+    )
+    { s = span(); }
+    <LPAREN> unit = TimeUnitOrName() {
+        args = startList(unit);
     }
     (
         <COMMA> e = Expression(ExprContext.ACCEPT_SUB_QUERY) {
@@ -65,7 +46,7 @@ SqlNode DateaddFunctionCall() :
         }
     )*
     <RPAREN> {
-        return createCall(qualifiedName, s.end(this), funcType, null, args);
+        return op.createCall(s.end(this), args);
     }
 }
 
@@ -174,6 +155,7 @@ SqlCreate SqlCreateTable(Span s, boolean replace) :
     < DATE_PART: "DATE_PART" >
 |   < DATEADD: "DATEADD" >
 |   < DATEDIFF: "DATEDIFF" >
+|   < DATEPART: "DATEPART" >
 |   < NEGATE: "!" >
 |   < TILDE: "~" >
 }
@@ -204,5 +186,5 @@ void NullSafeEqual(List<Object> list, ExprContext exprContext, Span s) :
         checkNonQueryExpression(exprContext);
         list.add(new SqlParserUtil.ToTreeListItem(SqlLibraryOperators.NULL_SAFE_EQUAL, getPos()));
     }
-    Expression2b(ExprContext.ACCEPT_SUB_QUERY, list)
+    AddExpression2b(list, ExprContext.ACCEPT_SUB_QUERY)
 }
diff --git a/babel/src/main/codegen/includes/parserPostgresqlImpls.ftl b/babel/src/main/codegen/includes/parserPostgresqlImpls.ftl
new file mode 100644
index 00000000000..fee70a58d7b
--- /dev/null
+++ b/babel/src/main/codegen/includes/parserPostgresqlImpls.ftl
@@ -0,0 +1,264 @@
+<#--
+// 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.
+-->
+
+/** SHOW (<TRANSACTION ISOLATION LEVEL> | name) */
+SqlNode PostgresqlSqlShow() :
+{
+    final SqlIdentifier parameter;
+    final Span s;
+}
+{
+    <SHOW> { s = span(); }
+  (
+      parameter = PostgresqlTransactionIsolationLevel()
+|
+      <IDENTIFIER> {
+          parameter = new SqlIdentifier(token.image.toLowerCase(Locale.ROOT), getPos());
+      }
+  ) { return SqlShow.OPERATOR.createCall(null, s.end(this), parameter); }
+}
+
+SqlIdentifier PostgresqlTransactionIsolationLevel() :
+{
+    final Span s;
+}
+{
+  { s = span(); } <TRANSACTION> <ISOLATION> <LEVEL> {
+    return new SqlIdentifier("transaction_isolation", s.end(this));
+  }
+}
+
+/**
+ * SET [ SESSION | LOCAL ] configuration_parameter { TO | = } { value | 'value' | DEFAULT }
+ * SET [ SESSION | LOCAL ] TIME ZONE { value | 'value' | LOCAL | DEFAULT }
+ * SET [ SESSION | LOCAL ] (SCHEMA | NAMES | SEED) value
+ * value - Values can be specified as string constants, identifiers, numbers, or comma-separated lists of these
+ */
+SqlNode PostgresqlSqlSetOption() :
+{
+    SqlIdentifier name;
+    final SqlNode val;
+    String scope = null;
+    Span s;
+}
+{
+    { s = span(); }
+    (
+        <SET> {
+            s.add(this);
+        }
+        [ scope = PostgresqlOptionScope() ]
+        (
+          <TIME> <ZONE> { name = new SqlIdentifier("timezone", getPos()); }
+          (
+            val = Default()
+          |
+            <LOCAL> { val = SqlLiteral.createCharString("LOCAL", getPos()); }
+          |
+            val = Literal()
+          )
+        |
+          (
+              <SCHEMA> { name = new SqlIdentifier("search_path", getPos()); }
+            |
+              <NAMES> { name = new SqlIdentifier("client_encoding", getPos()); }
+            |
+              <SEED> { name = new SqlIdentifier("seed", getPos()); }
+            |
+              name = CompoundIdentifier()
+              ( <EQ> | <TO> )
+          )
+          val = PostgresqlSqlOptionValues()
+        ){
+          return new SqlSetOption(s.end(val), scope, name, val);
+        }
+
+    |
+        <RESET> {
+            s.add(this);
+        }
+        (
+            name = CompoundIdentifier()
+        |
+            <ALL> {
+                name = new SqlIdentifier(token.image.toUpperCase(Locale.ROOT),
+                    getPos());
+            }
+        )
+        {
+            return new SqlSetOption(s.end(name), scope, name, null);
+        }
+    )
+}
+
+String PostgresqlOptionScope() :
+{
+}
+{
+    ( <LOCAL> | <SESSION> ) { return token.image.toUpperCase(Locale.ROOT); }
+}
+
+SqlNode PostgresqlSqlOptionValues():
+{
+  final List<SqlNode> list;
+  Span s;
+  SqlNode e;
+}
+{
+   e = PostgresqlSqlOptionValue() { s = span(); list = startList(e); }
+   ( <COMMA> e = PostgresqlSqlOptionValue() { list.add(e); } )*
+   { 
+      return list.size() > 1 ? new SqlNodeList(list, s.end(this)) : e; 
+   }
+}
+
+SqlNode PostgresqlSqlOptionValue():
+{
+  final SqlNode val;
+}
+{
+  (
+      val = Default()
+  |
+      val = Literal()
+  |
+      val = SimpleIdentifier()
+  ) {
+    return val;
+  }
+}
+
+/** DISCARD { ALL | PLANS | SEQUENCES | TEMPORARY | TEMP } */
+SqlNode PostgresqlSqlDiscard() :
+{
+  final Span s;
+}
+{
+  { s = span(); }
+   <DISCARD> ( <ALL> | <PLANS> | <SEQUENCES> | <TEMPORARY> | <TEMP> ) {
+      return SqlDiscard.OPERATOR.createCall(s.end(this), new SqlIdentifier(
+         token.image.toUpperCase(Locale.ROOT), getPos()));
+   }
+}
+
+/**
+ * BEGIN [ WORK | TRANSACTION ] [ transaction_mode [, ...] ]
+ * where transaction_mode is one of:
+ * ISOLATION LEVEL { SERIALIZABLE | REPEATABLE READ | READ COMMITTED | READ UNCOMMITTED }
+ * READ WRITE | READ ONLY
+ * [ NOT ] DEFERRABLE
+ */
+SqlNode PostgresqlSqlBegin() :
+{
+  final Span s;
+  SqlNodeList transactionModeList = SqlNodeList.EMPTY;
+}
+{
+  { s = span(); }
+  <BEGIN> [ ( <WORK> | <TRANSACTION> ) ] [transactionModeList = PostgresqlSqlBeginTransactionModeList()] {
+    return SqlBegin.OPERATOR.createCall(s.end(this), (SqlNode) transactionModeList);
+  }
+}
+
+SqlNodeList PostgresqlSqlBeginTransactionModeList():
+{
+  final List<SqlNode> list;
+  Span s;
+  SqlNode e;
+}
+{
+  { s = span(); }
+  e = PostgresqlSqlBeginTransactionMode() { s = span(); list = startList(e); }
+  ( <COMMA> e = PostgresqlSqlBeginTransactionMode() { list.add(e); } )*
+  { return new SqlNodeList(list, s.end(this)); }
+}
+
+SqlNode PostgresqlSqlBeginTransactionMode():
+{
+  final Span s;
+  SqlBegin.TransactionMode m;
+}
+{
+    { s = span(); }
+(   
+    LOOKAHEAD(2)
+    <READ> 
+    (
+      <WRITE> { m = SqlBegin.TransactionMode.READ_WRITE; } 
+    | 
+      <ONLY>  { m = SqlBegin.TransactionMode.READ_ONLY; }
+    )
+|
+    <DEFERRABLE> { m = SqlBegin.TransactionMode.DEFERRABLE; }
+|
+    <NOT> <DEFERRABLE> { m = SqlBegin.TransactionMode.NOT_DEFERRABLE; }
+|
+    <ISOLATION> <LEVEL> 
+    (
+        <SERIALIZABLE> { m = SqlBegin.TransactionMode.ISOLATION_LEVEL_SERIALIZABLE; }
+    | 
+        <REPEATABLE> <READ> { m = SqlBegin.TransactionMode.ISOLATION_LEVEL_REPEATABLE_READ; }
+    | 
+        <READ> 
+        ( 
+          <COMMITTED> { m = SqlBegin.TransactionMode.ISOLATION_LEVEL_READ_COMMITTED; } 
+        | 
+          <UNCOMMITTED>  { m = SqlBegin.TransactionMode.ISOLATION_LEVEL_READ_UNCOMMITTED; }
+        ) 
+    )
+) {
+    return m.symbol(s.end(this));
+  }
+}
+
+/** COMMIT [ WORK | TRANSACTION ] [ AND [ NO ] CHAIN ] */
+SqlNode PostgresqlSqlCommit():
+{
+  final Span s;
+  AndChain chain = AndChain.AND_NO_CHAIN;
+}
+{
+  { s = span(); }
+  <COMMIT> [ <WORK> | <TRANSACTION> ] [ 
+  (
+    <AND> <CHAIN> { chain = AndChain.AND_CHAIN; }
+  |
+    <AND> <NO> <CHAIN>
+  )] {
+    final SqlParserPos pos = s.end(this); 
+    return SqlCommit.OPERATOR.createCall(pos, chain.symbol(pos));
+  }
+}
+
+/** ROLLBACK [ WORK | TRANSACTION ] [ AND [ NO ] CHAIN ] */
+SqlNode PostgresqlSqlRollback():
+{
+  final Span s;
+  AndChain chain = AndChain.AND_NO_CHAIN;
+}
+{
+  { s = span(); }
+  <ROLLBACK> [ <WORK> | <TRANSACTION> ] [ 
+  (
+    <AND> <CHAIN> { chain = AndChain.AND_CHAIN; }
+  |
+    <AND> <NO> <CHAIN>
+  )] {
+    final SqlParserPos pos = s.end(this); 
+    return SqlRollback.OPERATOR.createCall(pos, chain.symbol(pos));
+  }
+}
diff --git a/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/AndChain.java b/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/AndChain.java
new file mode 100644
index 00000000000..f9129b5a048
--- /dev/null
+++ b/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/AndChain.java
@@ -0,0 +1,36 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.sql.babel.postgresql;
+
+import org.apache.calcite.sql.Symbolizable;
+
+/**
+ * Defines the keywords that can occur immediately after the "ROLLBACK" or "COMMIT" keywords.
+ *
+ * @see SqlCommit
+ * @see SqlRollback
+ * @see <a href="https://www.postgresql.org/docs/current/sql-commit.html">COMMIT specification</a>
+ * @see <a href="https://www.postgresql.org/docs/current/sql-rollback.html">ROLLBACK specification</a>
+ */
+public enum AndChain implements Symbolizable {
+  AND_CHAIN,
+  AND_NO_CHAIN;
+
+  @Override public String toString() {
+    return super.toString().replace("_", " ");
+  }
+}
diff --git a/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/SqlBegin.java b/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/SqlBegin.java
new file mode 100644
index 00000000000..bfd275c3ef1
--- /dev/null
+++ b/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/SqlBegin.java
@@ -0,0 +1,89 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.sql.babel.postgresql;
+
+import org.apache.calcite.sql.SqlCall;
+import org.apache.calcite.sql.SqlKind;
+import org.apache.calcite.sql.SqlLiteral;
+import org.apache.calcite.sql.SqlNode;
+import org.apache.calcite.sql.SqlNodeList;
+import org.apache.calcite.sql.SqlOperator;
+import org.apache.calcite.sql.SqlSpecialOperator;
+import org.apache.calcite.sql.SqlWriter;
+import org.apache.calcite.sql.Symbolizable;
+import org.apache.calcite.sql.parser.SqlParserPos;
+import org.apache.calcite.sql.type.ReturnTypes;
+
+import com.google.common.collect.ImmutableList;
+
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+import java.util.List;
+
+/**
+ * Parse tree node representing a {@code BEGIN} clause.
+ * @see <a href="https://www.postgresql.org/docs/current/sql-begin.html">BEGIN specification</a>
+ */
+public class SqlBegin extends SqlCall {
+  public static final SqlSpecialOperator OPERATOR =
+      new SqlSpecialOperator("BEGIN", SqlKind.OTHER_FUNCTION, 32, false, ReturnTypes.BOOLEAN, null,
+          null) {
+        @Override public SqlCall createCall(@Nullable final SqlLiteral functionQualifier,
+            final SqlParserPos pos,
+            final @Nullable SqlNode... operands) {
+          return new SqlBegin(pos, (SqlNodeList) operands[0]);
+        }
+      };
+
+  private final SqlNodeList transactionModeList;
+
+  protected SqlBegin(final SqlParserPos pos, final SqlNodeList transactionModeList) {
+    super(pos);
+    this.transactionModeList = transactionModeList;
+  }
+
+  @Override public SqlOperator getOperator() {
+    return OPERATOR;
+  }
+
+  @Override public List<SqlNode> getOperandList() {
+    return ImmutableList.of(transactionModeList);
+  }
+
+  @Override public void unparse(final SqlWriter writer, final int leftPrec, final int rightPrec) {
+    writer.keyword("BEGIN");
+    transactionModeList.unparse(writer, -1, -1);
+  }
+
+  /**
+   * Transaction mode.
+   */
+  public enum TransactionMode implements Symbolizable {
+    READ_WRITE,
+    READ_ONLY,
+    DEFERRABLE,
+    NOT_DEFERRABLE,
+    ISOLATION_LEVEL_SERIALIZABLE,
+    ISOLATION_LEVEL_REPEATABLE_READ,
+    ISOLATION_LEVEL_READ_COMMITTED,
+    ISOLATION_LEVEL_READ_UNCOMMITTED;
+
+    @Override public String toString() {
+      return super.toString().replace("_", " ");
+    }
+  }
+}
diff --git a/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/SqlCommit.java b/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/SqlCommit.java
new file mode 100644
index 00000000000..8b9491803f6
--- /dev/null
+++ b/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/SqlCommit.java
@@ -0,0 +1,71 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.sql.babel.postgresql;
+
+import org.apache.calcite.sql.SqlCall;
+import org.apache.calcite.sql.SqlKind;
+import org.apache.calcite.sql.SqlLiteral;
+import org.apache.calcite.sql.SqlNode;
+import org.apache.calcite.sql.SqlOperator;
+import org.apache.calcite.sql.SqlSpecialOperator;
+import org.apache.calcite.sql.SqlWriter;
+import org.apache.calcite.sql.parser.SqlParserPos;
+import org.apache.calcite.sql.type.ReturnTypes;
+
+import com.google.common.collect.ImmutableList;
+
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+import java.util.List;
+
+/**
+ * Parse tree node representing a {@code COMMIT} clause.
+ * @see <a href="https://www.postgresql.org/docs/current/sql-commit.html">COMMIT specification</a>
+ */
+public class SqlCommit extends SqlCall {
+
+  public static final SqlSpecialOperator OPERATOR =
+      new SqlSpecialOperator("COMMIT", SqlKind.OTHER_FUNCTION, 32, false, ReturnTypes.BOOLEAN, null,
+          null) {
+        @Override public SqlCall createCall(@Nullable final SqlLiteral functionQualifier,
+            final SqlParserPos pos,
+            final @Nullable SqlNode... operands) {
+          return new SqlCommit(pos, (SqlLiteral) operands[0]);
+        }
+      };
+  private final SqlLiteral chain;
+
+  protected SqlCommit(final SqlParserPos pos, final SqlLiteral chain) {
+    super(pos);
+    this.chain = chain;
+  }
+
+  @Override public SqlOperator getOperator() {
+    return OPERATOR;
+  }
+
+  @Override public List<SqlNode> getOperandList() {
+    return ImmutableList.of(this.chain);
+  }
+
+  @Override public void unparse(final SqlWriter writer, final int leftPrec, final int rightPrec) {
+    writer.keyword("COMMIT");
+    if (this.chain.symbolValue(AndChain.class) == AndChain.AND_CHAIN) {
+      writer.literal("AND CHAIN");
+    }
+  }
+}
diff --git a/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/SqlDiscard.java b/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/SqlDiscard.java
new file mode 100644
index 00000000000..78adbd8574f
--- /dev/null
+++ b/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/SqlDiscard.java
@@ -0,0 +1,70 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.sql.babel.postgresql;
+
+import org.apache.calcite.sql.SqlCall;
+import org.apache.calcite.sql.SqlIdentifier;
+import org.apache.calcite.sql.SqlKind;
+import org.apache.calcite.sql.SqlLiteral;
+import org.apache.calcite.sql.SqlNode;
+import org.apache.calcite.sql.SqlOperator;
+import org.apache.calcite.sql.SqlSpecialOperator;
+import org.apache.calcite.sql.SqlWriter;
+import org.apache.calcite.sql.parser.SqlParserPos;
+import org.apache.calcite.sql.type.ReturnTypes;
+
+import com.google.common.collect.ImmutableList;
+
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+import java.util.List;
+
+/**
+ * Parse tree node representing a {@code DISCARD} clause.
+ * @see <a href="https://www.postgresql.org/docs/current/sql-discard.html">DISCARD specification</a>
+ */
+public class SqlDiscard extends SqlCall {
+  public static final SqlSpecialOperator OPERATOR =
+      new SqlSpecialOperator("DISCARD", SqlKind.OTHER_FUNCTION, 32, false, ReturnTypes.BOOLEAN,
+          null, null) {
+        @Override public SqlCall createCall(@Nullable final SqlLiteral functionQualifier,
+            final SqlParserPos pos,
+            final @Nullable SqlNode... operands) {
+          return new SqlDiscard(pos, (SqlIdentifier) operands[0]);
+        }
+      };
+
+  private final SqlIdentifier subcommand;
+
+  public SqlDiscard(final SqlParserPos pos, final SqlIdentifier subcommand) {
+    super(pos);
+    this.subcommand = subcommand;
+  }
+
+  @Override public SqlOperator getOperator() {
+    return OPERATOR;
+  }
+
+  @Override public List<SqlNode> getOperandList() {
+    return ImmutableList.of(subcommand);
+  }
+
+  @Override public void unparse(final SqlWriter writer, final int leftPrec, final int rightPrec) {
+    writer.keyword("DISCARD");
+    writer.literal(subcommand.toString());
+  }
+}
diff --git a/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/SqlRollback.java b/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/SqlRollback.java
new file mode 100644
index 00000000000..c400f0c8432
--- /dev/null
+++ b/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/SqlRollback.java
@@ -0,0 +1,71 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.sql.babel.postgresql;
+
+import org.apache.calcite.sql.SqlCall;
+import org.apache.calcite.sql.SqlKind;
+import org.apache.calcite.sql.SqlLiteral;
+import org.apache.calcite.sql.SqlNode;
+import org.apache.calcite.sql.SqlOperator;
+import org.apache.calcite.sql.SqlSpecialOperator;
+import org.apache.calcite.sql.SqlWriter;
+import org.apache.calcite.sql.parser.SqlParserPos;
+import org.apache.calcite.sql.type.ReturnTypes;
+
+import com.google.common.collect.ImmutableList;
+
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+import java.util.List;
+
+/**
+ * Parse tree node representing a {@code ROLLBACK} clause.
+ * @see <a href="https://www.postgresql.org/docs/current/sql-rollback.html">ROLLBACK specification</a>
+ */
+public class SqlRollback extends SqlCall {
+
+  public static final SqlSpecialOperator OPERATOR =
+      new SqlSpecialOperator("ROLLBACK", SqlKind.OTHER_FUNCTION, 32, false, ReturnTypes.BOOLEAN,
+          null, null) {
+        @Override public SqlCall createCall(@Nullable final SqlLiteral functionQualifier,
+            final SqlParserPos pos,
+            final @Nullable SqlNode... operands) {
+          return new SqlRollback(pos, (SqlLiteral) operands[0]);
+        }
+      };
+  private final SqlLiteral chain;
+
+  protected SqlRollback(final SqlParserPos pos, final SqlLiteral chain) {
+    super(pos);
+    this.chain = chain;
+  }
+
+  @Override public SqlOperator getOperator() {
+    return OPERATOR;
+  }
+
+  @Override public List<SqlNode> getOperandList() {
+    return ImmutableList.of(this.chain);
+  }
+
+  @Override public void unparse(final SqlWriter writer, final int leftPrec, final int rightPrec) {
+    writer.keyword("ROLLBACK");
+    if (this.chain.symbolValue(AndChain.class) == AndChain.AND_CHAIN) {
+      writer.literal("AND CHAIN");
+    }
+  }
+}
diff --git a/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/SqlShow.java b/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/SqlShow.java
new file mode 100644
index 00000000000..6e81b01cb23
--- /dev/null
+++ b/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/SqlShow.java
@@ -0,0 +1,74 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.sql.babel.postgresql;
+
+import org.apache.calcite.sql.SqlCall;
+import org.apache.calcite.sql.SqlIdentifier;
+import org.apache.calcite.sql.SqlKind;
+import org.apache.calcite.sql.SqlLiteral;
+import org.apache.calcite.sql.SqlNode;
+import org.apache.calcite.sql.SqlOperator;
+import org.apache.calcite.sql.SqlSpecialOperator;
+import org.apache.calcite.sql.SqlWriter;
+import org.apache.calcite.sql.parser.SqlParserPos;
+import org.apache.calcite.sql.type.ReturnTypes;
+
+import com.google.common.collect.ImmutableList;
+
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+import java.util.List;
+
+/**
+ * Parse tree node representing a {@code SHOW} clause.
+ * @see <a href="https://www.postgresql.org/docs/current/sql-show.html">SHOW specification</a>
+ */
+public class SqlShow extends SqlCall {
+  public static final SqlSpecialOperator OPERATOR =
+      new SqlSpecialOperator("SHOW", SqlKind.OTHER_FUNCTION, 32, false, ReturnTypes.VARCHAR_2000,
+          null, null) {
+    @Override public SqlCall createCall(@Nullable final SqlLiteral functionQualifier,
+        final SqlParserPos pos,
+        final @Nullable SqlNode... operands) {
+      return new SqlShow(pos, (SqlIdentifier) operands[0]);
+    }
+  };
+
+  private final SqlIdentifier name;
+
+  protected SqlShow(final SqlParserPos pos, SqlIdentifier name) {
+    super(pos);
+    this.name = name;
+  }
+
+  @Override public SqlOperator getOperator() {
+    return OPERATOR;
+  }
+
+  @Override public List<SqlNode> getOperandList() {
+    return ImmutableList.of(name);
+  }
+
+  @Override public void unparse(final SqlWriter writer, final int leftPrec, final int rightPrec) {
+    writer.keyword("SHOW");
+    writer.identifier(name.getSimple(), false);
+  }
+
+  public SqlIdentifier getName() {
+    return name;
+  }
+}
diff --git a/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/package-info.java b/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/package-info.java
new file mode 100644
index 00000000000..2362f6f4636
--- /dev/null
+++ b/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/package-info.java
@@ -0,0 +1,21 @@
+/*
+ * 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.
+ */
+
+/**
+ * Parse tree for PostgreSQL extensions used by the Babel parser.
+ */
+package org.apache.calcite.sql.babel.postgresql;
diff --git a/babel/src/test/java/org/apache/calcite/test/BabelDdlExecutor.java b/babel/src/test/java/org/apache/calcite/test/BabelDdlExecutor.java
new file mode 100644
index 00000000000..5002bf131e0
--- /dev/null
+++ b/babel/src/test/java/org/apache/calcite/test/BabelDdlExecutor.java
@@ -0,0 +1,43 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.test;
+
+import org.apache.calcite.server.DdlExecutor;
+import org.apache.calcite.sql.parser.SqlAbstractParserImpl;
+import org.apache.calcite.sql.parser.SqlParserImplFactory;
+import org.apache.calcite.sql.parser.babel.SqlBabelParserImpl;
+
+import java.io.Reader;
+
+/** Executes the few DDL commands supported by
+ * {@link SqlBabelParserImpl}. */
+public class BabelDdlExecutor extends MockDdlExecutor {
+  static final BabelDdlExecutor INSTANCE = new BabelDdlExecutor();
+
+  /** Parser factory. */
+  @SuppressWarnings("unused") // used via reflection
+  public static final SqlParserImplFactory PARSER_FACTORY =
+      new SqlParserImplFactory() {
+        @Override public SqlAbstractParserImpl getParser(Reader stream) {
+          return SqlBabelParserImpl.FACTORY.getParser(stream);
+        }
+
+        @Override public DdlExecutor getDdlExecutor() {
+          return BabelDdlExecutor.INSTANCE;
+        }
+      };
+}
diff --git a/babel/src/test/java/org/apache/calcite/test/BabelParserTest.java b/babel/src/test/java/org/apache/calcite/test/BabelParserTest.java
index 777e34aa0c7..310929592a6 100644
--- a/babel/src/test/java/org/apache/calcite/test/BabelParserTest.java
+++ b/babel/src/test/java/org/apache/calcite/test/BabelParserTest.java
@@ -18,6 +18,7 @@
 
 import org.apache.calcite.sql.SqlDialect;
 import org.apache.calcite.sql.dialect.MysqlSqlDialect;
+import org.apache.calcite.sql.dialect.PostgresqlSqlDialect;
 import org.apache.calcite.sql.parser.SqlAbstractParserImpl;
 import org.apache.calcite.sql.parser.SqlParser;
 import org.apache.calcite.sql.parser.SqlParserFixture;
@@ -177,25 +178,52 @@ class BabelParserTest extends SqlParserTest {
     final String sql = "SELECT DATEADD(day, 1, t),\n"
         + " DATEDIFF(week, 2, t),\n"
         + " DATE_PART(year, t) FROM mytable";
-    final String expected = "SELECT `DATEADD`(DAY, 1, `T`),"
-        + " `DATEDIFF`(WEEK, 2, `T`), `DATE_PART`(YEAR, `T`)\n"
+    final String expected = "SELECT DATEADD(DAY, 1, `T`),"
+        + " DATEDIFF(WEEK, 2, `T`), DATE_PART(YEAR, `T`)\n"
         + "FROM `MYTABLE`";
 
     sql(sql).ok(expected);
   }
 
+  /** Overrides, adding tests for DATEADD, DATEDIFF, DATE_PART functions
+   * in addition to EXTRACT. */
+  @Test protected void testTimeUnitCodes() {
+    super.testTimeUnitCodes();
+
+    // As for FLOOR in the base class, so for DATEADD, DATEDIFF, DATE_PART.
+    // Extensions such as 'y' remain as identifiers; they are resolved in the
+    // validator.
+    final String ts = "'2022-06-03 12:00:00.000'";
+    final String ts2 = "'2022-06-03 15:30:00.000'";
+    expr("DATEADD(year, 1, " + ts + ")")
+        .ok("DATEADD(YEAR, 1, " + ts + ")");
+    expr("DATEADD(y, 1, " + ts + ")")
+        .ok("DATEADD(`Y`, 1, " + ts + ")");
+    expr("DATEDIFF(year, 1, " + ts + ", " + ts2 + ")")
+        .ok("DATEDIFF(YEAR, 1, '2022-06-03 12:00:00.000', "
+            + "'2022-06-03 15:30:00.000')");
+    expr("DATEDIFF(y, 1, " + ts + ", " + ts2 + ")")
+        .ok("DATEDIFF(`Y`, 1, '2022-06-03 12:00:00.000', "
+            + "'2022-06-03 15:30:00.000')");
+    expr("DATE_PART(year, " + ts + ")")
+        .ok("DATE_PART(YEAR, '2022-06-03 12:00:00.000')");
+    expr("DATE_PART(y, " + ts + ")")
+        .ok("DATE_PART(`Y`, '2022-06-03 12:00:00.000')");
+  }
+
   /** PostgreSQL and Redshift allow TIMESTAMP literals that contain only a
    * date part. */
   @Test void testShortTimestampLiteral() {
+    // Parser doesn't actually check the contents of the string. The validator
+    // will convert it to '1969-07-20 00:00:00', when it has decided that
+    // TIMESTAMP maps to the TIMESTAMP type.
     sql("select timestamp '1969-07-20'")
-        .ok("SELECT TIMESTAMP '1969-07-20 00:00:00'");
+        .ok("SELECT TIMESTAMP '1969-07-20'");
     // PostgreSQL allows the following. We should too.
     sql("select ^timestamp '1969-07-20 1:2'^")
-        .fails("Illegal TIMESTAMP literal '1969-07-20 1:2': not in format "
-            + "'yyyy-MM-dd HH:mm:ss'"); // PostgreSQL gives 1969-07-20 01:02:00
+        .ok("SELECT TIMESTAMP '1969-07-20 1:2'");
     sql("select ^timestamp '1969-07-20:23:'^")
-        .fails("Illegal TIMESTAMP literal '1969-07-20:23:': not in format "
-            + "'yyyy-MM-dd HH:mm:ss'"); // PostgreSQL gives 1969-07-20 23:00:00
+        .ok("SELECT TIMESTAMP '1969-07-20:23:'");
   }
 
   /** Tests parsing PostgreSQL-style "::" cast operator. */
@@ -278,6 +306,113 @@ private void checkParseInfixCast(String sqlType) {
     sql(sql).ok(expected);
   }
 
+  @Test void testArrayLiteralFromString() {
+    sql("select array '{1,2,3}'")
+        .ok("SELECT (ARRAY[1, 2, 3])");
+    sql("select array '{{1,2,5}, {3,4,7}}'")
+        .ok("SELECT (ARRAY[(ARRAY[1, 2, 5]), (ARRAY[3, 4, 7])])");
+    sql("select array '{}'")
+        .ok("SELECT (ARRAY[])");
+    sql("select array '{\"1\", \"2\", \"3\"}'")
+        .ok("SELECT (ARRAY['1', '2', '3'])");
+    sql("select array '{null, 1, null, 2}'")
+        .ok("SELECT (ARRAY[NULL, 1, NULL, 2])");
+
+    sql("select array ^'null, 1, null, 2'^")
+        .fails("Illegal array expression 'null, 1, null, 2'");
+  }
+
+  @Test void testArrayLiteralBigQuery() {
+    final SqlParserFixture f = fixture().withDialect(BIG_QUERY);
+    f.sql("select array '{1, 2}'")
+        .ok("SELECT (ARRAY[1, 2])");
+    f.sql("select array \"{1, 2}\"")
+        .ok("SELECT (ARRAY[1, 2])");
+    f.sql("select array '{\"a\", \"b\"}'")
+        .ok("SELECT (ARRAY['a', 'b'])");
+    f.sql("select array \"{\\\"a\\\", \\\"b\\\"}\"")
+        .ok("SELECT (ARRAY['a', 'b'])");
+  }
+
+  @Test void testPostgresqlShow() {
+    SqlParserFixture f = fixture().withDialect(PostgresqlSqlDialect.DEFAULT);
+    f.sql("SHOW autovacuum")
+        .ok("SHOW \"autovacuum\"");
+    f.sql("SHOW TRANSACTION ISOLATION LEVEL")
+        .ok("SHOW \"transaction_isolation\"");
+  }
+
+  @Test void testPostgresqlSetOption() {
+    SqlParserFixture f = fixture().withDialect(PostgresqlSqlDialect.DEFAULT);
+    f.sql("SET SESSION autovacuum = true")
+        .ok("ALTER SESSION SET \"autovacuum\" = TRUE");
+    f.sql("SET SESSION autovacuum = DEFAULT")
+        .ok("ALTER SESSION SET \"autovacuum\" = DEFAULT");
+    f.sql("SET LOCAL autovacuum TO 'DEFAULT'")
+        .ok("ALTER LOCAL SET \"autovacuum\" = 'DEFAULT'");
+
+    f.sql("SET SESSION TIME ZONE DEFAULT")
+        .ok("ALTER SESSION SET \"timezone\" = DEFAULT");
+    f.sql("SET SESSION TIME ZONE LOCAL")
+        .ok("ALTER SESSION SET \"timezone\" = 'LOCAL'");
+    f.sql("SET TIME ZONE 'PST8PDT'")
+        .ok("SET \"timezone\" = 'PST8PDT'");
+    f.sql("SET TIME ZONE INTERVAL '-08:00' HOUR TO MINUTE")
+        .ok("SET \"timezone\" = INTERVAL '-08:00' HOUR TO MINUTE");
+
+    f.sql("SET search_path = public,public,\"$user\"")
+        .ok("SET \"search_path\" = \"public\", \"public\", \"$user\"");
+    f.sql("SET SCHEMA public,public,\"$user\"")
+        .ok("SET \"search_path\" = \"public\", \"public\", \"$user\"");
+    f.sql("SET NAMES iso_8859_15_to_utf8")
+        .ok("SET \"client_encoding\" = \"iso_8859_15_to_utf8\"");
+  }
+
+  @Test void testPostgresqlBegin() {
+    SqlParserFixture f = fixture().withDialect(PostgresqlSqlDialect.DEFAULT);
+    f.sql("BEGIN").same();
+    f.sql("BEGIN READ ONLY").same();
+    f.sql("BEGIN TRANSACTION READ WRITE")
+        .ok("BEGIN READ WRITE");
+    f.sql("BEGIN WORK ISOLATION LEVEL SERIALIZABLE")
+        .ok("BEGIN ISOLATION LEVEL SERIALIZABLE");
+    f.sql("BEGIN ISOLATION LEVEL SERIALIZABLE, READ ONLY, DEFERRABLE").same();
+    f.sql("BEGIN ISOLATION LEVEL SERIALIZABLE, READ WRITE, NOT DEFERRABLE").same();
+  }
+
+  @Test void testPostgresqlCommit() {
+    SqlParserFixture f = fixture().withDialect(PostgresqlSqlDialect.DEFAULT);
+    f.sql("COMMIT").same();
+    f.sql("COMMIT WORK")
+        .ok("COMMIT");
+    f.sql("COMMIT TRANSACTION")
+        .ok("COMMIT");
+    f.sql("COMMIT AND NO CHAIN")
+        .ok("COMMIT");
+    f.sql("COMMIT AND CHAIN").same();
+  }
+
+  @Test void testPostgresqlRollback() {
+    SqlParserFixture f = fixture().withDialect(PostgresqlSqlDialect.DEFAULT);
+    f.sql("ROLLBACK").same();
+    f.sql("ROLLBACK WORK")
+        .ok("ROLLBACK");
+    f.sql("ROLLBACK TRANSACTION")
+        .ok("ROLLBACK");
+    f.sql("ROLLBACK AND NO CHAIN")
+        .ok("ROLLBACK");
+    f.sql("ROLLBACK AND CHAIN").same();
+  }
+
+  @Test void testPostgresqlDiscard() {
+    SqlParserFixture f = fixture().withDialect(PostgresqlSqlDialect.DEFAULT);
+    f.sql("DISCARD ALL").same();
+    f.sql("DISCARD PLANS").same();
+    f.sql("DISCARD SEQUENCES").same();
+    f.sql("DISCARD TEMPORARY").same();
+    f.sql("DISCARD TEMP").same();
+  }
+
   /** Similar to {@link #testHoist()} but using custom parser. */
   @Test void testHoistMySql() {
     // SQL contains back-ticks, which require MySQL's quoting,
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 5cb6dc27438..69bdbaf1e1f 100644
--- a/babel/src/test/java/org/apache/calcite/test/BabelQuidemTest.java
+++ b/babel/src/test/java/org/apache/calcite/test/BabelQuidemTest.java
@@ -17,6 +17,7 @@
 package org.apache.calcite.test;
 
 import org.apache.calcite.config.CalciteConnectionProperty;
+import org.apache.calcite.config.Lex;
 import org.apache.calcite.jdbc.CalciteConnection;
 import org.apache.calcite.materialize.MaterializationService;
 import org.apache.calcite.plan.Contexts;
@@ -26,6 +27,7 @@
 import org.apache.calcite.sql.parser.SqlParser;
 import org.apache.calcite.sql.parser.babel.SqlBabelParserImpl;
 import org.apache.calcite.sql.pretty.SqlPrettyWriter;
+import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.sql.validate.SqlConformanceEnum;
 import org.apache.calcite.tools.Frameworks;
 import org.apache.calcite.tools.Planner;
@@ -69,7 +71,7 @@ public static void main(String[] args) throws Exception {
   }
 
   /** For {@link QuidemTest#test(String)} parameters. */
-  public static Collection<Object[]> data() {
+  @Override public Collection<String> getPath() {
     // Start with a test file we know exists, then find the directory and list
     // its files.
     final String first = "sql/select.iq";
@@ -105,11 +107,29 @@ public static Collection<Object[]> data() {
           return CalciteAssert.that()
               .with(CalciteAssert.Config.SCOTT)
               .with(CalciteConnectionProperty.FUN, "standard,bigquery")
+              .with(CalciteConnectionProperty.LEX, Lex.BIG_QUERY)
               .with(CalciteConnectionProperty.PARSER_FACTORY,
                   SqlBabelParserImpl.class.getName() + "#FACTORY")
               .with(CalciteConnectionProperty.CONFORMANCE,
                   SqlConformanceEnum.BABEL)
               .with(CalciteConnectionProperty.LENIENT_OPERATOR_LOOKUP, true)
+              .with(
+                  ConnectionFactories.addType("DATETIME", typeFactory ->
+                      typeFactory.createSqlType(SqlTypeName.TIMESTAMP)))
+              .with(
+                  ConnectionFactories.addType("TIMESTAMP", typeFactory ->
+                      typeFactory.createSqlType(
+                          SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE)))
+              .connect();
+        case "scott-postgresql":
+          return CalciteAssert.that()
+              .with(CalciteAssert.SchemaSpec.SCOTT)
+              .with(CalciteConnectionProperty.FUN, "standard,postgresql")
+              .with(CalciteConnectionProperty.PARSER_FACTORY,
+                  BabelDdlExecutor.class.getName() + "#PARSER_FACTORY")
+              .with(CalciteConnectionProperty.CONFORMANCE,
+                  SqlConformanceEnum.BABEL)
+              .with(CalciteConnectionProperty.LENIENT_OPERATOR_LOOKUP, true)
               .connect();
         default:
           return super.connect(name, reference);
diff --git a/babel/src/test/java/org/apache/calcite/test/BabelTest.java b/babel/src/test/java/org/apache/calcite/test/BabelTest.java
index 64301cf6e5c..afe05ed2baa 100644
--- a/babel/src/test/java/org/apache/calcite/test/BabelTest.java
+++ b/babel/src/test/java/org/apache/calcite/test/BabelTest.java
@@ -17,6 +17,11 @@
 package org.apache.calcite.test;
 
 import org.apache.calcite.config.CalciteConnectionProperty;
+import org.apache.calcite.rel.type.DelegatingTypeSystem;
+import org.apache.calcite.rel.type.TimeFrameSet;
+import org.apache.calcite.sql.SqlOperatorTable;
+import org.apache.calcite.sql.fun.SqlLibrary;
+import org.apache.calcite.sql.fun.SqlLibraryOperatorTableFactory;
 import org.apache.calcite.sql.parser.SqlParserFixture;
 import org.apache.calcite.sql.parser.babel.SqlBabelParserImpl;
 
@@ -61,6 +66,11 @@ private static UnaryOperator<CalciteAssert.PropBuilder> useLenientOperatorLookup
             Boolean.toString(lenient));
   }
 
+  static SqlOperatorTable operatorTableFor(SqlLibrary library) {
+    return SqlLibraryOperatorTableFactory.INSTANCE.getOperatorTable(
+        SqlLibrary.STANDARD, library);
+  }
+
   static Connection connect() throws SQLException {
     return connect(UnaryOperator.identity());
   }
@@ -130,6 +140,57 @@ private void checkInfixCast(Statement statement, String typeName, int sqlType)
         .fails("(?s).*Encountered \":\" at .*");
   }
 
+  /** Tests that DATEADD, DATEDIFF, DATEPART, DATE_PART allow custom time
+   * frames. */
+  @Test void testTimeFrames() {
+    final SqlValidatorFixture f = Fixtures.forValidator()
+        .withParserConfig(p -> p.withParserFactory(SqlBabelParserImpl.FACTORY))
+        .withOperatorTable(operatorTableFor(SqlLibrary.MSSQL))
+        .withFactory(tf ->
+            tf.withTypeSystem(typeSystem ->
+                new DelegatingTypeSystem(typeSystem) {
+                  @Override public TimeFrameSet deriveTimeFrameSet(
+                      TimeFrameSet frameSet) {
+                    return TimeFrameSet.builder()
+                        .addAll(frameSet)
+                        .addDivision("minute15", 4, "HOUR")
+                        .build();
+                  }
+                }));
+
+    final String ts = "timestamp '2020-06-27 12:34:56'";
+    final String ts2 = "timestamp '2020-06-27 13:45:56'";
+    f.withSql("SELECT DATEADD(YEAR, 3, " + ts + ")").ok();
+    f.withSql("SELECT DATEADD(HOUR^.^A, 3, " + ts + ")")
+        .fails("(?s).*Encountered \".\" at .*");
+    f.withSql("SELECT DATEADD(^A^, 3, " + ts + ")")
+        .fails("'A' is not a valid time frame");
+    f.withSql("SELECT DATEADD(minute15, 3, " + ts + ")")
+        .ok();
+    f.withSql("SELECT DATEDIFF(^A^, " + ts + ", " + ts2 + ")")
+        .fails("'A' is not a valid time frame");
+    f.withSql("SELECT DATEDIFF(minute15, " + ts + ", " + ts2 + ")")
+        .ok();
+    f.withSql("SELECT DATEPART(^A^, " + ts + ")")
+        .fails("'A' is not a valid time frame");
+    f.withSql("SELECT DATEPART(minute15, " + ts + ")")
+        .ok();
+
+    // Where DATEPART is MSSQL, DATE_PART is Postgres
+    f.withSql("SELECT ^DATE_PART(A, " + ts + ")^")
+        .fails("No match found for function signature "
+            + "DATE_PART\\(<INTERVAL_DAY_TIME>, <TIMESTAMP>\\)");
+    final SqlValidatorFixture f2 =
+        f.withOperatorTable(operatorTableFor(SqlLibrary.POSTGRESQL));
+    f2.withSql("SELECT ^DATEPART(A, " + ts + ")^")
+        .fails("No match found for function signature "
+            + "DATEPART\\(<INTERVAL_DAY_TIME>, <TIMESTAMP>\\)");
+    f2.withSql("SELECT DATE_PART(^A^, " + ts + ")")
+        .fails("'A' is not a valid time frame");
+    f2.withSql("SELECT DATE_PART(minute15, " + ts + ")")
+        .ok();
+  }
+
   @Test void testNullSafeEqual() {
     // x <=> y
     checkSqlResult("mysql", "SELECT 1 <=> NULL", "EXPR$0=false\n");
diff --git a/babel/src/test/resources/sql/big-query.iq b/babel/src/test/resources/sql/big-query.iq
index 6792fb6ed2f..0df376e76ac 100755
--- a/babel/src/test/resources/sql/big-query.iq
+++ b/babel/src/test/resources/sql/big-query.iq
@@ -15,123 +15,3315 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+# In this file (due to the use of 'scott-big-query' below, and unlike typical
+# Quidem tests), types are aliased to be consistent with BigQuery's type names,
+# not Calcite's usual type names. # In particular:
+#  * DATETIME is what Calcite calls TIMESTAMP;
+#  * TIMESTAMP is what Calcite calls TIMESTAMP WITH LOCAL TIME ZONE;
+#  * DATE and TIME are the same as Calcite;
+#  * BYTES means VARBINARY(*);
+#  * STRING means VARCHAR(*).
+#
+# The DATETIME() and TIMESTAMP() functions are also substituted so that they
+# produce values that BigQuery would call DATETIME and TIMESTAMP.
+#
 !use scott-big-query
-!set outputformat csv
+!set outputformat mysql
 
-# TIMESTAMP_SECONDS, TIMESTAMP_MILLIS, TIMESTAMP_MICROS
-select v,
-  timestamp_seconds(v) as t0,
-  timestamp_millis(v * 1000) as t1,
-  timestamp_micros(v * 1000 * 1000) as t2
-from (values cast(0 as bigint),
-   cast(null as bigint),
-   cast(1230219000 as bigint),
-   cast(-1230219000 as bigint)) as t (v)
-order by v;
-V, T0, T1, T2
--1230219000, 1931-01-07 08:30:00, 1931-01-07 08:30:00, 1931-01-07 08:30:00
-0, 1970-01-01 00:00:00, 1970-01-01 00:00:00, 1970-01-01 00:00:00
-1230219000, 2008-12-25 15:30:00, 2008-12-25 15:30:00, 2008-12-25 15:30:00
-null, null, null, null
+# TODO: create a means to set the current date/time/timestamp for the
+#   current session CURRENT_TIMESTAMP etc. will return those values.
+#   Then enable the CURRENT_x tests.
+!if (false) {
+!set timestamp '2022-06-03 12:15:48.678'
+!}
+
+# TODO: create a means to set the session timezone.
+# They will affect all queries that are tagged as follows:
+#   Display of results may differ, depending upon the environment and
+#   time zone where this query was executed.
+!if (false) {
+!set timezone 'America/Pacific'
+!}
+
+# BigQuery allows CTEs called 'table' and 'date'
+!if (false) {
+with table as (select 1 as x)
+select *
+from table;
 !ok
 
-select timestamp_seconds(1234567890) as t;
-T
-2009-02-13 23:31:30
+with date as (select 1 as x)
+select *
+from date;
 !ok
+!}
 
-select timestamp_millis(1234567890) as t;
-T
-1970-01-15 06:56:07
+
+#####################################################################
+# DATE, DATETIME, TIME and TIMESTAMP functions ######################
+
+#####################################################################
+# CURRENT_DATE
+#
+# CURRENT_DATE([time_zone])
+#
+# Returns the current date as of the specified or default time
+# zone. Parentheses are optional when called with no arguments.
+#
+# This function supports an optional time_zone parameter. This
+# parameter is a string representing the time zone to use. If no time
+# zone is specified, the default time zone, UTC, is used. See Time
+# zone definitions for information on how to specify a time zone.
+#
+# If the time_zone parameter evaluates to NULL, this function returns NULL.
+#
+# Returns DATE
+
+!if (false) {
+SELECT CURRENT_DATE() AS the_date;
++--------------+
+| the_date     |
++--------------+
+| 2016-12-25   |
++--------------+
 !ok
+!}
 
-select timestamp_micros(1234567890) as t;
-T
-1970-01-01 00:20:34
+!if (false) {
+SELECT CURRENT_DATE AS the_date;
++--------------+
+| the_date     |
++--------------+
+| 2016-12-25   |
++--------------+
 !ok
+!}
 
-# UNIX_SECONDS, UNIX_MILLIS, UNIX_MICROS
-select v,
-  unix_seconds(v) as t0,
-  unix_millis(v) as t1,
-  unix_micros(v) as t2
-from (values TIMESTAMP '1970-01-01 00:00:00',
-   cast(null as timestamp),
-   TIMESTAMP '2008-12-25 15:30:00',
-   TIMESTAMP '1931-01-07 08:30:00') as t (v)
-order by v;
-V, T0, T1, T2
-1931-01-07 08:30:00, -1230219000, -1230219000000, -1230219000000000
-1970-01-01 00:00:00, 0, 0, 0
-2008-12-25 15:30:00, 1230219000, 1230219000000, 1230219000000000
-null, null, null, null
+!if (false) {
+SELECT CURRENT_DATE("Europe/Moscow") AS the_date;
++--------------+
+| the_date     |
++--------------+
+| 2016-12-26   |
++--------------+
 !ok
 
-select unix_seconds(timestamp '2008-12-25 15:30:00') as t;
-T
-1230219000
+SELECT CURRENT_DATE(null) AS the_date;
++----------+
+| the_date |
++----------+
+|          |
++----------+
 !ok
+!}
 
-select unix_millis(timestamp '2008-12-25 15:30:00') as t;
-T
-1230219000000
+# When a column named current_date is present, the column name and the
+# function call without parentheses are ambiguous. To ensure the
+# function call, add parentheses; to ensure the column name, qualify
+# it with its range variable. For example, the following query will
+# select the function in the the_date column and the table column in
+# the current_date column.
+
+!if (false) {
+WITH t AS (SELECT 'column value' AS `current_date`)
+SELECT current_date() AS the_date, t.current_date FROM t;
++------------+--------------+
+| the_date   | current_date |
++------------+--------------+
+| 2016-12-25 | column value |
++------------+--------------+
 !ok
+!}
 
-select unix_micros(timestamp '2008-12-25 15:30:00') as t;
-T
-1230219000000000
+#####################################################################
+# CURRENT_DATETIME
+#
+# CURRENT_DATETIME([time_zone])
+#
+# Returns the current time as a DATETIME object. Parentheses are
+# optional when called with no arguments.
+#
+# This function supports an optional time_zone parameter. See Time
+# zone definitions for information on how to specify a time zone.
+#
+# Returns DATETIME
+
+!if (false) {
+SELECT CURRENT_DATETIME() as now;
++----------------------------+
+| now                        |
++----------------------------+
+| 2016-05-19T10:38:47.046465 |
++----------------------------+
 !ok
 
-# DATE_FROM_UNIX_DATE
-select v,
-  date_from_unix_date(v) as d
-from (values 0,
-   cast(null as integer),
-   1230219000 / 86400,
-   -1230219000 / 86400) as t (v)
-order by v;
-V, D
--14238, 1931-01-08
-0, 1970-01-01
-14238, 2008-12-25
-null, null
+SELECT CURRENT_DATETIME as now;
++----------------------------+
+| now                        |
++----------------------------+
+| 2016-05-19T10:38:47.046465 |
++----------------------------+
 !ok
+!}
 
-select date_from_unix_date(14238);
-EXPR$0
-2008-12-25
+# When a column named current_datetime is present, the column name and
+# the function call without parentheses are ambiguous. To ensure the
+# function call, add parentheses; to ensure the column name, qualify
+# it with its range variable. For example, the following query will
+# select the function in the now column and the table column in the
+# current_datetime column.
+
+!if (false) {
+WITH t AS (SELECT 'column value' AS `current_datetime`)
+SELECT current_datetime() as now, t.current_datetime FROM t;
++----------------------------+------------------+
+| now                        | current_datetime |
++----------------------------+------------------+
+| 2016-05-19T10:38:47.046465 | column value     |
++----------------------------+------------------+
 !ok
+!}
+
+#####################################################################
+# CURRENT_TIME
+#
+# CURRENT_TIME([time_zone])
+#
+#
+# Returns the current time as a TIME object. Parentheses are optional
+# when called with no arguments.
+#
+# This function supports an optional time_zone parameter. See Time
+# zone definitions for information on how to specify a time zone.
+#
+# Returns TIME
+
+!if (false) {
+SELECT CURRENT_TIME() as now;
+
++----------------------------+
+| now                        |
++----------------------------+
+| 15:31:38.776361            |
++----------------------------+
+!ok
+!}
+
+# When a column named current_time is present, the column name and the
+# function call without parentheses are ambiguous. To ensure the
+# function call, add parentheses; to ensure the column name, qualify
+# it with its range variable. For example, the following query will
+# select the function in the now column and the table column in the
+# current_time column.
+
+!if (false) {
+WITH t AS (SELECT 'column value' AS `current_time`)
+SELECT current_time() as now, t.current_time FROM t;
+
++-----------------+--------------+
+| now             | current_time |
++-----------------+--------------+
+| 15:31:38.776361 | column value |
++-----------------+--------------+
+!ok
+!}
+
+#####################################################################
+# CURRENT_TIMESTAMP
+# Parentheses are optional
+!if (false) {
+select current_timestamp() as now;
++---------------------+
+| now                 |
++---------------------+
+| 2022-06-02 17:58:58 |
++---------------------+
+(1 row)
+
+!ok
+!}
+
+!if (false) {
+select current_timestamp as now;
++---------------------+
+| now                 |
++---------------------+
+| 2022-06-02 17:58:58 |
++---------------------+
+(1 row)
+
+!ok
+!}
+
+# When a column named current_timestamp is present, the column name
+# and the function call without parentheses are ambiguous. To ensure
+# the function call, add parentheses; to ensure the column name,
+# qualify it with its range variable. For example, the following query
+# will select the function in the now column and the table column in
+# the current_timestamp column.
+!if (false) {
+WITH t AS (SELECT 'column value' AS `current_timestamp`)
+SELECT current_timestamp() AS now, t.current_timestamp FROM t;
++--------------------------------+-------------------+
+| now                            | current_timestamp |
++--------------------------------+-------------------+
+| 2020-06-02 23:57:12.120174 UTC | column value      |
++--------------------------------+-------------------+
+!ok
+!}
+
+#####################################################################
+# EXTRACT
+#
+# EXTRACT(part FROM date_expression)
+#   Returns the value corresponding to the specified date part
+# EXTRACT(part FROM datetime_expression)
+#   Returns a value that corresponds to the specified part from a
+#   supplied datetime_expression.
+# EXTRACT(part FROM time_expression)
+#   Returns a value that corresponds to the specified part from a
+#   supplied time_expression.
+# EXTRACT(part FROM timestamp_expression [AT TIME ZONE time_zone])
+#
+# For date, the part must be one of:
+#
+#   DAYOFWEEK: Returns values in the range [1,7] with Sunday as the
+#     first day of the week.
+#   DAY
+#   DAYOFYEAR
+#   WEEK: Returns the week number of the date in the range [0,
+#     53]. Weeks begin with Sunday, and dates prior to the first
+#     Sunday of the year are in week 0.
+#   WEEK(<WEEKDAY>): Returns the week number of the date in the range
+#     [0, 53]. Weeks begin on WEEKDAY. Dates prior to the first
+#     WEEKDAY of the year are in week 0. Valid values for WEEKDAY are
+#     SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, and
+#     SATURDAY.
+#   ISOWEEK: Returns the ISO 8601 week number of the
+#     date_expression. ISOWEEKs begin on Monday. Return values are in
+#     the range [1, 53]. The first ISOWEEK of each ISO year begins on
+#     the Monday before the first Thursday of the Gregorian calendar
+#     year.
+#   MONTH
+#   QUARTER: Returns values in the range [1,4].
+#   YEAR
+#   ISOYEAR: Returns the ISO 8601 week-numbering year, which is the
+#     Gregorian calendar year containing the Thursday of the week to
+#     which date_expression belongs.
+#
+# For time, allowed part values are:
+#   MICROSECOND
+#   MILLISECOND
+#   SECOND
+#   MINUTE
+#   HOUR
+#
+# For timestamp and datetime, allowed part values are:
+#   MICROSECOND
+#   MILLISECOND
+#   SECOND
+#   MINUTE
+#   HOUR
+#   DAYOFWEEK: Returns values in the range [1,7] with Sunday as the
+#     first day of of the week.
+#   DAY
+#   DAYOFYEAR
+#   WEEK: Returns the week number of the date in the range [0,
+#     53]. Weeks begin with Sunday, and dates prior to the first Sunday of
+#     the year are in week 0.
+#   WEEK(<WEEKDAY>): Returns the week number of datetime_expression in
+#     the range [0, 53]. Weeks begin on WEEKDAY. datetimes prior to the
+#     first WEEKDAY of the year are in week 0. Valid values for WEEKDAY
+#     are SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, and
+#     SATURDAY.
+#   ISOWEEK: Returns the ISO 8601 week number of the
+#     datetime_expression. ISOWEEKs begin on Monday. Return values are
+#     in the range [1, 53]. The first ISOWEEK of each ISO year begins
+#     on the Monday before the first Thursday of the Gregorian
+#     calendar year.
+#   MONTH
+#   QUARTER
+#   YEAR
+#   ISOYEAR: Returns the ISO 8601 week-numbering year, which is the
+#     Gregorian calendar year containing the Thursday of the week to
+#     which date_expression belongs.
+#   DATE
+#   TIME
+#
+# Returned values truncate lower order time periods. For example, when
+# extracting seconds, EXTRACT truncates the millisecond and
+# microsecond values.
+#
+# Returns INT64, except in the following cases:
+#   If part is DATE, returns a DATE object.
+#   If part is TIME, returns a TIME object.
+
+# In the following example, EXTRACT returns a value corresponding to
+# the DAY date part.
+
+SELECT EXTRACT(DAY FROM DATE '2013-12-25') AS the_day;
++---------+
+| the_day |
++---------+
+|      25 |
++---------+
+(1 row)
+
+!ok
+
+SELECT
+  EXTRACT(DAYOFWEEK FROM DATE '2008-12-25') as day_of_week,
+  EXTRACT(DOW FROM DATE '2008-12-25') as dow;
++-------------+-----+
+| day_of_week | dow |
++-------------+-----+
+|           5 |   5 |
++-------------+-----+
+(1 row)
+
+!ok
+
+SELECT
+  EXTRACT(DAYOFYEAR FROM DATE '2008-12-25') as day_of_year,
+  EXTRACT(DOY FROM DATE '2008-12-25') as doy;
++-------------+-----+
+| day_of_year | doy |
++-------------+-----+
+|         360 | 360 |
++-------------+-----+
+(1 row)
+
+!ok
+
+# 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
+FROM UNNEST(
+  ARRAY [DATE '2015-12-23',
+         DATE '2015-12-24',
+         DATE '2015-12-25',
+         DATE '2015-12-26',
+         DATE '2015-12-27',
+         DATE '2015-12-28',
+         DATE '2015-12-29',
+         DATE '2015-12-30',
+         DATE '2015-12-31',
+         DATE '2016-01-01',
+         DATE '2016-01-02',
+         DATE '2016-01-03',
+         DATE '2016-01-04',
+         DATE '2016-01-05',
+         DATE '2016-01-06',
+         DATE '2016-01-07',
+         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    |
++------------+---------+---------+------+------+
+!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(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          |
++------------+-------------+-------------+
+!ok
+!}
+
+# In the following example, EXTRACT returns a value corresponding to
+# the HOUR time part.
+!if (false) {
+SELECT EXTRACT(HOUR FROM DATETIME(2008, 12, 25, 15, 30, 00)) as hour;
++------------------+
+| hour             |
++------------------+
+| 15               |
++------------------+
+!ok
+!}
+
+# In the following example, EXTRACT returns values corresponding to
+# different time parts from a column of datetimes.
+!if (false) {
+WITH Datetimes AS (
+  SELECT DATETIME '2005-01-03 12:34:56' AS dt UNION ALL
+  SELECT DATETIME '2007-12-31' UNION ALL
+  SELECT DATETIME '2009-01-01' UNION ALL
+  SELECT DATETIME '2009-12-31' UNION ALL
+  SELECT DATETIME '2017-01-02' UNION ALL
+  SELECT DATETIME '2017-05-26'
+)
+SELECT
+  datetime,
+  EXTRACT(ISOYEAR FROM dt) AS isoyear,
+  EXTRACT(ISOWEEK FROM dt) AS isoweek,
+  EXTRACT(YEAR FROM dt) AS year,
+  EXTRACT(WEEK FROM dt) AS week
+FROM Datetimes
+ORDER BY dt;
++---------------------+---------+---------+------+------+
+| dt                  | isoyear | isoweek | year | week |
++---------------------+---------+---------+------+------+
+| 2005-01-03T12:34:56 | 2005    | 1       | 2005 | 1    |
+| 2007-12-31T00:00:00 | 2008    | 1       | 2007 | 52   |
+| 2009-01-01T00:00:00 | 2009    | 1       | 2009 | 0    |
+| 2009-12-31T00:00:00 | 2009    | 53      | 2009 | 52   |
+| 2017-01-02T00:00:00 | 2017    | 1       | 2017 | 1    |
+| 2017-05-26T00:00:00 | 2017    | 21      | 2017 | 21   |
++---------------------+---------+---------+------+------+
+!ok
+!}
+
+# In the following example, datetime_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 DATETIME(TIMESTAMP "2017-11-05 00:00:00+00", "UTC") AS dt)
+SELECT
+  dt,
+  EXTRACT(WEEK(SUNDAY) FROM dt) AS week_sunday,
+  EXTRACT(WEEK(MONDAY) FROM dt) AS week_monday
+FROM t;
++---------------------+-------------+---------------+
+| dt                  | week_sunday | week_monday   |
++---------------------+-------------+---------------+
+| 2017-11-05T00:00:00 | 45          | 44            |
++---------------------+-------------+---------------+
+!ok
+!}
+
+!if (false) {
+WITH Input AS (SELECT TIMESTAMP("2008-12-25 05:30:00+00") AS timestamp_value)
+SELECT
+  EXTRACT(DAY FROM timestamp_value AT TIME ZONE "UTC") AS the_day_utc,
+  EXTRACT(DAY FROM timestamp_value AT TIME ZONE "America/Los_Angeles") AS the_day_california
+FROM Input;
++-------------+--------------------+
+| the_day_utc | the_day_california |
++-------------+--------------------+
+| 25          | 24                 |
++-------------+--------------------+
+!ok
+!}
+
+# Display of results may differ, depending upon the environment and
+# time zone where this query was executed.
+!if (false) {
+WITH Timestamps AS (
+  SELECT TIMESTAMP("2005-01-03 12:34:56+00") AS timestamp_value UNION ALL
+  SELECT TIMESTAMP("2007-12-31 12:00:00+00") UNION ALL
+  SELECT TIMESTAMP("2009-01-01 12:00:00+00") UNION ALL
+  SELECT TIMESTAMP("2009-12-31 12:00:00+00") UNION ALL
+  SELECT TIMESTAMP("2017-01-02 12:00:00+00") UNION ALL
+  SELECT TIMESTAMP("2017-05-26 12:00:00+00")
+)
+SELECT
+  timestamp_value,
+  EXTRACT(ISOYEAR FROM timestamp_value) AS isoyear,
+  EXTRACT(ISOWEEK FROM timestamp_value) AS isoweek,
+  EXTRACT(YEAR FROM timestamp_value) AS year,
+  EXTRACT(WEEK FROM timestamp_value) AS week
+FROM Timestamps
+ORDER BY timestamp_value;
++-------------------------+---------+---------+------+------+
+| timestamp_value         | isoyear | isoweek | year | week |
++-------------------------+---------+---------+------+------+
+| 2005-01-03 12:34:56 UTC | 2005    | 1       | 2005 | 1    |
+| 2007-12-31 12:00:00 UTC | 2008    | 1       | 2007 | 52   |
+| 2009-01-01 12:00:00 UTC | 2009    | 1       | 2009 | 0    |
+| 2009-12-31 12:00:00 UTC | 2009    | 53      | 2009 | 52   |
+| 2017-01-02 12:00:00 UTC | 2017    | 1       | 2017 | 1    |
+| 2017-05-26 12:00:00 UTC | 2017    | 21      | 2017 | 21   |
++-------------------------+---------+---------+------+------+
+!ok
+!}
+
+# In the following example, timestamp_expression falls on a Monday.
+# EXTRACT calculates the first column using weeks that begin on
+# Sunday, and it calculates the second column using weeks that begin
+# on Monday.
+
+# Display of results may differ, depending upon the environment and
+# time zone where this query was executed.
+!if (false) {
+WITH t AS (SELECT TIMESTAMP("2017-11-05 00:00:00+00") AS timestamp_value)
+SELECT
+  timestamp_value,
+  EXTRACT(WEEK(SUNDAY) FROM timestamp_value) AS week_sunday,
+  EXTRACT(WEEK(MONDAY) FROM timestamp_value) AS week_monday
+FROM t;
++-------------------------+-------------+---------------+
+| timestamp_value         | week_sunday | week_monday   |
++-------------------------+-------------+---------------+
+| 2017-11-05 00:00:00 UTC | 45          | 44            |
++-------------------------+-------------+---------------+
+!ok
+!}
+
+#####################################################################
+# NOT EQUAL Operator (value1 != value2)
+#
+# Compares value1 and value2 and returns TRUE if not equal.
+SELECT (5 != 3) as result;
++--------+
+| result |
++--------+
+| true   |
++--------+
+(1 row)
+
+!ok
+
+SELECT (5 != 5) as result;
++--------+
+| result |
++--------+
+| false  |
++--------+
+(1 row)
+
+!ok
+
+#####################################################################
+# MODULO % OPERATOR (value1 % value2)
+#
+# Returns the remainder of dividing value1 by value2.
+SELECT (5 % 3) as result;
++--------+
+| result |
++--------+
+|      2 |
++--------+
+(1 row)
+
+!ok
+
+SELECT (19 % 19) as result;
++--------+
+| result |
++--------+
+|      0 |
++--------+
+(1 row)
+
+!ok
+
+#####################################################################
+# SPLIT
+#
+# SPLIT(string [, delimiter])
+#
+# Splits string using the delimiter argument. For STRING, the default
+# delimiter is the comma.
+#
+# Returns a STRING array as result.
+WITH letters AS
+  (SELECT '' as letter_group
+  UNION ALL
+  SELECT 'a' as letter_group
+  UNION ALL
+  SELECT 'b c d' as letter_group)
+SELECT SPLIT(letter_group, ' ') as example
+FROM letters;
++-----------+
+| example   |
++-----------+
+| []        |
+| [a]       |
+| [b, c, d] |
++-----------+
+(3 rows)
+
+!ok
+
+SELECT SPLIT("h,e,l,l,o") as result;
++-----------------+
+| result          |
++-----------------+
+| [h, e, l, l, o] |
++-----------------+
+(1 row)
+
+!ok
+
+SELECT SPLIT("") as result;
++--------+
+| result |
++--------+
+| []     |
++--------+
+(1 row)
+
+!ok
+
+# Careful to treat the delimiter as a string, not a regular expression
+SELECT SPLIT("abc.de.", ".") as result;
++-------------+
+| result      |
++-------------+
+| [abc, de, ] |
++-------------+
+(1 row)
+
+!ok
+
+WITH letters AS
+  (SELECT x'' as letter_group
+  UNION ALL
+  SELECT x'41' as letter_group
+  UNION ALL
+  SELECT x'42ff43ff44' as letter_group)
+SELECT SPLIT(letter_group, x'ff') as example
+FROM letters;
++-----------+
+| example   |
++-----------+
+| []        |
+| [A]       |
+| [B, C, D] |
++-----------+
+(3 rows)
+
+!ok
+
+SELECT SPLIT(x'abc2') as result;
+Call to function 'SPLIT' with argument of type 'BINARY(2)' requires extra delimiter argument
+!error
+
+#####################################################################
+# LN
+#
+# LN(x)
+#
+# Computes the natural logarithm of x. Generates an error if x is less than or
+# equal to zero.
+
+SELECT LN(100) as result;
++-------------------+
+| result            |
++-------------------+
+| 4.605170185988092 |
++-------------------+
+(1 row)
+
+!ok
+
+#####################################################################
+# LOG
+#
+# LOG(x, y)
+#
+# If only x is present, LOG is a synonym of LN. If y is also
+# present, LOG computes the logarithm of x to base y.
+SELECT LOG(64, 8) as result;
++--------+
+| result |
++--------+
+|    2.0 |
++--------+
+(1 row)
+
+!ok
+
+SELECT LOG(100) as result;
++-------------------+
+| result            |
++-------------------+
+| 4.605170185988092 |
++-------------------+
+(1 row)
+
+!ok
+
+#####################################################################
+# LOG10
+#
+# LOG10(x)
+#
+# Similar to LOG, but computes logarithm to base 10.
+
+SELECT LOG10(100) as result;
++--------+
+| result |
++--------+
+|    2.0 |
++--------+
+(1 row)
+
+!ok
+
+#####################################################################
+# STRING
+#
+# STRING(timestamp_expression[, time_zone])
+#
+# Converts a timestamp_expression to a STRING data type.
+# Supports an optional parameter to specify a time zone.
+
+!if (false) {
+SELECT STRING(TIMESTAMP "2008-12-25 15:30:00+00", "UTC") AS string;
++-------------------------------+
+| string                        |
++-------------------------------+
+| 2008-12-25 15:30:00+00        |
++-------------------------------+
+!ok
+!}
+
+#####################################################################
+# LENGTH(string)
+#
+# Returns the number of characters in the provided string.
+SELECT LENGTH("hello") as length;
++--------+
+| length |
++--------+
+|      5 |
++--------+
+(1 row)
+
+!ok
+
+#####################################################################
+# SAFE_CAST(x AS type)
+#
+# Identical to CAST(), except it returns NULL instead of raising an error.
+
+WITH Casted AS (
+  SELECT SAFE_CAST("a" as int) as casted, "a" as input, "int" as as UNION ALL
+  SELECT SAFE_CAST("a" as varchar(1)), "a", "varchar(1)" UNION ALL
+  SELECT SAFE_CAST("2023-03-07" as DATE), DATE("2023-03-07"), "date" UNION ALL
+  SELECT SAFE_CAST("2023-03-07a" as DATE), "2023-03-07a", "date" UNION ALL
+  SELECT SAFE_CAST(0 as BOOLEAN), 0, "boolean"
+)
+SELECT
+  *
+FROM Casted;
++------------+-------------+------------+
+| casted     | input       | as         |
++------------+-------------+------------+
+|            | a           | int        |
+| a          | a           | varchar(1) |
+| 2023-03-07 | 2023-03-07  | date       |
+|            | 2023-03-07a | date       |
+| FALSE      | 0           | boolean    |
++------------+-------------+------------+
+(5 rows)
+
+!ok
+
+WITH Casted AS (
+  SELECT SAFE_CAST("12:12:11" as TIME) as casted,
+   "12:12:11" as input, "time" as as UNION ALL
+  SELECT SAFE_CAST("12:12:11a" as TIME), "12:12:11a", "time"
+)
+SELECT
+  *
+FROM Casted;
++----------+-----------+------+
+| casted   | input     | as   |
++----------+-----------+------+
+| 12:12:11 | 12:12:11  | time |
+|          | 12:12:11a | time |
++----------+-----------+------+
+(2 rows)
+
+!ok
+
+WITH Casted AS (
+  SELECT SAFE_CAST(TRUE as BOOLEAN) as casted, "true" as input,
+   "boolean" as as UNION ALL
+  SELECT SAFE_CAST(FALSE as BOOLEAN) as casted, "false" as input,
+   "boolean" as as
+)
+SELECT
+  *
+FROM Casted;
++--------+-------+---------+
+| casted | input | as      |
++--------+-------+---------+
+| true   | true  | boolean |
+| false  | false | boolean |
++--------+-------+---------+
+(2 rows)
+
+!ok
+
+WITH Casted AS (
+  SELECT SAFE_CAST(interval '12' month as interval year) as casted,
+   "interval 1 month" as input,
+   "interval year" as as UNION ALL
+   SELECT SAFE_CAST("a" as interval year), "a",
+     "interval year" UNION ALL
+   SELECT SAFE_CAST(null as interval year), "null", "interval year"
+)
+SELECT
+  *
+FROM Casted;
++--------+------------------+---------------+
+| casted | input            | as            |
++--------+------------------+---------------+
+| +1     | interval 1 month | interval year |
+|        | a                | interval year |
+|        | null             | interval year |
++--------+------------------+---------------+
+(3 rows)
+
+!ok
+
+WITH Casted AS (
+  SELECT SAFE_CAST(interval '1:1' hour to minute as interval minute to second)
+   as casted, "interval 1:1 hour to minute" as input,
+    "interval minute to second" as as UNION ALL
+  SELECT SAFE_CAST("a" as interval minute to second),
+   "a", "interval minute to second"
+)
+SELECT
+  *
+FROM Casted;
++---------------+-----------------------------+---------------------------+
+| casted        | input                       | as                        |
++---------------+-----------------------------+---------------------------+
+| +61:00.000000 | interval 1:1 hour to minute | interval minute to second |
+|               | a                           | interval minute to second |
++---------------+-----------------------------+---------------------------+
+(2 rows)
+
+!ok
+
+WITH Casted AS (
+  SELECT SAFE_CAST('true' as BIGINT) as casted, "true" as input,
+    "bigint" as as UNION ALL
+  SELECT SAFE_CAST(1.0 as BIGINT), "1.0", "bigint" UNION ALL
+  SELECT SAFE_CAST(1 as BIGINT), "1", "bigint" UNION ALL
+  SELECT SAFE_CAST(SAFE_CAST(TRUE AS BOOLEAN) AS BIGINT),
+       "TRUE", "bigint"
+)
+SELECT
+  *
+FROM Casted;
++--------+-------+--------+
+| casted | input | as     |
++--------+-------+--------+
+|        | true  | bigint |
+|      1 | 1.0   | bigint |
+|      1 | 1     | bigint |
+|      1 | TRUE  | bigint |
++--------+-------+--------+
+(4 rows)
 
-# UNIX_DATE
-select v,
-  unix_date(v) as d
-from (values date '1970-01-01',
-   cast(null as date),
-   DATE '2008-12-25',
-   DATE '1931-01-07') as t (v)
-order by v;
-V, D
-1931-01-07, -14239
-1970-01-01, 0
-2008-12-25, 14238
-null, null
 !ok
 
-select unix_date(timestamp '2008-12-25');
-EXPR$0
-14238
+#####################################################################
+# STRPOS(string, substring)
+#
+# Returns the 1-based position of the first occurrence of substring
+# within string. Returns 0 if not found.
+SELECT STRPOS("abc", "a") as result;
++--------+
+| result |
++--------+
+|      1 |
++--------+
+(1 row)
+
+!ok
+
+SELECT STRPOS("abc", "d") as result;
++--------+
+| result |
++--------+
+|      0 |
++--------+
+(1 row)
+
+!ok
+
+SELECT STRPOS("abcabc", "bc") as result;
++--------+
+| result |
++--------+
+|      2 |
++--------+
+(1 row)
+
 !ok
 
+#####################################################################
 # DATE
+#
+# 0. DATE(string)
+#   Shorthand for 'CAST(string AS DATE)'
+# 1. DATE(year, month, day)
+#   Constructs a DATE from INT64 values representing the year, month,
+#   and day.
+# 2. DATE(timestamp_expression[, time_zone])
+#   Extracts the DATE from a TIMESTAMP expression. It supports an
+#   optional parameter to specify a time zone. If no time zone is
+#   specified, the default time zone, UTC, is used.
+# 3. DATE(datetime_expression)
+#   Extracts the DATE from a DATETIME expression.
+#
+# Returns DATE
+
 # 'date(x) is shorthand for 'cast(x as date)'
 select date('1970-01-01') as d;
-D
-1970-01-01
++------------+
+| d          |
++------------+
+| 1970-01-01 |
++------------+
+(1 row)
+
 !ok
 
 select date(cast(null as varchar(10))) as d;
-D
-null
++---+
+| d |
++---+
+|   |
++---+
+(1 row)
+
+!ok
+
+SELECT
+  DATE(2016, 12, 25) AS date_ymd,
+  DATE(DATETIME "2016-12-25 23:59:59") AS date_dt,
+  DATE(TIMESTAMP "2016-12-24 22:30:00" /* TODO should be "2016-12-25 05:30:00+07" */ , "America/Los_Angeles") AS date_tstz;
++------------+------------+------------+
+| date_ymd   | date_dt    | date_tstz  |
++------------+------------+------------+
+| 2016-12-25 | 2016-12-25 | 2016-12-24 |
++------------+------------+------------+
+(1 row)
+
+!ok
+
+select date(2022, 11, 15) as d1,
+       date(datetime "2008-01-01 01:03:05") as d2,
+       date(datetime(2008, 1, 1, 1, 3, 5)) as d3;
++------------+------------+------------+
+| d1         | d2         | d3         |
++------------+------------+------------+
+| 2022-11-15 | 2008-01-01 | 2008-01-01 |
++------------+------------+------------+
+(1 row)
+
+!ok
+
+# Test timezone conversion when converting TIMESTAMP to DATE.
+# Denver observes DST whereas Phoenix does not.
+# Both cities have a -07:00 offset in winter, but Denver has -06:00 in summer.
+select date(timestamp("2008-06-21 06:30:00")) as sum_utc,
+       date(timestamp("2008-06-21 06:30:00"), "America/Denver") as sum_dst,
+       date(timestamp("2008-06-21 06:30:00"), "America/Phoenix") as sum_std,
+       date(timestamp("2008-12-21 06:30:00")) as win_utc,
+       date(timestamp("2008-12-21 06:30:00"), "America/Denver") as win_dst,
+       date(timestamp("2008-12-21 06:30:00"), "America/Phoenix") as win_std;
++------------+------------+------------+------------+------------+------------+
+| sum_utc    | sum_dst    | sum_std    | win_utc    | win_dst    | win_std    |
++------------+------------+------------+------------+------------+------------+
+| 2008-06-21 | 2008-06-21 | 2008-06-20 | 2008-12-21 | 2008-12-20 | 2008-12-20 |
++------------+------------+------------+------------+------------+------------+
+(1 row)
+
+!ok
+
+# Date-time literals.
+# As for other tests in this script, data type semantics match BigQuery:
+# DATETIME is what Calcite calls TIMESTAMP;
+# TIMESTAMP is what Calcite calls TIMESTAMP WITH LOCAL TIME ZONE;
+# DATE and TIME are the same as Calcite.
+SELECT
+  DATETIME "1969-07-21 02:56:00" AS dt,
+  TIMESTAMP "1969-07-21 02:56:00" AS ts,
+  DATE "1969-07-21" AS d,
+  TIME "02:56:00" AS t;
++---------------------+---------------------+------------+----------+
+| dt                  | ts                  | d          | t        |
++---------------------+---------------------+------------+----------+
+| 1969-07-21 02:56:00 | 1969-07-21 02:56:00 | 1969-07-21 | 02:56:00 |
++---------------------+---------------------+------------+----------+
+(1 row)
+
+!ok
+
+#####################################################################
+# DATETIME
+#
+# DATETIME(year, month, day, hour, minute, second)
+#   Constructs a DATETIME object using INT64 values representing the
+#   year, month, day, hour, minute, and second.
+# DATETIME(date_expression[, time_expression])
+#   Constructs a DATETIME object using a DATE object and an optional
+#   TIME object.
+# DATETIME(timestamp_expression [, time_zone])
+#   Constructs a DATETIME object using a TIMESTAMP object. It supports
+#   an optional parameter to specify a time zone. If no time zone is
+#   specified, the default time zone, UTC, is used.
+#
+# Returns DATETIME
+
+SELECT
+  DATETIME(2008, 12, 25, 05, 30, 00) as datetime_ymdhms,
+  DATETIME(TIMESTAMP "2008-12-25 05:30:00" /* TODO should be "2008-12-25 05:30:00+00" */, "America/Los_Angeles") as datetime_tstz;
++---------------------+---------------------+
+| datetime_ymdhms     | datetime_tstz       |
++---------------------+---------------------+
+| 2008-12-25 05:30:00 | 2008-12-24 21:30:00 |
++---------------------+---------------------+
+(1 row)
+
+!ok
+
+select datetime(2003, 05, 25, 12, 30, 59) as dt1,
+       datetime(date(2003, 05, 25)) as d2,
+       datetime(date(2003, 05, 25), time(12, 30, 59)) as d3;
++---------------------+---------------------+---------------------+
+| dt1                 | d2                  | d3                  |
++---------------------+---------------------+---------------------+
+| 2003-05-25 12:30:59 | 2003-05-25 00:00:00 | 2003-05-25 12:30:59 |
++---------------------+---------------------+---------------------+
+(1 row)
+
+!ok
+
+# This tests time zone conversion from a timestamp.
+select datetime(timestamp "2008-01-01 01:03:05") as t_winter,
+       datetime(timestamp "2008-01-01 01:03:05", "America/Los_Angeles") as t_winter_offs,
+       datetime(timestamp "2008-07-01 01:03:05", "America/Los_Angeles") as t_summer_offs;
++---------------------+---------------------+---------------------+
+| t_winter            | t_winter_offs       | t_summer_offs       |
++---------------------+---------------------+---------------------+
+| 2008-01-01 01:03:05 | 2007-12-31 17:03:05 | 2008-06-30 18:03:05 |
++---------------------+---------------------+---------------------+
+(1 row)
+
+!ok
+
+#####################################################################
+# TIME
+#
+# 1. TIME(hour, minute, second)
+#   Constructs a TIME object using INT64 values representing the hour,
+#   minute, and second.
+# 2. TIME(timestamp, [time_zone])
+#   Constructs a TIME object using a TIMESTAMP object. It supports an
+#   optional parameter to specify a time zone. If no time zone is
+#   specified, the default time zone, UTC, is used.
+# 3. TIME(datetime)
+#   Constructs a TIME object using a DATETIME object.
+#
+# Returns TIME
+
+SELECT
+  TIME(15, 30, 00) as time_hms,
+  TIME(TIMESTAMP "2008-12-25 07:30:00" /* TODO should be "2008-12-25 15:30:00+08" */, "America/Los_Angeles") as time_tstz;
++----------+-----------+
+| time_hms | time_tstz |
++----------+-----------+
+| 15:30:00 | 23:30:00  |
++----------+-----------+
+(1 row)
+
+!ok
+
+SELECT TIME(DATETIME "2008-12-25 15:30:00.000000") AS time_dt;
++----------+
+| time_dt  |
++----------+
+| 15:30:00 |
++----------+
+(1 row)
+
+!ok
+
+select time(12, 30, 59) as t1,
+       time(datetime(2008, 01, 01, 12, 30, 59)) as t2,
+       time(datetime(2008, 07, 01, 12, 30, 59)) as t3;
++----------+----------+----------+
+| t1       | t2       | t3       |
++----------+----------+----------+
+| 12:30:59 | 12:30:59 | 12:30:59 |
++----------+----------+----------+
+(1 row)
+
+!ok
+
+# Test timezone conversion when converting TIMESTAMP to TIME.
+# Denver observes DST whereas Phoenix does not.
+# Both cities have a -07:00 offset in winter, but Denver has -06:00 in summer.
+select time(timestamp("2008-06-21 06:30:00")) as sum_utc,
+       time(timestamp("2008-06-21 06:30:00"), "America/Denver") as sum_dst,
+       time(timestamp("2008-06-21 06:30:00"), "America/Phoenix") as sum_std,
+       time(timestamp("2008-12-21 06:30:00")) as win_utc,
+       time(timestamp("2008-12-21 06:30:00"), "America/Denver") as win_dst,
+       time(timestamp("2008-12-21 06:30:00"), "America/Phoenix") as win_std;
++----------+----------+----------+----------+----------+----------+
+| sum_utc  | sum_dst  | sum_std  | win_utc  | win_dst  | win_std  |
++----------+----------+----------+----------+----------+----------+
+| 06:30:00 | 00:30:00 | 23:30:00 | 06:30:00 | 23:30:00 | 23:30:00 |
++----------+----------+----------+----------+----------+----------+
+(1 row)
+
 !ok
 
+# Test timezone conversion when converting DATE to TIMESTAMP.
+# Denver observes DST whereas Phoenix does not.
+# Both cities have a -07:00 offset in winter, but Denver has -06:00 in summer.
+select timestamp(date(2008, 6, 21)) as sum_utc,
+       timestamp(date(2008, 6, 21), "America/Denver") as sum_dst,
+       timestamp(date(2008, 6, 21), "America/Phoenix") as sum_std,
+       timestamp(date(2008, 12, 21)) as win_utc,
+       timestamp(date(2008, 12, 21), "America/Denver") as win_dst,
+       timestamp(date(2008, 12, 21), "America/Phoenix") as win_std;
++---------------------+---------------------+---------------------+---------------------+---------------------+---------------------+
+| sum_utc             | sum_dst             | sum_std             | win_utc             | win_dst             | win_std             |
++---------------------+---------------------+---------------------+---------------------+---------------------+---------------------+
+| 2008-06-21 00:00:00 | 2008-06-21 06:00:00 | 2008-06-21 07:00:00 | 2008-12-21 00:00:00 | 2008-12-21 07:00:00 | 2008-12-21 07:00:00 |
++---------------------+---------------------+---------------------+---------------------+---------------------+---------------------+
+(1 row)
+
+!ok
+
+#####################################################################
+# TIMESTAMP
+#
+# TIMESTAMP(string_expression[, time_zone])
+#   Converts a STRING expression
+#   to a TIMESTAMP data type. string_expression must include a
+#   timestamp literal. If string_expression includes a
+#   time_zone in the timestamp literal, do not include an
+#   explicit time_zone argument.
+# TIMESTAMP(date_expression[, time_zone])
+#   Converts a DATE object to a TIMESTAMP data type.
+# TIMESTAMP(datetime_expression[, time_zone])
+#   Converts a DATETIME object to a TIMESTAMP data type.
+#
+# This function supports an optional parameter to specify a time zone.
+# If no time zone is specified, the default time zone, UTC, is used.
+
+# Display of results may differ, depending upon the environment and
+# time zone where this query was executed.
+!if (false) {
+SELECT TIMESTAMP("2008-12-25 15:30:00+00") AS timestamp_str;
++-------------------------+
+| timestamp_str           |
++-------------------------+
+| 2008-12-25 15:30:00 UTC |
++-------------------------+
+!ok
+!}
+
+# Display of results may differ, depending upon the environment and
+# time zone where this query was executed.
+!if (false) {
+SELECT TIMESTAMP("2008-12-25 15:30:00", "America/Los_Angeles") AS timestamp_str;
++-------------------------+
+| timestamp_str           |
++-------------------------+
+| 2008-12-25 23:30:00 UTC |
++-------------------------+
+!ok
+!}
+
+# Display of results may differ, depending upon the environment and
+# time zone where this query was executed.
+!if (false) {
+SELECT TIMESTAMP("2008-12-25 15:30:00 UTC") AS timestamp_str;
++-------------------------+
+| timestamp_str           |
++-------------------------+
+| 2008-12-25 15:30:00 UTC |
++-------------------------+
+!ok
+!}
+
+# Display of results may differ, depending upon the environment and
+# time zone where this query was executed.
+#
+# After [CALCITE-5446] is fixed, this and other TIMESTAMP WITH LOCAL TIME
+# values will end in UTC, like this: 2008-12-25 15:30:00 UTC.
+#
+SELECT TIMESTAMP(DATETIME "2008-12-25 15:30:00") AS timestamp_datetime;
++---------------------+
+| timestamp_datetime  |
++---------------------+
+| 2008-12-25 15:30:00 |
++---------------------+
+(1 row)
+
+!ok
+
+# Display of results may differ, depending upon the environment and
+# time zone where this query was executed.
+SELECT TIMESTAMP(DATE "2008-12-25") AS timestamp_date;
++---------------------+
+| timestamp_date      |
++---------------------+
+| 2008-12-25 00:00:00 |
++---------------------+
+(1 row)
+
+!ok
+
+# All these timestamps should be equal.
+# This tests the BQ timestamp literal string formatter
+# (optional 'T', optional leading zeros, optional offset with conversion).
+select timestamp("2008-01-01 01:03:05+00") as t_space,
+       timestamp("2008-01-01T01:03:05+00") as t_iso,
+       timestamp("2008-01-01 01:03:05") as t_no_offset,
+       timestamp("2008-1-1 3:5:7+02:02:02") as t_offset;
++---------------------+---------------------+---------------------+---------------------+
+| t_space             | t_iso               | t_no_offset         | t_offset            |
++---------------------+---------------------+---------------------+---------------------+
+| 2008-01-01 01:03:05 | 2008-01-01 01:03:05 | 2008-01-01 01:03:05 | 2008-01-01 01:03:05 |
++---------------------+---------------------+---------------------+---------------------+
+(1 row)
+
+!ok
+
+# Negative and positive offsets.
+select timestamp("2008-01-01 01:03:05+01") as space_01,
+       timestamp("2008-01-01T01:03:05+01") as iso_1,
+       timestamp("2008-01-01T01:03:05+01:00") as iso_1_00,
+       timestamp("2008-01-01T01:03:05-11") as iso_neg_11;
++---------------------+---------------------+---------------------+---------------------+
+| space_01            | iso_1               | iso_1_00            | iso_neg_11          |
++---------------------+---------------------+---------------------+---------------------+
+| 2008-01-01 00:03:05 | 2008-01-01 00:03:05 | 2008-01-01 00:03:05 | 2008-01-01 12:03:05 |
++---------------------+---------------------+---------------------+---------------------+
+(1 row)
+
+!ok
+
+# This tests time zone conversion from a datetime.
+select timestamp(datetime "2008-01-01 01:03:05") as t_winter,
+       timestamp(datetime "2008-01-01 01:03:05", "America/Los_Angeles") as t_winter_offs,
+       timestamp(datetime "2008-07-01 01:03:05", "America/Los_Angeles") as t_summer_offs;
++---------------------+---------------------+---------------------+
+| t_winter            | t_winter_offs       | t_summer_offs       |
++---------------------+---------------------+---------------------+
+| 2008-01-01 01:03:05 | 2008-01-01 09:03:05 | 2008-07-01 08:03:05 |
++---------------------+---------------------+---------------------+
+(1 row)
+
+!ok
+
+#####################################################################
+# TIMESTAMP_SECONDS
+#
+# TIMESTAMP_SECONDS(int64_expression)
+#
+# Interprets int64_expression as the number of seconds since
+# 1970-01-01 00:00:00 UTC and returns a timestamp.
+
+# Display of results may differ, depending upon the environment and
+# time zone where this query was executed.
+
+# Note that BigQuery prints "2008-12-25 15:30:00 UTC" as the result,
+# whereas Calcite's result does not include "UTC". This is because
+# BigQuery's TIMESTAMP type is an instant (the equivalent of Calcite's
+# TIMESTAMP WITH LOCAL TIME ZONE type). It would have been too confusing
+# for a function called 'TIMESTAMP_SECONDS' to return a TIMESTAMP WITH
+# LOCAL TIME ZONE, so this function returns a Calcite TIMESTAMP which,
+# as a local time does not include UTC or any time zone.
+
+SELECT TIMESTAMP_SECONDS(1230219000) AS timestamp_value;
++---------------------+
+| timestamp_value     |
++---------------------+
+| 2008-12-25 15:30:00 |
++---------------------+
+(1 row)
+
+!ok
+
+
+#####################################################################
+# TIMESTAMP_MILLIS
+#
+# TIMESTAMP_MILLIS(int64_expression)
+#
+# Interprets int64_expression as the number of milliseconds since
+# 1970-01-01 00:00:00 UTC and returns a timestamp.
+
+# Display of results may differ, depending upon the environment and
+# time zone where this query was executed.
+
+# BigQuery's result ends in "UTC" but Calcite's does not, for the reasons
+# explained in TIMESTAMP_SECONDS.
+
+SELECT TIMESTAMP_MILLIS(1230219000000) AS timestamp_value;
++---------------------+
+| timestamp_value     |
++---------------------+
+| 2008-12-25 15:30:00 |
++---------------------+
+(1 row)
+
+!ok
+
+
+#####################################################################
+# TIMESTAMP_MICROS
+#
+# TIMESTAMP_MICROS(int64_expression)
+#
+# Interprets int64_expression as the number of microseconds since
+# 1970-01-01 00:00:00 UTC and returns a timestamp.
+
+# Display of results may differ, depending upon the environment and
+# time zone where this query was executed.
+!if (false) {
+SELECT TIMESTAMP_MICROS(1230219000000000) AS timestamp_value;
++-------------------------+
+| timestamp_value         |
++-------------------------+
+| 2008-12-25 15:30:00 UTC |
++-------------------------+
+!ok
+!}
+
+# TIMESTAMP_SECONDS, TIMESTAMP_MILLIS, TIMESTAMP_MICROS
+select v,
+  timestamp_seconds(v) as t0,
+  timestamp_millis(v * 1000) as t1,
+  timestamp_micros(v * 1000 * 1000) as t2
+from (values cast(0 as bigint),
+   cast(null as bigint),
+   cast(1230219000 as bigint),
+   cast(-1230219000 as bigint)) as t (v)
+order by v;
++-------------+---------------------+---------------------+---------------------+
+| v           | t0                  | t1                  | t2                  |
++-------------+---------------------+---------------------+---------------------+
+| -1230219000 | 1931-01-07 08:30:00 | 1931-01-07 08:30:00 | 1931-01-07 08:30:00 |
+|           0 | 1970-01-01 00:00:00 | 1970-01-01 00:00:00 | 1970-01-01 00:00:00 |
+|  1230219000 | 2008-12-25 15:30:00 | 2008-12-25 15:30:00 | 2008-12-25 15:30:00 |
+|             |                     |                     |                     |
++-------------+---------------------+---------------------+---------------------+
+(4 rows)
+
+!ok
+
+select timestamp_seconds(1234567890) as t;
++---------------------+
+| t                   |
++---------------------+
+| 2009-02-13 23:31:30 |
++---------------------+
+(1 row)
+
+!ok
+
+select timestamp_millis(1234567890) as t;
++---------------------+
+| t                   |
++---------------------+
+| 1970-01-15 06:56:07 |
++---------------------+
+(1 row)
+
+!ok
+
+select timestamp_micros(1234567890) as t;
++---------------------+
+| t                   |
++---------------------+
+| 1970-01-01 00:20:34 |
++---------------------+
+(1 row)
+
+!ok
+
+#####################################################################
+# UNIX_SECONDS
+#
+# UNIX_SECONDS(timestamp_expression)
+#
+# Returns the number of seconds since 1970-01-01 00:00:00
+# UTC. Truncates higher levels of precision.
+
+!if (false) {
+SELECT UNIX_SECONDS(TIMESTAMP "2008-12-25 15:30:00+00") AS seconds;
++------------+
+| seconds    |
++------------+
+| 1230219000 |
++------------+
+!ok
+!}
+
+#####################################################################
+# UNIX_MILLIS
+#
+# UNIX_MILLIS(timestamp_expression)
+#
+# Returns the number of milliseconds since 1970-01-01 00:00:00
+# UTC. Truncates higher levels of precision.
+
+!if (false) {
+SELECT UNIX_MILLIS(TIMESTAMP "2008-12-25 15:30:00+00") AS millis;
++---------------+
+| millis        |
++---------------+
+| 1230219000000 |
++---------------+
+!ok
+!}
+
+#####################################################################
+# UNIX_MICROS
+#
+# UNIX_MICROS(timestamp_expression)
+#
+# Returns the number of microseconds since 1970-01-01 00:00:00
+# UTC. Truncates higher levels of precision.
+
+!if (false) {
+SELECT UNIX_MICROS(TIMESTAMP "2008-12-25 15:30:00+00") AS micros;
++------------------+
+| micros           |
++------------------+
+| 1230219000000000 |
++------------------+
+!ok
+!}
+
+# UNIX_SECONDS, UNIX_MILLIS, UNIX_MICROS
+select v,
+  unix_seconds(v) as t0,
+  unix_millis(v) as t1,
+  unix_micros(v) as t2
+from (values TIMESTAMP '1970-01-01 00:00:00',
+   cast(null as timestamp),
+   TIMESTAMP '2008-12-25 15:30:00',
+   TIMESTAMP '1931-01-07 08:30:00') as t (v)
+order by v;
++---------------------+-------------+----------------+-------------------+
+| v                   | t0          | t1             | t2                |
++---------------------+-------------+----------------+-------------------+
+| 1931-01-07 08:30:00 | -1230219000 | -1230219000000 | -1230219000000000 |
+| 1970-01-01 00:00:00 |           0 |              0 |                 0 |
+| 2008-12-25 15:30:00 |  1230219000 |  1230219000000 |  1230219000000000 |
+|                     |             |                |                   |
++---------------------+-------------+----------------+-------------------+
+(4 rows)
+
+!ok
+
+select unix_seconds(timestamp '2008-12-25 15:30:00') as t;
++------------+
+| t          |
++------------+
+| 1230219000 |
++------------+
+(1 row)
+
+!ok
+
+select unix_millis(timestamp '2008-12-25 15:30:00') as t;
++---------------+
+| t             |
++---------------+
+| 1230219000000 |
++---------------+
+(1 row)
+
+!ok
+
+select unix_micros(timestamp '2008-12-25 15:30:00') as t;
++------------------+
+| t                |
++------------------+
+| 1230219000000000 |
++------------------+
+(1 row)
+
+!ok
+
+#####################################################################
+# DATE_FROM_UNIX_DATE
+select v,
+  date_from_unix_date(v) as d
+from (values 0,
+   cast(null as integer),
+   1230219000 / 86400,
+   -1230219000 / 86400) as t (v)
+order by v;
++--------+------------+
+| v      | d          |
++--------+------------+
+| -14238 | 1931-01-08 |
+|      0 | 1970-01-01 |
+|  14238 | 2008-12-25 |
+|        |            |
++--------+------------+
+(4 rows)
+
+!ok
+
+select date_from_unix_date(14238);
++------------+
+| EXPR$0     |
++------------+
+| 2008-12-25 |
++------------+
+(1 row)
+
+!ok
+
+#####################################################################
+# UNIX_DATE
+select v,
+  unix_date(v) as d
+from (values date '1970-01-01',
+   cast(null as date),
+   DATE '2008-12-25',
+   DATE '1931-01-07') as t (v)
+order by v;
++------------+--------+
+| v          | d      |
++------------+--------+
+| 1931-01-07 | -14239 |
+| 1970-01-01 |      0 |
+| 2008-12-25 |  14238 |
+|            |        |
++------------+--------+
+(4 rows)
+
+!ok
+
+select unix_date(datetime '2008-12-25') as d;
++-------+
+| d     |
++-------+
+| 14238 |
++-------+
+(1 row)
+
+!ok
+
+
+#####################################################################
+# DATE_ADD
+#
+# DATE_ADD(date_expression, INTERVAL int64_expression date_part)
+#
+# Adds a specified time interval to a DATE.
+#
+# DATE_ADD supports the following date_part values:
+#   DAY
+#   WEEK. Equivalent to 7 DAYs.
+#   MONTH
+#   QUARTER
+#   YEAR
+#
+# Special handling is required for MONTH, QUARTER, and YEAR parts when
+# the date is at (or near) the last day of the month. If the resulting
+# month has fewer days than the original date's day, then the
+# resulting date is the last date of that month.
+#
+# Returns DATE
+
+SELECT DATE_ADD(DATE "2008-12-25", INTERVAL 5 DAY) AS five_days_later;
++-----------------+
+| five_days_later |
++-----------------+
+| 2008-12-30      |
++-----------------+
+(1 row)
+
+!ok
+
+#####################################################################
+# DATETIME_ADD
+#
+# DATETIME_ADD(datetime_expression, INTERVAL int64_expression part)
+#
+# Adds int64_expression units of part to the DATETIME object.
+#
+# DATETIME_ADD supports the following values for part:
+#
+#   MICROSECOND
+#   MILLISECOND
+#   SECOND
+#   MINUTE
+#   HOUR
+#   DAY
+#   WEEK. Equivalent to 7 DAYs.
+#   MONTH
+#   QUARTER
+#   YEAR
+#
+# Special handling is required for MONTH, QUARTER, and YEAR parts when
+# the date is at (or near) the last day of the month. If the resulting
+# month has fewer days than the original DATETIME's day, then the
+# result day is the last day of the new month.
+#
+# Returns DATETIME
+
+SELECT
+  DATETIME "2008-12-25 15:30:00" as original_date,
+  DATETIME_ADD(DATETIME "2008-12-25 15:30:00", INTERVAL 10 MINUTE) as later;
++---------------------+---------------------+
+| original_date       | later               |
++---------------------+---------------------+
+| 2008-12-25 15:30:00 | 2008-12-25 15:40:00 |
++---------------------+---------------------+
+(1 row)
+
+!ok
+
+SELECT
+  DATETIME "2008-12-25 15:30:00" as original_date,
+  DATETIME_ADD(TIMESTAMP "2008-12-25 15:30:00", INTERVAL 20 MINUTE) as later;
++---------------------+---------------------+
+| original_date       | later               |
++---------------------+---------------------+
+| 2008-12-25 15:30:00 | 2008-12-25 15:50:00 |
++---------------------+---------------------+
+(1 row)
+
+!ok
+
+#####################################################################
+# TIME_ADD
+#
+# TIME_ADD(time_expression, INTERVAL int64_expression part)
+#
+# Adds int64_expression units of part to the TIME object.
+#
+# TIME_ADD supports the following values for part:
+#
+#   MICROSECOND
+#   MILLISECOND
+#   SECOND
+#   MINUTE
+#   HOUR
+#
+# This function automatically adjusts when values fall outside of the
+# 00:00:00 to 24:00:00 boundary. For example, if you add an hour to
+# 23:30:00, the returned value is 00:30:00.
+#
+# Returns TIME
+
+SELECT
+  TIME "15:30:00" as original_time,
+  TIME_ADD(TIME "15:30:00", INTERVAL 10 MINUTE) as later;
++---------------+----------+
+| original_time | later    |
++---------------+----------+
+| 15:30:00      | 15:40:00 |
++---------------+----------+
+(1 row)
+
+!ok
+
+#####################################################################
+# TIMESTAMP_ADD
+#
+# TIMESTAMP_ADD(timestamp_expression, INTERVAL int64_expression date_part)
+#
+# Adds int64_expression units of date_part to the timestamp,
+# independent of any time zone.
+#
+# TIMESTAMP_ADD supports the following values for date_part:
+#  MICROSECOND
+#  MILLISECOND
+#  SECOND
+#  MINUTE
+#  HOUR. Equivalent to 60 MINUTEs.
+#  DAY. Equivalent to 24 HOURs.
+
+# Display of results may differ, depending upon the environment and
+# time zone where this query was executed.
+!if (false) {
+# Enable when we have TIMESTAMP() function,
+# and when we allow "+00" timezone offset in timestamp values.
+SELECT
+  TIMESTAMP("2008-12-25 15:30:00+00") AS original,
+  TIMESTAMP_ADD(TIMESTAMP "2008-12-25 15:30:00+00", INTERVAL 10 MINUTE) AS later;
++-------------------------+-------------------------+
+| original                | later                   |
++-------------------------+-------------------------+
+| 2008-12-25 15:30:00 UTC | 2008-12-25 15:40:00 UTC |
++-------------------------+-------------------------+
+(1 row)
+
+!ok
+!}
+
+# As previous, but uses TIMESTAMP literal rather than function,
+# and "+00" timezone offsets have been removed.
+SELECT
+  TIMESTAMP "2008-12-25 15:30:00" AS original,
+  TIMESTAMP_ADD(TIMESTAMP "2008-12-25 15:30:00", INTERVAL 10 MINUTE) AS later;
++---------------------+---------------------+
+| original            | later               |
++---------------------+---------------------+
+| 2008-12-25 15:30:00 | 2008-12-25 15:40:00 |
++---------------------+---------------------+
+(1 row)
+
+!ok
+
+#####################################################################
+# LPAD(original_value, return_length, pattern)
+#
+# Returns a STRING or BYTES value that consists of original_value prepended
+# with pattern.
+#
+# This function supports specifying collation.
+WITH Examples AS (
+  SELECT LPAD('12345', 8, 'a') as result, "8" as pad_length, "a" as p UNION ALL
+  SELECT LPAD('12345', 8), "8", " " UNION ALL
+  SELECT LPAD('12345', 8, 'aba'), "8", "aba" UNION ALL
+  SELECT LPAD('12345', 3), "3", " " UNION ALL
+  SELECT LPAD(x'aa', 4, x'bb'), "4", "x'bb'" UNION ALL
+  SELECT LPAD(x'aa', 4), "4", "20" UNION ALL
+  SELECT LPAD(x'aaaaaa', 2), "2", "20" UNION ALL
+  SELECT LPAD(x'aaaaaa', 2, x'bb'), "2", "x'bb'"
+)
+SELECT
+  *
+FROM Examples;
++----------+------------+-------+
+| result   | pad_length | p     |
++----------+------------+-------+
+| aaa12345 | 8          | a     |
+|    12345 | 8          |       |
+| aba12345 | 8          | aba   |
+| 123      | 3          |       |
+| bbbbbbaa | 4          | x'bb' |
+| 202020aa | 4          | 20    |
+| aaaa     | 2          | 20    |
+| aaaa     | 2          | x'bb' |
++----------+------------+-------+
+(8 rows)
+
+!ok
+
+#####################################################################
+# RPAD(original_value, return_length, pattern)
+#
+# Returns a STRING or BYTES value that consists of original_value prepended
+# with pattern.
+#
+# This function supports specifying collation.
+WITH Examples AS (
+  SELECT RPAD('12345', 8, 'a') as result, "8" as pad_length, "a" as p UNION ALL
+  SELECT RPAD('12345', 8), "8", " " UNION ALL
+  SELECT RPAD('12345', 8, 'aba'), "8", "aba" UNION ALL
+  SELECT RPAD('12345', 3), "3", " " UNION ALL
+  SELECT RPAD(x'aa', 4, x'bb'), "4", "x'bb'" UNION ALL
+  SELECT RPAD(x'aa', 4), "4", "20" UNION ALL
+  SELECT RPAD(x'aaaaaa', 2), "2", "20" UNION ALL
+  SELECT RPAD(x'aaaaaa', 2, x'bb'), "2", "x'bb'"
+)
+SELECT
+  *
+FROM Examples;
++----------+------------+-------+
+| result   | pad_length | p     |
++----------+------------+-------+
+| 12345aaa | 8          | a     |
+| 12345    | 8          |       |
+| 12345aba | 8          | aba   |
+| 123      | 3          |       |
+| aabbbbbb | 4          | x'bb' |
+| aa202020 | 4          | 20    |
+| aaaa     | 2          | 20    |
+| aaaa     | 2          | x'bb' |
++----------+------------+-------+
+(8 rows)
+
+!ok
+
+#####################################################################
+# DATE_SUB
+#
+# DATE_SUB(date_expression, INTERVAL int64_expression date_part)
+#
+# Subtracts a specified time interval from a DATE.
+#
+# DATE_SUB supports the following date_part values:
+#
+#   DAY
+#   WEEK. Equivalent to 7 DAYs.
+#   MONTH
+#   QUARTER
+#   YEAR
+#
+# Special handling is required for MONTH, QUARTER, and YEAR parts when
+# the date is at (or near) the last day of the month. If the resulting
+# month has fewer days than the original date's day, then the
+# resulting date is the last date of that month.
+#
+# Returns DATE
+
+SELECT DATE_SUB(DATE "2008-12-25", INTERVAL 5 DAY) AS five_days_ago;
++---------------+
+| five_days_ago |
++---------------+
+| 2008-12-20    |
++---------------+
+(1 row)
+
+!ok
+
+#####################################################################
+# DATETIME_SUB
+#
+# DATETIME_SUB(datetime_expression, INTERVAL int64_expression part)
+#
+# Subtracts int64_expression units of part from the DATETIME.
+#
+# DATETIME_SUB supports the following values for part:
+#   MICROSECOND
+#   MILLISECOND
+#   SECOND
+#   MINUTE
+#   HOUR
+#   DAY
+#   WEEK. Equivalent to 7 DAYs.
+#   MONTH
+#   QUARTER
+#   YEAR
+#
+# Special handling is required for MONTH, QUARTER, and YEAR parts when
+# the date is at (or near) the last day of the month. If the resulting
+# month has fewer days than the original DATETIME's day, then the
+# result day is the last day of the new month.
+#
+# Returns DATETIME
+
+SELECT
+  DATETIME "2008-12-25 15:30:00" as original_date,
+  DATETIME_SUB(DATETIME "2008-12-25 15:30:00", INTERVAL 10 MINUTE) as earlier;
++---------------------+---------------------+
+| original_date       | earlier             |
++---------------------+---------------------+
+| 2008-12-25 15:30:00 | 2008-12-25 15:20:00 |
++---------------------+---------------------+
+(1 row)
+
+!ok
+
+SELECT
+  TIMESTAMP "2008-12-25 15:30:00" as original_date,
+  DATETIME_SUB(TIMESTAMP "2008-12-25 15:30:00", INTERVAL 10 MINUTE) as earlier;
++---------------------+---------------------+
+| original_date       | earlier             |
++---------------------+---------------------+
+| 2008-12-25 15:30:00 | 2008-12-25 15:20:00 |
++---------------------+---------------------+
+(1 row)
+
+!ok
+
+
+#####################################################################
+# TIME_SUB
+#
+# TIME_SUB(time_expression, INTERVAL int64_expression part)
+#
+# Subtracts int64_expression units of part from the TIME object.
+#
+# TIME_SUB supports the following values for part:
+#
+#   MICROSECOND
+#   MILLISECOND
+#   SECOND
+#   MINUTE
+#   HOUR
+#
+# This function automatically adjusts when values fall outside of the
+# 00:00:00 to 24:00:00 boundary. For example, if you subtract an hour
+# from 00:30:00, the returned value is 23:30:00.
+#
+# Returns TIME
+
+SELECT
+  TIME "15:30:00" as original_date,
+  TIME_SUB(TIME "15:30:00", INTERVAL 10 MINUTE) as earlier;
++---------------+----------+
+| original_date | earlier  |
++---------------+----------+
+| 15:30:00      | 15:20:00 |
++---------------+----------+
+(1 row)
+
+!ok
+
+#####################################################################
+# TIMESTAMP_SUB
+#
+# TIMESTAMP_SUB(timestamp_expression, INTERVAL int64_expression date_part)
+#
+# Subtracts int64_expression units of date_part from the
+# timestamp, independent of any time zone.
+#
+# TIMESTAMP_SUB supports the following values for date_part:
+#  MICROSECOND
+#  MILLISECOND
+#  SECOND
+#  MINUTE
+#  HOUR. Equivalent to 60 MINUTEs.
+# DAY. Equivalent to 24 HOURs.
+
+# Display of results may differ, depending upon the environment and
+# time zone where this query was executed.
+
+SELECT
+  TIMESTAMP "2008-12-25 15:30:00" AS original,
+  TIMESTAMP_SUB(TIMESTAMP "2008-12-25 15:30:00", INTERVAL 10 MINUTE) AS earlier;
++---------------------+---------------------+
+| original            | earlier             |
++---------------------+---------------------+
+| 2008-12-25 15:30:00 | 2008-12-25 15:20:00 |
++---------------------+---------------------+
+(1 row)
+
+!ok
+
+#####################################################################
+# DATE_DIFF
+#
+# DATE_DIFF(date_expression_a, date_expression_b, date_part)
+#
+# Returns the whole number of specified date_part intervals between
+# two DATE objects (date_expression_a - date_expression_b). If the
+# first DATE is earlier than the second one, the output is negative.
+#
+# DATE_DIFF supports the following date_part values:
+#   DAY
+#   WEEK This date part begins on Sunday.
+#   WEEK(<WEEKDAY>): This date part begins on WEEKDAY. Valid values
+#     for WEEKDAY are SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY,
+#     FRIDAY, and SATURDAY.
+#   ISOWEEK: Uses ISO 8601 week boundaries. ISO weeks begin on Monday.
+#   MONTH, except when the first two arguments are TIMESTAMP objects.
+#   QUARTER
+#   YEAR
+#   ISOYEAR: Uses the ISO 8601 week-numbering year boundary. The ISO
+#     year boundary is the Monday of the first week whose Thursday
+#     belongs to the corresponding Gregorian calendar year.
+#
+# Returns INT64
+
+SELECT DATE_DIFF(DATE '2010-07-07', DATE '2008-12-25', DAY) AS days_diff;
++-----------+
+| days_diff |
++-----------+
+|       559 |
++-----------+
+(1 row)
+
+!ok
+
+SELECT
+  DATE_DIFF(DATE '2017-10-15', DATE '2017-10-14', DAY) AS days_diff,
+  DATE_DIFF(DATE '2017-10-15', DATE '2017-10-14', WEEK) AS weeks_diff;
++-----------+------------+
+| days_diff | weeks_diff |
++-----------+------------+
+|         1 |          1 |
++-----------+------------+
+(1 row)
+
+!ok
+
+# The example above shows the result of DATE_DIFF for two days in
+# succession. DATE_DIFF with the date part WEEK returns 1 because
+# DATE_DIFF counts the number of date part boundaries in this range of
+# dates. Each WEEK begins on Sunday, so there is one date part
+# boundary between Saturday, 2017-10-14 and Sunday, 2017-10-15.
+
+# The following example shows the result of DATE_DIFF for two dates in
+# different years. DATE_DIFF with the date part YEAR returns 3 because
+# it counts the number of Gregorian calendar year boundaries between
+# the two dates. DATE_DIFF with the date part ISOYEAR returns 2
+# because the second date belongs to the ISO year 2015. The first
+# Thursday of the 2015 calendar year was 2015-01-01, so the ISO year
+# 2015 begins on the preceding Monday, 2014-12-29.
+
+SELECT
+  DATE_DIFF('2017-12-30', '2014-12-30', YEAR) AS year_diff,
+  DATE_DIFF('2017-12-30', '2014-12-30', ISOYEAR) AS isoyear_diff;
++-----------+--------------+
+| year_diff | isoyear_diff |
++-----------+--------------+
+|         3 |            2 |
++-----------+--------------+
+(1 row)
+
+!ok
+
+# The following example shows the result of DATE_DIFF for two days in
+# succession. The first date falls on a Monday and the second date
+# falls on a Sunday. DATE_DIFF with the date part WEEK returns 0
+# because this date part uses weeks that begin on Sunday. DATE_DIFF
+# with the date part WEEK(MONDAY) returns 1. DATE_DIFF with the date
+# part ISOWEEK also returns 1 because ISO weeks begin on Monday.
+
+SELECT
+  DATE_DIFF('2017-12-18', '2017-12-17', WEEK) AS week_diff,
+  DATE_DIFF('2017-12-18', '2017-12-17', WEEK(MONDAY)) AS week_weekday_diff,
+  DATE_DIFF('2017-12-18', '2017-12-17', ISOWEEK) AS isoweek_diff;
++-----------+-------------------+--------------+
+| week_diff | week_weekday_diff | isoweek_diff |
++-----------+-------------------+--------------+
+|         0 |                 1 |            1 |
++-----------+-------------------+--------------+
+(1 row)
+
+!ok
+
+#####################################################################
+# DATETIME_DIFF
+#
+# DATETIME_DIFF(datetime_expression_a, datetime_expression_b, part)
+#
+# Returns the whole number of specified part intervals between two
+# DATETIME objects (datetime_expression_a - datetime_expression_b). If
+# the first DATETIME is earlier than the second one, the output is
+# negative. Throws an error if the computation overflows the result
+# type, such as if the difference in microseconds between the two
+# DATETIME objects would overflow an INT64 value.
+#
+# DATETIME_DIFF supports the following values for part:
+#
+#   MICROSECOND
+#   MILLISECOND
+#   SECOND
+#   MINUTE
+#   HOUR
+#   DAY
+#   WEEK: This date part begins on Sunday.
+#   WEEK(<WEEKDAY>): This date part begins on WEEKDAY. Valid values
+#     for WEEKDAY are SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY,
+#     FRIDAY, and SATURDAY.
+#   ISOWEEK: Uses ISO 8601 week boundaries. ISO weeks begin on Monday.
+#   MONTH, except when the first two arguments are TIMESTAMP objects.
+#   QUARTER
+#   YEAR
+#   ISOYEAR: Uses the ISO 8601 week-numbering year boundary. The ISO
+#     year boundary is the Monday of the first week whose Thursday
+#     belongs to the corresponding Gregorian calendar year.
+#
+# Returns INT64
+
+SELECT
+  DATETIME "2010-07-07 10:20:00" as first_datetime,
+  DATETIME "2008-12-25 15:30:00" as second_datetime,
+  DATETIME_DIFF(DATETIME "2010-07-07 10:20:00",
+    DATETIME "2008-12-25 15:30:00", DAY) as difference;
++---------------------+---------------------+------------+
+| first_datetime      | second_datetime     | difference |
++---------------------+---------------------+------------+
+| 2010-07-07 10:20:00 | 2008-12-25 15:30:00 |        559 |
++---------------------+---------------------+------------+
+(1 row)
+
+!ok
+
+SELECT
+  DATETIME_DIFF(DATETIME '2017-10-15 00:00:00',
+    DATETIME '2017-10-14 00:00:00', DAY) as days_diff,
+  DATETIME_DIFF(DATETIME '2017-10-15 00:00:00',
+    DATETIME '2017-10-14 00:00:00', WEEK) as weeks_diff;
++-----------+------------+
+| days_diff | weeks_diff |
++-----------+------------+
+|         1 |          1 |
++-----------+------------+
+(1 row)
+
+!ok
+
+# The example above shows the result of DATETIME_DIFF for two
+# DATETIMEs that are 24 hours apart. DATETIME_DIFF with the part WEEK
+# returns 1 because DATETIME_DIFF counts the number of part boundaries
+# in this range of DATETIMEs. Each WEEK begins on Sunday, so there is
+# one part boundary between Saturday, 2017-10-14 00:00:00 and Sunday,
+# 2017-10-15 00:00:00.
+#
+# The following example shows the result of DATETIME_DIFF for two
+# dates in different years. DATETIME_DIFF with the date part YEAR
+# returns 3 because it counts the number of Gregorian calendar year
+# boundaries between the two DATETIMEs. DATETIME_DIFF with the date
+# part ISOYEAR returns 2 because the second DATETIME belongs to the
+# ISO year 2015. The first Thursday of the 2015 calendar year was
+# 2015-01-01, so the ISO year 2015 begins on the preceding Monday,
+# 2014-12-29.
+
+SELECT
+  DATETIME_DIFF('2017-12-30 00:00:00',
+    '2014-12-30 00:00:00', YEAR) AS year_diff,
+  DATETIME_DIFF('2017-12-30 00:00:00',
+    '2014-12-30 00:00:00', ISOYEAR) AS isoyear_diff;
++-----------+--------------+
+| year_diff | isoyear_diff |
++-----------+--------------+
+|         3 |            2 |
++-----------+--------------+
+(1 row)
+
+!ok
+
+# The following example shows the result of DATETIME_DIFF for two days
+# in succession. The first date falls on a Monday and the second date
+# falls on a Sunday. DATETIME_DIFF with the date part WEEK returns 0
+# because this time part uses weeks that begin on
+# Sunday. DATETIME_DIFF with the date part WEEK(MONDAY) returns
+# 1. DATETIME_DIFF with the date part ISOWEEK also returns 1 because
+# ISO weeks begin on Monday.
+
+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,
+  DATETIME_DIFF('2017-12-18', '2017-12-17', ISOWEEK) AS isoweek_diff;
++-----------+-------------------+--------------+
+| week_diff | week_weekday_diff | isoweek_diff |
++-----------+-------------------+--------------+
+|         0 |                 1 |            1 |
++-----------+-------------------+--------------+
+(1 row)
+
+!ok
+
+#####################################################################
+# TIME_DIFF
+#
+# TIME_DIFF(time_expression_a, time_expression_b, part)
+#
+# Returns the whole number of specified part intervals between two
+# TIME objects (time_expression_a - time_expression_b). If the first
+# TIME is earlier than the second one, the output is negative. Throws
+# an error if the computation overflows the result type, such as if
+# the difference in microseconds between the two TIME objects would
+# overflow an INT64 value.
+#
+# TIME_DIFF supports the following values for part:
+#   MICROSECOND
+#   MILLISECOND
+#   SECOND
+#   MINUTE
+#   HOUR
+#
+# Returns INT64
+
+SELECT
+  TIME "15:30:00" as first_time,
+  TIME "14:35:00" as second_time,
+  TIME_DIFF(TIME "15:30:00", TIME "14:35:00", MINUTE) as difference;
++------------+-------------+------------+
+| first_time | second_time | difference |
++------------+-------------+------------+
+| 15:30:00   | 14:35:00    |         55 |
++------------+-------------+------------+
+(1 row)
+
+!ok
+
+#####################################################################
+# TIMESTAMP_DIFF
+#
+# TIMESTAMP_DIFF(timestamp_expression_a, timestamp_expression_b, date_part)
+#
+# Returns the whole number of specified date_part intervals
+# between two TIMESTAMP objects (timestamp_expression_a -
+# timestamp_expression_b). If the first TIMESTAMP is earlier
+# than the second one, the output is negative. Throws an
+# error if the computation overflows the result type, such
+# as if the difference in microseconds between the two
+# TIMESTAMP objects would overflow an INT64 value.
+#
+# TIMESTAMP_DIFF supports the following values for date_part:
+#  MICROSECOND
+#  MILLISECOND
+#  SECOND
+#  MINUTE
+#  HOUR. Equivalent to 60 MINUTEs.
+#  DAY. Equivalent to 24 HOURs.
+
+# Display of results may differ, depending upon the environment and
+# time zone where this query was executed.
+SELECT
+  TIMESTAMP "2010-07-07 10:20:00" AS later_timestamp,
+  TIMESTAMP "2008-12-25 15:30:00" AS earlier_timestamp,
+  TIMESTAMP_DIFF(TIMESTAMP "2010-07-07 10:20:00", TIMESTAMP "2008-12-25 15:30:00", HOUR) AS hours;
++---------------------+---------------------+-------+
+| later_timestamp     | earlier_timestamp   | hours |
++---------------------+---------------------+-------+
+| 2010-07-07 10:20:00 | 2008-12-25 15:30:00 | 13410 |
++---------------------+---------------------+-------+
+(1 row)
+
+!ok
+
+# In the following example, the first timestamp occurs
+# before the second timestamp, resulting in a negative output.
+SELECT TIMESTAMP_DIFF(TIMESTAMP "2018-08-14", TIMESTAMP "2018-10-14", DAY) AS negative_diff;
++---------------+
+| negative_diff |
++---------------+
+|           -61 |
++---------------+
+(1 row)
+
+!ok
+
+# In this example, the result is 0 because only the number
+# of whole specified HOUR intervals are included.
+SELECT TIMESTAMP_DIFF("2001-02-01 01:00:00", "2001-02-01 00:00:01", HOUR) AS negative_diff;
++---------------+
+| negative_diff |
++---------------+
+|             0 |
++---------------+
+(1 row)
+
+!ok
+
+# In this example, the time unit is a 'flag' literal.
+SELECT TIMESTAMP_DIFF(TIMESTAMP '2008-12-25', TIMESTAMP '2008-09-25', `quarter`) as diff;
++------+
+| diff |
++------+
+|    1 |
++------+
+(1 row)
+
+!ok
+#####################################################################
+# DATE_TRUNC
+#
+# DATE_TRUNC(date_expression, date_part)
+#
+# Truncates a DATE value to the granularity of date_part. The DATE
+# value is always rounded to the beginning of date_part, which can be
+# one of the following:
+#   DAY: The day in the Gregorian calendar year that contains the DATE
+#     value.
+#   WEEK: The first day of the week in the week that contains the DATE
+#     value. Weeks begin on Sundays. WEEK is equivalent to
+#     WEEK(SUNDAY).
+#   WEEK(WEEKDAY): The first day of the week in the week that contains
+#     the DATE value. Weeks begin on WEEKDAY. WEEKDAY must be one of
+#     the following: SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY,
+#     FRIDAY, or SATURDAY.
+#   ISOWEEK: The first day of the ISO 8601 week in the ISO week that
+#     contains the DATE value. The ISO week begins on Monday. The
+#     first ISO week of each ISO year contains the first Thursday of
+#     the corresponding Gregorian calendar year.
+#   MONTH: The first day of the month in the month that contains the
+#     DATE value.
+#   QUARTER: The first day of the quarter in the quarter that contains
+#     the DATE value.
+#   YEAR: The first day of the year in the year that contains the DATE
+#     value.
+#   ISOYEAR: The first day of the ISO 8601 week-numbering year in the
+#     ISO year that contains the DATE value. The ISO year is the
+#     Monday of the first week whose Thursday belongs to the
+#     corresponding Gregorian calendar year.
+#
+# Returns DATE
+WITH Dates AS (
+  SELECT DATE_TRUNC(DATE '2008-12-25', YEAR) as d , "year" as frame UNION ALL
+  SELECT DATE_TRUNC(DATE '2008-12-25', ISOYEAR), "isoyear" UNION ALL
+  SELECT DATE_TRUNC(DATE '2008-12-25', QUARTER), "quarter" UNION ALL
+  SELECT DATE_TRUNC(DATE '2008-12-25', MONTH), "month" UNION ALL
+  SELECT DATE_TRUNC(DATE '2008-12-25', WEEK), "week" UNION ALL
+  SELECT DATE_TRUNC(DATE '2008-12-25', WEEK(SUNDAY)), "week(sunday)" UNION ALL
+  SELECT DATE_TRUNC(DATE '2008-12-25', WEEK(MONDAY)), "week(monday)" UNION ALL
+  SELECT DATE_TRUNC(DATE '2008-12-25', WEEK(TUESDAY)), "week(tuesday)" UNION ALL
+  SELECT DATE_TRUNC(DATE '2008-12-25', ISOWEEK), "isoweek" UNION ALL
+  SELECT DATE_TRUNC(DATE '2008-12-25', DAY), "day"
+)
+SELECT
+  *
+FROM Dates;
++------------+---------------+
+| d          | frame         |
++------------+---------------+
+| 2008-01-01 | year          |
+| 2007-12-31 | isoyear       |
+| 2008-10-01 | quarter       |
+| 2008-12-01 | month         |
+| 2008-12-21 | week          |
+| 2008-12-21 | week(sunday)  |
+| 2008-12-22 | week(monday)  |
+| 2008-12-23 | week(tuesday) |
+| 2008-12-22 | isoweek       |
+| 2008-12-25 | day           |
++------------+---------------+
+(10 rows)
+
+!ok
+
+# In the following example, the original date falls on a
+# Sunday. Because the date_part is WEEK(MONDAY), DATE_TRUNC returns
+# the DATE for the preceding Monday.
+
+!if (false) {
+SELECT date AS original, DATE_TRUNC(date, WEEK(MONDAY)) AS truncated
+FROM (SELECT DATE('2017-11-05') AS date);
++------------+------------+
+| original   | truncated  |
++------------+------------+
+| 2017-11-05 | 2017-10-30 |
++------------+------------+
+!ok
+!}
+
+# In the following example, the original date_expression is in the
+# Gregorian calendar year 2015. However, DATE_TRUNC with the ISOYEAR
+# date part truncates the date_expression to the beginning of the ISO
+# year, not the Gregorian calendar year. The first Thursday of the
+# 2015 calendar year was 2015-01-01, so the ISO year 2015 begins on
+# the preceding Monday, 2014-12-29. Therefore the ISO year boundary
+# preceding the date_expression 2015-06-15 is 2014-12-29.
+
+!if (false) {
+SELECT
+  DATE_TRUNC('2015-06-15', ISOYEAR) AS isoyear_boundary,
+  EXTRACT(ISOYEAR FROM DATE '2015-06-15') AS isoyear_number;
++------------------+----------------+
+| isoyear_boundary | isoyear_number |
++------------------+----------------+
+| 2014-12-29       | 2015           |
++------------------+----------------+
+!ok
+!}
+
+#####################################################################
+# DATETIME_TRUNC
+#
+# DATETIME_TRUNC(datetime_expression, date_time_part)
+#
+# Truncates a DATETIME value to the granularity of date_time_part. The
+# DATETIME value is always rounded to the beginning of date_time_part,
+# which can be one of the following:
+#
+#   MICROSECOND: If used, nothing is truncated from the value.
+#   MILLISECOND: The nearest lessor or equal millisecond.
+#   SECOND: The nearest lessor or equal second.
+#   MINUTE: The nearest lessor or equal minute.
+#   HOUR: The nearest lessor or equal hour.
+#   DAY: The day in the Gregorian calendar year that contains the
+#     DATETIME value.
+#   WEEK: The first day of the week in the week that contains the
+#     DATETIME value. Weeks begin on Sundays. WEEK is equivalent to
+#     WEEK(SUNDAY).
+#   WEEK(WEEKDAY): The first day of the week in the week that contains
+#     the DATETIME value. Weeks begin on WEEKDAY. WEEKDAY must be one
+#     of the following: SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY,
+#     FRIDAY, or SATURDAY.
+#   ISOWEEK: The first day of the ISO 8601 week in the ISO week that
+#     contains the DATETIME value. The ISO week begins on Monday. The
+#     first ISO week of each ISO year contains the first Thursday of
+#     the corresponding Gregorian calendar year.
+#   MONTH: The first day of the month in the month that contains the
+#     DATETIME value.
+#   QUARTER: The first day of the quarter in the quarter that contains
+#     the DATETIME value.
+#   YEAR: The first day of the year in the year that contains the
+#     DATETIME value.
+#   ISOYEAR: The first day of the ISO 8601 week-numbering year in the
+#     ISO year that contains the DATETIME value. The ISO year is the
+#     Monday of the first week whose Thursday belongs to the
+#     corresponding Gregorian calendar year.
+#
+# Returns DATETIME
+
+
+SELECT
+  DATETIME "2008-12-25 15:30:00" as original,
+  DATETIME_TRUNC(DATETIME "2008-12-25 15:30:00", DAY) as truncated;
++---------------------+---------------------+
+| original            | truncated           |
++---------------------+---------------------+
+| 2008-12-25 15:30:00 | 2008-12-25 00:00:00 |
++---------------------+---------------------+
+(1 row)
+
+!ok
+
+
+# In the following example, the original DATETIME falls on a
+# Sunday. Because the part is WEEK(MONDAY), DATE_TRUNC returns the
+# DATETIME for the preceding Monday.
+
+!if (false) {
+SELECT
+ datetime AS original,
+ DATETIME_TRUNC(datetime, WEEK(MONDAY)) AS truncated
+FROM (SELECT DATETIME(TIMESTAMP "2017-11-05 00:00:00+00", "UTC") AS datetime);
++---------------------+---------------------+
+| original            | truncated           |
++---------------------+---------------------+
+| 2017-11-05T00:00:00 | 2017-10-30T00:00:00 |
++---------------------+---------------------+
+!ok
+!}
+
+# In the following example, the original datetime_expression is in the
+# Gregorian calendar year 2015. However, DATETIME_TRUNC with the
+# ISOYEAR date part truncates the datetime_expression to the beginning
+# of the ISO year, not the Gregorian calendar year. The first Thursday
+# of the 2015 calendar year was 2015-01-01, so the ISO year 2015
+# begins on the preceding Monday, 2014-12-29. Therefore the ISO year
+# boundary preceding the datetime_expression 2015-06-15 00:00:00 is
+# 2014-12-29.
+
+!if (false) {
+SELECT
+  DATETIME_TRUNC('2015-06-15 00:00:00', ISOYEAR) AS isoyear_boundary,
+  EXTRACT(ISOYEAR FROM DATETIME '2015-06-15 00:00:00') AS isoyear_number;
++---------------------+----------------+
+| isoyear_boundary    | isoyear_number |
++---------------------+----------------+
+| 2014-12-29T00:00:00 | 2015           |
++---------------------+----------------+
+!ok
+!}
+
+#####################################################################
+# TIME_TRUNC
+#
+# TIME_TRUNC(time_expression, time_part)
+#
+# Truncates a TIME value to the granularity of time_part. The TIME
+# value is always rounded to the beginning of time_part, which can be
+# one of the following:
+#
+#   MICROSECOND: If used, nothing is truncated from the value.
+#   MILLISECOND: The nearest lessor or equal millisecond.
+#   SECOND: The nearest lessor or equal second.
+#   MINUTE: The nearest lessor or equal minute.
+#   HOUR: The nearest lessor or equal hour.
+#
+# Returns TIME
+
+SELECT
+  TIME "15:30:00" as original,
+  TIME_TRUNC(TIME "15:30:00", HOUR) as truncated;
++----------+-----------+
+| original | truncated |
++----------+-----------+
+| 15:30:00 | 15:00:00  |
++----------+-----------+
+(1 row)
+
+!ok
+
+#####################################################################
+# TIMESTAMP_TRUNC
+#
+# TIMESTAMP_TRUNC(timestamp_expression, date_time_part[, time_zone])
+#
+# Truncates a TIMESTAMP value to the granularity of
+# date_time_part. The TIMESTAMP value is always rounded to
+# the beginning of date_time_part, which can be one of the following:
+#  MICROSECOND: If used, nothing is truncated from the value.
+#  MILLISECOND: The nearest lessor or equal millisecond.
+#  SECOND: The nearest lessor or equal second.
+#  MINUTE: The nearest lessor or equal minute.
+#  HOUR: The nearest lessor or equal hour.
+#  DAY: The day in the Gregorian calendar year that contains the
+#    TIMESTAMP value.
+#  WEEK: The first day of the week in the week that contains the
+#    TIMESTAMP value. Weeks begin on Sundays. WEEK is equivalent to
+#    WEEK(SUNDAY).
+#  WEEK(WEEKDAY): The first day of the week in the week that contains
+#    the TIMESTAMP value. Weeks begin on WEEKDAY. WEEKDAY must be one
+#    of the following: SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY,
+#    FRIDAY, or SATURDAY.
+#  ISOWEEK: The first day of the ISO 8601 week in the ISO week that
+#    contains the TIMESTAMP value. The ISO week begins on Monday.
+#    The first ISO week of each ISO year contains the first Thursday
+#    of the corresponding Gregorian calendar year.
+#  MONTH: The first day of the month in the month that contains the
+#    TIMESTAMP value.
+#  QUARTER: The first day of the quarter in the quarter that contains
+#    the TIMESTAMP value.
+#  YEAR: The first day of the year in the year that contains the
+#    TIMESTAMP value.
+#  ISOYEAR: The first day of the ISO 8601 week-numbering year in the
+#    ISO year that contains the TIMESTAMP value. The ISO year is the
+#    Monday of the first week whose Thursday belongs to the
+#    corresponding Gregorian calendar year.
+#
+# TIMESTAMP_TRUNC function supports an optional time_zone parameter.
+# This parameter applies to the following date_time_part:
+#  MINUTE
+#  HOUR
+#  DAY
+#  WEEK
+#  WEEK(<WEEKDAY>)
+#  ISOWEEK
+#  MONTH
+#  QUARTER
+#  YEAR
+#  ISOYEAR
+#
+# Use this parameter if you want to use a time zone other than the
+# default time zone, UTC, as part of the truncate operation.
+#
+# When truncating a TIMESTAMP to MINUTE or HOUR, TIMESTAMP_TRUNC
+# determines the civil time of the TIMESTAMP in the specified (or
+# default) time zone and subtracts the minutes and seconds (when
+# truncating to HOUR) or the seconds (when truncating to MINUTE) from
+# that TIMESTAMP. While this provides intuitive results in most cases,
+# the result is non-intuitive near daylight savings transitions that
+# are not hour aligned.
+
+# Display of results may differ, depending upon the environment and
+# time zone where this query was executed.
+!if (false) {
+SELECT
+  TIMESTAMP_TRUNC(TIMESTAMP "2008-12-25 15:30:00+00", DAY, "UTC") AS utc,
+  TIMESTAMP_TRUNC(TIMESTAMP "2008-12-25 15:30:00+00", DAY, "America/Los_Angeles") AS la;
++-------------------------+-----------------=-------+
+| utc                     | la                      |
++-------------------------+-------------------------+
+| 2008-12-25 00:00:00 UTC | 2008-12-25 08:00:00 UTC |
++-------------------------+-------------------------+
+!ok
+!}
+
+# In the following example, timestamp_expression has a time zone
+# offset of +12. The first column shows the timestamp_expression in
+# UTC time. The second column shows the output of TIMESTAMP_TRUNC
+# using weeks that start on Monday. Because the timestamp_expression
+# falls on a Sunday in UTC, TIMESTAMP_TRUNC truncates it to the
+# preceding Monday. The third column shows the same function with the
+# optional Time zone definition argument 'Pacific/Auckland'. Here the
+# function truncates the timestamp_expression using New Zealand
+# Daylight Time, where it falls on a Monday.
+
+# Display of results may differ, depending upon the environment and
+# time zone where this query was executed.
+!if (false) {
+SELECT
+  timestamp_value AS timestamp_value,
+  TIMESTAMP_TRUNC(timestamp_value, WEEK(MONDAY), "UTC") AS utc_truncated,
+  TIMESTAMP_TRUNC(timestamp_value, WEEK(MONDAY), "Pacific/Auckland") AS nzdt_truncated
+FROM (SELECT TIMESTAMP("2017-11-06 00:00:00+12") AS timestamp_value);
++-------------------------+-------------------------+-------------------------+
+| timestamp_value         | utc_truncated           | nzdt_truncated          |
++-------------------------+-------------------------+-------------------------+
+| 2017-11-05 12:00:00 UTC | 2017-10-30 00:00:00 UTC | 2017-11-05 11:00:00 UTC |
++-------------------------+-------------------------+-------------------------+
+!ok
+!}
+
+# In the following example, the original timestamp_expression is in
+# the Gregorian calendar year 2015. However, TIMESTAMP_TRUNC with the
+# ISOYEAR date part truncates the timestamp_expression to the
+# beginning of the ISO year, not the Gregorian calendar year. The
+# first Thursday of the 2015 calendar year was 2015-01-01, so the ISO
+# year 2015 begins on the preceding Monday, 2014-12-29. Therefore the
+# ISO year boundary preceding the timestamp_expression 2015-06-15
+# 00:00:00+00 is 2014-12-29.
+
+# Display of results may differ, depending upon the environment and
+# time zone where this query was executed.
+!if (false) {
+SELECT
+  TIMESTAMP_TRUNC("2015-06-15 00:00:00+00", ISOYEAR) AS isoyear_boundary,
+  EXTRACT(ISOYEAR FROM TIMESTAMP "2015-06-15 00:00:00+00") AS isoyear_number;
++-------------------------+----------------+
+| isoyear_boundary        | isoyear_number |
++-------------------------+----------------+
+| 2014-12-29 00:00:00 UTC | 2015           |
++-------------------------+----------------+
+!ok
+!}
+
+#####################################################################
+# LAST_DAY
+#
+# LAST_DAY(datetime_expression[, date_part])
+#
+# Returns the last day from a datetime expression that contains the
+# date. This is commonly used to return the last day of the month.
+#
+# You can optionally specify the date part for which the last day is
+# returned. If this parameter is not used, the default value is
+# MONTH. LAST_DAY supports the following values for date_part:
+#
+#   YEAR
+#   QUARTER
+#   MONTH
+#   WEEK. Equivalent to 7 DAYs.
+#   WEEK(<WEEKDAY>). <WEEKDAY> represents the starting day of the
+#     week. Valid values are SUNDAY, MONDAY, TUESDAY, WEDNESDAY,
+#     THURSDAY, FRIDAY, and SATURDAY.
+#   ISOWEEK. Uses ISO 8601 week boundaries. ISO weeks begin on Monday.
+#   ISOYEAR. Uses the ISO 8601 week-numbering year boundary. The ISO
+#     year boundary is the Monday of the first week whose Thursday
+#     belongs to the corresponding Gregorian calendar year.
+#
+# Returns DATE
+#
+# These both return the last day of the month:
+
+!if (false) {
+SELECT LAST_DAY(DATETIME '2008-11-25', MONTH) AS last_day;
++------------+
+| last_day   |
++------------+
+| 2008-11-30 |
++------------+
+!ok
+!}
+
+!if (false) {
+SELECT LAST_DAY(DATETIME '2008-11-25') AS last_day;
++------------+
+| last_day   |
++------------+
+| 2008-11-30 |
++------------+
+!ok
+!}
+
+# This returns the last day of the year:
+!if (false) {
+SELECT LAST_DAY(DATETIME '2008-11-25 15:30:00', YEAR) AS last_day;
++------------+
+| last_day   |
++------------+
+| 2008-12-31 |
++------------+
+!ok
+!}
+
+# This returns the last day of the week for a week that starts on a
+# Sunday:
+!if (false) {
+SELECT LAST_DAY(DATETIME '2008-11-10 15:30:00', WEEK(SUNDAY)) AS last_day;
++------------+
+| last_day   |
++------------+
+| 2008-11-15 |
++------------+
+!ok
+!}
+
+# This returns the last day of the week for a week that starts on a
+# Monday:
+!if (false) {
+SELECT LAST_DAY(DATETIME '2008-11-10 15:30:00', WEEK(MONDAY)) AS last_day;
++------------+
+| last_day   |
++------------+
+| 2008-11-16 |
++------------+
+!ok
+!}
+
+#####################################################################
+#
+# IFNULL(value1, value2)
+#
+# Returns value1 if not NULL, else value2
+#
+WITH items AS (
+  SELECT 'IFNULL(null, 5)' question, IFNULL(null, 5) AS answer UNION ALL
+  SELECT 'IFNULL(2, 1)', IFNULL(2, 1) UNION ALL
+  SELECT "IFNULL('b', null)", IFNULL('b', null) UNION ALL
+  SELECT 'IFNULL(null, null)', IFNULL(null, null)
+)
+SELECT * FROM items;
++--------------------+--------+
+| question           | answer |
++--------------------+--------+
+| IFNULL(null, 5)    | 5      |
+| IFNULL(2, 1)       | 2      |
+| IFNULL('b', null)  | b      |
+| IFNULL(null, null) |        |
++--------------------+--------+
+(4 rows)
+
+!ok
+
+#####################################################################
+# FORMAT_DATE
+#
+# FORMAT_DATE(format_string, date_expr)
+#
+# Formats the date_expr according to the specified format_string.
+#
+# See Supported Format Elements For DATE for a list of format elements
+# that this function supports.
+#
+# Returns STRING
+
+SELECT FORMAT_DATE("%x", DATE "2008-12-25") AS US_format;
++-----------+
+| US_format |
++-----------+
+| 12/25/08  |
++-----------+
+(1 row)
+
+!ok
+
+SELECT FORMAT_DATE("%b-%d-%Y", DATE "2008-12-25") AS formatted;
++-------------+
+| formatted   |
++-------------+
+| Dec-25-2008 |
++-------------+
+(1 row)
+
+!ok
+
+SELECT FORMAT_DATE("%b %Y", DATE "2008-12-25") AS formatted;
++-----------+
+| formatted |
++-----------+
+| Dec 2008  |
++-----------+
+(1 row)
+
+!ok
+
+#####################################################################
+# FORMAT_DATETIME
+#
+# FORMAT_DATETIME(format_string, datetime_expression)
+# Formats a DATETIME object according to the specified
+# format_string. See Supported Format Elements For DATETIME for a list
+# of format elements that this function supports.
+#
+# Returns STRING
+
+SELECT
+  FORMAT_DATETIME("%c", DATETIME "2008-12-25 15:30:00")
+  AS formatted;
++--------------------------+
+| formatted                |
++--------------------------+
+| Thu Dec 25 15:30:00 2008 |
++--------------------------+
+(1 row)
+
+!ok
+
+SELECT
+  FORMAT_DATETIME("%b-%d-%Y", DATETIME "2008-12-25 15:30:00")
+  AS formatted;
++-------------+
+| formatted   |
++-------------+
+| Dec-25-2008 |
++-------------+
+(1 row)
+
+!ok
+
+SELECT
+  FORMAT_DATETIME("%b %Y", DATETIME "2008-12-25 15:30:00")
+  AS formatted;
++-----------+
+| formatted |
++-----------+
+| Dec 2008  |
++-----------+
+(1 row)
+
+!ok
+
+#####################################################################
+# FORMAT_TIME
+#
+# FORMAT_TIME(format_string, time_object)
+#
+# Formats a TIME object according to the specified format_string. See
+# Supported Format Elements For TIME for a list of format elements
+# that this function supports.
+#
+# Returns STRING
+
+SELECT FORMAT_TIME("%R", TIME "15:30:00") as formatted_time;
++----------------+
+| formatted_time |
++----------------+
+| 15:30          |
++----------------+
+(1 row)
+
+!ok
+
+#####################################################################
+# FORMAT_TIMESTAMP
+#
+# FORMAT_TIMESTAMP(format_string, timestamp[, time_zone])
+#
+#
+# Formats a timestamp according to the specified format_string.
+#
+# See Supported Format Elements For TIMESTAMP for a list of format
+# elements that this function supports.
+
+SELECT FORMAT_TIMESTAMP("%c", TIMESTAMP "2008-12-25 15:30:00" /* TODO should be "2008-12-25 15:30:00+00" */, "UTC") AS formatted;
++--------------------------+
+| formatted                |
++--------------------------+
+| Thu Dec 25 15:30:00 2008 |
++--------------------------+
+(1 row)
+
+!ok
+
+SELECT FORMAT_TIMESTAMP("%b-%d-%Y", TIMESTAMP "2008-12-25 15:30:00" /* TODO should be "2008-12-25 15:30:00+00" */) AS formatted;
++-------------+
+| formatted   |
++-------------+
+| Dec-25-2008 |
++-------------+
+(1 row)
+
+!ok
+
+SELECT FORMAT_TIMESTAMP("%b %Y", TIMESTAMP "2008-12-25 15:30:00" /* TODO should be "2008-12-25 15:30:00+00" */)
+  AS formatted;
++-----------+
+| formatted |
++-----------+
+| Dec 2008  |
++-----------+
+(1 row)
+
+!ok
+
+#####################################################################
+# PARSE_DATE
+#
+# PARSE_DATE(format_string, date_string)
+#
+# Converts a string representation of date to a DATE object.
+#
+# format_string contains the format elements that define how
+# date_string is formatted. Each element in date_string must have a
+# corresponding element in format_string. The location of each element
+# in format_string must match the location of each element in
+# date_string.
+
+!if (false) {
+# This works because elements on both sides match.
+SELECT PARSE_DATE("%A %b %e %Y", "Thursday Dec 25 2008");
+!ok
+!}
+
+!if (false) {
+# This doesn't work because the year element is in different locations.
+SELECT PARSE_DATE("%Y %A %b %e", "Thursday Dec 25 2008");
+!error
+!}
+
+!if (false) {
+# This doesn't work because one of the year elements is missing.
+SELECT PARSE_DATE("%A %b %e", "Thursday Dec 25 2008");
+!error
+!}
+
+!if (false) {
+# This works because %F can find all matching elements in date_string.
+SELECT PARSE_DATE("%F", "2000-12-30");
+!ok
+!}
+
+# When using PARSE_DATE, keep the following in mind:
+#
+# Unspecified fields. Any unspecified field is initialized from
+#   1970-01-01.
+# Case insensitivity. Names, such as Monday, February, and so on, are
+#   case insensitive.
+# Whitespace. One or more consecutive white spaces in the format
+#   string matches zero or more consecutive white spaces in the date
+#   string. In addition, leading and trailing white spaces in the date
+#   string are always allowed -- even if they are not in the format
+#   string.
+# Format precedence. When two (or more) format elements have
+#   overlapping information (for example both %F and %Y affect the
+#   year), the last one generally overrides any earlier ones.
+#
+# Returns DATE
+
+# This example converts a MM/DD/YY formatted string to a DATE object:
+
+!if (false) {
+SELECT PARSE_DATE("%x", "12/25/08") AS parsed;
++------------+
+| parsed     |
++------------+
+| 2008-12-25 |
++------------+
+!ok
+!}
+
+# This example converts a YYYYMMDD formatted string to a DATE object:
+
+!if (false) {
+SELECT PARSE_DATE("%Y%m%d", "20081225") AS parsed;
++------------+
+| parsed     |
++------------+
+| 2008-12-25 |
++------------+
+!ok
+!}
+
+#####################################################################
+# PARSE_DATETIME
+#
+# PARSE_DATETIME(format_string, datetime_string)
+#
+# Converts a string representation of a datetime to a DATETIME object.
+#
+# format_string contains the format elements that define how
+# datetime_string is formatted. Each element in datetime_string must
+# have a corresponding element in format_string. The location of each
+# element in format_string must match the location of each element in
+# datetime_string.
+
+# This works because elements on both sides match.
+!if (false) {
+SELECT PARSE_DATETIME("%a %b %e %I:%M:%S %Y", "Thu Dec 25 07:30:00 2008");
+!ok
+!}
+
+# This doesn't work because the year element is in different locations.
+!if (false) {
+SELECT PARSE_DATETIME("%a %b %e %Y %I:%M:%S", "Thu Dec 25 07:30:00 2008");
+!error
+!}
+
+# This doesn't work because one of the year elements is missing.
+!if (false) {
+SELECT PARSE_DATETIME("%a %b %e %I:%M:%S", "Thu Dec 25 07:30:00 2008");
+!error
+!}
+
+# This works because %c can find all matching elements in datetime_string.
+!if (false) {
+SELECT PARSE_DATETIME("%c", "Thu Dec 25 07:30:00 2008");
+!ok
+!}
+
+# The format string fully supports most format elements, except for %P.
+#
+# PARSE_DATETIME parses string according to the following rules:
+#   Unspecified fields. Any unspecified field is initialized from
+#     1970-01-01 00:00:00.0. For example, if the year is unspecified
+#     then it defaults to 1970.
+#   Case insensitivity. Names, such as Monday and February, are case
+#     insensitive.
+#   Whitespace. One or more consecutive white spaces in the format
+#     string matches zero or more consecutive white spaces in the
+#     DATETIME string. Leading and trailing white spaces in the
+#     DATETIME string are always allowed, even if they are not in the
+#     format string.
+#   Format precedence. When two or more format elements have
+#     overlapping information, the last one generally overrides any
+#     earlier ones, with some exceptions. For example, both %F and %Y
+#     affect the year, so the earlier element overrides the later. See
+#     the descriptions of %s, %C, and %y in Supported Format Elements
+#     For DATETIME.
+#   Format divergence. %p can be used with am, AM, pm, and PM.
+#
+# Returns DATETIME
+
+# The following examples parse a STRING literal as a DATETIME.
+
+!if (false) {
+SELECT PARSE_DATETIME('%Y-%m-%d %H:%M:%S', '1998-10-18 13:45:55') AS datetime;
++---------------------+
+| datetime            |
++---------------------+
+| 1998-10-18T13:45:55 |
++---------------------+
+!ok
+!}
+
+!if (false) {
+SELECT PARSE_DATETIME('%m/%d/%Y %I:%M:%S %p', '8/30/2018 2:23:38 pm') AS datetime
++---------------------+
+| datetime            |
++---------------------+
+| 2018-08-30T14:23:38 |
++---------------------+
+!ok
+!}
+
+# The following example parses a STRING literal containing a date in a
+# natural language format as a DATETIME.
+
+!if (false) {
+SELECT PARSE_DATETIME('%A, %B %e, %Y','Wednesday, December 19, 2018')
+  AS datetime;
++---------------------+
+| datetime            |
++---------------------+
+| 2018-12-19T00:00:00 |
++---------------------+
+!ok
+!}
+
+#####################################################################
+# PARSE_TIME
+#
+# PARSE_TIME(format_string, time_string)
+#
+# Converts a string representation of time to a TIME object.
+#
+# format_string contains the format elements that define how
+# time_string is formatted. Each element in time_string must have a
+# corresponding element in format_string. The location of each element
+# in format_string must match the location of each element in
+# time_string.
+#
+
+!if (false) {
+# This works because elements on both sides match.
+SELECT PARSE_TIME("%I:%M:%S", "07:30:00");
+!ok
+!}
+
+!if (false) {
+# This doesn't work because the seconds element is in different locations.
+SELECT PARSE_TIME("%S:%I:%M", "07:30:00");
+!error
+!}
+
+!if (false) {
+# This doesn't work because one of the seconds elements is missing.
+SELECT PARSE_TIME("%I:%M", "07:30:00");
+!error
+!}
+
+!if (false) {
+# This works because %T can find all matching elements in time_string.
+SELECT PARSE_TIME("%T", "07:30:00");
+!ok
+!}
+
+# The format string fully supports most format elements except for %P.
+#
+# When using PARSE_TIME, keep the following in mind:
+#   Unspecified fields. Any unspecified field is initialized from
+#     00:00:00.0. For instance, if seconds is unspecified then it
+#     defaults to 00, and so on.
+#   Whitespace. One or more consecutive white spaces in the format
+#     string matches zero or more consecutive white spaces in the TIME
+#     string. In addition, leading and trailing white spaces in the
+#     TIME string are always allowed, even if they are not in the
+#     format string.
+#   Format precedence. When two (or more) format elements have
+#     overlapping information, the last one generally overrides any
+#     earlier ones.
+#   Format divergence. %p can be used with am, AM, pm, and PM.
+#
+# Returns TIME
+
+!if (false) {
+SELECT PARSE_TIME("%H", "15") as parsed_time;
++-------------+
+| parsed_time |
++-------------+
+| 15:00:00    |
++-------------+
+!ok
+!}
+
+!if (false) {
+SELECT PARSE_TIME('%I:%M:%S %p', '2:23:38 pm') AS parsed_time;
++-------------+
+| parsed_time |
++-------------+
+| 14:23:38    |
++-------------+
+!ok
+!}
+
+#####################################################################
+# PARSE_TIMESTAMP
+#
+# PARSE_TIMESTAMP(format_string, timestamp_string[, time_zone])
+#
+# Converts a string representation of a timestamp to a TIMESTAMP
+# object.
+#
+# format_string contains the format elements that define how
+# timestamp_string is formatted. Each element in timestamp_string must
+# have a corresponding element in format_string. The location of each
+# element in format_string must match the location of each element in
+# timestamp_string.
+
+# This works because elements on both sides match.
+!if (false) {
+SELECT PARSE_TIMESTAMP("%a %b %e %I:%M:%S %Y", "Thu Dec 25 07:30:00 2008");
+!ok
+!}
+
+# This doesn't work because the year element is in different locations.
+!if (false) {
+SELECT PARSE_TIMESTAMP("%a %b %e %Y %I:%M:%S", "Thu Dec 25 07:30:00 2008");
+!error
+!}
+
+# This doesn't work because one of the year elements is missing.
+!if (false) {
+SELECT PARSE_TIMESTAMP("%a %b %e %I:%M:%S", "Thu Dec 25 07:30:00 2008");
+!error
+!}
+
+# This works because %c can find all matching elements in timestamp_string.
+!if (false) {
+SELECT PARSE_TIMESTAMP("%c", "Thu Dec 25 07:30:00 2008");
+!ok
+!}
+
+# The format string fully supports most format elements, except for %P.
+#
+# When using PARSE_TIMESTAMP, keep the following in mind:
+#   Unspecified fields. Any unspecified field is initialized from
+#     1970-01-01 00:00:00.0. This initialization value uses the time
+#     zone specified by the function's time zone argument, if
+#     present. If not, the initialization value uses the default time
+#     zone, UTC. For instance, if the year is unspecified then it
+#     defaults to 1970, and so on.
+#   Case insensitivity. Names, such as Monday, February, and so on,
+#     are case insensitive.
+#   Whitespace. One or more consecutive white spaces in the format
+#     string matches zero or more consecutive white spaces in the
+#     timestamp string. In addition, leading and trailing white spaces
+#     in the timestamp string are always allowed, even if they are not
+#     in the format string.
+#   Format precedence. When two (or more) format elements have
+#     overlapping information (for example both %F and %Y affect the
+#     year), the last one generally overrides any earlier ones, with
+#     some exceptions (see the descriptions of %s, %C, and %y).
+#   Format divergence. %p can be used with am, AM, pm, and PM.
+
+# Display of results may differ, depending upon the environment and
+# time zone where this query was executed.
+!if (false) {
+SELECT PARSE_TIMESTAMP("%c", "Thu Dec 25 07:30:00 2008") AS parsed;
++-------------------------+
+| parsed                  |
++-------------------------+
+| 2008-12-25 07:30:00 UTC |
++-------------------------+
+!ok
+!}
+
+#####################################################################
+# STRING and BYTES functions ########################################
+
+#####################################################################
+# ENDS_WITH(value1, value2)
+#
+# Takes two STRING or BYTES values. Returns TRUE if the second
+# value is a suffix of the first.
+#
+# This function supports specifying collation.
+WITH items AS (
+  SELECT '1234' as item UNION ALL
+  SELECT '123' UNION ALL
+  SELECT '' UNION ALL
+  SELECT NULL
+)
+SELECT
+  item, ENDS_WITH(item, '34') as example
+FROM items;
++------+---------+
+| item | example |
++------+---------+
+|      | false   |
+| 123  | false   |
+| 1234 | true    |
+|      |         |
++------+---------+
+(4 rows)
+
+!ok
+
+#####################################################################
+# STARTS_WITH(value1, value2)
+#
+# Takes two STRING or BYTES values. Returns TRUE if the second
+# value is a prefix of the first.
+#
+# This function supports specifying collation.
+WITH items AS (
+  SELECT 'foo' as item UNION ALL
+  SELECT 'bar' UNION ALL
+  SELECT 'baz' UNION ALL
+  SELECT NULL
+)
+SELECT
+  item, STARTS_WITH(item, 'b') as example
+FROM items;
++------+---------+
+| item | example |
++------+---------+
+| bar  | true    |
+| baz  | true    |
+| foo  | false   |
+|      |         |
++------+---------+
+(4 rows)
+
+!ok
+
+
 # End big-query.iq
diff --git a/babel/src/test/resources/sql/postgresql.iq b/babel/src/test/resources/sql/postgresql.iq
new file mode 100644
index 00000000000..f82b2a91bb2
--- /dev/null
+++ b/babel/src/test/resources/sql/postgresql.iq
@@ -0,0 +1,59 @@
+# postgresql.iq - Babel test for PostgreSQL dialect of SQL
+#
+# 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.
+#
+!use scott-postgresql
+!set outputformat csv
+
+# Test string and array comparison
+select array[0,1,2] = '{0,1,2}';
+EXPR$0
+true
+!ok
+
+select array[0,1,2] = '{3,1,2}';
+EXPR$0
+false
+!ok
+
+select array['hello', 'world'] = '{"hello", "world"}';
+EXPR$0
+true
+!ok
+
+select array['hello', 'world'] = '{1,2}';
+EXPR$0
+false
+!ok
+
+# Test coercion string to array inside INSERT
+create table sal_emp (name varchar, pay_by_quarter int array, schedule varchar array array);
+(0 rows modified)
+
+!update
+
+INSERT INTO sal_emp
+    VALUES ('Bill',
+    '{10000, 10000, 10000, 10000}',
+    '{{"meeting", "lunch"}, {"training", "presentation"}}');
+(1 row modified)
+
+!update
+
+SELECT * FROM sal_emp;
+NAME, PAY_BY_QUARTER, SCHEDULE
+Bill, [10000, 10000, 10000, 10000], [[meeting, lunch], [training, presentation]]
+!ok
diff --git a/babel/src/test/resources/sql/redshift.iq b/babel/src/test/resources/sql/redshift.iq
index 5cfc27978ab..4917e3124a0 100755
--- a/babel/src/test/resources/sql/redshift.iq
+++ b/babel/src/test/resources/sql/redshift.iq
@@ -1261,6 +1261,17 @@ select date_trunc('week', date '2008-09-09');
 SELECT "DATE_TRUNC"('week', DATE '2008-09-09')
 !explain-validated-on calcite
 
+with orders (id, order_date) as
+  (values (1, date '2023-02-15'), (2, date '2023-01-01'))
+select DATE_TRUNC('month', orders.order_date)
+from orders
+order by id;
+WITH "ORDERS" ("ID", "ORDER_DATE") AS (VALUES ROW(1, DATE '2023-02-15'),
+            ROW(2, DATE '2023-01-01')) (SELECT "DATE_TRUNC"('month', "ORDERS"."ORDER_DATE")
+        FROM "ORDERS" AS "ORDERS"
+        ORDER BY "ORDERS"."ID")
+!explain-validated-on calcite
+
 # EXTRACT (datepart FROM {TIMESTAMP 'literal' | timestamp}) returns DOUBLE
 # Extracts a date part from a timestamp or literal.
 -- returns 8
@@ -1777,17 +1788,25 @@ manhattan
 
 # LPAD and RPAD
 select lpad('cat', 7);
-SELECT "LPAD"('cat', 7)
-!explain-validated-on calcite
+EXPR$0
+    cat
+!ok
 
 -- returns 'eeriness'
 select rpad(lpad('rine', 6, 'e'), 8, 's');
-SELECT "RPAD"("LPAD"('rine', 6, 'e'), 8, 's')
-!explain-validated-on calcite
+EXPR$0
+eeriness
+!ok
 
-select rpad('cat', 7);
-SELECT "RPAD"('cat', 7)
-!explain-validated-on calcite
+select rpad('cat', 7) || '!';
+EXPR$0
+cat    !
+!ok
+
+select rpad('cat', 7, '!');
+EXPR$0
+cat!!!!
+!ok
 
 # LTRIM
 -- returns 'kery'
diff --git a/babel/src/test/resources/sql/select.iq b/babel/src/test/resources/sql/select.iq
index 07399eb7da1..e82f21d7d40 100755
--- a/babel/src/test/resources/sql/select.iq
+++ b/babel/src/test/resources/sql/select.iq
@@ -60,4 +60,16 @@ select(...)
 !explain-validated-on mysql8+ oracle
 !}
 
+# [CALCITE-5410] Assertion error on PERCENT_REMAINDER operator with DECIMAL type
+
+select 1.0 % 2;
++--------+
+| EXPR$0 |
++--------+
+|    1.0 |
++--------+
+(1 row)
+
+!ok
+
 # End select.iq
diff --git a/bom/build.gradle.kts b/bom/build.gradle.kts
index b35d4803d9e..670afb5ce1f 100644
--- a/bom/build.gradle.kts
+++ b/bom/build.gradle.kts
@@ -55,7 +55,10 @@ dependencies {
         apiv("com.beust:jcommander")
         apiv("org.checkerframework:checker-qual", "checkerframework")
         apiv("com.datastax.oss:java-driver-core", "cassandra-java-driver-core")
-        apiv("com.esri.geometry:esri-geometry-api")
+        apiv("org.locationtech.jts:jts-core")
+        apiv("org.locationtech.jts.io:jts-io-common")
+        apiv("org.locationtech.proj4j:proj4j")
+        apiv("org.locationtech.proj4j:proj4j-epsg", "proj4j")
         apiv("com.fasterxml.jackson.core:jackson-databind")
         apiv("com.github.kstyrc:embedded-redis")
         apiv("com.github.stephenc.jcip:jcip-annotations")
@@ -95,6 +98,7 @@ dependencies {
         apiv("org.apache.cassandra:cassandra-all")
         apiv("org.apache.commons:commons-dbcp2")
         apiv("org.apache.commons:commons-lang3")
+        apiv("org.apache.commons:commons-math3")
         apiv("org.apache.commons:commons-pool2")
         apiv("org.apache.geode:geode-core")
         apiv("org.apache.hadoop:hadoop-client", "hadoop")
diff --git a/build.gradle.kts b/build.gradle.kts
index 4c2e80570d2..7f3499e43b9 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -25,6 +25,7 @@ import com.github.vlsi.gradle.properties.dsl.props
 import com.github.vlsi.gradle.release.RepositoryType
 import de.thetaphi.forbiddenapis.gradle.CheckForbiddenApis
 import de.thetaphi.forbiddenapis.gradle.CheckForbiddenApisExtension
+import java.net.URI
 import net.ltgt.gradle.errorprone.errorprone
 import org.apache.calcite.buildtools.buildext.dsl.ParenthesisBalancer
 import org.gradle.api.tasks.testing.logging.TestExceptionFormat
@@ -37,6 +38,8 @@ plugins {
     // Verification
     checkstyle
     calcite.buildext
+    jacoco
+    id("jacoco-report-aggregation")
     id("org.checkerframework") apply false
     id("com.github.autostyle")
     id("org.nosphere.apache.rat")
@@ -46,6 +49,7 @@ plugins {
     id("com.github.vlsi.jandex") apply false
     id("org.owasp.dependencycheck")
     id("com.github.johnrengelman.shadow") apply false
+    id("org.sonarqube")
     // IDE configuration
     id("org.jetbrains.gradle.plugin.idea-ext")
     id("com.github.vlsi.ide")
@@ -62,6 +66,15 @@ repositories {
     mavenCentral()
 }
 
+tasks.wrapper {
+    distributionType = Wrapper.DistributionType.BIN
+    doLast {
+        val sha256Uri = URI("$distributionUrl.sha256")
+        val sha256Sum = String(sha256Uri.toURL().readBytes())
+        propertiesFile.appendText("distributionSha256Sum=${sha256Sum}\n")
+    }
+}
+
 fun reportsForHumans() = !(System.getenv()["CI"]?.toBoolean() ?: false)
 
 val lastEditYear by extra(lastEditYear())
@@ -71,6 +84,7 @@ val enableSpotBugs = props.bool("spotbugs")
 val enableCheckerframework by props()
 val enableErrorprone by props()
 val enableDependencyAnalysis by props()
+val enableJacoco by props()
 val skipJandex by props()
 val skipCheckstyle by props()
 val skipAutostyle by props()
@@ -158,12 +172,23 @@ releaseParams {
     }
 }
 
+reporting {
+    reports {
+        if (enableJacoco) {
+            val jacocoAggregateTestReport by creating(JacocoCoverageReport::class) {
+                testType.set(TestSuiteType.UNIT_TEST)
+            }
+        }
+    }
+}
+
 val javadocAggregate by tasks.registering(Javadoc::class) {
     group = JavaBasePlugin.DOCUMENTATION_GROUP
     description = "Generates aggregate javadoc for all the artifacts"
 
     val sourceSets = subprojects
         .mapNotNull { it.extensions.findByType<SourceSetContainer>() }
+        .filter { it.names.contains("main") }
         .map { it.named("main") }
 
     classpath = files(sourceSets.map { set -> set.map { it.output + it.compileClasspath } })
@@ -216,6 +241,11 @@ dependencies {
     for (m in dataSetsForSqlline) {
         sqllineClasspath(module(m))
     }
+    if (enableJacoco) {
+        for (p in subprojects) {
+            jacocoAggregation(p)
+        }
+    }
 }
 
 val buildSqllineClasspath by tasks.registering(Jar::class) {
@@ -284,6 +314,13 @@ fun com.github.autostyle.gradle.BaseFormatExtension.license() {
     endWithNewline()
 }
 
+sonarqube {
+    properties {
+        property("sonar.test.inclusions", "**/*Test*/**")
+        property("sonar.coverage.jacoco.xmlReportPaths", "$buildDir/reports/jacoco/jacocoAggregateTestReport/jacocoAggregateTestReport.xml")
+    }
+}
+
 allprojects {
     group = "org.apache.calcite"
     version = buildVersion
@@ -298,6 +335,11 @@ allprojects {
     val javaUsed = file("src/main/java").isDirectory
     if (javaUsed) {
         apply(plugin = "java-library")
+        configurations {
+            "implementation" {
+                exclude(group = "org.jetbrains", module = "annotations")
+            }
+        }
     }
 
     plugins.withId("java-library") {
@@ -323,6 +365,9 @@ allprojects {
                 testRuntimeOnly("org.junit.vintage:junit-vintage-engine")
             }
         }
+        if (enableJacoco) {
+            apply(plugin = "jacoco")
+        }
     }
 
     if (!skipAutostyle) {
@@ -432,7 +477,7 @@ allprojects {
                 noTimestamp.value = true
                 showFromProtected()
                 // javadoc: error - The code being documented uses modules but the packages
-                // defined in https://docs.oracle.com/javase/9/docs/api/ are in the unnamed module
+                // defined in https://docs.oracle.com/en/java/javase/17/docs/api/ are in the unnamed module
                 source = "1.8"
                 docEncoding = "UTF-8"
                 charSet = "UTF-8"
@@ -444,7 +489,7 @@ allprojects {
                     "Copyright &copy; 2012-$lastEditYear Apache Software Foundation. All Rights Reserved."
                 if (JavaVersion.current() >= JavaVersion.VERSION_1_9) {
                     addBooleanOption("html5", true)
-                    links("https://docs.oracle.com/javase/9/docs/api/")
+                    links("https://docs.oracle.com/en/java/javase/17/docs/api/")
                 } else {
                     links("https://docs.oracle.com/javase/8/docs/api/")
                 }
@@ -543,7 +588,11 @@ allprojects {
                     replaceRegex("require message for requireNonNull", """(?<!#)requireNonNull\(\s*(\w+)\s*(?:,\s*"(?!\1")\w+"\s*)?\)""", "requireNonNull($1, \"$1\")")
                     // (?-m) disables multiline, so $ matches the very end of the file rather than end of line
                     replaceRegex("Remove '// End file.java' trailer", "(?-m)\n// End [^\n]+\\.\\w+\\s*$", "")
-                    replaceRegex("<p> should not be placed a the end of the line", "(?-m)\\s*+<p> *+\n \\* ", "\n *\n * <p>")
+                    replaceRegex("<p> should not be placed at the end of the line", "(?-m)\\s*+<p> *+\n \\* ", "\n *\n * <p>")
+                    replaceRegex("Method parameter list should not end in whitespace or newline", "(?<!;)\\s+\\) \\{", ") {")
+                    replaceRegex("Method argument list should not end in whitespace or newline", "(?<!;)\\s+(\\)+[;,])", "$1")
+                    replaceRegex("Long assignment should be broken after '='", "^([^/*\"\\n]*) = ([^@\\n]*)\\(\n( *)", "$1 =\n$3$2(")
+                    replaceRegex("Long assignment should be broken after '='", "^([^/*\"\\n]*) = ([^@\\n]*)\\((.*,)\n( *)", "$1 =\n$4$2($3 ")
                     // Assume developer copy-pasted the link, and updated text only, so the url is old, and we replace it with the proper one
                     replaceRegex(">[CALCITE-...] link styles: 1", "<a(?:(?!CALCITE-)[^>])++CALCITE-\\d+[^>]++>\\s*+\\[?(CALCITE-\\d+)\\]?", "<a href=\"https://issues.apache.org/jira/browse/\$1\">[\$1]")
                     // If the link was crafted manually, ensure it has [CALCITE-...] in the link text
@@ -753,6 +802,14 @@ allprojects {
                 }
                 enabled = enableSpotBugs
             }
+            configureEach<JacocoReport> {
+                reports {
+                    // The reports are mainly consumed by Sonar, which only uses the XML format
+                    xml.required.set(true)
+                    html.required.set(false)
+                    csv.required.set(false)
+                }
+            }
 
             afterEvaluate {
                 // Add default license/notice when missing
diff --git a/buildSrc/build.gradle.kts b/buildSrc/build.gradle.kts
index 45462214330..06f486a9fcd 100644
--- a/buildSrc/build.gradle.kts
+++ b/buildSrc/build.gradle.kts
@@ -53,8 +53,6 @@ fun Project.applyKotlinProjectConventions() {
     }
 
     tasks.withType<KotlinCompile> {
-        sourceCompatibility = "unused"
-        targetCompatibility = "unused"
         kotlinOptions {
             jvmTarget = "1.8"
         }
diff --git a/cassandra/src/main/java/org/apache/calcite/adapter/cassandra/CassandraEnumerator.java b/cassandra/src/main/java/org/apache/calcite/adapter/cassandra/CassandraEnumerator.java
index 1cf187a5de8..98d30664a7d 100644
--- a/cassandra/src/main/java/org/apache/calcite/adapter/cassandra/CassandraEnumerator.java
+++ b/cassandra/src/main/java/org/apache/calcite/adapter/cassandra/CassandraEnumerator.java
@@ -87,9 +87,10 @@ class CassandraEnumerator implements Enumerator<Object> {
    */
   private @Nullable Object currentRowField(int index) {
     assert current != null;
-    final Object o =  current.get(index,
-        CodecRegistry.DEFAULT.codecFor(
-            current.getColumnDefinitions().get(index).getType()));
+    final Object o =
+         current.get(index,
+             CodecRegistry.DEFAULT.codecFor(
+                 current.getColumnDefinitions().get(index).getType()));
 
     return convertToEnumeratorObject(o);
   }
diff --git a/cassandra/src/main/java/org/apache/calcite/adapter/cassandra/CassandraProject.java b/cassandra/src/main/java/org/apache/calcite/adapter/cassandra/CassandraProject.java
index b5a77c74f82..947d6e5cd09 100644
--- a/cassandra/src/main/java/org/apache/calcite/adapter/cassandra/CassandraProject.java
+++ b/cassandra/src/main/java/org/apache/calcite/adapter/cassandra/CassandraProject.java
@@ -28,6 +28,7 @@
 import org.apache.calcite.util.Pair;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 
@@ -42,7 +43,7 @@
 public class CassandraProject extends Project implements CassandraRel {
   public CassandraProject(RelOptCluster cluster, RelTraitSet traitSet,
       RelNode input, List<? extends RexNode> projects, RelDataType rowType) {
-    super(cluster, traitSet, ImmutableList.of(), input, projects, rowType);
+    super(cluster, traitSet, ImmutableList.of(), input, projects, rowType, ImmutableSet.of());
     assert getConvention() == CassandraRel.CONVENTION;
     assert getConvention() == input.getConvention();
   }
diff --git a/cassandra/src/main/java/org/apache/calcite/adapter/cassandra/CassandraRules.java b/cassandra/src/main/java/org/apache/calcite/adapter/cassandra/CassandraRules.java
index ce38ed3d18d..6fc1f47432a 100644
--- a/cassandra/src/main/java/org/apache/calcite/adapter/cassandra/CassandraRules.java
+++ b/cassandra/src/main/java/org/apache/calcite/adapter/cassandra/CassandraRules.java
@@ -273,8 +273,7 @@ protected CassandraProjectRule(Config config) {
           return false;
         }
       }
-
-      return true;
+      return project.getVariablesSet().isEmpty();
     }
 
     @Override public RelNode convert(RelNode rel) {
diff --git a/cassandra/src/main/java/org/apache/calcite/adapter/cassandra/CassandraSchema.java b/cassandra/src/main/java/org/apache/calcite/adapter/cassandra/CassandraSchema.java
index de774cfa6c5..e5b4d8aa3ae 100644
--- a/cassandra/src/main/java/org/apache/calcite/adapter/cassandra/CassandraSchema.java
+++ b/cassandra/src/main/java/org/apache/calcite/adapter/cassandra/CassandraSchema.java
@@ -90,11 +90,32 @@ public class CassandraSchema extends AbstractSchema {
    * @param name the schema name
    */
   public CassandraSchema(CqlSession session, SchemaPlus parentSchema, String name) {
+    this(
+        session,
+        parentSchema,
+        session.getKeyspace()
+          .orElseThrow(() -> new RuntimeException("No keyspace for session " + session.getName()))
+          .asInternal(),
+        name);
+  }
+
+  /**
+   * Creates a Cassandra schema.
+   *
+   * @param session a Cassandra session
+   * @param parentSchema the parent schema
+   * @param keyspace the keyspace name
+   * @param name the schema name
+   */
+  public CassandraSchema(
+      CqlSession session,
+      SchemaPlus parentSchema,
+      String keyspace,
+      String name) {
     super();
+
     this.session = session;
-    this.keyspace = session.getKeyspace()
-        .orElseThrow(() -> new RuntimeException("No keyspace for session " + session.getName()))
-        .asInternal();
+    this.keyspace = keyspace;
     this.parentSchema = parentSchema;
     this.name = name;
     this.hook = prepareHook();
@@ -138,16 +159,16 @@ RelProtoDataType getRelDataType(String columnFamily, boolean view) {
       final String columnName = column.getName().asInternal();
 
       if (dataType instanceof ListType) {
-        SqlTypeName arrayInnerType = CQL_TO_SQL_TYPE.lookup(
-            ((ListType) dataType).getElementType());
+        SqlTypeName arrayInnerType =
+            CQL_TO_SQL_TYPE.lookup(((ListType) dataType).getElementType());
 
         fieldInfo.add(columnName,
                 typeFactory.createArrayType(
                     typeFactory.createSqlType(arrayInnerType), -1))
             .nullable(true);
       } else if (dataType instanceof SetType) {
-        SqlTypeName multiSetInnerType = CQL_TO_SQL_TYPE.lookup(
-            ((SetType) dataType).getElementType());
+        SqlTypeName multiSetInnerType =
+            CQL_TO_SQL_TYPE.lookup(((SetType) dataType).getElementType());
 
         fieldInfo.add(columnName,
             typeFactory.createMultisetType(
@@ -323,11 +344,11 @@ private void addMaterializedViews() {
     final ImmutableMap.Builder<String, Table> builder = ImmutableMap.builder();
     for (TableMetadata table : getKeyspace().getTables().values()) {
       String tableName = table.getName().asInternal();
-      builder.put(tableName, new CassandraTable(this, tableName));
+      builder.put(tableName, new CassandraTable(this, keyspace, tableName));
 
       for (ViewMetadata view : getKeyspace().getViewsOnTable(table.getName()).values()) {
         String viewName = view.getName().asInternal();
-        builder.put(viewName, new CassandraTable(this, viewName, true));
+        builder.put(viewName, new CassandraTable(this, keyspace, viewName, true));
       }
     }
     return builder.build();
diff --git a/cassandra/src/main/java/org/apache/calcite/adapter/cassandra/CassandraSchemaFactory.java b/cassandra/src/main/java/org/apache/calcite/adapter/cassandra/CassandraSchemaFactory.java
index 8aa796cbbc1..d392c80a6af 100644
--- a/cassandra/src/main/java/org/apache/calcite/adapter/cassandra/CassandraSchemaFactory.java
+++ b/cassandra/src/main/java/org/apache/calcite/adapter/cassandra/CassandraSchemaFactory.java
@@ -21,7 +21,9 @@
 import org.apache.calcite.schema.SchemaPlus;
 import org.apache.calcite.util.trace.CalciteTrace;
 
+import com.datastax.oss.driver.api.core.CqlIdentifier;
 import com.datastax.oss.driver.api.core.CqlSession;
+import com.datastax.oss.driver.api.core.CqlSessionBuilder;
 import com.google.common.collect.ImmutableSet;
 
 import org.slf4j.Logger;
@@ -41,8 +43,8 @@ public class CassandraSchemaFactory implements SchemaFactory {
   private static final int DEFAULT_CASSANDRA_PORT = 9042;
   private static final Map<Map<String, Object>, CqlSession> INFO_TO_SESSION =
       new ConcurrentHashMap<>();
-  private static final Set<String> SESSION_DEFINING_KEYS = ImmutableSet.of(
-      "host", "port", "keyspace", "username", "password");
+  private static final Set<String> SESSION_DEFINING_KEYS =
+      ImmutableSet.of("host", "port", "keyspace", "username", "password");
   protected static final Logger LOGGER = CalciteTrace.getPlannerTracer();
 
   public CassandraSchemaFactory() {
@@ -56,7 +58,6 @@ public CassandraSchemaFactory() {
 
     INFO_TO_SESSION.computeIfAbsent(sessionMap, m -> {
       String host = (String) m.get("host");
-      String keyspace = (String) m.get("keyspace");
       String username = (String) m.get("username");
       String password = (String) m.get("password");
       int port = getPort(m);
@@ -65,26 +66,34 @@ public CassandraSchemaFactory() {
         LOGGER.debug("Creating session for info {}", m);
       }
       try {
-        if (username != null && password != null) {
-          return CqlSession.builder()
-              .addContactPoint(new InetSocketAddress(host, port))
-              .withAuthCredentials(username, password)
-              .withKeyspace(keyspace)
-              .withLocalDatacenter("datacenter1")
-              .build();
-        } else {
-          return CqlSession.builder()
-              .addContactPoint(new InetSocketAddress(host, port))
-              .withKeyspace(keyspace)
-              .withLocalDatacenter("datacenter1")
-              .build();
+        CqlSessionBuilder builder =
+            username != null && password != null
+                ? CqlSession.builder()
+                  .addContactPoint(new InetSocketAddress(host, port))
+                  .withAuthCredentials(username, password)
+                : CqlSession.builder()
+                  .addContactPoint(new InetSocketAddress(host, port));
+
+        if (m.containsKey("keyspace")) {
+          String keyspace = (String) m.get("keyspace");
+          builder = builder.withKeyspace(keyspace);
         }
+
+        return builder
+            .withLocalDatacenter("datacenter1")
+            .build();
       } catch (Exception e) {
         throw new RuntimeException(e);
       }
     });
 
-    return new CassandraSchema(INFO_TO_SESSION.get(sessionMap), parentSchema, name);
+    CqlSession session = INFO_TO_SESSION.get(sessionMap);
+
+    String keyspace = session.getKeyspace()
+        .map(CqlIdentifier::asInternal)
+        .orElse(name);
+
+    return new CassandraSchema(session, parentSchema, keyspace, name);
   }
 
   private static Map<String, Object> projectMapOverKeys(
diff --git a/cassandra/src/main/java/org/apache/calcite/adapter/cassandra/CassandraTable.java b/cassandra/src/main/java/org/apache/calcite/adapter/cassandra/CassandraTable.java
index 2cb9519ebe7..b5f3c4c6bb2 100644
--- a/cassandra/src/main/java/org/apache/calcite/adapter/cassandra/CassandraTable.java
+++ b/cassandra/src/main/java/org/apache/calcite/adapter/cassandra/CassandraTable.java
@@ -47,7 +47,9 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
-import java.util.Objects;
+import java.util.Optional;
+
+import static java.util.Objects.requireNonNull;
 
 /**
  * Table based on a Cassandra column family.
@@ -58,10 +60,27 @@ public class CassandraTable extends AbstractQueryableTable
   List<String> partitionKeys;
   List<String> clusteringKeys;
   List<RelFieldCollation> clusteringOrder;
+  private final Optional<String> keyspace;
   private final String columnFamily;
 
+  @Deprecated // to be removed before 2.0
   public CassandraTable(CassandraSchema schema, String columnFamily, boolean isView) {
     super(Object[].class);
+    this.keyspace = Optional.empty();
+    this.columnFamily = columnFamily;
+    this.protoRowType = schema.getRelDataType(columnFamily, isView);
+    this.partitionKeys = schema.getPartitionKeys(columnFamily, isView);
+    this.clusteringKeys = schema.getClusteringKeys(columnFamily, isView);
+    this.clusteringOrder = schema.getClusteringOrder(columnFamily, isView);
+  }
+
+  public CassandraTable(
+      CassandraSchema schema,
+      String keyspace,
+      String columnFamily,
+      boolean isView) {
+    super(Object[].class);
+    this.keyspace = Optional.of(keyspace);
     this.columnFamily = columnFamily;
     this.protoRowType = schema.getRelDataType(columnFamily, isView);
     this.partitionKeys = schema.getPartitionKeys(columnFamily, isView);
@@ -69,10 +88,15 @@ public CassandraTable(CassandraSchema schema, String columnFamily, boolean isVie
     this.clusteringOrder = schema.getClusteringOrder(columnFamily, isView);
   }
 
+  @Deprecated // to be removed before 2.0
   public CassandraTable(CassandraSchema schema, String columnFamily) {
     this(schema, columnFamily, false);
   }
 
+  public CassandraTable(CassandraSchema schema, String keyspace, String columnFamily) {
+    this(schema, keyspace, columnFamily, false);
+  }
+
   @Override public String toString() {
     return "CassandraTable {" + columnFamily + "}";
   }
@@ -115,8 +139,8 @@ public Enumerable<Object> query(final CqlSession session, List<Map.Entry<String,
     final RelDataType rowType = getRowType(typeFactory);
 
     Function1<String, Void> addField = fieldName -> {
-      RelDataType relDataType = Objects.requireNonNull(
-              rowType.getField(fieldName, true, false)).getType();
+      RelDataType relDataType =
+          requireNonNull(rowType.getField(fieldName, true, false)).getType();
       fieldInfo.add(fieldName, relDataType).nullable(true);
       return null;
     };
@@ -168,11 +192,18 @@ public Enumerable<Object> query(final CqlSession session, List<Map.Entry<String,
 
     // Build and issue the query and return an Enumerator over the results
     StringBuilder queryBuilder = new StringBuilder("SELECT ");
-    queryBuilder.append(selectString)
-        .append(" FROM \"")
+    queryBuilder
+        .append(selectString)
+        .append(" FROM \"");
+
+    keyspace.ifPresent(s ->
+        queryBuilder.append(s).append("\".\""));
+
+    queryBuilder
         .append(columnFamily)
         .append("\"")
         .append(whereClause);
+
     if (!order.isEmpty()) {
       queryBuilder.append(Util.toString(order, " ORDER BY ", ", ", ""));
     }
@@ -236,7 +267,7 @@ private CassandraTable getTable() {
     }
 
     private CqlSession getSession() {
-      return Objects.requireNonNull(schema.unwrap(CassandraSchema.class)).session;
+      return requireNonNull(schema.unwrap(CassandraSchema.class)).session;
     }
 
     /** Called via code-generation.
diff --git a/cassandra/src/test/java/org/apache/calcite/test/CassandraAdapterDataTypesTest.java b/cassandra/src/test/java/org/apache/calcite/test/CassandraAdapterDataTypesTest.java
index ab6f950dee4..a4bea38115b 100644
--- a/cassandra/src/test/java/org/apache/calcite/test/CassandraAdapterDataTypesTest.java
+++ b/cassandra/src/test/java/org/apache/calcite/test/CassandraAdapterDataTypesTest.java
@@ -30,7 +30,7 @@
 import org.junit.jupiter.api.parallel.Execution;
 import org.junit.jupiter.api.parallel.ExecutionMode;
 
-import java.util.Objects;
+import static java.util.Objects.requireNonNull;
 
 /**
  * Tests for the {@code org.apache.calcite.adapter.cassandra} package related to data types.
@@ -195,8 +195,9 @@ static void load(CqlSession session) {
 
   @Test void testCollectionsInnerValues() {
     // timestamp retrieval depends on the user timezone, we must compute the expected result
-    long v = Objects.requireNonNull(
-        TypeCodecs.TIMESTAMP.parse("'2015-05-03 13:30:54.234'")).toEpochMilli();
+    long v =
+        requireNonNull(TypeCodecs.TIMESTAMP.parse("'2015-05-03 13:30:54.234'"))
+            .toEpochMilli();
     String expectedTimestamp = DateTimeUtils.unixTimestampToString(v);
 
     CalciteAssert.that()
diff --git a/cassandra/src/test/java/org/apache/calcite/test/CassandraAdapterTest.java b/cassandra/src/test/java/org/apache/calcite/test/CassandraAdapterTest.java
index 411ffdbb65b..73e9abe618b 100644
--- a/cassandra/src/test/java/org/apache/calcite/test/CassandraAdapterTest.java
+++ b/cassandra/src/test/java/org/apache/calcite/test/CassandraAdapterTest.java
@@ -46,6 +46,9 @@ class CassandraAdapterTest {
   private static final ImmutableMap<String, String> TWISSANDRA =
           CassandraExtension.getDataset("/model.json");
 
+  private static final ImmutableMap<String, String> TWISSANDRA_WITHOUT_KEYSPACE =
+      CassandraExtension.getDataset("/model-without-keyspace.json");
+
   @BeforeAll
   static void load(CqlSession session) {
     new CQLDataLoader(session)
diff --git a/cassandra/src/test/java/org/apache/calcite/test/CassandraAdapterWithoutKeyspaceTest.java b/cassandra/src/test/java/org/apache/calcite/test/CassandraAdapterWithoutKeyspaceTest.java
new file mode 100644
index 00000000000..8822e9dbe6b
--- /dev/null
+++ b/cassandra/src/test/java/org/apache/calcite/test/CassandraAdapterWithoutKeyspaceTest.java
@@ -0,0 +1,57 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.test;
+
+import com.datastax.oss.driver.api.core.CqlSession;
+import com.google.common.collect.ImmutableMap;
+
+import org.cassandraunit.CQLDataLoader;
+import org.cassandraunit.dataset.cql.ClassPathCQLDataSet;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.parallel.Execution;
+import org.junit.jupiter.api.parallel.ExecutionMode;
+
+/**
+ * Tests for the {@code org.apache.calcite.adapter.cassandra} package.
+ *
+ *
+ * Instantiates a CQL session without keyspace, but passes it to
+ * {@code org.apache.calcite.adapter.cassandra.CassandraTable}.
+ * All generated CQL queries should still succeed and explicitly
+ * reference the keyspace.
+ */
+@Execution(ExecutionMode.SAME_THREAD)
+@ExtendWith(CassandraExtension.class)
+class CassandraAdapterWithoutKeyspaceTest {
+  private static final ImmutableMap<String, String> TWISSANDRA_WITHOUT_KEYSPACE =
+          CassandraExtension.getDataset("/model-without-keyspace.json");
+
+  @BeforeAll
+  static void load(CqlSession session) {
+    new CQLDataLoader(session)
+        .load(new ClassPathCQLDataSet("twissandra-small.cql"));
+  }
+
+  @Test void testSelect() {
+    CalciteAssert.that()
+        .with(TWISSANDRA_WITHOUT_KEYSPACE)
+        .query("select * from \"users\"")
+        .returnsCount(10);
+  }
+}
diff --git a/cassandra/src/test/resources/model-without-keyspace.json b/cassandra/src/test/resources/model-without-keyspace.json
new file mode 100644
index 00000000000..6bcc6a51343
--- /dev/null
+++ b/cassandra/src/test/resources/model-without-keyspace.json
@@ -0,0 +1,31 @@
+/*
+ * 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.
+ */
+{
+  "version": "1.0",
+  "defaultSchema": "twissandra_small",
+  "schemas": [
+    {
+      "name": "twissandra_small",
+      "type": "custom",
+      "factory": "org.apache.calcite.adapter.cassandra.CassandraSchemaFactory",
+      "operand": {
+        "host": "localhost",
+        "port": 9142
+      }
+    }
+  ]
+}
diff --git a/cassandra/src/test/resources/twissandra-small.cql b/cassandra/src/test/resources/twissandra-small.cql
new file mode 100644
index 00000000000..a3241776650
--- /dev/null
+++ b/cassandra/src/test/resources/twissandra-small.cql
@@ -0,0 +1,36 @@
+/*
+ * 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.
+ */
+CREATE KEYSPACE twissandra_small
+WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'};
+
+CREATE TABLE twissandra_small.users (
+    username text PRIMARY KEY,
+    password text
+);
+
+USE twissandra_small;
+
+INSERT INTO users(username, password) VALUES ('fOGctyIDES','cGfDNvOUWH');
+INSERT INTO users(username, password) VALUES ('cWIZrdKQmh','haENHSnBMF');
+INSERT INTO users(username, password) VALUES ('lixvTEUaBj','gmDSxlydEL');
+INSERT INTO users(username, password) VALUES ('PNexGqHdVE','ZSBNHcIrvC');
+INSERT INTO users(username, password) VALUES ('PDKIVoezHs','UINXFlcAod');
+INSERT INTO users(username, password) VALUES ('HuGetcsXbQ','fXwYWMaSjc');
+INSERT INTO users(username, password) VALUES ('MdHQeWbPjB','QlaxOTioNZ');
+INSERT INTO users(username, password) VALUES ('UWzCrfaxQi','EzyQckbKOh');
+INSERT INTO users(username, password) VALUES ('JmuhsAaMdw','SQbIaqvzfW');
+INSERT INTO users(username, password) VALUES ('nFtPHprNOd','CESzsfTALr');
diff --git a/core/build.gradle.kts b/core/build.gradle.kts
index 6c31bfe20f1..a447f25c484 100644
--- a/core/build.gradle.kts
+++ b/core/build.gradle.kts
@@ -46,7 +46,9 @@ val testMysql by configurations.creating(integrationTestConfig)
 dependencies {
     api(project(":linq4j"))
 
-    api("com.esri.geometry:esri-geometry-api")
+    api("org.locationtech.jts:jts-core")
+    api("org.locationtech.jts.io:jts-io-common")
+    api("org.locationtech.proj4j:proj4j")
     api("com.fasterxml.jackson.core:jackson-annotations")
     api("com.google.errorprone:error_prone_annotations")
     api("com.google.guava:guava")
@@ -68,6 +70,7 @@ dependencies {
     implementation("net.hydromatic:aggdesigner-algorithm")
     implementation("org.apache.commons:commons-dbcp2")
     implementation("org.apache.commons:commons-lang3")
+    implementation("org.apache.commons:commons-math3")
     implementation("commons-io:commons-io")
     implementation("org.codehaus.janino:commons-compiler")
     implementation("org.codehaus.janino:janino")
@@ -95,6 +98,10 @@ dependencies {
     testImplementation(kotlin("stdlib-jdk8"))
     testImplementation(kotlin("test"))
     testImplementation(kotlin("test-junit5"))
+
+    // proj4j-epsg must not be converted to 'implementation' due to its license
+    testRuntimeOnly("org.locationtech.proj4j:proj4j-epsg")
+
     testRuntimeOnly("org.apache.logging.log4j:log4j-slf4j-impl")
 }
 
diff --git a/core/src/main/codegen/default_config.fmpp b/core/src/main/codegen/default_config.fmpp
index 8e9cdc00414..3e8e792e127 100644
--- a/core/src/main/codegen/default_config.fmpp
+++ b/core/src/main/codegen/default_config.fmpp
@@ -83,8 +83,14 @@ parser: {
     "CURSOR_NAME"
     "DATA"
     "DATABASE"
+    "DATE_DIFF"
+    "DATE_TRUNC"
+    "DATETIME_DIFF"
     "DATETIME_INTERVAL_CODE"
     "DATETIME_INTERVAL_PRECISION"
+    "DATETIME_TRUNC"
+    "DAYOFWEEK"
+    "DAYOFYEAR"
     "DAYS"
     "DECADE"
     "DEFAULTS"
@@ -213,6 +219,7 @@ parser: {
     "PRIVILEGES"
     "PUBLIC"
     "QUARTER"
+    "QUARTERS"
     "READ"
     "RELATIVE"
     "REPEATABLE"
@@ -314,8 +321,12 @@ parser: {
     "TABLE_NAME"
     "TEMPORARY"
     "TIES"
+    "TIME_DIFF"
+    "TIME_TRUNC"
     "TIMESTAMPADD"
     "TIMESTAMPDIFF"
+    "TIMESTAMP_DIFF"
+    "TIMESTAMP_TRUNC"
     "TOP_LEVEL_COUNT"
     "TRANSACTION"
     "TRANSACTIONS_ACTIVE"
@@ -345,6 +356,7 @@ parser: {
     "VERSION"
     "VIEW"
     "WEEK"
+    "WEEKS"
     "WORK"
     "WRAPPER"
     "WRITE"
@@ -388,7 +400,7 @@ parser: {
 
   # List of methods for parsing builtin function calls.
   # Return type of method implementation should be "SqlNode".
-  # Example: "DateFunctionCall()".
+  # Example: "DateTimeConstructorCall()".
   builtinFunctionCallMethods: [
   ]
 
@@ -432,4 +444,5 @@ parser: {
   includeCompoundIdentifier: true
   includeBraces: true
   includeAdditionalDeclarations: false
+  includeParsingStringLiteralAsArrayLiteral: false
 }
diff --git a/core/src/main/codegen/templates/Parser.jj b/core/src/main/codegen/templates/Parser.jj
index c18f1950244..fe6e354daa8 100644
--- a/core/src/main/codegen/templates/Parser.jj
+++ b/core/src/main/codegen/templates/Parser.jj
@@ -34,7 +34,6 @@ import ${importStr};
 </#list>
 
 import org.apache.calcite.avatica.util.Casing;
-import org.apache.calcite.avatica.util.DateTimeUtils;
 import org.apache.calcite.avatica.util.TimeUnit;
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.runtime.CalciteContextException;
@@ -48,7 +47,6 @@ import org.apache.calcite.sql.SqlCharStringLiteral;
 import org.apache.calcite.sql.SqlCollation;
 import org.apache.calcite.sql.SqlCollectionTypeNameSpec;
 import org.apache.calcite.sql.SqlDataTypeSpec;
-import org.apache.calcite.sql.SqlDateLiteral;
 import org.apache.calcite.sql.SqlDelete;
 import org.apache.calcite.sql.SqlDescribeSchema;
 import org.apache.calcite.sql.SqlDescribeTable;
@@ -62,7 +60,6 @@ import org.apache.calcite.sql.SqlHint;
 import org.apache.calcite.sql.SqlIdentifier;
 import org.apache.calcite.sql.SqlInsert;
 import org.apache.calcite.sql.SqlInsertKeyword;
-import org.apache.calcite.sql.SqlIntervalLiteral;
 import org.apache.calcite.sql.SqlIntervalQualifier;
 import org.apache.calcite.sql.SqlJdbcDataTypeName;
 import org.apache.calcite.sql.SqlJdbcFunctionCall;
@@ -94,8 +91,6 @@ import org.apache.calcite.sql.SqlSelectKeyword;
 import org.apache.calcite.sql.SqlSetOption;
 import org.apache.calcite.sql.SqlSnapshot;
 import org.apache.calcite.sql.SqlTableRef;
-import org.apache.calcite.sql.SqlTimeLiteral;
-import org.apache.calcite.sql.SqlTimestampLiteral;
 import org.apache.calcite.sql.SqlTypeNameSpec;
 import org.apache.calcite.sql.SqlUnnestOperator;
 import org.apache.calcite.sql.SqlUnpivot;
@@ -120,22 +115,23 @@ 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.util.Glossary;
-import org.apache.calcite.util.NlsString;
 import org.apache.calcite.util.Pair;
 import org.apache.calcite.util.SourceStringReader;
 import org.apache.calcite.util.Util;
 import org.apache.calcite.util.trace.CalciteTrace;
 
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
 import org.slf4j.Logger;
 
 import java.io.Reader;
 import java.math.BigDecimal;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Calendar;
 import java.util.Collections;
 import java.util.List;
 import java.util.Locale;
+import java.util.Map;
 
 import static org.apache.calcite.util.Static.RESOURCE;
 
@@ -154,6 +150,12 @@ public class ${parser.class} extends SqlAbstractParserImpl
     private static final char DOUBLE_QUOTE = 0x22;
     private static final String DQ = DOUBLE_QUOTE + "";
     private static final String DQDQ = DQ + DQ;
+    private static final SqlLiteral LITERAL_ZERO =
+        SqlLiteral.createExactNumeric("0", SqlParserPos.ZERO);
+    private static final SqlLiteral LITERAL_ONE =
+        SqlLiteral.createExactNumeric("1", SqlParserPos.ZERO);
+    private static final SqlLiteral LITERAL_MINUS_ONE =
+        SqlLiteral.createExactNumeric("-1", SqlParserPos.ZERO);
 
     private static Metadata metadata;
 
@@ -237,6 +239,17 @@ public class ${parser.class} extends SqlAbstractParserImpl
         return SqlStmtList();
     }
 
+    public SqlNode parseArray() throws SqlParseException {
+        switchTo(LexicalState.BQID);
+        try {
+          return ArrayLiteral();
+        } catch (ParseException ex) {
+          throw normalizeException(ex);
+        } catch (TokenMgrError ex) {
+          throw normalizeException(ex);
+        }
+    }
+
     private SqlNode extend(SqlNode table, SqlNodeList extendList) {
         return SqlStdOperatorTable.EXTEND.createCall(
             Span.of(table, extendList).pos(), table, extendList);
@@ -343,6 +356,7 @@ SqlNode FloorCeilOptions(Span s, boolean floorFlag) :
 JAVACODE
 void E() {}
 
+/** @Deprecated */
 JAVACODE List startList(Object o)
 {
     List list = new ArrayList();
@@ -422,6 +436,15 @@ JAVACODE void checkNonQueryExpression(ExprContext exprContext)
     }
 }
 
+JAVACODE SqlNode checkNotJoin(SqlNode e)
+{
+    if (e instanceof SqlJoin) {
+        throw SqlUtil.newContextException(e.getParserPosition(),
+            RESOURCE.illegalJoinExpression());
+    }
+    return e;
+}
+
 /**
  * Converts a ParseException (local to this particular instantiation
  * of the parser) into a SqlParseException (common to all parsers).
@@ -468,7 +491,6 @@ JAVACODE SqlParseException convertException(Throwable ex)
                 token.endColumn);
         }
     } else if (ex instanceof TokenMgrError) {
-        TokenMgrError tme = (TokenMgrError) ex;
         expectedTokenSequences = null;
         tokenImage = null;
         // Example:
@@ -528,7 +550,6 @@ JAVACODE ParseException cleanupParseException(ParseException ex)
     // would yield
     //       {}
     //       {D}
-    boolean id = false;
     final List<int[]> prefixList = new ArrayList<int[]>();
     for (int i = 0; i < ex.expectedTokenSequences.length; ++i) {
         int[] seq = ex.expectedTokenSequences[i];
@@ -595,6 +616,29 @@ JAVACODE boolean matchesPrefix(int[] seq, int[][] prefixes)
  * Syntactical Descriptions              *
  *****************************************/
 
+SqlNode ExprOrJoinOrOrderedQuery(ExprContext exprContext) :
+{
+    SqlNode e;
+    final List<Object> list = new ArrayList<Object>();
+}
+{
+    // Lookhead to distinguish between "TABLE emp" (which will be
+    // matched by ExplicitTable() via Query())
+    // and "TABLE fun(args)" (which will be matched by TableRef())
+    (
+        LOOKAHEAD(2)
+        e = Query(exprContext)
+        e = OrderByLimitOpt(e)
+        { return e; }
+    |
+        e = TableRef1(ExprContext.ACCEPT_QUERY_OR_JOIN)
+        ( e = JoinTable(e) )*
+        { list.add(e); }
+        ( AddSetOpQuery(list, exprContext) )*
+        { return SqlParserUtil.toTree(list); }
+    )
+}
+
 /**
  * Parses either a row expression or a query expression with an optional
  * ORDER BY.
@@ -606,6 +650,13 @@ JAVACODE boolean matchesPrefix(int[] seq, int[][] prefixes)
  *    [ OFFSET start ]</pre>
  * </blockquote>
  *
+ * <p>Trino syntax for limit:
+ *
+ * <blockquote><pre>
+ *    [ OFFSET start ]
+ *    [ LIMIT { count | ALL } ]</pre>
+ * </blockquote>
+ *
  * <p>MySQL syntax for limit:
  *
  * <blockquote><pre>
@@ -622,61 +673,111 @@ JAVACODE boolean matchesPrefix(int[] seq, int[][] prefixes)
 SqlNode OrderedQueryOrExpr(ExprContext exprContext) :
 {
     SqlNode e;
-    SqlNodeList orderBy = null;
-    SqlNode start = null;
-    SqlNode count = null;
+}
+{
+    e = QueryOrExpr(exprContext)
+    e = OrderByLimitOpt(e)
+    { return e; }
+}
+
+/** Reads optional "ORDER BY", "LIMIT", "OFFSET", "FETCH" following a query,
+ * {@code e}. If any of them are present, adds them to the query;
+ * otherwise returns the query unchanged.
+ * Throws if they are present and {@code e} is not a query. */
+SqlNode OrderByLimitOpt(SqlNode e) :
+{
+    final SqlNodeList orderBy;
+    final Span s = Span.of();
+    SqlNode[] offsetFetch = {null, null};
 }
 {
     (
-        e = QueryOrExpr(exprContext)
-    )
-    [
         // use the syntactic type of the expression we just parsed
         // to decide whether ORDER BY makes sense
         orderBy = OrderBy(e.isA(SqlKind.QUERY))
-    ]
+    |   { orderBy = null; }
+    )
     [
-        // Postgres-style syntax. "LIMIT ... OFFSET ..."
-        <LIMIT>
-        (
-            // MySQL-style syntax. "LIMIT start, count"
-            LOOKAHEAD(2)
-            start = UnsignedNumericLiteralOrParam()
-            <COMMA> count = UnsignedNumericLiteralOrParam() {
-                if (!this.conformance.isLimitStartCountAllowed()) {
-                    throw SqlUtil.newContextException(getPos(), RESOURCE.limitStartCountNotAllowed());
+        LimitClause(s, offsetFetch)
+        [ OffsetClause(s, offsetFetch) ]
+    |
+        OffsetClause(s, offsetFetch)
+        [
+            LimitClause(s, offsetFetch) {
+                if (!this.conformance.isOffsetLimitAllowed()) {
+                    throw SqlUtil.newContextException(s.end(this),
+                        RESOURCE.offsetLimitNotAllowed());
                 }
             }
         |
-            count = UnsignedNumericLiteralOrParam()
-        |
-            <ALL>
-        )
-    ]
-    [
-        // ROW or ROWS is required in SQL:2008 but we make it optional
-        // because it is not present in Postgres-style syntax.
-        // If you specify both LIMIT start and OFFSET, OFFSET wins.
-        <OFFSET> start = UnsignedNumericLiteralOrParam() [ <ROW> | <ROWS> ]
-    ]
-    [
-        // SQL:2008-style syntax. "OFFSET ... FETCH ...".
-        // If you specify both LIMIT and FETCH, FETCH wins.
-        <FETCH> ( <FIRST> | <NEXT> ) count = UnsignedNumericLiteralOrParam()
-        ( <ROW> | <ROWS> ) <ONLY>
+            FetchClause(offsetFetch)
+        ]
+    |
+        FetchClause(offsetFetch)
     ]
     {
-        if (orderBy != null || start != null || count != null) {
-            if (orderBy == null) {
-                orderBy = SqlNodeList.EMPTY;
-            }
-            e = new SqlOrderBy(getPos(), e, orderBy, start, count);
-
+        if (orderBy != null || offsetFetch[0] != null || offsetFetch[1] != null) {
+            return new SqlOrderBy(getPos(), e,
+                Util.first(orderBy, SqlNodeList.EMPTY),
+                offsetFetch[0], offsetFetch[1]);
         }
         return e;
     }
 }
 
+/**
+ * Parses an OFFSET clause in an ORDER BY expression.
+ */
+void OffsetClause(Span s, SqlNode[] offsetFetch) :
+{
+}
+{
+    // ROW or ROWS is required in SQL:2008 but we make it optional
+    // because it is not present in Postgres-style syntax.
+    <OFFSET> { s.add(this); }
+    offsetFetch[0] = UnsignedNumericLiteralOrParam()
+    [ <ROW> | <ROWS> ]
+}
+
+/**
+ * Parses a FETCH clause in an ORDER BY expression.
+ */
+void FetchClause(SqlNode[] offsetFetch) :
+{
+}
+{
+    // SQL:2008-style syntax. "OFFSET ... FETCH ...".
+    // If you specify both LIMIT and FETCH, FETCH wins.
+    <FETCH> ( <FIRST> | <NEXT> ) offsetFetch[1] = UnsignedNumericLiteralOrParam()
+    ( <ROW> | <ROWS> ) <ONLY>
+}
+
+/**
+ * Parses a LIMIT clause in an ORDER BY expression.
+ */
+void LimitClause(Span s, SqlNode[] offsetFetch) :
+{
+}
+{
+    // Postgres-style syntax. "LIMIT ... OFFSET ..."
+    <LIMIT> { s.add(this); }
+    (
+        // MySQL-style syntax. "LIMIT start, count"
+        LOOKAHEAD(2)
+        offsetFetch[0] = UnsignedNumericLiteralOrParam()
+        <COMMA> offsetFetch[1] = UnsignedNumericLiteralOrParam() {
+            if (!this.conformance.isLimitStartCountAllowed()) {
+                throw SqlUtil.newContextException(s.end(this),
+                    RESOURCE.limitStartCountNotAllowed());
+            }
+        }
+    |
+        offsetFetch[1] = UnsignedNumericLiteralOrParam()
+    |
+        <ALL>
+    )
+}
+
 /**
  * Parses a leaf in a query expression (SELECT, VALUES or TABLE).
  */
@@ -698,6 +799,7 @@ SqlNode LeafQuery(ExprContext exprContext) :
 
 /**
  * Parses a parenthesized query or single row expression.
+ * Depending on {@code exprContext}, may also accept a join.
  */
 SqlNode ParenthesizedExpression(ExprContext exprContext) :
 {
@@ -717,9 +819,10 @@ SqlNode ParenthesizedExpression(ExprContext exprContext) :
             break;
         }
     }
-    e = OrderedQueryOrExpr(exprContext)
+    e = ExprOrJoinOrOrderedQuery(exprContext)
     <RPAREN>
     {
+        exprContext.throwIfNotCompatible(e);
         return e;
     }
 }
@@ -752,7 +855,7 @@ SqlNodeList ParenthesizedQueryOrCommaList(
     ExprContext exprContext) :
 {
     SqlNode e;
-    List<SqlNode> list;
+    final List<SqlNode> list = new ArrayList<SqlNode>();
     ExprContext firstExprContext = exprContext;
     final Span s;
 }
@@ -771,20 +874,14 @@ SqlNodeList ParenthesizedQueryOrCommaList(
             break;
         }
     }
-    e = OrderedQueryOrExpr(firstExprContext)
-    {
-        list = startList(e);
-    }
+    e = OrderedQueryOrExpr(firstExprContext) { list.add(e); }
     (
         <COMMA>
         {
             // a comma-list can't appear where only a query is expected
             checkNonQueryExpression(exprContext);
         }
-        e = Expression(exprContext)
-        {
-            list.add(e);
-        }
+        AddExpression(list, exprContext)
     )*
     <RPAREN>
     {
@@ -799,7 +896,7 @@ SqlNodeList ParenthesizedQueryOrCommaListWithDefault(
     ExprContext exprContext) :
 {
     SqlNode e;
-    List<SqlNode> list;
+    final List<SqlNode> list = new ArrayList<SqlNode>();
     ExprContext firstExprContext = exprContext;
     final Span s;
 }
@@ -819,13 +916,10 @@ SqlNodeList ParenthesizedQueryOrCommaListWithDefault(
         }
     }
     (
-        e = OrderedQueryOrExpr(firstExprContext)
+        e = OrderedQueryOrExpr(firstExprContext) { list.add(e); }
     |
-        e = Default()
+        e = Default() { list.add(e); }
     )
-    {
-        list = startList(e);
-    }
     (
         <COMMA>
         {
@@ -833,13 +927,10 @@ SqlNodeList ParenthesizedQueryOrCommaListWithDefault(
             checkNonQueryExpression(exprContext);
         }
         (
-            e = Expression(exprContext)
+            e = Expression(exprContext) { list.add(e); }
         |
-            e = Default()
+            e = Default() { list.add(e); }
         )
-        {
-            list.add(e);
-        }
     )*
     <RPAREN>
     {
@@ -851,14 +942,12 @@ SqlNodeList ParenthesizedQueryOrCommaListWithDefault(
  * Parses function parameter lists.
  * If the list starts with DISTINCT or ALL, it is discarded.
  */
-List UnquantifiedFunctionParameterList(
-    ExprContext exprContext) :
+List<SqlNode> UnquantifiedFunctionParameterList(ExprContext exprContext) :
 {
-    final List args;
+    final List<SqlNode> args;
 }
 {
     args = FunctionParameterList(exprContext) {
-        final SqlLiteral quantifier = (SqlLiteral) args.get(0);
         args.remove(0); // remove DISTINCT or ALL, if present
         return args;
     }
@@ -868,11 +957,10 @@ List UnquantifiedFunctionParameterList(
  * Parses function parameter lists including DISTINCT keyword recognition,
  * DEFAULT, and named argument assignment.
  */
-List FunctionParameterList(
-    ExprContext exprContext) :
+List<SqlNode> FunctionParameterList(ExprContext exprContext) :
 {
     final SqlLiteral qualifier;
-    final List list = new ArrayList();
+    final List<SqlNode> list = new ArrayList<SqlNode>();
 }
 {
     <LPAREN>
@@ -881,13 +969,13 @@ List FunctionParameterList(
     |
         { list.add(null); }
     )
-    Arg0(list, exprContext)
+    AddArg0(list, exprContext)
     (
         <COMMA> {
             // a comma-list can't appear where only a query is expected
             checkNonQueryExpression(exprContext);
         }
-        Arg(list, exprContext)
+        AddArg(list, exprContext)
     )*
     <RPAREN>
     {
@@ -904,10 +992,10 @@ SqlLiteral AllOrDistinct() :
     <ALL> { return SqlSelectKeyword.ALL.symbol(getPos()); }
 }
 
-void Arg0(List list, ExprContext exprContext) :
+void AddArg0(List<SqlNode> list, ExprContext exprContext) :
 {
-    SqlIdentifier name = null;
-    SqlNode e = null;
+    final SqlIdentifier name;
+    SqlNode e;
     final ExprContext firstExprContext;
     {
         // we've now seen left paren, so queries inside should
@@ -926,47 +1014,50 @@ void Arg0(List list, ExprContext exprContext) :
     }
 }
 {
-    [
+    (
         LOOKAHEAD(2) name = SimpleIdentifier() <NAMED_ARGUMENT_ASSIGNMENT>
-    ]
+    |   { name = null; }
+    )
     (
         e = Default()
     |
-        e = OrderedQueryOrExpr(firstExprContext)
+        LOOKAHEAD(3)
+        e = TableParam()
+    |
+        e = PartitionedQueryOrQueryOrExpr(firstExprContext)
     )
     {
-        if (e != null) {
-            if (name != null) {
-                e = SqlStdOperatorTable.ARGUMENT_ASSIGNMENT.createCall(
-                    Span.of(name, e).pos(), e, name);
-            }
-            list.add(e);
+        if (name != null) {
+            e = SqlStdOperatorTable.ARGUMENT_ASSIGNMENT.createCall(
+                Span.of(name, e).pos(), e, name);
         }
+        list.add(e);
     }
 }
 
-void Arg(List list, ExprContext exprContext) :
+void AddArg(List<SqlNode> list, ExprContext exprContext) :
 {
-    SqlIdentifier name = null;
-    SqlNode e = null;
+    final SqlIdentifier name;
+    SqlNode e;
 }
 {
-    [
+    (
         LOOKAHEAD(2) name = SimpleIdentifier() <NAMED_ARGUMENT_ASSIGNMENT>
-    ]
+    |   { name = null; }
+    )
     (
         e = Default()
     |
         e = Expression(exprContext)
+    |
+        e = TableParam()
     )
     {
-        if (e != null) {
-            if (name != null) {
-                e = SqlStdOperatorTable.ARGUMENT_ASSIGNMENT.createCall(
-                    Span.of(name, e).pos(), e, name);
-            }
-            list.add(e);
+        if (name != null) {
+            e = SqlStdOperatorTable.ARGUMENT_ASSIGNMENT.createCall(
+                Span.of(name, e).pos(), e, name);
         }
+        list.add(e);
     }
 }
 
@@ -1093,10 +1184,10 @@ SqlNodeList ParenthesizedKeyValueOptionCommaList() :
 {
     { s = span(); }
     <LPAREN>
-    KeyValueOption(list)
+    AddKeyValueOption(list)
     (
         <COMMA>
-        KeyValueOption(list)
+        AddKeyValueOption(list)
     )*
     <RPAREN> {
         return new SqlNodeList(list, s.end(this));
@@ -1107,7 +1198,7 @@ SqlNodeList ParenthesizedKeyValueOptionCommaList() :
 * Parses an option with format key=val whose key is a simple identifier or string literal
 * and value is a string literal.
 */
-void KeyValueOption(List<SqlNode> list) :
+void AddKeyValueOption(List<SqlNode> list) :
 {
     final SqlNode key;
     final SqlNode value;
@@ -1125,22 +1216,17 @@ void KeyValueOption(List<SqlNode> list) :
     }
 }
 
-/**
-* Parses an option value, it's either a string or a numeric.
-*/
-SqlNode OptionValue() :
+/** Parses an option value (either a string or a numeric) and adds to a list. */
+void AddOptionValue(List<SqlNode> list) :
 {
     final SqlNode value;
 }
 {
     (
-        value = NumericLiteral()
+        value = NumericLiteral() { list.add(value); }
     |
-        value = StringLiteral()
+        value = StringLiteral() { list.add(value); }
     )
-    {
-        return value;
-    }
 }
 
 /**
@@ -1150,37 +1236,26 @@ SqlNodeList ParenthesizedLiteralOptionCommaList() :
 {
     final Span s;
     final List<SqlNode> list = new ArrayList<SqlNode>();
-    SqlNode optionVal;
 }
 {
     { s = span(); }
     <LPAREN>
-    optionVal = OptionValue()
-    {
-        list.add(optionVal);
-    }
-    (
-        <COMMA>
-        optionVal = OptionValue()
-        {
-            list.add(optionVal);
-        }
-    )*
+    AddOptionValue(list) ( <COMMA> AddOptionValue(list) )*
     <RPAREN> {
         return new SqlNodeList(list, s.end(this));
     }
 }
 
-void CommaSeparatedSqlHints(List<SqlNode> hints) :
+void AddHint(List<SqlNode> hints) :
 {
-    SqlIdentifier hintName;
-    SqlNodeList hintOptions;
-    SqlNode optionVal;
-    SqlHint.HintOptionFormat optionFormat;
+    final SqlIdentifier hintName;
+    final SqlNodeList hintOptions;
+    final SqlHint.HintOptionFormat optionFormat;
 }
 {
     hintName = SimpleIdentifier()
-    (   LOOKAHEAD(5)
+    (
+       LOOKAHEAD(5)
         hintOptions = ParenthesizedKeyValueOptionCommaList() {
             optionFormat = SqlHint.HintOptionFormat.KV_LIST;
         }
@@ -1203,66 +1278,23 @@ void CommaSeparatedSqlHints(List<SqlNode> hints) :
         }
     )
     {
-        hints.add(new SqlHint(Span.of(hintOptions).end(this), hintName, hintOptions, optionFormat));
+        hints.add(
+           new SqlHint(Span.of(hintOptions).end(this), hintName, hintOptions,
+               optionFormat));
     }
-    (
-        <COMMA>
-        hintName = SimpleIdentifier()
-        (
-            LOOKAHEAD(5)
-            hintOptions = ParenthesizedKeyValueOptionCommaList() {
-                optionFormat = SqlHint.HintOptionFormat.KV_LIST;
-            }
-        |
-            LOOKAHEAD(3)
-            hintOptions = ParenthesizedSimpleIdentifierList() {
-                optionFormat = SqlHint.HintOptionFormat.ID_LIST;
-            }
-        |
-            LOOKAHEAD(3)
-            hintOptions = ParenthesizedLiteralOptionCommaList() {
-                optionFormat = SqlHint.HintOptionFormat.LITERAL_LIST;
-            }
-        |
-            LOOKAHEAD(2)
-            [<LPAREN> <RPAREN>]
-            {
-                hintOptions = SqlNodeList.EMPTY;
-                optionFormat = SqlHint.HintOptionFormat.EMPTY;
-            }
-        )
-        {
-            hints.add(new SqlHint(Span.of(hintOptions).end(this), hintName, hintOptions, optionFormat));
-        }
-    )*
 }
 
-/**
- * Parses a table reference with optional hints.
- */
-SqlNode TableRefWithHintsOpt() :
+/** Parses hints following a table reference,
+ * and returns the wrapped table reference. */
+SqlNode TableHints(SqlIdentifier tableName) :
 {
-    SqlNode tableRef;
-    SqlNodeList hintList;
     final List<SqlNode> hints = new ArrayList<SqlNode>();
-    final Span s;
 }
 {
-    { s = span(); }
-    tableRef = CompoundTableIdentifier()
-    [
-        LOOKAHEAD(2)
-        <HINT_BEG>
-        CommaSeparatedSqlHints(hints)
-        <COMMENT_END>
-        {
-            hintList = new SqlNodeList(hints, s.addAll(hints).end(this));
-            tableRef = new SqlTableRef(Span.of(tableRef, hintList).pos(),
-                    (SqlIdentifier) tableRef, hintList);
-        }
-    ]
-    {
-        return tableRef;
+    <HINT_BEG> AddHint(hints) ( <COMMA> AddHint(hints) )* <COMMENT_END> {
+        final SqlParserPos pos = Span.of(tableName).addAll(hints).end(this);
+        final SqlNodeList hintList = new SqlNodeList(hints, pos);
+        return new SqlTableRef(pos, tableName, hintList);
     }
 }
 
@@ -1274,25 +1306,19 @@ SqlSelect SqlSelect() :
     final List<SqlLiteral> keywords = new ArrayList<SqlLiteral>();
     final SqlLiteral keyword;
     final SqlNodeList keywordList;
-    List<SqlNode> selectList;
+    final List<SqlNode> selectList = new ArrayList<SqlNode>();
     final SqlNode fromClause;
     final SqlNode where;
     final SqlNodeList groupBy;
     final SqlNode having;
     final SqlNodeList windowDecls;
+    final SqlNode qualify;
     final List<SqlNode> hints = new ArrayList<SqlNode>();
     final Span s;
 }
 {
-    <SELECT>
-    {
-        s = span();
-    }
-    [
-        <HINT_BEG>
-        CommaSeparatedSqlHints(hints)
-        <COMMENT_END>
-    ]
+    <SELECT> { s = span(); }
+    [ <HINT_BEG> AddHint(hints) ( <COMMA> AddHint(hints) )* <COMMENT_END> ]
     SqlSelectKeywords(keywords)
     (
         <STREAM> {
@@ -1305,13 +1331,15 @@ SqlSelect SqlSelect() :
     {
         keywordList = new SqlNodeList(keywords, s.addAll(keywords).pos());
     }
-    selectList = SelectList()
+    AddSelectItem(selectList)
+    ( <COMMA> AddSelectItem(selectList) )*
     (
         <FROM> fromClause = FromClause()
-        where = WhereOpt()
-        groupBy = GroupByOpt()
-        having = HavingOpt()
-        windowDecls = WindowOpt()
+        ( where = Where() | { where = null; } )
+        ( groupBy = GroupBy() | { groupBy = null; } )
+        ( having = Having() | { having = null; } )
+        ( windowDecls = Window() | { windowDecls = null; } )
+        ( qualify = Qualify() | { qualify = null; } )
     |
         E() {
             fromClause = null;
@@ -1319,13 +1347,14 @@ SqlSelect SqlSelect() :
             groupBy = null;
             having = null;
             windowDecls = null;
+            qualify = null;
         }
     )
     {
         return new SqlSelect(s.end(this), keywordList,
             new SqlNodeList(selectList, Span.of(selectList).pos()),
-            fromClause, where, groupBy, having, windowDecls, null, null, null,
-            new SqlNodeList(hints, getPos()));
+            fromClause, where, groupBy, having, windowDecls, qualify,
+            null, null, null, new SqlNodeList(hints, getPos()));
     }
 }
 
@@ -1482,11 +1511,8 @@ SqlNode SqlDescribe() :
            | <BRACKET_QUOTED_IDENTIFIER> )
         (<TABLE>)?
         table = CompoundIdentifier()
-        (
-            column = SimpleIdentifier()
-        |
-            E() { column = null; }
-        ) {
+        ( column = SimpleIdentifier() | { column = null; } )
+        {
             return new SqlDescribeTable(s.add(table).addIf(column).pos(),
                 table, column);
         }
@@ -1533,7 +1559,7 @@ SqlNode NamedRoutineCall(
     SqlFunctionCategory routineType,
     ExprContext exprContext) :
 {
-    SqlIdentifier name;
+    final SqlIdentifier name;
     final List<SqlNode> list = new ArrayList<SqlNode>();
     final Span s;
 }
@@ -1543,13 +1569,13 @@ SqlNode NamedRoutineCall(
     }
     <LPAREN>
     [
-        Arg0(list, exprContext)
+        AddArg0(list, exprContext)
         (
             <COMMA> {
                 // a comma-list can't appear where only a query is expected
                 checkNonQueryExpression(exprContext);
             }
-            Arg(list, exprContext)
+            AddArg(list, exprContext)
         )*
     ]
     <RPAREN>
@@ -1558,6 +1584,111 @@ SqlNode NamedRoutineCall(
     }
 }
 
+/**
+ * Table parameter of a table function.
+ * The input table with set semantics may be partitioned/ordered on one or more columns.
+ */
+SqlNode TableParam() :
+{
+    final Span s;
+    final SqlNodeList partitionList;
+    final SqlNodeList orderList;
+    SqlNode tableRef;
+}
+{
+    { s = span(); }
+    tableRef = ExplicitTable(getPos())
+    (
+        <PARTITION> <BY>
+        partitionList = SimpleIdentifierOrList()
+    |   { partitionList = SqlNodeList.EMPTY; }
+    )
+    (
+        orderList = OrderByOfSetSemanticsTable()
+     |  { orderList = SqlNodeList.EMPTY; }
+    )
+    { return CreateSetSemanticsTableIfNeeded(s, tableRef, partitionList, orderList); }
+}
+
+SqlNode PartitionedQueryOrQueryOrExpr(ExprContext exprContext) :
+{
+    SqlNode e;
+}
+{
+    e = OrderedQueryOrExpr(exprContext)
+    e = PartitionedByAndOrderBy(e)
+
+    { return e; }
+}
+
+SqlNode PartitionedByAndOrderBy(SqlNode e) :
+{
+    final Span s;
+    final SqlNodeList partitionList;
+    final SqlNodeList orderList;
+}
+{
+    { s = span(); }
+    (
+        <PARTITION> <BY>
+        partitionList = SimpleIdentifierOrList()
+    |   { partitionList = SqlNodeList.EMPTY; }
+    )
+    (
+        orderList = OrderByOfSetSemanticsTable()
+     |  { orderList = SqlNodeList.EMPTY; }
+    )
+    { return CreateSetSemanticsTableIfNeeded(s, e, partitionList, orderList); }
+}
+
+SqlNodeList OrderByOfSetSemanticsTable() :
+{
+    final List<SqlNode> list = new ArrayList<SqlNode>();
+    final Span s;
+}
+{
+  <ORDER>
+  { s = span(); }
+  <BY>
+  (
+      LOOKAHEAD(2)
+      <LPAREN> AddOrderItem(list)
+      (
+        // NOTE jvs 6-Feb-2004:  See comments at top of file for why
+        // hint is necessary here.
+        LOOKAHEAD(2) <COMMA> AddOrderItem(list)
+      )*
+      <RPAREN> {
+          return new SqlNodeList(list, s.addAll(list).pos());
+      }
+  |
+      AddOrderItem(list)
+      {
+          return new SqlNodeList(list, s.addAll(list).pos());
+      }
+  )
+}
+
+SqlNode CreateSetSemanticsTableIfNeeded(
+    final Span s,
+    final SqlNode e,
+    final SqlNodeList partitionList,
+    final SqlNodeList orderList) :
+{
+
+}
+{
+
+    {
+        if (partitionList.isEmpty() && orderList.isEmpty()) {
+            return e;
+        } else {
+            return SqlStdOperatorTable.SET_SEMANTICS_TABLE.createCall(
+                s.pos(), e, partitionList, orderList);
+        }
+    }
+}
+
 /**
  * Parses an INSERT statement.
  */
@@ -1565,11 +1696,12 @@ SqlNode SqlInsert() :
 {
     final List<SqlLiteral> keywords = new ArrayList<SqlLiteral>();
     final SqlNodeList keywordList;
-    SqlNode table;
-    SqlNodeList extendList = null;
+    final SqlIdentifier tableName;
+    SqlNode tableRef;
     SqlNode source;
-    SqlNodeList columnList = null;
+    final SqlNodeList columnList;
     final Span s;
+    final Pair<SqlNodeList, SqlNodeList> p;
 }
 {
     (
@@ -1581,28 +1713,25 @@ SqlNode SqlInsert() :
     SqlInsertKeywords(keywords) {
         keywordList = new SqlNodeList(keywords, s.addAll(keywords).pos());
     }
-    <INTO> table = TableRefWithHintsOpt()
-    [
-        LOOKAHEAD(5)
-        [ <EXTEND> ]
-        extendList = ExtendList() {
-            table = extend(table, extendList);
-        }
-    ]
-    [
+    <INTO> tableName = CompoundTableIdentifier()
+    ( tableRef = TableHints(tableName) | { tableRef = tableName; } )
+    [ LOOKAHEAD(5) tableRef = ExtendTable(tableRef) ]
+    (
         LOOKAHEAD(2)
-        { final Pair<SqlNodeList, SqlNodeList> p; }
         p = ParenthesizedCompoundIdentifierList() {
             if (p.right.size() > 0) {
-                table = extend(table, p.right);
+                tableRef = extend(tableRef, p.right);
             }
             if (p.left.size() > 0) {
                 columnList = p.left;
+            } else {
+                columnList = null;
             }
         }
-    ]
+    |   { columnList = null; }
+    )
     source = OrderedQueryOrExpr(ExprContext.ACCEPT_QUERY) {
-        return new SqlInsert(s.end(source), keywordList, table, source,
+        return new SqlInsert(s.end(source), keywordList, tableRef, source,
             columnList);
     }
 }
@@ -1620,28 +1749,24 @@ SqlNode SqlInsert() :
  */
 SqlNode SqlDelete() :
 {
-    SqlNode table;
-    SqlNodeList extendList = null;
-    SqlIdentifier alias = null;
-    final SqlNode condition;
+    final SqlIdentifier tableName;
+    SqlNode tableRef;
+    final SqlIdentifier alias;
+    final SqlNode where;
     final Span s;
 }
 {
     <DELETE> {
         s = span();
     }
-    <FROM> table = TableRefWithHintsOpt()
-    [
-        [ <EXTEND> ]
-        extendList = ExtendList() {
-            table = extend(table, extendList);
-        }
-    ]
-    [ [ <AS> ] alias = SimpleIdentifier() ]
-    condition = WhereOpt()
+    <FROM> tableName = CompoundTableIdentifier()
+    ( tableRef = TableHints(tableName) | { tableRef = tableName; } )
+    [ tableRef = ExtendTable(tableRef) ]
+    ( [ <AS> ] alias = SimpleIdentifier() | { alias = null; } )
+    ( where = Where() | { where = null; } )
     {
-        return new SqlDelete(s.add(table).addIf(extendList).addIf(alias)
-            .addIf(condition).pos(), table, condition, null, alias);
+        return new SqlDelete(s.add(tableRef).addIf(alias).addIf(where).pos(),
+            tableRef, where, null, alias);
     }
 }
 
@@ -1650,52 +1775,41 @@ SqlNode SqlDelete() :
  */
 SqlNode SqlUpdate() :
 {
-    SqlNode table;
-    SqlNodeList extendList = null;
-    SqlIdentifier alias = null;
-    SqlNode condition;
-    SqlNodeList sourceExpressionList;
-    SqlNodeList targetColumnList;
+    final SqlIdentifier tableName;
+    SqlNode tableRef;
+    final SqlIdentifier alias;
+    final SqlNode where;
+    final SqlNodeList sourceExpressionList;
+    final SqlNodeList targetColumnList;
     SqlIdentifier id;
-    SqlNode exp;
     final Span s;
 }
 {
-    <UPDATE> { s = span(); }
-    table = TableRefWithHintsOpt() {
+    <UPDATE> {
+        s = span();
         targetColumnList = new SqlNodeList(s.pos());
         sourceExpressionList = new SqlNodeList(s.pos());
     }
-    [
-        [ <EXTEND> ]
-        extendList = ExtendList() {
-            table = extend(table, extendList);
-        }
-    ]
-    [ [ <AS> ] alias = SimpleIdentifier() ]
+    tableName = CompoundTableIdentifier()
+    ( tableRef = TableHints(tableName) | { tableRef = tableName; } )
+    [ tableRef = ExtendTable(tableRef) ]
+    ( [ <AS> ] alias = SimpleIdentifier() | { alias = null; } )
     <SET> id = SimpleIdentifier() {
         targetColumnList.add(id);
     }
-    <EQ> exp = Expression(ExprContext.ACCEPT_SUB_QUERY) {
-        // TODO:  support DEFAULT also
-        sourceExpressionList.add(exp);
-    }
+    // TODO:  support DEFAULT also
+    <EQ> AddExpression(sourceExpressionList, ExprContext.ACCEPT_SUB_QUERY)
     (
         <COMMA>
-        id = SimpleIdentifier()
-        {
-            targetColumnList.add(id);
-        }
-        <EQ> exp = Expression(ExprContext.ACCEPT_SUB_QUERY)
-        {
-            sourceExpressionList.add(exp);
-        }
+        id = SimpleIdentifier() { targetColumnList.add(id); }
+        <EQ> AddExpression(sourceExpressionList, ExprContext.ACCEPT_SUB_QUERY)
     )*
-    condition = WhereOpt()
+    ( where = Where() | { where = null; } )
     {
-        return new SqlUpdate(s.addAll(targetColumnList)
-            .addAll(sourceExpressionList).addIf(condition).pos(), table,
-            targetColumnList, sourceExpressionList, condition, null, alias);
+        final SqlParserPos pos = s.addAll(targetColumnList)
+            .addAll(sourceExpressionList).addIf(where).pos();
+        return new SqlUpdate(pos, tableRef, targetColumnList,
+            sourceExpressionList, where, null, alias);
     }
 }
 
@@ -1704,36 +1818,34 @@ SqlNode SqlUpdate() :
  */
 SqlNode SqlMerge() :
 {
-    SqlNode table;
-    SqlNodeList extendList = null;
-    SqlIdentifier alias = null;
-    SqlNode sourceTableRef;
-    SqlNode condition;
-    SqlUpdate updateCall = null;
-    SqlInsert insertCall = null;
+    final SqlIdentifier tableName;
+    SqlNode tableRef;
+    final SqlIdentifier alias;
+    final SqlNode sourceTableRef;
+    final SqlNode condition;
+    final SqlUpdate updateCall;
+    final SqlInsert insertCall;
     final Span s;
 }
 {
-    <MERGE> { s = span(); } <INTO> table = TableRefWithHintsOpt()
-    [
-        [ <EXTEND> ]
-        extendList = ExtendList() {
-            table = extend(table, extendList);
-        }
-    ]
-    [ [ <AS> ] alias = SimpleIdentifier() ]
+    <MERGE> { s = span(); } <INTO> tableName = CompoundTableIdentifier()
+    ( tableRef = TableHints(tableName) | { tableRef = tableName; } )
+    [ tableRef = ExtendTable(tableRef) ]
+    ( [ <AS> ] alias = SimpleIdentifier() | { alias = null; } )
     <USING> sourceTableRef = TableRef()
     <ON> condition = Expression(ExprContext.ACCEPT_SUB_QUERY)
     (
         LOOKAHEAD(2)
-        updateCall = WhenMatchedClause(table, alias)
-        [ insertCall = WhenNotMatchedClause(table) ]
+        updateCall = WhenMatchedClause(tableRef, alias)
+        ( insertCall = WhenNotMatchedClause(tableRef) | { insertCall = null; } )
     |
-        insertCall = WhenNotMatchedClause(table)
+        { updateCall = null; }
+        insertCall = WhenNotMatchedClause(tableRef)
     )
     {
-        return new SqlMerge(s.addIf(updateCall).addIf(insertCall).pos(), table,
-            condition, sourceTableRef, updateCall, insertCall, null, alias);
+        final SqlParserPos pos = s.addIf(updateCall).addIf(insertCall).pos();
+        return new SqlMerge(pos, tableRef, condition, sourceTableRef,
+            updateCall, insertCall, null, alias);
     }
 }
 
@@ -1742,7 +1854,6 @@ SqlUpdate WhenMatchedClause(SqlNode table, SqlIdentifier alias) :
     SqlIdentifier id;
     final Span s;
     final SqlNodeList updateColumnList = new SqlNodeList(SqlParserPos.ZERO);
-    SqlNode exp;
     final SqlNodeList updateExprList = new SqlNodeList(SqlParserPos.ZERO);
 }
 {
@@ -1750,17 +1861,13 @@ SqlUpdate WhenMatchedClause(SqlNode table, SqlIdentifier alias) :
     <UPDATE> <SET> id = CompoundIdentifier() {
         updateColumnList.add(id);
     }
-    <EQ> exp = Expression(ExprContext.ACCEPT_SUB_QUERY) {
-        updateExprList.add(exp);
-    }
+    <EQ> AddExpression(updateExprList, ExprContext.ACCEPT_SUB_QUERY)
     (
         <COMMA>
         id = CompoundIdentifier() {
             updateColumnList.add(id);
         }
-        <EQ> exp = Expression(ExprContext.ACCEPT_SUB_QUERY) {
-            updateExprList.add(exp);
-        }
+        <EQ> AddExpression(updateExprList, ExprContext.ACCEPT_SUB_QUERY)
     )*
     {
         return new SqlUpdate(s.addAll(updateExprList).pos(), table,
@@ -1773,7 +1880,7 @@ SqlInsert WhenNotMatchedClause(SqlNode table) :
     final Span insertSpan, valuesSpan;
     final List<SqlLiteral> keywords = new ArrayList<SqlLiteral>();
     final SqlNodeList keywordList;
-    SqlNodeList insertColumnList = null;
+    final SqlNodeList insertColumnList;
     SqlNode rowConstructor;
     SqlNode insertValues;
 }
@@ -1784,14 +1891,18 @@ SqlInsert WhenNotMatchedClause(SqlNode table) :
     SqlInsertKeywords(keywords) {
         keywordList = new SqlNodeList(keywords, insertSpan.end(this));
     }
-    [
+    (
         LOOKAHEAD(2)
         insertColumnList = ParenthesizedSimpleIdentifierList()
-    ]
-    [ <LPAREN> ]
-    <VALUES> { valuesSpan = span(); }
-    rowConstructor = RowConstructor()
-    [ <RPAREN> ]
+    |   { insertColumnList = null; }
+    )
+    (
+        <LPAREN>
+        <VALUES> { valuesSpan = span(); } rowConstructor = RowConstructor()
+        <RPAREN>
+    |
+        <VALUES> { valuesSpan = span(); } rowConstructor = RowConstructor()
+    )
     {
         // TODO zfong 5/26/06: note that extra parentheses are accepted above
         // around the VALUES clause as a hack for unparse, but this is
@@ -1803,39 +1914,17 @@ SqlInsert WhenNotMatchedClause(SqlNode table) :
     }
 }
 
-/**
- * Parses the select list of a SELECT statement.
- */
-List<SqlNode> SelectList() :
-{
-    final List<SqlNode> list = new ArrayList<SqlNode>();
-    SqlNode item;
-}
-{
-    item = SelectItem() {
-        list.add(item);
-    }
-    (
-        <COMMA> item = SelectItem() {
-            list.add(item);
-        }
-    )*
-    {
-        return list;
-    }
-}
-
 /**
  * Parses one item in a select list.
  */
-SqlNode SelectItem() :
+void AddSelectItem(List<SqlNode> list) :
 {
-    SqlNode e;
+    final SqlNode e;
     final SqlIdentifier id;
 }
 {
     e = SelectExpression()
-    [
+    (
         [ <AS> ]
         (
             id = SimpleIdentifier()
@@ -1845,13 +1934,9 @@ SqlNode SelectItem() :
             LOOKAHEAD(1)
             id = SimpleIdentifierFromStringLiteral()
         )
-        {
-            e = SqlStdOperatorTable.AS.createCall(span().end(e), e, id);
-        }
-    ]
-    {
-        return e;
-    }
+        { list.add(SqlStdOperatorTable.AS.createCall(span().end(e), e, id)); }
+    |   { list.add(e); }
+    )
 }
 
 /**
@@ -1908,6 +1993,57 @@ SqlLiteral JoinType() :
     }
 }
 
+/**
+ * Parses the FROM clause for a SELECT.
+ *
+ * <p>FROM is mandatory in standard SQL, optional in dialects such as MySQL,
+ * PostgreSQL. The parser allows SELECT without FROM, but the validator fails
+ * if conformance is, say, STRICT_2003.
+ */
+SqlNode FromClause() :
+{
+    SqlNode e, e2;
+    SqlLiteral joinType;
+}
+{
+    e = Join()
+    (
+        // Comma joins should only occur at top-level in the FROM clause.
+        // Valid:
+        //  * FROM a, b
+        //  * FROM (a CROSS JOIN b), c
+        // Not valid:
+        //  * FROM a CROSS JOIN (b, c)
+        LOOKAHEAD(1)
+        <COMMA> { joinType = JoinType.COMMA.symbol(getPos()); }
+        e2 = Join() {
+            e = new SqlJoin(joinType.getParserPosition(),
+                e,
+                SqlLiteral.createBoolean(false, joinType.getParserPosition()),
+                joinType,
+                e2,
+                JoinConditionType.NONE.symbol(SqlParserPos.ZERO),
+                null);
+        }
+    )*
+    { return e; }
+}
+
+SqlNode Join() :
+{
+    SqlNode e;
+}
+{
+    e = TableRef1(ExprContext.ACCEPT_QUERY_OR_JOIN)
+    (
+        LOOKAHEAD(2)
+        e = JoinTable(e)
+    )*
+    {
+        return e;
+    }
+}
+
 /** Matches "LEFT JOIN t ON ...", "RIGHT JOIN t USING ...", "JOIN t". */
 SqlNode JoinTable(SqlNode e) :
 {
@@ -1916,9 +2052,22 @@ SqlNode JoinTable(SqlNode e) :
     SqlNodeList list;
 }
 {
+    // LOOKAHEAD(3) is needed here rather than a LOOKAHEAD(2) because JavaCC
+    // calculates minimum lookahead count incorrectly for choice that contains
+    // zero size child. For instance, with the generated code,
+    // "LOOKAHEAD(2, Natural(), JoinType())"
+    // returns true immediately if it sees a single "<CROSS>" token. Where we
+    // expect the lookahead succeeds after "<CROSS> <APPLY>".
+    //
+    // For more information about the issue,
+    // see https://github.com/javacc/javacc/issues/86
+    //
+    // We allow CROSS JOIN (joinType = CROSS_JOIN) to have a join condition,
+    // even though that is not valid SQL; the validator will catch it.
+    LOOKAHEAD(3)
     natural = Natural()
     joinType = JoinType()
-    e2 = TableRef()
+    e2 = TableRef1(ExprContext.ACCEPT_QUERY_OR_JOIN)
     (
         <ON> { on = JoinConditionType.ON.symbol(getPos()); }
         condition = Expression(ExprContext.ACCEPT_SUB_QUERY) {
@@ -1952,148 +2101,54 @@ SqlNode JoinTable(SqlNode e) :
                 null);
         }
     )
+|
+    <CROSS> { joinType = JoinType.CROSS.symbol(getPos()); } <APPLY>
+    e2 = TableRef2(true) {
+        if (!this.conformance.isApplyAllowed()) {
+            throw SqlUtil.newContextException(getPos(), RESOURCE.applyNotAllowed());
+        }
+        return new SqlJoin(joinType.getParserPosition(),
+            e,
+            SqlLiteral.createBoolean(false, joinType.getParserPosition()),
+            joinType,
+            e2,
+            JoinConditionType.NONE.symbol(SqlParserPos.ZERO),
+            null);
+    }
+|
+    <OUTER> { joinType = JoinType.LEFT.symbol(getPos()); } <APPLY>
+    e2 = TableRef2(true) {
+        if (!this.conformance.isApplyAllowed()) {
+            throw SqlUtil.newContextException(getPos(), RESOURCE.applyNotAllowed());
+        }
+        return new SqlJoin(joinType.getParserPosition(),
+            e,
+            SqlLiteral.createBoolean(false, joinType.getParserPosition()),
+            joinType,
+            e2,
+            JoinConditionType.ON.symbol(SqlParserPos.ZERO),
+            SqlLiteral.createBoolean(true, joinType.getParserPosition()));
+    }
 }
 
-// TODO jvs 15-Nov-2003:  SQL standard allows parentheses in the FROM list for
-// building up non-linear join trees (e.g. OUTER JOIN two tables, and then INNER
-// JOIN the result).  Also note that aliases on parenthesized FROM expressions
-// "hide" all table names inside the parentheses (without aliases, they're
-// visible).
-//
-// We allow CROSS JOIN to have a join condition, even though that is not valid
-// SQL; the validator will catch it.
 /**
- * Parses the FROM clause for a SELECT.
- *
- * <p>FROM is mandatory in standard SQL, optional in dialects such as MySQL,
- * PostgreSQL. The parser allows SELECT without FROM, but the validator fails
- * if conformance is, say, STRICT_2003.
+ * Parses a table reference in a FROM clause, not lateral unless LATERAL
+ * is explicitly specified.
  */
-SqlNode FromClause() :
+SqlNode TableRef() :
 {
-    SqlNode e, e2, condition;
-    SqlLiteral natural, joinType, joinConditionType;
-    SqlNodeList list;
-    SqlParserPos pos;
+    final SqlNode e;
 }
 {
-    e = TableRef()
-    (
-        LOOKAHEAD(2)
-        (
-            // Decide whether to read a JOIN clause or a comma, or to quit having
-            // seen a single entry FROM clause like 'FROM emps'. See comments
-            // elsewhere regarding <COMMA> lookahead.
-            //
-            // And LOOKAHEAD(3) is needed here rather than a LOOKAHEAD(2). Because currently JavaCC
-            // calculates minimum lookahead count incorrectly for choice that contains zero size
-            // child. For instance, with the generated code, "LOOKAHEAD(2, Natural(), JoinType())"
-            // returns true immediately if it sees a single "<CROSS>" token. Where we expect
-            // the lookahead succeeds after "<CROSS> <APPLY>".
-            //
-            // For more information about the issue, see https://github.com/javacc/javacc/issues/86
-            LOOKAHEAD(3)
-            natural = Natural()
-            joinType = JoinType()
-            e2 = TableRef()
-            (
-                <ON> {
-                    joinConditionType = JoinConditionType.ON.symbol(getPos());
-                }
-                condition = Expression(ExprContext.ACCEPT_SUB_QUERY) {
-                    e = new SqlJoin(joinType.getParserPosition(),
-                        e,
-                        natural,
-                        joinType,
-                        e2,
-                        joinConditionType,
-                        condition);
-                }
-            |
-                <USING> {
-                    joinConditionType = JoinConditionType.USING.symbol(getPos());
-                }
-                list = ParenthesizedSimpleIdentifierList() {
-                    e = new SqlJoin(joinType.getParserPosition(),
-                        e,
-                        natural,
-                        joinType,
-                        e2,
-                        joinConditionType,
-                        new SqlNodeList(list.getList(), Span.of(joinConditionType).end(this)));
-                }
-            |
-                {
-                    e = new SqlJoin(joinType.getParserPosition(),
-                        e,
-                        natural,
-                        joinType,
-                        e2,
-                        JoinConditionType.NONE.symbol(joinType.getParserPosition()),
-                        null);
-                }
-            )
-        |
-            // NOTE jvs 6-Feb-2004:  See comments at top of file for why
-            // hint is necessary here.  I had to use this special semantic
-            // lookahead form to get JavaCC to shut up, which makes
-            // me even more uneasy.
-            //LOOKAHEAD({true})
-            <COMMA> { joinType = JoinType.COMMA.symbol(getPos()); }
-            e2 = TableRef() {
-                e = new SqlJoin(joinType.getParserPosition(),
-                    e,
-                    SqlLiteral.createBoolean(false, joinType.getParserPosition()),
-                    joinType,
-                    e2,
-                    JoinConditionType.NONE.symbol(SqlParserPos.ZERO),
-                    null);
-            }
-        |
-            <CROSS> { joinType = JoinType.CROSS.symbol(getPos()); } <APPLY>
-            e2 = TableRef2(true) {
-                if (!this.conformance.isApplyAllowed()) {
-                    throw SqlUtil.newContextException(getPos(), RESOURCE.applyNotAllowed());
-                }
-                e = new SqlJoin(joinType.getParserPosition(),
-                    e,
-                    SqlLiteral.createBoolean(false, joinType.getParserPosition()),
-                    joinType,
-                    e2,
-                    JoinConditionType.NONE.symbol(SqlParserPos.ZERO),
-                    null);
-            }
-        |
-            <OUTER> { joinType = JoinType.LEFT.symbol(getPos()); } <APPLY>
-            e2 = TableRef2(true) {
-                if (!this.conformance.isApplyAllowed()) {
-                    throw SqlUtil.newContextException(getPos(), RESOURCE.applyNotAllowed());
-                }
-                e = new SqlJoin(joinType.getParserPosition(),
-                    e,
-                    SqlLiteral.createBoolean(false, joinType.getParserPosition()),
-                    joinType,
-                    e2,
-                    JoinConditionType.ON.symbol(SqlParserPos.ZERO),
-                    SqlLiteral.createBoolean(true, joinType.getParserPosition()));
-            }
-        )
-    )*
-    {
-        return e;
-    }
+    e = TableRef3(ExprContext.ACCEPT_QUERY, false) { return e; }
 }
 
-/**
- * Parses a table reference in a FROM clause, not lateral unless LATERAL
- * is explicitly specified.
- */
-SqlNode TableRef() :
+SqlNode TableRef1(ExprContext exprContext) :
 {
     final SqlNode e;
 }
 {
-    e = TableRef2(false) { return e; }
+    e = TableRef3(exprContext, false) { return e; }
 }
 
 /**
@@ -2101,62 +2156,38 @@ SqlNode TableRef() :
  */
 SqlNode TableRef2(boolean lateral) :
 {
+    final SqlNode e;
+}
+{
+    e = TableRef3(ExprContext.ACCEPT_QUERY, lateral) { return e; }
+}
+
+SqlNode TableRef3(ExprContext exprContext, boolean lateral) :
+{
+    final SqlIdentifier tableName;
     SqlNode tableRef;
-    final SqlNode over;
-    final SqlNode snapshot;
-    final SqlNode match;
-    SqlNodeList extendList = null;
     final SqlIdentifier alias;
-    final Span s, s2;
+    final Span s;
     SqlNodeList args;
-    SqlNode sample;
-    boolean isBernoulli;
-    SqlNumericLiteral samplePercentage;
-    boolean isRepeatable = false;
-    int repeatableSeed = 0;
-    SqlNodeList columnAliasList = null;
+    final SqlNodeList columnAliasList;
     SqlUnnestOperator unnestOp = SqlStdOperatorTable.UNNEST;
 }
 {
     (
         LOOKAHEAD(2)
-        tableRef = TableRefWithHintsOpt()
-        [
-            [ <EXTEND> ]
-            extendList = ExtendList() {
-                tableRef = extend(tableRef, extendList);
-            }
-        ]
-        over = TableOverOpt() {
-            if (over != null) {
-                tableRef = SqlStdOperatorTable.OVER.createCall(
-                    getPos(), tableRef, over);
-            }
-        }
-        [
-            tableRef = Snapshot(tableRef)
-        ]
-        [
-            tableRef = MatchRecognize(tableRef)
-        ]
+        tableName = CompoundTableIdentifier()
+        ( tableRef = TableHints(tableName) | { tableRef = tableName; } )
+        [ tableRef = ExtendTable(tableRef) ]
+        tableRef = Over(tableRef)
+        [ tableRef = Snapshot(tableRef) ]
+        [ tableRef = MatchRecognize(tableRef) ]
     |
         LOOKAHEAD(2)
         [ <LATERAL> { lateral = true; } ]
-        tableRef = ParenthesizedExpression(ExprContext.ACCEPT_QUERY)
-        over = TableOverOpt()
-        {
-            if (over != null) {
-                tableRef = SqlStdOperatorTable.OVER.createCall(
-                    getPos(), tableRef, over);
-            }
-            if (lateral) {
-                tableRef = SqlStdOperatorTable.LATERAL.createCall(
-                    getPos(), tableRef);
-            }
-        }
-        [
-            tableRef = MatchRecognize(tableRef)
-        ]
+        tableRef = ParenthesizedExpression(exprContext)
+        tableRef = Over(tableRef)
+        tableRef = addLateral(tableRef, lateral)
+        [ tableRef = MatchRecognize(tableRef) ]
     |
         <UNNEST> { s = span(); }
         args = ParenthesizedQueryOrCommaList(ExprContext.ACCEPT_SUB_QUERY)
@@ -2169,16 +2200,9 @@ SqlNode TableRef2(boolean lateral) :
             tableRef = unnestOp.createCall(s.end(this), (List<SqlNode>) args);
         }
     |
-        [<LATERAL> { lateral = true; } ]
-        <TABLE> { s = span(); } <LPAREN>
-        tableRef = TableFunctionCall(s.pos())
-        <RPAREN>
-        {
-            if (lateral) {
-                tableRef = SqlStdOperatorTable.LATERAL.createCall(
-                    s.end(this), tableRef);
-            }
-        }
+        [ <LATERAL> { lateral = true; } ]
+        tableRef = TableFunctionCall()
+        tableRef = addLateral(tableRef, lateral)
     |
         tableRef = ExtendedTableRef()
     )
@@ -2192,8 +2216,17 @@ SqlNode TableRef2(boolean lateral) :
     ]
     [
         [ <AS> ] alias = SimpleIdentifier()
-        [ columnAliasList = ParenthesizedSimpleIdentifierList() ]
+        (
+            columnAliasList = ParenthesizedSimpleIdentifierList()
+        |   { columnAliasList = null; }
+        )
         {
+            // Standard SQL (and Postgres) allow applying "AS alias" to a JOIN,
+            // e.g. "FROM (a CROSS JOIN b) AS c". The new alias obscures the
+            // internal aliases, and columns cannot be referenced if they are
+            // not unique. TODO: Support this behavior; see
+            // [CALCITE-5168] Allow AS after parenthesized JOIN
+            checkNotJoin(tableRef);
             if (columnAliasList == null) {
                 tableRef = SqlStdOperatorTable.AS.createCall(
                     Span.of(tableRef).end(this), tableRef, alias);
@@ -2207,71 +2240,88 @@ SqlNode TableRef2(boolean lateral) :
             }
         }
     ]
-    [
-        <TABLESAMPLE> { s2 = span(); }
+    [ tableRef = Tablesample(tableRef) ]
+    { return tableRef; }
+}
+
+SqlNode Tablesample(SqlNode tableRef) :
+{
+    final Span s;
+    final SqlNode sample;
+    final boolean isBernoulli;
+    final SqlNumericLiteral samplePercentage;
+    boolean isRepeatable = false;
+    int repeatableSeed = 0;
+}
+{
+    <TABLESAMPLE> { s = span(); checkNotJoin(tableRef); }
+    (
+        <SUBSTITUTE> <LPAREN> sample = StringLiteral() <RPAREN>
+        {
+            String sampleName =
+                SqlLiteral.unchain(sample).getValueAs(String.class);
+            SqlSampleSpec sampleSpec = SqlSampleSpec.createNamed(sampleName);
+            final SqlLiteral sampleLiteral =
+                SqlLiteral.createSample(sampleSpec, s.end(this));
+            tableRef = SqlStdOperatorTable.TABLESAMPLE.createCall(
+                s.add(tableRef).end(this), tableRef, sampleLiteral);
+        }
+    |
         (
-            <SUBSTITUTE> <LPAREN> sample = StringLiteral() <RPAREN>
+            <BERNOULLI> { isBernoulli = true; }
+        |
+            <SYSTEM> { isBernoulli = false; }
+        )
+        <LPAREN> samplePercentage = UnsignedNumericLiteral() <RPAREN>
+        [
+            <REPEATABLE> <LPAREN> repeatableSeed = IntLiteral() <RPAREN>
             {
-                String sampleName =
-                    SqlLiteral.unchain(sample).getValueAs(String.class);
-                SqlSampleSpec sampleSpec = SqlSampleSpec.createNamed(sampleName);
-                final SqlLiteral sampleLiteral =
-                    SqlLiteral.createSample(sampleSpec, s2.end(this));
-                tableRef = SqlStdOperatorTable.TABLESAMPLE.createCall(
-                    s2.add(tableRef).end(this), tableRef, sampleLiteral);
+                isRepeatable = true;
             }
-        |
-            (
-                <BERNOULLI>
-                {
-                    isBernoulli = true;
-                }
-            |
-                <SYSTEM>
-                {
-                    isBernoulli = false;
-                }
-            )
-            <LPAREN> samplePercentage = UnsignedNumericLiteral() <RPAREN>
-            [
-                <REPEATABLE> <LPAREN> repeatableSeed = IntLiteral() <RPAREN>
-                {
-                    isRepeatable = true;
-                }
-            ]
+        ]
+        {
+            final BigDecimal ONE_HUNDRED = BigDecimal.valueOf(100L);
+            BigDecimal rate = samplePercentage.bigDecimalValue();
+            if (rate.compareTo(BigDecimal.ZERO) < 0
+                || rate.compareTo(ONE_HUNDRED) > 0)
             {
-                final BigDecimal ONE_HUNDRED = BigDecimal.valueOf(100L);
-                BigDecimal rate = samplePercentage.bigDecimalValue();
-                if (rate.compareTo(BigDecimal.ZERO) < 0
-                    || rate.compareTo(ONE_HUNDRED) > 0)
-                {
-                    throw SqlUtil.newContextException(getPos(), RESOURCE.invalidSampleSize());
-                }
+                throw SqlUtil.newContextException(getPos(), RESOURCE.invalidSampleSize());
+            }
 
-                // Treat TABLESAMPLE(0) and TABLESAMPLE(100) as no table
-                // sampling at all.  Not strictly correct: TABLESAMPLE(0)
-                // should produce no output, but it simplifies implementation
-                // to know that some amount of sampling will occur.
-                // In practice values less than ~1E-43% are treated as 0.0 and
-                // values greater than ~99.999997% are treated as 1.0
-                float fRate = rate.divide(ONE_HUNDRED).floatValue();
-                if (fRate > 0.0f && fRate < 1.0f) {
-                    SqlSampleSpec tableSampleSpec =
+            // Treat TABLESAMPLE(0) and TABLESAMPLE(100) as no table
+            // sampling at all.  Not strictly correct: TABLESAMPLE(0)
+            // should produce no output, but it simplifies implementation
+            // to know that some amount of sampling will occur.
+            // In practice values less than ~1E-43% are treated as 0.0 and
+            // values greater than ~99.999997% are treated as 1.0
+            float fRate = rate.divide(ONE_HUNDRED).floatValue();
+            if (fRate > 0.0f && fRate < 1.0f) {
+                SqlSampleSpec tableSampleSpec =
                     isRepeatable
                         ? SqlSampleSpec.createTableSample(
                             isBernoulli, fRate, repeatableSeed)
                         : SqlSampleSpec.createTableSample(isBernoulli, fRate);
 
-                    SqlLiteral tableSampleLiteral =
-                        SqlLiteral.createSample(tableSampleSpec, s2.end(this));
-                    tableRef = SqlStdOperatorTable.TABLESAMPLE.createCall(
-                        s2.end(this), tableRef, tableSampleLiteral);
-                }
+                SqlLiteral tableSampleLiteral =
+                    SqlLiteral.createSample(tableSampleSpec, s.end(this));
+                tableRef = SqlStdOperatorTable.TABLESAMPLE.createCall(
+                    s.end(this), tableRef, tableSampleLiteral);
             }
-        )
-    ]
-    {
-        return tableRef;
+        }
+    )
+    { return tableRef; }
+}
+
+/** Wraps a table reference in a call to EXTEND if an optional "EXTEND" clause
+ * is present. */
+SqlNode ExtendTable(SqlNode tableRef) :
+{
+    final SqlNodeList extendList;
+}
+{
+    [ <EXTEND> ]
+    extendList = ExtendList() {
+        return extend(tableRef, extendList);
     }
 }
 
@@ -2282,29 +2332,25 @@ SqlNodeList ExtendList() :
 }
 {
     <LPAREN> { s = span(); }
-    ColumnType(list)
+    AddColumnType(list)
     (
-        <COMMA> ColumnType(list)
+        <COMMA> AddColumnType(list)
     )*
     <RPAREN> {
         return new SqlNodeList(list, s.end(this));
     }
 }
 
-void ColumnType(List<SqlNode> list) :
+void AddColumnType(List<SqlNode> list) :
 {
-    SqlIdentifier name;
-    SqlDataTypeSpec type;
-    boolean nullable = true;
+    final SqlIdentifier name;
+    final SqlDataTypeSpec type;
+    final boolean nullable;
 }
 {
     name = CompoundIdentifier()
     type = DataType()
-    [
-        <NOT> <NULL> {
-            nullable = false;
-        }
-    ]
+    nullable = NotNullOpt()
     {
         list.add(name);
         list.add(type.withNullable(nullable, getPos()));
@@ -2314,22 +2360,20 @@ void ColumnType(List<SqlNode> list) :
 /**
  * Parses a compound identifier with optional type.
  */
-void CompoundIdentifierType(List<SqlNode> list, List<SqlNode> extendList) :
+void AddCompoundIdentifierType(List<SqlNode> list, List<SqlNode> extendList) :
 {
     final SqlIdentifier name;
-    SqlDataTypeSpec type = null;
-    boolean nullable = true;
+    final SqlDataTypeSpec type;
+    final boolean nullable;
 }
 {
     name = CompoundIdentifier()
-    [
+    (
         type = DataType()
-        [
-            <NOT> <NULL> {
-                nullable = false;
-            }
-        ]
-    ]
+        nullable = NotNullOpt()
+    |
+        { type = null; nullable = true; }
+    )
     {
         if (type != null) {
             if (!this.conformance.allowExtend()) {
@@ -2343,12 +2387,14 @@ void CompoundIdentifierType(List<SqlNode> list, List<SqlNode> extendList) :
     }
 }
 
-SqlNode TableFunctionCall(SqlParserPos pos) :
+SqlNode TableFunctionCall() :
 {
-    SqlNode call;
+    final Span s;
+    final SqlNode call;
     SqlFunctionCategory funcType = SqlFunctionCategory.USER_DEFINED_TABLE_FUNCTION;
 }
 {
+    <TABLE> { s = span(); } <LPAREN>
     [
         <SPECIFIC>
         {
@@ -2356,8 +2402,9 @@ SqlNode TableFunctionCall(SqlParserPos pos) :
         }
     ]
     call = NamedRoutineCall(funcType, ExprContext.ACCEPT_CURSOR)
+    <RPAREN>
     {
-        return SqlStdOperatorTable.COLLECTION_TABLE.createCall(pos, call);
+        return SqlStdOperatorTable.COLLECTION_TABLE.createCall(s.end(this), call);
     }
 }
 
@@ -2397,31 +2444,38 @@ SqlNode ExplicitTable(SqlParserPos pos) :
  */
 SqlNode TableConstructor() :
 {
-    final List<SqlNode> rowConstructorList = new ArrayList<SqlNode>();
+    final List<SqlNode> list = new ArrayList<SqlNode>();
     final Span s;
 }
 {
-    <VALUES> { s = span(); }
-    RowConstructorList(rowConstructorList)
+    (
+        <VALUES> { s = span(); }
+    |
+        <VALUE>
+        {
+            s = span();
+            if (!this.conformance.isValueAllowed()) {
+                throw SqlUtil.newContextException(getPos(), RESOURCE.valueNotAllowed());
+            }
+        }
+    )
+    AddRowConstructor(list)
+    (
+        LOOKAHEAD(2)
+        <COMMA> AddRowConstructor(list)
+    )*
     {
-        return SqlStdOperatorTable.VALUES.createCall(
-            s.end(this), rowConstructorList);
+        return SqlStdOperatorTable.VALUES.createCall(s.end(this), list);
     }
 }
 
-/**
- * Parses one or more rows in a VALUES expression.
- */
-void RowConstructorList(List<SqlNode> list) :
+/** Parses a row constructor and adds it to a list. */
+void AddRowConstructor(List<SqlNode> list) :
 {
-    SqlNode rowConstructor;
+    SqlNode e;
 }
 {
-    rowConstructor = RowConstructor() { list.add(rowConstructor); }
-    (
-        LOOKAHEAD(2)
-        <COMMA> rowConstructor = RowConstructor() { list.add(rowConstructor); }
-    )*
+    e = RowConstructor() { list.add(e); }
 }
 
 /**
@@ -2429,8 +2483,8 @@ void RowConstructorList(List<SqlNode> list) :
  */
 SqlNode RowConstructor() :
 {
-    SqlNodeList valueList;
-    SqlNode value;
+    final SqlNodeList valueList;
+    final SqlNode value;
     final Span s;
 }
 {
@@ -2459,10 +2513,10 @@ SqlNode RowConstructor() :
             // not.  Taken together with multi-row table constructors, it leads
             // to very easy mistakes if you forget the parentheses on a
             // single-row constructor.  This is also the reason for the
-            // LOOKAHEAD in RowConstructorList().  It would be so much more
+            // LOOKAHEAD in TableConstructor().  It would be so much more
             // reasonable to require parentheses.  Sigh.
             s = Span.of(value);
-            valueList = new SqlNodeList(Collections.singletonList(value),
+            valueList = new SqlNodeList(ImmutableList.of(value),
                 value.getParserPosition());
         }
     )
@@ -2475,90 +2529,82 @@ SqlNode RowConstructor() :
     }
 }
 
-/**
- * Parses the optional WHERE clause for SELECT, DELETE, and UPDATE.
- */
-SqlNode WhereOpt() :
+/** Parses a WHERE clause for SELECT, DELETE, and UPDATE. */
+SqlNode Where() :
 {
     SqlNode condition;
 }
 {
-    <WHERE> condition = Expression(ExprContext.ACCEPT_SUB_QUERY)
-    {
+    <WHERE> condition = Expression(ExprContext.ACCEPT_SUB_QUERY) {
         return condition;
     }
-    |
-    {
-        return null;
-    }
 }
 
-/**
- * Parses the optional GROUP BY clause for SELECT.
- */
-SqlNodeList GroupByOpt() :
+/** Parses a GROUP BY clause for SELECT. */
+SqlNodeList GroupBy() :
 {
-    List<SqlNode> list = new ArrayList<SqlNode>();
+    final List<SqlNode> list;
+    final boolean distinct;
     final Span s;
 }
 {
     <GROUP> { s = span(); }
-    <BY> list = GroupingElementList() {
-        return new SqlNodeList(list, s.addAll(list).pos());
-    }
-|
-    {
-        return null;
+    <BY>
+    (
+        <DISTINCT> { distinct = true; }
+    |   <ALL> { distinct = false; }
+    |   { distinct = false; }
+    )
+    list = GroupingElementList() {
+        final SqlParserPos pos = s.end(this);
+        final List<SqlNode> list2 = distinct
+            ? ImmutableList.of(
+                SqlInternalOperators.GROUP_BY_DISTINCT.createCall(pos, list))
+            : list;
+        return new SqlNodeList(list2, pos);
     }
 }
 
 List<SqlNode> GroupingElementList() :
 {
-    List<SqlNode> list = new ArrayList<SqlNode>();
-    SqlNode e;
+    final List<SqlNode> list = new ArrayList<SqlNode>();
 }
 {
-    e = GroupingElement() { list.add(e); }
-    (
-        LOOKAHEAD(2)
-        <COMMA>
-        e = GroupingElement() { list.add(e); }
-    )*
+    AddGroupingElement(list)
+    ( LOOKAHEAD(2) <COMMA> AddGroupingElement(list) )*
     { return list; }
 }
 
-SqlNode GroupingElement() :
+void AddGroupingElement(List<SqlNode> list) :
 {
-    List<SqlNode> list;
+    final List<SqlNode> subList;
     final SqlNodeList nodes;
-    final SqlNode e;
     final Span s;
 }
 {
     LOOKAHEAD(2)
     <GROUPING> { s = span(); }
-    <SETS> <LPAREN> list = GroupingElementList() <RPAREN> {
-        return SqlStdOperatorTable.GROUPING_SETS.createCall(s.end(this), list);
+    <SETS> <LPAREN> subList = GroupingElementList() <RPAREN> {
+        list.add(
+            SqlStdOperatorTable.GROUPING_SETS.createCall(s.end(this), subList));
     }
 |   <ROLLUP> { s = span(); }
     <LPAREN> nodes = ExpressionCommaList(s, ExprContext.ACCEPT_SUB_QUERY)
     <RPAREN> {
-        return SqlStdOperatorTable.ROLLUP.createCall(s.end(this),
-            nodes.getList());
+        list.add(
+            SqlStdOperatorTable.ROLLUP.createCall(s.end(this), nodes.getList()));
     }
 |   <CUBE> { s = span(); }
     <LPAREN> nodes = ExpressionCommaList(s, ExprContext.ACCEPT_SUB_QUERY)
     <RPAREN> {
-        return SqlStdOperatorTable.CUBE.createCall(s.end(this),
-            nodes.getList());
+        list.add(
+            SqlStdOperatorTable.CUBE.createCall(s.end(this), nodes.getList()));
     }
 |   LOOKAHEAD(3)
-    <LPAREN> <RPAREN> {
-        return new SqlNodeList(getPos());
-    }
-|   e = Expression(ExprContext.ACCEPT_SUB_QUERY) {
-        return e;
+    <LPAREN> { s = span(); } <RPAREN> {
+        list.add(new SqlNodeList(s.end(this)));
     }
+|   AddExpression(list, ExprContext.ACCEPT_SUB_QUERY)
 }
 
 /**
@@ -2571,7 +2617,7 @@ SqlNodeList ExpressionCommaList(
     final List<SqlNode> list = new ArrayList<SqlNode>();
 }
 {
-    ExpressionCommaList2(list, exprContext) {
+    AddExpressions(list, exprContext) {
         return new SqlNodeList(list, s.addAll(list).pos());
     }
 }
@@ -2580,66 +2626,55 @@ SqlNodeList ExpressionCommaList(
  * Parses a list of expressions separated by commas,
  * appending expressions to a given list.
  */
-void ExpressionCommaList2(List<SqlNode> list, ExprContext exprContext) :
+void AddExpressions(List<SqlNode> list, ExprContext exprContext) :
 {
-    SqlNode e;
 }
 {
-    e = Expression(exprContext) { list.add(e); }
+    AddExpression(list, exprContext)
     (
         // NOTE jvs 6-Feb-2004:  See comments at top of file for why
         // hint is necessary here.
         LOOKAHEAD(2)
-        <COMMA> e = Expression(ExprContext.ACCEPT_SUB_QUERY) {
-            list.add(e);
-        }
+        <COMMA> AddExpression(list, ExprContext.ACCEPT_SUB_QUERY)
     )*
 }
 
-/**
- * Parses the optional HAVING clause for SELECT.
- */
-SqlNode HavingOpt() :
+/** Parses a HAVING clause for SELECT. */
+SqlNode Having() :
 {
     SqlNode e;
 }
 {
     <HAVING> e = Expression(ExprContext.ACCEPT_SUB_QUERY) { return e; }
-|
-    { return null; }
 }
 
-/**
- * Parses the optional WINDOW clause for SELECT
- */
-SqlNodeList WindowOpt() :
+/** Parses a WINDOW clause for SELECT. */
+SqlNodeList Window() :
 {
-    SqlIdentifier id;
-    SqlWindow e;
-    List<SqlNode> list;
+    final List<SqlNode> list = new ArrayList<SqlNode>();
     final Span s;
 }
 {
     <WINDOW> { s = span(); }
-    id = SimpleIdentifier() <AS> e = WindowSpecification() {
-        e.setDeclName(id);
-        list = startList(e);
-    }
+    AddWindowSpec(list)
     (
-        // NOTE jhyde 22-Oct-2004:  See comments at top of file for why
-        // hint is necessary here.
         LOOKAHEAD(2)
-        <COMMA> id = SimpleIdentifier() <AS> e = WindowSpecification() {
-            e.setDeclName(id);
-            list.add(e);
-        }
+        <COMMA> AddWindowSpec(list)
     )*
     {
         return new SqlNodeList(list, s.addAll(list).pos());
     }
-|
-    {
-        return null;
+}
+
+void AddWindowSpec(List<SqlNode> list) :
+{
+    final SqlIdentifier id;
+    final SqlWindow e;
+}
+{
+    id = SimpleIdentifier() <AS> e = WindowSpecification() {
+        e.setDeclName(id);
+        list.add(e);
     }
 }
 
@@ -2648,36 +2683,31 @@ SqlNodeList WindowOpt() :
  */
 SqlWindow WindowSpecification() :
 {
-    SqlIdentifier id;
-    List list;
-    SqlNodeList partitionList;
-    SqlNodeList orderList;
-    SqlLiteral isRows = SqlLiteral.createBoolean(false, SqlParserPos.ZERO);
-    SqlNode lowerBound = null, upperBound = null;
-    SqlParserPos startPos;
+    final SqlIdentifier id;
+    final SqlNodeList partitionList;
+    final SqlNodeList orderList;
+    final SqlLiteral isRows;
+    final SqlNode lowerBound, upperBound;
     final Span s, s1, s2;
-    SqlLiteral allowPartial = null;
+    final SqlLiteral allowPartial;
 }
 {
     <LPAREN> { s = span(); }
     (
         id = SimpleIdentifier()
-    |
-        { id = null; }
+    |   { id = null; }
     )
     (
         <PARTITION> { s1 = span(); }
         <BY>
         partitionList = ExpressionCommaList(s1, ExprContext.ACCEPT_NON_QUERY)
-    |
-        { partitionList = SqlNodeList.EMPTY; }
+    |   { partitionList = SqlNodeList.EMPTY; }
     )
     (
         orderList = OrderBy(true)
-    |
-        { orderList = SqlNodeList.EMPTY; }
+    |   { orderList = SqlNodeList.EMPTY; }
     )
-    [
+    (
         (
             <ROWS> { isRows = SqlLiteral.createBoolean(true, getPos()); }
         |
@@ -2688,9 +2718,15 @@ SqlWindow WindowSpecification() :
             <AND> upperBound = WindowRange()
         |
             lowerBound = WindowRange()
+            { upperBound = null; }
         )
-    ]
-    [
+    |
+        {
+            isRows = SqlLiteral.createBoolean(false, SqlParserPos.ZERO);
+            lowerBound = upperBound = null;
+        }
+    )
+    (
         <ALLOW> { s2 = span(); } <PARTIAL> {
             allowPartial = SqlLiteral.createBoolean(true, s2.end(this));
         }
@@ -2698,11 +2734,11 @@ SqlWindow WindowSpecification() :
         <DISALLOW> { s2 = span(); } <PARTIAL> {
             allowPartial = SqlLiteral.createBoolean(false, s2.end(this));
         }
-    ]
+    |   { allowPartial = null; }
+    )
     <RPAREN>
     {
-        return SqlWindow.create(
-            null, id, partitionList, orderList,
+        return SqlWindow.create(null, id, partitionList, orderList,
             isRows, lowerBound, upperBound, allowPartial, s.end(this));
     }
 }
@@ -2742,13 +2778,21 @@ SqlNode WindowRange() :
     )
 }
 
+/** Parses a QUALIFY clause for SELECT. */
+SqlNode Qualify() :
+{
+    SqlNode e;
+}
+{
+    <QUALIFY> e = Expression(ExprContext.ACCEPT_SUB_QUERY) { return e; }
+}
+
 /**
  * Parses an ORDER BY clause.
  */
 SqlNodeList OrderBy(boolean accept) :
 {
-    List<SqlNode> list;
-    SqlNode e;
+    final List<SqlNode> list = new ArrayList<SqlNode>();
     final Span s;
 }
 {
@@ -2761,13 +2805,11 @@ SqlNodeList OrderBy(boolean accept) :
             throw SqlUtil.newContextException(s.pos(), RESOURCE.illegalOrderBy());
         }
     }
-    <BY> e = OrderItem() {
-        list = startList(e);
-    }
+    <BY> AddOrderItem(list)
     (
         // NOTE jvs 6-Feb-2004:  See comments at top of file for why
         // hint is necessary here.
-        LOOKAHEAD(2) <COMMA> e = OrderItem() { list.add(e); }
+        LOOKAHEAD(2) <COMMA> AddOrderItem(list)
     )*
     {
         return new SqlNodeList(list, s.addAll(list).pos());
@@ -2775,9 +2817,9 @@ SqlNodeList OrderBy(boolean accept) :
 }
 
 /**
- * Parses one list item in an ORDER BY clause.
+ * Parses one item in an ORDER BY clause, and adds it to a list.
  */
-SqlNode OrderItem() :
+void AddOrderItem(List<SqlNode> list) :
 {
     SqlNode e;
 }
@@ -2800,10 +2842,35 @@ SqlNode OrderItem() :
         }
     )?
     {
-        return e;
+        list.add(e);
     }
 }
 
+/** Wraps a table reference in a call to OVER if an optional "OVER" clause
+ * is present (if the dialect supports OVER for table expressions). */
+SqlNode Over(SqlNode tableRef) :
+{
+    final SqlNode over;
+}
+{
+    over = TableOverOpt() {
+        if (over != null) {
+            return SqlStdOperatorTable.OVER.createCall(
+                getPos(), checkNotJoin(tableRef), over);
+        } else {
+            return tableRef;
+        }
+    }
+}
+
+/** Wraps a table reference in a call to LATERAL if {@code lateral} is true. */
+JAVACODE SqlNode addLateral(SqlNode tableRef, boolean lateral) {
+    return lateral
+        ? SqlStdOperatorTable.LATERAL.createCall(getPos(),
+            checkNotJoin(tableRef))
+        : tableRef;
+}
+
 /**
  * Parses a FOR SYSTEM_TIME clause following a table expression.
  */
@@ -2839,12 +2906,12 @@ SqlNode Pivot(SqlNode tableRef) :
     final SqlNodeList inList;
 }
 {
-    <PIVOT> { s = span(); }
+    <PIVOT> { s = span(); checkNotJoin(tableRef); }
     <LPAREN>
-    PivotAgg(aggList) ( <COMMA> PivotAgg(aggList) )*
+    AddPivotAgg(aggList) ( <COMMA> AddPivotAgg(aggList) )*
     <FOR> axisList = SimpleIdentifierOrList()
     <IN> <LPAREN> { s2 = span(); }
-    [ PivotValue(valueList) ( <COMMA> PivotValue(valueList) )* ]
+    [ AddPivotValue(valueList) ( <COMMA> AddPivotValue(valueList) )* ]
     <RPAREN> {
         inList = new SqlNodeList(valueList, s2.end(this));
     }
@@ -2856,7 +2923,7 @@ SqlNode Pivot(SqlNode tableRef) :
     }
 }
 
-void PivotAgg(List<SqlNode> list) :
+void AddPivotAgg(List<SqlNode> list) :
 {
     final SqlNode e;
     final SqlIdentifier alias;
@@ -2864,6 +2931,8 @@ void PivotAgg(List<SqlNode> list) :
 {
     e = NamedFunctionCall()
     (
+        // Because babel put FOR into non-reserved keyword set.
+        LOOKAHEAD({getToken(1).kind != COMMA && getToken(1).kind != FOR})
         [ <AS> ] alias = SimpleIdentifier() {
             list.add(
                 SqlStdOperatorTable.AS.createCall(Span.of(e).end(this), e,
@@ -2874,7 +2943,7 @@ void PivotAgg(List<SqlNode> list) :
     )
 }
 
-void PivotValue(List<SqlNode> list) :
+void AddPivotValue(List<SqlNode> list) :
 {
     final SqlNode e;
     final SqlNodeList tuple;
@@ -2905,7 +2974,7 @@ SqlNode Unpivot(SqlNode tableRef) :
     final SqlNodeList inList;
 }
 {
-    <UNPIVOT> { s = span(); }
+    <UNPIVOT> { s = span(); checkNotJoin(tableRef); }
     (
         <INCLUDE> <NULLS> { includeNulls = true; }
     |   <EXCLUDE> <NULLS> { includeNulls = false; }
@@ -2916,7 +2985,7 @@ SqlNode Unpivot(SqlNode tableRef) :
     <FOR> axisList = SimpleIdentifierOrList()
     <IN>
     <LPAREN> { s2 = span(); }
-    UnpivotValue(values) ( <COMMA> UnpivotValue(values) )*
+    AddUnpivotValue(values) ( <COMMA> AddUnpivotValue(values) )*
     <RPAREN>
     { inList = new SqlNodeList(values, s2.end(this)); }
     <RPAREN> {
@@ -2925,7 +2994,7 @@ SqlNode Unpivot(SqlNode tableRef) :
     }
 }
 
-void UnpivotValue(List<SqlNode> list) :
+void AddUnpivotValue(List<SqlNode> list) :
 {
     final SqlNodeList columnList;
     final SqlNode values;
@@ -2950,33 +3019,38 @@ void UnpivotValue(List<SqlNode> list) :
 SqlMatchRecognize MatchRecognize(SqlNode tableRef) :
 {
     final Span s, s0, s1, s2;
-    SqlNodeList measureList = SqlNodeList.EMPTY;
-    SqlNodeList partitionList = SqlNodeList.EMPTY;
-    SqlNodeList orderList = SqlNodeList.EMPTY;
-    SqlNode pattern;
-    SqlLiteral interval;
-    SqlNodeList patternDefList;
+    final SqlNodeList measureList;
+    final SqlNodeList partitionList;
+    final SqlNodeList orderList;
+    final SqlNode pattern;
+    final SqlLiteral interval;
+    final SqlNodeList patternDefList;
     final SqlNode after;
-    SqlParserPos pos;
     final SqlNode var;
     final SqlLiteral rowsPerMatch;
-    SqlNodeList subsetList = SqlNodeList.EMPTY;
-    SqlLiteral isStrictStarts = SqlLiteral.createBoolean(false, getPos());
-    SqlLiteral isStrictEnds = SqlLiteral.createBoolean(false, getPos());
+    final SqlNodeList subsetList;
+    final SqlLiteral isStrictStarts;
+    final SqlLiteral isStrictEnds;
 }
 {
-    <MATCH_RECOGNIZE> { s = span(); } <LPAREN>
-    [
+    <MATCH_RECOGNIZE> { s = span(); checkNotJoin(tableRef); } <LPAREN>
+    (
         <PARTITION> { s2 = span(); } <BY>
         partitionList = ExpressionCommaList(s2, ExprContext.ACCEPT_NON_QUERY)
-    ]
-    [
+    |
+        { partitionList = SqlNodeList.EMPTY; }
+    )
+    (
         orderList = OrderBy(true)
-    ]
-    [
+    |
+        { orderList = SqlNodeList.EMPTY; }
+    )
+    (
         <MEASURES>
         measureList = MeasureColumnCommaList(span())
-    ]
+    |
+        { measureList = SqlNodeList.EMPTY; }
+    )
     (
         <ONE> { s0 = span(); } <ROW> <PER> <MATCH> {
             rowsPerMatch = SqlMatchRecognize.RowsPerMatchOption.ONE_ROW.symbol(s0.end(this));
@@ -2985,10 +3059,7 @@ SqlMatchRecognize MatchRecognize(SqlNode tableRef) :
         <ALL> { s0 = span(); } <ROWS> <PER> <MATCH> {
             rowsPerMatch = SqlMatchRecognize.RowsPerMatchOption.ALL_ROWS.symbol(s0.end(this));
         }
-    |
-        {
-            rowsPerMatch = null;
-        }
+    |   { rowsPerMatch = null; }
     )
     (
         <AFTER> { s1 = span(); } <MATCH> <SKIP_>
@@ -3028,32 +3099,28 @@ SqlMatchRecognize MatchRecognize(SqlNode tableRef) :
                      .symbol(s1.end(this));
             }
         )
-    |
-        { after = null; }
+    |   { after = null; }
     )
     <PATTERN>
     <LPAREN>
     (
         <CARET> { isStrictStarts = SqlLiteral.createBoolean(true, getPos()); }
-    |
-        { isStrictStarts = SqlLiteral.createBoolean(false, getPos()); }
+    |   { isStrictStarts = SqlLiteral.createBoolean(false, getPos()); }
     )
     pattern = PatternExpression()
     (
         <DOLLAR> { isStrictEnds = SqlLiteral.createBoolean(true, getPos()); }
-    |
-        { isStrictEnds = SqlLiteral.createBoolean(false, getPos()); }
+    |   { isStrictEnds = SqlLiteral.createBoolean(false, getPos()); }
     )
     <RPAREN>
     (
         <WITHIN> interval = IntervalLiteral()
-    |
-        { interval = null; }
+    |   { interval = null; }
+    )
+    (
+        <SUBSET> subsetList = SubsetDefinitionCommaList(span())
+    |   { subsetList = SqlNodeList.EMPTY; }
     )
-    [
-        <SUBSET>
-        subsetList = SubsetDefinitionCommaList(span())
-    ]
     <DEFINE>
     patternDefList = PatternDefinitionCommaList(span())
     <RPAREN> {
@@ -3065,34 +3132,24 @@ SqlMatchRecognize MatchRecognize(SqlNode tableRef) :
 
 SqlNodeList MeasureColumnCommaList(Span s) :
 {
-    SqlNode e;
-    final List<SqlNode> eList = new ArrayList<SqlNode>();
+    final List<SqlNode> list = new ArrayList<SqlNode>();
 }
 {
-    e = MeasureColumn() {
-        eList.add(e);
-    }
-    (
-        <COMMA>
-        e = MeasureColumn() {
-            eList.add(e);
-        }
-    )*
-    {
-        return new SqlNodeList(eList, s.addAll(eList).pos());
-    }
+    AddMeasureColumn(list)
+    ( <COMMA> AddMeasureColumn(list) )*
+    { return new SqlNodeList(list, s.addAll(list).pos()); }
 }
 
-SqlNode MeasureColumn() :
+void AddMeasureColumn(List<SqlNode> list) :
 {
-    SqlNode e;
-    SqlIdentifier alias;
+    final SqlNode e;
+    final SqlIdentifier alias;
 }
 {
     e = Expression(ExprContext.ACCEPT_NON_QUERY)
     <AS>
     alias = SimpleIdentifier() {
-        return SqlStdOperatorTable.AS.createCall(Span.of(e).end(this), e, alias);
+        list.add(SqlStdOperatorTable.AS.createCall(Span.of(e).end(this), e, alias));
     }
 }
 
@@ -3135,77 +3192,75 @@ SqlNode PatternTerm() :
 
 SqlNode PatternFactor() :
 {
-    SqlNode e;
-    SqlNode extra;
-    SqlLiteral startNum = null;
-    SqlLiteral endNum = null;
-    SqlLiteral reluctant = SqlLiteral.createBoolean(false, SqlParserPos.ZERO);
+    final SqlNode e;
+    final SqlNode extra;
+    final SqlLiteral startNum;
+    final SqlLiteral endNum;
+    final SqlLiteral reluctant;
 }
 {
     e = PatternPrimary()
-    [
+    (
         LOOKAHEAD(1)
         (
             <STAR> {
-                startNum = SqlLiteral.createExactNumeric("0", SqlParserPos.ZERO);
-                endNum = SqlLiteral.createExactNumeric("-1", SqlParserPos.ZERO);
+                startNum = LITERAL_ZERO;
+                endNum = LITERAL_MINUS_ONE;
             }
         |
             <PLUS> {
-                startNum = SqlLiteral.createExactNumeric("1", SqlParserPos.ZERO);
-                endNum = SqlLiteral.createExactNumeric("-1", SqlParserPos.ZERO);
+                startNum = LITERAL_ONE;
+                endNum = LITERAL_MINUS_ONE;
             }
         |
             <HOOK> {
-                startNum = SqlLiteral.createExactNumeric("0", SqlParserPos.ZERO);
-                endNum = SqlLiteral.createExactNumeric("1", SqlParserPos.ZERO);
+                startNum = LITERAL_ZERO;
+                endNum = LITERAL_ONE;
             }
         |
             <LBRACE>
             (
-                startNum = UnsignedNumericLiteral() { endNum = startNum; }
-                [
-                    <COMMA> {
-                        endNum = SqlLiteral.createExactNumeric("-1", SqlParserPos.ZERO);
-                    }
-                    [
+                startNum = UnsignedNumericLiteral()
+                (
+                    <COMMA>
+                    (
                         endNum = UnsignedNumericLiteral()
-                    ]
-                ]
+                    |
+                        { endNum = LITERAL_MINUS_ONE; }
+                    )
+                |
+                     { endNum = startNum; }
+                )
                 <RBRACE>
             |
-                {
-                    startNum = SqlLiteral.createExactNumeric("-1", SqlParserPos.ZERO);
-                }
                 <COMMA>
                 endNum = UnsignedNumericLiteral()
                 <RBRACE>
+                { startNum = LITERAL_MINUS_ONE; }
             |
                 <MINUS> extra = PatternExpression() <MINUS> <RBRACE> {
-                    extra = SqlStdOperatorTable.PATTERN_EXCLUDE.createCall(
-                        Span.of(extra).end(this), extra);
-                    e = SqlStdOperatorTable.PATTERN_CONCAT.createCall(
-                        Span.of(e).end(this), e, extra);
-                    return e;
+                    return SqlStdOperatorTable.PATTERN_CONCAT.createCall(
+                        Span.of(e).end(this), e,
+                        SqlStdOperatorTable.PATTERN_EXCLUDE.createCall(
+                            Span.of(extra).end(this), extra));
                 }
             )
         )
-        [
-            <HOOK>
-            {
-                if (startNum.intValue(true) != endNum.intValue(true)) {
-                    reluctant = SqlLiteral.createBoolean(true, SqlParserPos.ZERO);
-                }
+        (
+            <HOOK> {
+                reluctant = SqlLiteral.createBoolean(
+                    startNum.intValue(true) != endNum.intValue(true),
+                    SqlParserPos.ZERO);
             }
-        ]
-    ]
+        |
+            { reluctant = SqlLiteral.createBoolean(false, SqlParserPos.ZERO); }
+        )
+    |
+        { return e; }
+    )
     {
-        if (startNum == null) {
-            return e;
-        } else {
-            return SqlStdOperatorTable.PATTERN_QUANTIFIER.createCall(
-                span().end(e), e, startNum, endNum, reluctant);
-        }
+        return SqlStdOperatorTable.PATTERN_QUANTIFIER.createCall(
+            span().end(e), e, startNum, endNum, reluctant);
     }
 }
 
@@ -3213,66 +3268,42 @@ SqlNode PatternPrimary() :
 {
     final Span s;
     SqlNode e;
-    List<SqlNode> eList;
+    final List<SqlNode> list;
 }
 {
+    e = SimpleIdentifier() { return e; }
+|
+    <LPAREN> e = PatternExpression() <RPAREN> { return e; }
+|
+    <LBRACE> { s = span(); }
+    <MINUS> e = PatternExpression()
+    <MINUS> <RBRACE> {
+        return SqlStdOperatorTable.PATTERN_EXCLUDE.createCall(s.end(this), e);
+    }
+|
     (
-        e = SimpleIdentifier()
-    |
-        <LPAREN> e = PatternExpression() <RPAREN>
-    |
-        <LBRACE> { s = span(); }
-        <MINUS> e = PatternExpression()
-        <MINUS> <RBRACE> {
-            e = SqlStdOperatorTable.PATTERN_EXCLUDE.createCall(s.end(this), e);
+        <PERMUTE> { s = span(); list = new ArrayList<SqlNode>(); }
+        <LPAREN>
+        e = PatternExpression() { list.add(e); }
+        ( <COMMA> e = PatternExpression() { list.add(e); } )*
+        <RPAREN> {
+            return SqlStdOperatorTable.PATTERN_PERMUTE.createCall(
+                s.end(this), list);
         }
-    |
-        (
-            <PERMUTE> { s = span(); }
-            <LPAREN>
-            e = PatternExpression() {
-                eList = new ArrayList<SqlNode>();
-                eList.add(e);
-            }
-            (
-                <COMMA>
-                e = PatternExpression()
-                {
-                    eList.add(e);
-                }
-            )*
-            <RPAREN> {
-                e = SqlStdOperatorTable.PATTERN_PERMUTE.createCall(
-                    s.end(this), eList);
-            }
-        )
     )
-    {
-        return e;
-    }
 }
 
 SqlNodeList SubsetDefinitionCommaList(Span s) :
 {
-    SqlNode e;
-    final List<SqlNode> eList = new ArrayList<SqlNode>();
+    final List<SqlNode> list = new ArrayList<SqlNode>();
 }
 {
-    e = SubsetDefinition() {
-        eList.add(e);
-    }
-    (
-        <COMMA>
-        e = SubsetDefinition() {
-            eList.add(e);
-        }
-    )*
-    {
-        return new SqlNodeList(eList, s.addAll(eList).pos());
-    }
+    AddSubsetDefinition(list)
+    ( <COMMA> AddSubsetDefinition(list) )*
+    { return new SqlNodeList(list, s.addAll(list).pos()); }
 }
 
-SqlNode SubsetDefinition() :
+void AddSubsetDefinition(List<SqlNode> list) :
 {
     final SqlNode var;
     final SqlNodeList varList;
@@ -3283,8 +3314,9 @@ SqlNode SubsetDefinition() :
     <LPAREN>
     varList = ExpressionCommaList(span(), ExprContext.ACCEPT_NON_QUERY)
     <RPAREN> {
-        return SqlStdOperatorTable.EQUALS.createCall(span().end(var), var,
-            varList);
+        list.add(
+            SqlStdOperatorTable.EQUALS.createCall(span().end(var), var,
+                varList));
     }
 }
 
@@ -3314,112 +3346,164 @@ SqlNode PatternDefinition() :
     final SqlNode e;
 }
 {
-    var = SimpleIdentifier()
-    <AS>
-    e = Expression(ExprContext.ACCEPT_SUB_QUERY) {
-        return SqlStdOperatorTable.AS.createCall(Span.of(var, e).pos(), e, var);
-    }
+    var = SimpleIdentifier()
+    <AS>
+    e = Expression(ExprContext.ACCEPT_SUB_QUERY) {
+        return SqlStdOperatorTable.AS.createCall(Span.of(var, e).pos(), e, var);
+    }
+}
+
+// ----------------------------------------------------------------------------
+// Expressions
+
+/**
+ * Parses a SQL expression (such as might occur in a WHERE clause) followed by
+ * the end-of-file symbol.
+ */
+SqlNode SqlExpressionEof() :
+{
+    SqlNode e;
+}
+{
+    e = Expression(ExprContext.ACCEPT_SUB_QUERY) (<EOF>)
+    {
+        return e;
+    }
+}
+
+/**
+ * Parses either a row expression or a query expression without ORDER BY.
+ *
+ * <p>Examples of valid queries:
+ * <ul>
+ * <li>{@code SELECT c FROM t}
+ * <li>{@code SELECT c} (valid in some dialects)
+ * <li>{@code SELECT c FROM t UNION SELECT c2 FROM t2}
+ * <li>{@code WITH q AS (SELECT 1) SELECT * FROM q}
+ * <li>{@code VALUES (1, 2)}
+ * <li>{@code TABLE t}
+ * </ul>
+ *
+ * <p>Non-examples:
+ * <ul>
+ * <li>{@code emp CROSS JOIN dept}
+ * <li>{@code SELECT c FROM t ORDER BY c}
+ * <li>{@code (SELECT c FROM t)}
+ * </ul>
+ */
+SqlNode QueryOrExpr(ExprContext exprContext) :
+{
+    SqlNodeList withList = null;
+    final SqlNode e;
+    final List<Object> list = new ArrayList<Object>();
+}
+{
+    [ withList = WithList() ]
+    e = LeafQueryOrExpr(exprContext) { list.add(e); }
+    ( AddSetOpQuery(list, exprContext) )*
+    { return addWith(withList, SqlParserUtil.toTree(list)); }
+}
+
+SqlNode Query(ExprContext exprContext) :
+{
+    SqlNodeList withList = null;
+    final SqlNode e;
+    final List<Object> list = new ArrayList<Object>();
+}
+{
+    [ withList = WithList() ]
+    e = LeafQuery(exprContext) { list.add(e); }
+    ( AddSetOpQuery(list, exprContext) )*
+    { return addWith(withList, SqlParserUtil.toTree(list)); }
 }
 
-// ----------------------------------------------------------------------------
-// Expressions
+JAVACODE SqlNode addWith(SqlNodeList withList, SqlNode e) {
+    return withList == null
+        ? e
+        : new SqlWith(withList.getParserPosition(), withList, e);
+}
 
-/**
- * Parses a SQL expression (such as might occur in a WHERE clause) followed by
- * the end-of-file symbol.
- */
-SqlNode SqlExpressionEof() :
+/** Parses a set operator (e.g. UNION or INTERSECT)
+ * followed by a query or expression,
+ * and adds both to {@code list}. */
+void AddSetOpQueryOrExpr(List<Object> list, ExprContext exprContext) :
 {
-    SqlNode e;
+    final SqlOperator op;
+    final SqlParserPos pos;
+    final SqlNode e;
 }
 {
-    e = Expression(ExprContext.ACCEPT_SUB_QUERY) (<EOF>)
     {
-        return e;
+        if (list.size() == 1 && !((SqlNode) list.get(0)).isA(SqlKind.QUERY)) {
+            // whoops, expression we just parsed wasn't a query,
+            // but we're about to see something like UNION, so
+            // force an exception retroactively
+            checkNonQueryExpression(ExprContext.ACCEPT_QUERY);
+        }
+    }
+    op = BinaryQueryOperator() {
+        // ensure a query is legal in this context
+        pos = getPos();
+        checkQueryExpression(exprContext);
+    }
+    e = LeafQueryOrExpr(ExprContext.ACCEPT_QUERY) {
+        list.add(new SqlParserUtil.ToTreeListItem(op, pos));
+        list.add(e);
     }
 }
 
-/**
- * Parses either a row expression or a query expression without ORDER BY.
- */
-SqlNode QueryOrExpr(ExprContext exprContext) :
+/** Parses a set operator (e.g. UNION or INTERSECT)
+ * followed by a query,
+ * and adds both to {@code list}. */
+void AddSetOpQuery(List<Object> list, ExprContext exprContext) :
 {
-    SqlNodeList withList = null;
-    SqlNode e;
-    SqlOperator op;
-    SqlParserPos pos;
-    SqlParserPos withPos;
-    List<Object> list;
+    final SqlOperator op;
+    final SqlParserPos pos;
+    final SqlNode e;
 }
 {
-    [
-        withList = WithList()
-    ]
-    e = LeafQueryOrExpr(exprContext) {
-        list = startList(e);
-    }
-    (
-        {
-            if (!e.isA(SqlKind.QUERY)) {
-                // whoops, expression we just parsed wasn't a query,
-                // but we're about to see something like UNION, so
-                // force an exception retroactively
-                checkNonQueryExpression(ExprContext.ACCEPT_QUERY);
-            }
-        }
-        op = BinaryQueryOperator() {
-            // ensure a query is legal in this context
-            pos = getPos();
-            checkQueryExpression(exprContext);
-
-        }
-        e = LeafQueryOrExpr(ExprContext.ACCEPT_QUERY) {
-            list.add(new SqlParserUtil.ToTreeListItem(op, pos));
-            list.add(e);
-        }
-    )*
     {
-        e = SqlParserUtil.toTree(list);
-        if (withList != null) {
-            e = new SqlWith(withList.getParserPosition(), withList, e);
+        if (list.size() == 1 && !((SqlNode) list.get(0)).isA(SqlKind.QUERY)) {
+            // whoops, expression we just parsed wasn't a query,
+            // but we're about to see something like UNION, so
+            // force an exception retroactively
+            checkNonQueryExpression(ExprContext.ACCEPT_QUERY);
         }
-        return e;
+    }
+    op = BinaryQueryOperator() {
+        // ensure a query is legal in this context
+        pos = getPos();
+        checkQueryExpression(exprContext);
+    }
+    e = LeafQueryOrExpr(ExprContext.ACCEPT_QUERY) {
+        list.add(new SqlParserUtil.ToTreeListItem(op, pos));
+        list.add(e);
     }
 }
 
 SqlNodeList WithList() :
 {
-    SqlWithItem withItem;
-    SqlParserPos pos;
-    SqlNodeList list;
+    final Span s;
+    final List<SqlWithItem> list = new ArrayList<SqlWithItem>();
 }
 {
-    <WITH> { list = new SqlNodeList(getPos()); }
-    withItem = WithItem() {list.add(withItem);}
-    (
-        <COMMA> withItem = WithItem() {list.add(withItem);}
-    )*
-    { return list; }
+    <WITH> { s = span(); }
+    AddWithItem(list) ( <COMMA> AddWithItem(list) )*
+    { return new SqlNodeList(list, s.end(this)); }
 }
 
-SqlWithItem WithItem() :
+void AddWithItem(List<SqlWithItem> list) :
 {
-    SqlIdentifier id;
-    SqlNodeList columnList = null;
-    SqlNode definition;
+    final SqlIdentifier id;
+    final SqlNodeList columnList;
+    final SqlNode definition;
 }
 {
     id = SimpleIdentifier()
-    [
-        LOOKAHEAD(2)
-        columnList = ParenthesizedSimpleIdentifierList()
-    ]
+    ( columnList = ParenthesizedSimpleIdentifierList() | { columnList = null; } )
     <AS>
     definition = ParenthesizedExpression(ExprContext.ACCEPT_QUERY)
-    {
-        return new SqlWithItem(id.getParserPosition(), id, columnList,
-            definition);
-    }
+    { list.add(new SqlWithItem(id.getParserPosition(), id, columnList, definition)); }
 }
 
 /**
@@ -3431,9 +3515,18 @@ SqlNode LeafQueryOrExpr(ExprContext exprContext) :
     SqlNode e;
 }
 {
-    e = Expression(exprContext) { return e; }
-|
     e = LeafQuery(exprContext) { return e; }
+|
+    e = Expression(exprContext) { return e; }
+}
+
+/** As {@link #Expression} but appends to a list. */
+void AddExpression(List<SqlNode> list, ExprContext exprContext) :
+{
+    final SqlNode e;
+}
+{
+    e = Expression(exprContext) { list.add(e); }
 }
 
 /**
@@ -3441,20 +3534,13 @@ SqlNode LeafQueryOrExpr(ExprContext exprContext) :
  */
 SqlNode Expression(ExprContext exprContext) :
 {
-    List<Object> list;
-    SqlNode e;
+    final List<Object> list;
 }
 {
-    list = Expression2(exprContext)
-    {
-        e = SqlParserUtil.toTree(list);
-        return e;
-    }
+    list = Expression2(exprContext) { return SqlParserUtil.toTree(list); }
 }
 
-// TODO jvs 15-Nov-2003:  ANY/ALL
-
-void Expression2b(ExprContext exprContext, List<Object> list) :
+void AddExpression2b(List<Object> list, ExprContext exprContext) :
 {
     SqlNode e;
     SqlOperator op;
@@ -3508,7 +3594,7 @@ List<Object> Expression2(ExprContext exprContext) :
     final Span s = span();
 }
 {
-    Expression2b(exprContext, list)
+    AddExpression2b(list, exprContext)
     (
         LOOKAHEAD(2)
         (
@@ -3577,7 +3663,7 @@ List<Object> Expression2(ExprContext exprContext) :
                         <ASYMMETRIC>
                     ]
                 )
-                Expression2b(ExprContext.ACCEPT_SUB_QUERY, list3) {
+                AddExpression2b(list3, ExprContext.ACCEPT_SUB_QUERY) {
                     list.add(new SqlParserUtil.ToTreeListItem(op, s.pos()));
                     list.addAll(list3);
                     list3.clear();
@@ -3640,7 +3726,7 @@ List<Object> Expression2(ExprContext exprContext) :
                     checkNonQueryExpression(exprContext);
                     list.add(new SqlParserUtil.ToTreeListItem(op, getPos()));
                 }
-                Expression2b(ExprContext.ACCEPT_SUB_QUERY, list)
+                AddExpression2b(list, ExprContext.ACCEPT_SUB_QUERY)
             |
                 <LBRACKET>
                 e = Expression(ExprContext.ACCEPT_SUB_QUERY)
@@ -3712,10 +3798,8 @@ SqlNode Expression3(ExprContext exprContext) :
     final SqlNode e;
     final SqlNodeList list;
     final SqlNodeList list1;
-    final SqlNodeList list2;
-    final SqlOperator op;
     final Span s;
-    Span rowSpan = null;
+    final Span rowSpan;
 }
 {
     LOOKAHEAD(2)
@@ -3742,9 +3826,10 @@ SqlNode Expression3(ExprContext exprContext) :
         return SqlStdOperatorTable.ROW.createCall(list);
     }
 |
-    [
+    (
         <ROW> { rowSpan = span(); }
-    ]
+    |   { rowSpan = null; }
+    )
     list1 = ParenthesizedQueryOrCommaList(exprContext) {
         if (rowSpan != null) {
             // interpret as row constructor
@@ -3784,11 +3869,9 @@ SqlNode Expression3(ExprContext exprContext) :
                     final SqlCall call = (SqlCall) list1.get(0);
                     if (call.getKind() == SqlKind.MINUS
                             && call.operandCount() == 2) {
-                        List<SqlNode> list3 = startList(call.operand(0));
-                        list3.add(call.operand(1));
-                        list3.add(e);
                         return SqlStdOperatorTable.MINUS_DATE.createCall(
-                            Span.of(list1).end(this), list3);
+                            Span.of(list1).end(this), call.operand(0),
+                            call.operand(1), e);
                      }
                 }
                 throw SqlUtil.newContextException(span().end(list1),
@@ -3862,31 +3945,26 @@ SqlNode UnsignedNumericLiteralOrParam() :
  */
 SqlNode RowExpressionExtension() :
 {
-    final SqlFunctionCategory funcType;
+    final SqlFunctionCategory funcType = SqlFunctionCategory.USER_DEFINED_FUNCTION;
     final SqlIdentifier p;
     final Span s;
     final List<SqlNode> args;
-    SqlCall call;
-    SqlNode e;
-    SqlLiteral quantifier = null;
+    final SqlLiteral quantifier;
 }
 {
-    p = SimpleIdentifier() {
-        e = p;
-    }
+    p = SimpleIdentifier()
     (
         LOOKAHEAD( <LPAREN> ) { s = span(); }
-        {
-            funcType = SqlFunctionCategory.USER_DEFINED_FUNCTION;
-        }
         (
             LOOKAHEAD(2) <LPAREN> <STAR> {
-                args = startList(SqlIdentifier.star(getPos()));
+                quantifier = null;
+                args = ImmutableList.of(SqlIdentifier.star(getPos()));
             }
             <RPAREN>
         |
             LOOKAHEAD(2) <LPAREN> <RPAREN> {
-                args = Collections.emptyList();
+                quantifier = null;
+                args = ImmutableList.of();
             }
         |
             args = FunctionParameterList(ExprContext.ACCEPT_SUB_QUERY) {
@@ -3894,14 +3972,10 @@ SqlNode RowExpressionExtension() :
                 args.remove(0);
             }
         )
-        {
-            call = createCall(p, s.end(this), funcType, quantifier, args);
-            e = call;
-        }
-    )?
-    {
-        return e;
-    }
+        { return createCall(p, s.end(this), funcType, quantifier, args); }
+    |
+        { return p; }
+    )
 }
 
 /**
@@ -3912,7 +3986,7 @@ SqlCall StringAggFunctionCall() :
 {
     final Span s, s2;
     final SqlOperator op;
-    final List<SqlNode> args = new ArrayList();
+    final List<SqlNode> args = new ArrayList<SqlNode>();
     final SqlLiteral qualifier;
     final SqlNodeList orderBy;
     final Pair<SqlParserPos, SqlOperator> nullTreatment;
@@ -3928,21 +4002,20 @@ SqlCall StringAggFunctionCall() :
     <LPAREN>
     (
         qualifier = AllOrDistinct()
-    |
-        { qualifier = null; }
+    |   { qualifier = null; }
     )
-    Arg(args, ExprContext.ACCEPT_SUB_QUERY)
+    AddArg(args, ExprContext.ACCEPT_SUB_QUERY)
     (
         <COMMA> {
             // a comma-list can't appear where only a query is expected
+            // TODO: the following line is a no-op; remove it?
             checkNonQueryExpression(ExprContext.ACCEPT_SUB_QUERY);
         }
-        Arg(args, ExprContext.ACCEPT_SUB_QUERY)
+        AddArg(args, ExprContext.ACCEPT_SUB_QUERY)
     )*
     (
         nullTreatment = NullTreatment()
-    |
-        { nullTreatment = null; }
+    |   { nullTreatment = null; }
     )
     [
         orderBy = OrderBy(true) {
@@ -3974,6 +4047,7 @@ SqlNode AtomicRowExpression() :
 }
 {
     (
+        LOOKAHEAD(2)
         e = LiteralOrIntervalExpression()
     |
         e = DynamicParam()
@@ -4017,16 +4091,17 @@ SqlNode CaseExpression() :
     final Span thenSpan = Span.of();
     final Span s;
     SqlNode e;
-    SqlNode caseIdentifier = null;
-    SqlNode elseClause = null;
-    List<SqlNode> whenList = new ArrayList<SqlNode>();
-    List<SqlNode> thenList = new ArrayList<SqlNode>();
+    final SqlNode caseIdentifier;
+    final SqlNode elseClause;
+    final List<SqlNode> whenList = new ArrayList<SqlNode>();
+    final List<SqlNode> thenList = new ArrayList<SqlNode>();
 }
 {
     <CASE> { s = span(); }
-    [
+    (
         caseIdentifier = Expression(ExprContext.ACCEPT_SUB_QUERY)
-    ]
+    |   { caseIdentifier = null; }
+    )
     (
         <WHEN> { whenSpan.add(this); }
         e = ExpressionCommaList(s, ExprContext.ACCEPT_SUB_QUERY) {
@@ -4040,9 +4115,10 @@ SqlNode CaseExpression() :
             thenList.add(e);
         }
     )+
-    [
+    (
         <ELSE> elseClause = Expression(ExprContext.ACCEPT_SUB_QUERY)
-    ]
+    |   { elseClause = null; }
+    )
     <END> {
         return SqlCase.createSwitched(s.end(this), caseIdentifier,
             new SqlNodeList(whenList, whenSpan.addAll(whenList).pos()),
@@ -4339,8 +4415,7 @@ SqlLiteral SpecialLiteral() :
 SqlNode StringLiteral() :
 {
     String p;
-    int nfrags = 0;
-    List<SqlLiteral> frags = null;
+    final List<SqlLiteral> frags;
     char unicodeEscapeChar = 0;
     String charSet = null;
     SqlCharStringLiteral literal;
@@ -4354,10 +4429,10 @@ SqlNode StringLiteral() :
 
     <BINARY_STRING_LITERAL>
     {
+        frags = new ArrayList<SqlLiteral>();
         try {
             p = SqlParserUtil.trim(token.image, "xX'");
-            frags = startList(SqlLiteral.createBinaryString(p, getPos()));
-            nfrags++;
+            frags.add(SqlLiteral.createBinaryString(p, getPos()));
         } catch (NumberFormatException ex) {
             throw SqlUtil.newContextException(getPos(),
                 RESOURCE.illegalBinaryString(token.image));
@@ -4375,7 +4450,6 @@ SqlNode StringLiteral() :
             try {
                 p = SqlParserUtil.trim(token.image, "'"); // no embedded quotes
                 frags.add(SqlLiteral.createBinaryString(p, getPos()));
-                nfrags++;
             } catch (NumberFormatException ex) {
                 throw SqlUtil.newContextException(getPos(),
                     RESOURCE.illegalBinaryString(token.image));
@@ -4383,8 +4457,8 @@ SqlNode StringLiteral() :
         }
     )*
     {
-        assert (nfrags > 0);
-        if (nfrags == 1) {
+        assert !frags.isEmpty();
+        if (frags.size() == 1) {
             return frags.get(0); // just the head fragment
         } else {
             SqlParserPos pos2 = SqlParserPos.sum(frags);
@@ -4404,15 +4478,15 @@ SqlNode StringLiteral() :
         }
     )
     {
+        frags = new ArrayList<SqlLiteral>();
         p = SqlParserUtil.parseString(token.image);
         try {
             literal = SqlLiteral.createCharString(p, charSet, getPos());
+            frags.add(literal);
         } catch (java.nio.charset.UnsupportedCharsetException e) {
             throw SqlUtil.newContextException(getPos(),
                 RESOURCE.unknownCharacterSet(charSet));
         }
-        frags = startList(literal);
-        nfrags++;
     }
     (
         // The grammar is ambiguous when a continued literals and a character
@@ -4426,12 +4500,11 @@ SqlNode StringLiteral() :
             p = SqlParserUtil.parseString(token.image);
             try {
                 literal = SqlLiteral.createCharString(p, charSet, getPos());
+                frags.add(literal);
             } catch (java.nio.charset.UnsupportedCharsetException e) {
                 throw SqlUtil.newContextException(getPos(),
                     RESOURCE.unknownCharacterSet(charSet));
             }
-            frags.add(literal);
-            nfrags++;
         }
     )*
     [
@@ -4446,13 +4519,13 @@ SqlNode StringLiteral() :
         }
     ]
     {
-        assert nfrags > 0;
-        if (nfrags == 1) {
+        assert !frags.isEmpty();
+        if (frags.size() == 1) {
             // just the head fragment
             SqlLiteral lit = (SqlLiteral) frags.get(0);
             return lit.unescapeUnicode(unicodeEscapeChar);
         } else {
-            SqlNode[] rands = (SqlNode[]) frags.toArray(new SqlNode[nfrags]);
+            SqlNode[] rands = (SqlNode[]) frags.toArray(new SqlNode[0]);
             for (int i = 0; i < rands.length; ++i) {
                 rands[i] = ((SqlLiteral) rands[i]).unescapeUnicode(
                     unicodeEscapeChar);
@@ -4461,6 +4534,17 @@ SqlNode StringLiteral() :
             return SqlStdOperatorTable.LITERAL_CHAIN.createCall(pos2, rands);
         }
     }
+|
+    <C_STYLE_ESCAPED_STRING_LITERAL>
+    {
+        try {
+            p = SqlParserUtil.parseCString(getToken(0).image);
+        } catch (SqlParserUtil.MalformedUnicodeEscape e) {
+            throw SqlUtil.newContextException(getPos(),
+                RESOURCE.unicodeEscapeMalformed(e.i));
+       }
+       return SqlLiteral.createCharString(p, "UTF16", getPos());
+    }
 |
     <BIG_QUERY_DOUBLE_QUOTED_STRING>
     {
@@ -4487,54 +4571,105 @@ SqlNode StringLiteral() :
     }
 }
 
+/** Parses a character literal.
+ * Matches a single-quoted string, such as 'foo';
+ * on BigQuery also matches a double-quoted string, such as "foo".
+ * Returns the value of the string with quotes removed. */
+String SimpleStringLiteral() :
+{
+}
+{
+    <QUOTED_STRING> {
+        return SqlParserUtil.parseString(token.image);
+    }
+|
+    <BIG_QUERY_QUOTED_STRING> {
+        return SqlParserUtil.stripQuotes(token.image, "'", "'", "\\'", Casing.UNCHANGED);
+    }
+|
+    <BIG_QUERY_DOUBLE_QUOTED_STRING> {
+        return SqlParserUtil.stripQuotes(token.image, DQ, DQ, "\\\"", Casing.UNCHANGED);
+    }
+}
 
 /**
  * Parses a date/time literal.
  */
 SqlLiteral DateTimeLiteral() :
 {
-    final String  p;
+    final String p;
     final Span s;
 }
 {
     <LBRACE_D> <QUOTED_STRING> {
-        p = token.image;
+        p = SqlParserUtil.parseString(token.image);
     }
     <RBRACE> {
         return SqlParserUtil.parseDateLiteral(p, getPos());
     }
 |
     <LBRACE_T> <QUOTED_STRING> {
-        p = token.image;
+        p = SqlParserUtil.parseString(token.image);
     }
     <RBRACE> {
         return SqlParserUtil.parseTimeLiteral(p, getPos());
     }
 |
     <LBRACE_TS> { s = span(); } <QUOTED_STRING> {
-        p = token.image;
+        p = SqlParserUtil.parseString(token.image);
     }
     <RBRACE> {
         return SqlParserUtil.parseTimestampLiteral(p, s.end(this));
     }
 |
-    <DATE> { s = span(); } <QUOTED_STRING> {
-        return SqlParserUtil.parseDateLiteral(token.image, s.end(this));
+    <DATE> { s = span(); } p = SimpleStringLiteral() {
+      return SqlLiteral.createUnknown("DATE", p, s.end(this));
+    }
+|
+    <DATETIME> { s = span(); } p = SimpleStringLiteral() {
+        return SqlLiteral.createUnknown("DATETIME", p, s.end(this));
     }
 |
-    <TIME> { s = span(); } <QUOTED_STRING> {
-        return SqlParserUtil.parseTimeLiteral(token.image, s.end(this));
+    <TIME> { s = span(); } p = SimpleStringLiteral() {
+      return SqlLiteral.createUnknown("TIME", p, s.end(this));
     }
 |
-    <TIMESTAMP> { s = span(); } <QUOTED_STRING> {
-        return SqlParserUtil.parseTimestampLiteral(token.image, s.end(this));
+    LOOKAHEAD(2)
+    <TIMESTAMP> { s = span(); } p = SimpleStringLiteral() {
+        return SqlLiteral.createUnknown("TIMESTAMP", p, s.end(this));
+    }
+|
+    <TIMESTAMP> { s = span(); } <WITH> <LOCAL> <TIME> <ZONE> p = SimpleStringLiteral() {
+        return SqlLiteral.createUnknown("TIMESTAMP WITH LOCAL TIME ZONE", p, s.end(this));
+    }
+}
+
+/** Parses a Date/Time constructor function, for example "DATE(1969, 7, 21)"
+ * or "DATETIME(d, t)". Enabled in some libraries (e.g. BigQuery). */
+SqlNode DateTimeConstructorCall() :
+{
+    final SqlFunctionCategory funcType = SqlFunctionCategory.TIMEDATE;
+    final SqlIdentifier qualifiedName;
+    final Span s;
+    final SqlLiteral quantifier;
+    final List<? extends SqlNode> args;
+}
+{
+    (<DATE> | <TIME> | <DATETIME> | <TIMESTAMP>) {
+        s = span();
+        qualifiedName = new SqlIdentifier(unquotedIdentifier(), getPos());
+    }
+    args = FunctionParameterList(ExprContext.ACCEPT_SUB_QUERY) {
+        quantifier = (SqlLiteral) args.get(0);
+        args.remove(0);
+        return createCall(qualifiedName, s.end(this), funcType, quantifier, args);
     }
 }
 
 /** Parses a MULTISET constructor */
 SqlNode MultisetConstructor() :
 {
-    List<SqlNode> args;
+    final List<SqlNode> args = new ArrayList<SqlNode>();
     SqlNode e;
     final Span s;
 }
@@ -4552,10 +4687,8 @@ SqlNode MultisetConstructor() :
     |
         // by enumeration "MULTISET[e0, e1, ..., eN]"
         <LBRACKET> // TODO: do trigraph as well ??( ??)
-        e = Expression(ExprContext.ACCEPT_NON_QUERY) { args = startList(e); }
-        (
-            <COMMA> e = Expression(ExprContext.ACCEPT_NON_QUERY) { args.add(e); }
-        )*
+        AddExpression(args, ExprContext.ACCEPT_NON_QUERY)
+        ( <COMMA> AddExpression(args, ExprContext.ACCEPT_NON_QUERY) )*
         <RBRACKET>
         {
             return SqlStdOperatorTable.MULTISET_VALUE.createCall(
@@ -4570,6 +4703,7 @@ SqlNode ArrayConstructor() :
     SqlNodeList args;
     SqlNode e;
     final Span s;
+    final String p;
 }
 {
     <ARRAY> { s = span(); }
@@ -4577,7 +4711,7 @@ SqlNode ArrayConstructor() :
         LOOKAHEAD(1)
         <LPAREN>
         // by sub query "MULTISET(SELECT * FROM T)"
-        e = LeafQueryOrExpr(ExprContext.ACCEPT_QUERY)
+        e = OrderedQueryOrExpr(ExprContext.ACCEPT_QUERY)
         <RPAREN>
         {
             return SqlStdOperatorTable.ARRAY_QUERY.createCall(
@@ -4596,9 +4730,42 @@ SqlNode ArrayConstructor() :
             return SqlStdOperatorTable.ARRAY_VALUE_CONSTRUCTOR.createCall(
                 s.end(this), args.getList());
         }
+<#if (parser.includeParsingStringLiteralAsArrayLiteral!default.parser.includeParsingStringLiteralAsArrayLiteral) >
+    |
+        p = SimpleStringLiteral() {
+            try {
+                return SqlParserUtil.parseArrayLiteral(p);
+            } catch (SqlParseException ex) {
+                throw SqlUtil.newContextException(getPos(),
+                    RESOURCE.illegalArrayExpression(p));
+            }
+        }
+</#if>
     )
 }
 
+SqlCall ArrayLiteral() :
+{
+    final List<SqlNode> list;
+    SqlNode e;
+    final Span s;
+}
+{
+    <LBRACE> { s = span(); }
+    (
+        e = Literal() { list = startList(e); }
+        ( <COMMA> e = Literal() { list.add(e); } )*
+    |
+        e = ArrayLiteral() { list = startList(e); }
+        ( <COMMA> e = ArrayLiteral() { list.add(e); } )*
+    |
+        { list = Collections.emptyList(); }
+    )
+    <RBRACE> {
+       return SqlStdOperatorTable.ARRAY_VALUE_CONSTRUCTOR.createCall(s.end(this), list);
+    }
+}
+
 /** Parses a MAP constructor */
 SqlNode MapConstructor() :
 {
@@ -4637,17 +4804,17 @@ SqlNode MapConstructor() :
 /** Parses a PERIOD constructor */
 SqlNode PeriodConstructor() :
 {
-    final SqlNode e0, e1;
+    final List<SqlNode> args = new ArrayList<SqlNode>();
     final Span s;
 }
 {
     <PERIOD> { s = span(); }
     <LPAREN>
-    e0 = Expression(ExprContext.ACCEPT_SUB_QUERY)
+    AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
     <COMMA>
-    e1 = Expression(ExprContext.ACCEPT_SUB_QUERY)
+    AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
     <RPAREN> {
-        return SqlStdOperatorTable.ROW.createCall(s.end(this), e0, e1);
+        return SqlStdOperatorTable.ROW.createCall(s.end(this), args);
     }
 }
 
@@ -4668,7 +4835,7 @@ SqlLiteral IntervalLiteral() :
     |
         <PLUS> { sign = 1; }
     ]
-    <QUOTED_STRING> { p = token.image; }
+    p = SimpleStringLiteral()
     intervalQualifier = IntervalQualifier() {
         return SqlParserUtil.parseIntervalLiteral(s.end(intervalQualifier),
             sign, p, intervalQualifier);
@@ -4695,7 +4862,7 @@ SqlNode IntervalLiteralOrExpression() :
     ]
     (
         // literal (with quoted string)
-        <QUOTED_STRING> { p = token.image; }
+        p = SimpleStringLiteral()
         intervalQualifier = IntervalQualifier() {
             return SqlParserUtil.parseIntervalLiteral(s.end(intervalQualifier),
                 sign, p, intervalQualifier);
@@ -4731,6 +4898,15 @@ TimeUnit Year() :
     <YEARS> { return warn(TimeUnit.YEAR); }
 }
 
+TimeUnit Quarter() :
+{
+}
+{
+    <QUARTER> { return TimeUnit.QUARTER; }
+|
+    <QUARTERS> { return warn(TimeUnit.QUARTER); }
+}
+
 TimeUnit Month() :
 {
 }
@@ -4740,6 +4916,15 @@ TimeUnit Month() :
     <MONTHS> { return warn(TimeUnit.MONTH); }
 }
 
+TimeUnit Week() :
+{
+}
+{
+    <WEEK> { return TimeUnit.WEEK; }
+|
+    <WEEKS> { return warn(TimeUnit.WEEK); }
+}
+
 TimeUnit Day() :
 {
 }
@@ -4780,21 +4965,29 @@ SqlIntervalQualifier IntervalQualifier() :
 {
     final Span s;
     final TimeUnit start;
-    TimeUnit end = null;
-    int startPrec = RelDataType.PRECISION_NOT_SPECIFIED;
+    final TimeUnit end;
+    final int startPrec;
     int secondFracPrec = RelDataType.PRECISION_NOT_SPECIFIED;
 }
 {
     (
         start = Year() { s = span(); } startPrec = PrecisionOpt()
-        [
+        (
             LOOKAHEAD(2) <TO> end = Month()
-        ]
+        |   { end = null; }
+        )
+    |
+        start = Quarter() { s = span(); } startPrec = PrecisionOpt()
+        { end = null; }
     |
         start = Month() { s = span(); } startPrec = PrecisionOpt()
+        { end = null; }
+    |
+        start = Week() { s = span(); } startPrec = PrecisionOpt()
+        { end = null; }
     |
         start = Day() { s = span(); } startPrec = PrecisionOpt()
-        [
+        (
             LOOKAHEAD(2) <TO>
             (
                 end = Hour()
@@ -4803,10 +4996,11 @@ SqlIntervalQualifier IntervalQualifier() :
             |
                 end = Second() secondFracPrec = PrecisionOpt()
             )
-        ]
+        |   { end = null; }
+        )
     |
         start = Hour() { s = span(); } startPrec = PrecisionOpt()
-        [
+        (
             LOOKAHEAD(2) <TO>
             (
                 end = Minute()
@@ -4814,20 +5008,25 @@ SqlIntervalQualifier IntervalQualifier() :
                 end = Second()
                 [ <LPAREN> secondFracPrec = UnsignedIntLiteral() <RPAREN> ]
             )
-        ]
+        |   { end = null; }
+        )
     |
         start = Minute() { s = span(); } startPrec = PrecisionOpt()
-        [
-            LOOKAHEAD(2) <TO> end = Second()
+        (
+            LOOKAHEAD(2) <TO>
+            end = Second()
             [ <LPAREN> secondFracPrec = UnsignedIntLiteral() <RPAREN> ]
-        ]
+        |   { end = null; }
+        )
     |
         start = Second() { s = span(); }
-        [
+        (
             <LPAREN> startPrec = UnsignedIntLiteral()
             [ <COMMA> secondFracPrec = UnsignedIntLiteral() ]
             <RPAREN>
-        ]
+        |   { startPrec = -1; }
+        )
+        { end = null; }
     )
     {
         return new SqlIntervalQualifier(start, startPrec, end, secondFracPrec,
@@ -4847,7 +5046,9 @@ SqlIntervalQualifier IntervalQualifierStart() :
     (
         (
             start = Year()
+        |   start = Quarter()
         |   start = Month()
+        |   start = Week()
         |   start = Day()
         |   start = Hour()
         |   start = Minute()
@@ -4867,59 +5068,103 @@ SqlIntervalQualifier IntervalQualifierStart() :
     }
 }
 
-/**
- * Parses time unit for EXTRACT, CEIL and FLOOR functions.
- * Note that it does't include NANOSECOND and MICROSECOND.
+/** Parses a built-in time unit (e.g. "YEAR")
+ * or user-defined time frame (e.g. "MINUTE15")
+ * and in each case returns a {@link SqlIntervalQualifier}.
+ *
+ * <p>The units are used in several functions, incuding CEIL, FLOOR, EXTRACT.
+ * Includes NANOSECOND, MILLISECOND, which were previously allowed in EXTRACT
+ * but not CEIL, FLOOR.
+ *
+ * <p>Includes {@code WEEK} and {@code WEEK(SUNDAY)} through
+  {@code WEEK(SATURDAY)}.
+ *
+ * <p>Does not include SQL_TSI_DAY, SQL_TSI_FRAC_SECOND etc. These will be
+ * parsed as identifiers and can be resolved in the validator if they are
+ * registered as abbreviations in your time frame set.
  */
-TimeUnit TimeUnit() :
-{}
-{
-    <MILLISECOND> { return TimeUnit.MILLISECOND; }
-|   <SECOND> { return TimeUnit.SECOND; }
-|   <MINUTE> { return TimeUnit.MINUTE; }
-|   <HOUR> { return TimeUnit.HOUR; }
-|   <DAY> { return TimeUnit.DAY; }
-|   <DOW> { return TimeUnit.DOW; }
-|   <DOY> { return TimeUnit.DOY; }
-|   <ISODOW> { return TimeUnit.ISODOW; }
-|   <ISOYEAR> { return TimeUnit.ISOYEAR; }
-|   <WEEK> { return TimeUnit.WEEK; }
-|   <MONTH> { return TimeUnit.MONTH; }
-|   <QUARTER> { return TimeUnit.QUARTER; }
-|   <YEAR> { return TimeUnit.YEAR; }
-|   <EPOCH> { return TimeUnit.EPOCH; }
-|   <DECADE> { return TimeUnit.DECADE; }
-|   <CENTURY> { return TimeUnit.CENTURY; }
-|   <MILLENNIUM> { return TimeUnit.MILLENNIUM; }
-}
-
-TimeUnit TimestampInterval() :
-{}
+SqlIntervalQualifier TimeUnitOrName() : {
+    final SqlIdentifier unitName;
+    final SqlIntervalQualifier intervalQualifier;
+}
 {
-    <FRAC_SECOND> { return TimeUnit.MICROSECOND; }
-|   <MICROSECOND> { return TimeUnit.MICROSECOND; }
-|   <NANOSECOND> { return TimeUnit.NANOSECOND; }
-|   <SQL_TSI_FRAC_SECOND> { return TimeUnit.NANOSECOND; }
-|   <SQL_TSI_MICROSECOND> { return TimeUnit.MICROSECOND; }
-|   <SECOND> { return TimeUnit.SECOND; }
-|   <SQL_TSI_SECOND> { return TimeUnit.SECOND; }
-|   <MINUTE> { return TimeUnit.MINUTE; }
-|   <SQL_TSI_MINUTE> { return TimeUnit.MINUTE; }
-|   <HOUR> { return TimeUnit.HOUR; }
-|   <SQL_TSI_HOUR> { return TimeUnit.HOUR; }
-|   <DAY> { return TimeUnit.DAY; }
-|   <SQL_TSI_DAY> { return TimeUnit.DAY; }
-|   <WEEK> { return TimeUnit.WEEK; }
-|   <SQL_TSI_WEEK> { return TimeUnit.WEEK; }
-|   <MONTH> { return TimeUnit.MONTH; }
-|   <SQL_TSI_MONTH> { return TimeUnit.MONTH; }
-|   <QUARTER> { return TimeUnit.QUARTER; }
-|   <SQL_TSI_QUARTER> { return TimeUnit.QUARTER; }
-|   <YEAR> { return TimeUnit.YEAR; }
-|   <SQL_TSI_YEAR> { return TimeUnit.YEAR; }
+    // When we see a time unit that is also a non-reserved keyword, such as
+    // NANOSECOND, there is a choice between using the TimeUnit enum
+    // (TimeUnit.NANOSECOND) or the name. The following LOOKAHEAD directive
+    // tells the parser that we prefer the former.
+    //
+    // Reserved keywords, such as SECOND, cannot be identifiers, and are
+    // therefore not ambiguous.
+    LOOKAHEAD(2)
+    intervalQualifier = TimeUnit() {
+        return intervalQualifier;
+    }
+|   unitName = SimpleIdentifier() {
+        return new SqlIntervalQualifier(unitName.getSimple(),
+            unitName.getParserPosition());
+    }
 }
 
+/** Parses a built-in time unit (e.g. "YEAR")
+ * and returns a {@link SqlIntervalQualifier}.
+ *
+ * <p>Includes {@code WEEK} and {@code WEEK(SUNDAY)} through
+  {@code WEEK(SATURDAY)}.
+ *
+ * <p>Does not include SQL_TSI_DAY, SQL_TSI_FRAC_SECOND etc. These will be
+ * parsed as identifiers and can be resolved in the validator if they are
+ * registered as abbreviations in your time frame set.
+ */
+SqlIntervalQualifier TimeUnit() : {
+    final Span span;
+    final String w;
+}
+{
+    <NANOSECOND> { return new SqlIntervalQualifier(TimeUnit.NANOSECOND, null, getPos()); }
+|   <MICROSECOND> { return new SqlIntervalQualifier(TimeUnit.MICROSECOND, null, getPos()); }
+|   <MILLISECOND> { return new SqlIntervalQualifier(TimeUnit.MILLISECOND, null, getPos()); }
+|   <SECOND> { return new SqlIntervalQualifier(TimeUnit.SECOND, null, getPos()); }
+|   <MINUTE> { return new SqlIntervalQualifier(TimeUnit.MINUTE, null, getPos()); }
+|   <HOUR> { return new SqlIntervalQualifier(TimeUnit.HOUR, null, getPos()); }
+|   <DAY> { return new SqlIntervalQualifier(TimeUnit.DAY, null, getPos()); }
+|   <DAYOFWEEK> { return new SqlIntervalQualifier(TimeUnit.DOW, null, getPos()); }
+|   <DAYOFYEAR> { return new SqlIntervalQualifier(TimeUnit.DOY, null, getPos()); }
+|   <DOW> { return new SqlIntervalQualifier(TimeUnit.DOW, null, getPos()); }
+|   <DOY> { return new SqlIntervalQualifier(TimeUnit.DOY, null, getPos()); }
+|   <ISODOW> { return new SqlIntervalQualifier(TimeUnit.ISODOW, null, getPos()); }
+|   <ISOYEAR> { return new SqlIntervalQualifier(TimeUnit.ISOYEAR, null, getPos()); }
+|   <WEEK> { span = span(); }
+    (
+        // There is a choice between "WEEK(weekday)" and "WEEK". We prefer
+        // the former, and the parser will look ahead for '('.
+        LOOKAHEAD(2)
+        <LPAREN> w = weekdayName() <RPAREN> {
+            return new SqlIntervalQualifier(w, span.end(this));
+        }
+    |
+        { return new SqlIntervalQualifier(TimeUnit.WEEK, null, getPos()); }
+    )
+|   <MONTH> { return new SqlIntervalQualifier(TimeUnit.MONTH, null, getPos()); }
+|   <QUARTER> { return new SqlIntervalQualifier(TimeUnit.QUARTER, null, getPos()); }
+|   <YEAR> { return new SqlIntervalQualifier(TimeUnit.YEAR, null, getPos()); }
+|   <EPOCH> { return new SqlIntervalQualifier(TimeUnit.EPOCH, null, getPos()); }
+|   <DECADE> { return new SqlIntervalQualifier(TimeUnit.DECADE, null, getPos()); }
+|   <CENTURY> { return new SqlIntervalQualifier(TimeUnit.CENTURY, null, getPos()); }
+|   <MILLENNIUM> { return new SqlIntervalQualifier(TimeUnit.MILLENNIUM, null, getPos()); }
+}
 
+String weekdayName() :
+{
+}
+{
+    <SUNDAY> { return "WEEK_SUNDAY"; }
+|   <MONDAY> { return "WEEK_MONDAY"; }
+|   <TUESDAY> { return "WEEK_TUESDAY"; }
+|   <WEDNESDAY> { return "WEEK_WEDNESDAY"; }
+|   <THURSDAY> { return "WEEK_THURSDAY"; }
+|   <FRIDAY> { return "WEEK_FRIDAY"; }
+|   <SATURDAY> { return "WEEK_SATURDAY"; }
+}
 
 /**
  * Parses a dynamic parameter marker.
@@ -4940,7 +5185,7 @@ SqlDynamicParam DynamicParam() :
  * the entry in {@code positions} records its position and whether the
  * segment was quoted.
  */
-void IdentifierSegment(List<String> names, List<SqlParserPos> positions) :
+void AddIdentifierSegment(List<String> names, List<SqlParserPos> positions) :
 {
     final String id;
     char unicodeEscapeChar = BACKSLASH;
@@ -5018,18 +5263,17 @@ void IdentifierSegment(List<String> names, List<SqlParserPos> positions) :
     }
 }
 
-/** As {@link #IdentifierSegment} but part of a table name (for example,
+/** As {@link #AddIdentifierSegment} but part of a table name (for example,
  * following {@code FROM}, {@code INSERT} or {@code UPDATE}).
  *
  * <p>In some dialects the lexical rules for table names are different from
  * for other identifiers. For example, in BigQuery, table names may contain
  * hyphens. */
-void TableIdentifierSegment(List<String> names, List<SqlParserPos> positions) :
+void AddTableIdentifierSegment(List<String> names, List<SqlParserPos> positions) :
 {
 }
 {
-    IdentifierSegment(names, positions)
-    {
+    AddIdentifierSegment(names, positions) {
         final int n = names.size();
         if (n > 0
                 && positions.size() == n
@@ -5055,7 +5299,7 @@ String Identifier() :
     final List<String> names = new ArrayList<String>();
 }
 {
-    IdentifierSegment(names, null) {
+    AddIdentifierSegment(names, null) {
         return names.get(0);
     }
 }
@@ -5069,7 +5313,7 @@ SqlIdentifier SimpleIdentifier() :
     final List<SqlParserPos> positions = new ArrayList<SqlParserPos>();
 }
 {
-    IdentifierSegment(names, positions) {
+    AddIdentifierSegment(names, positions) {
         return new SqlIdentifier(names.get(0), positions.get(0));
     }
 }
@@ -5094,7 +5338,7 @@ SqlIdentifier SimpleIdentifierFromStringLiteral() :
 /**
  * Parses a comma-separated list of simple identifiers.
  */
-void SimpleIdentifierCommaList(List<SqlNode> list) :
+void AddSimpleIdentifiers(List<SqlNode> list) :
 {
     SqlIdentifier id;
 }
@@ -5118,7 +5362,7 @@ SqlNodeList ParenthesizedSimpleIdentifierList() :
 }
 {
     <LPAREN> { s = span(); }
-    SimpleIdentifierCommaList(list)
+    AddSimpleIdentifiers(list)
     <RPAREN> {
         return new SqlNodeList(list, s.end(this));
     }
@@ -5157,11 +5401,11 @@ SqlIdentifier CompoundIdentifier() :
     boolean star = false;
 }
 {
-    IdentifierSegment(nameList, posList)
+    AddIdentifierSegment(nameList, posList)
     (
         LOOKAHEAD(2)
         <DOT>
-        IdentifierSegment(nameList, posList)
+        AddIdentifierSegment(nameList, posList)
     )*
     (
         LOOKAHEAD(2)
@@ -5190,11 +5434,11 @@ SqlIdentifier CompoundTableIdentifier() :
     final List<SqlParserPos> posList = new ArrayList<SqlParserPos>();
 }
 {
-    TableIdentifierSegment(nameList, posList)
+    AddTableIdentifierSegment(nameList, posList)
     (
         LOOKAHEAD(2)
         <DOT>
-        TableIdentifierSegment(nameList, posList)
+        AddTableIdentifierSegment(nameList, posList)
     )*
     {
         SqlParserPos pos = SqlParserPos.sum(posList);
@@ -5205,12 +5449,12 @@ SqlIdentifier CompoundTableIdentifier() :
 /**
  * Parses a comma-separated list of compound identifiers.
  */
-void CompoundIdentifierTypeCommaList(List<SqlNode> list, List<SqlNode> extendList) :
+void AddCompoundIdentifierTypes(List<SqlNode> list, List<SqlNode> extendList) :
 {
 }
 {
-    CompoundIdentifierType(list, extendList)
-    (<COMMA> CompoundIdentifierType(list, extendList))*
+    AddCompoundIdentifierType(list, extendList)
+    (<COMMA> AddCompoundIdentifierType(list, extendList))*
 }
 
 /**
@@ -5225,7 +5469,7 @@ Pair<SqlNodeList, SqlNodeList> ParenthesizedCompoundIdentifierList() :
 }
 {
     <LPAREN> { s = span(); }
-    CompoundIdentifierTypeCommaList(list, extendList)
+    AddCompoundIdentifierTypes(list, extendList)
     <RPAREN> {
         return Pair.of(new SqlNodeList(list, s.end(this)), new SqlNodeList(extendList, s.end(this)));
     }
@@ -5551,17 +5795,35 @@ boolean NullableOptDefaultFalse() :
     { return false; }
 }
 
+/** Parses NOT NULL and returns false, or parses nothing and returns true. */
+boolean NotNullOpt() :
+{
+}
+{
+    <NOT> <NULL> { return false; }
+|
+    { return true; }
+}
+
 /**
 * Parse a "name1 type1 [NULL | NOT NULL], name2 type2 [NULL | NOT NULL] ..." list,
 * the field type default is not nullable.
 */
-void FieldNameTypeCommaList(
-        List<SqlIdentifier> fieldNames,
-        List<SqlDataTypeSpec> fieldTypes) :
+void AddFieldNameTypes(List<SqlIdentifier> fieldNames,
+    List<SqlDataTypeSpec> fieldTypes) :
+{
+}
+{
+    AddFieldNameType(fieldNames, fieldTypes)
+    ( <COMMA> AddFieldNameType(fieldNames, fieldTypes) )*
+}
+
+void AddFieldNameType(List<SqlIdentifier> fieldNames,
+    List<SqlDataTypeSpec> fieldTypes) :
 {
-    SqlIdentifier fName;
-    SqlDataTypeSpec fType;
-    boolean nullable;
+    final SqlIdentifier fName;
+    final SqlDataTypeSpec fType;
+    final boolean nullable;
 }
 {
     fName = SimpleIdentifier()
@@ -5571,16 +5833,6 @@ void FieldNameTypeCommaList(
         fieldNames.add(fName);
         fieldTypes.add(fType.withNullable(nullable, getPos()));
     }
-    (
-        <COMMA>
-        fName = SimpleIdentifier()
-        fType = DataType()
-        nullable = NullableOptDefaultFalse()
-        {
-            fieldNames.add(fName);
-            fieldTypes.add(fType.withNullable(nullable, getPos()));
-        }
-    )*
 }
 
 /**
@@ -5595,7 +5847,7 @@ SqlTypeNameSpec RowTypeName() :
 }
 {
     <ROW>
-    <LPAREN> FieldNameTypeCommaList(fieldNames, fieldTypes) <RPAREN>
+    <LPAREN> AddFieldNameTypes(fieldNames, fieldTypes) <RPAREN>
     {
         return new SqlRowTypeNameSpec(getPos(), fieldNames, fieldTypes);
     }
@@ -5738,19 +5990,23 @@ SqlNode CursorExpression(ExprContext exprContext) :
 SqlNode BuiltinFunctionCall() :
 {
     final SqlIdentifier name;
-    List<SqlNode> args = null;
-    SqlNode e = null;
+    final List<SqlNode> args = new ArrayList<SqlNode>();
+    SqlNode e;
     final Span s;
     SqlDataTypeSpec dt;
-    TimeUnit interval;
-    final TimeUnit unit;
+    final SqlIntervalQualifier unit;
     final SqlNode node;
+    final SqlLiteral style; // mssql convert 'style' operand
+    final SqlFunction f;
 }
 {
     //~ FUNCTIONS WITH SPECIAL SYNTAX ---------------------------------------
     (
-        <CAST> { s = span(); }
-        <LPAREN> e = Expression(ExprContext.ACCEPT_SUB_QUERY) { args = startList(e); }
+        (  <CAST> { f = SqlStdOperatorTable.CAST; }
+        | <SAFE_CAST> { f = SqlLibraryOperators.SAFE_CAST; }
+        )
+        { s = span(); }
+        <LPAREN> AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
         <AS>
         (
             dt = DataType() { args.add(dt); }
@@ -5758,21 +6014,15 @@ SqlNode BuiltinFunctionCall() :
             <INTERVAL> e = IntervalQualifier() { args.add(e); }
         )
         <RPAREN> {
-            return SqlStdOperatorTable.CAST.createCall(s.end(this), args);
+            return f.createCall(s.end(this), args);
         }
     |
-        <EXTRACT> {
-            s = span();
+        <EXTRACT> { s = span(); }
+        <LPAREN> unit = TimeUnitOrName() {
+            args.add(unit);
         }
-        <LPAREN>
-        (
-            <NANOSECOND> { unit = TimeUnit.NANOSECOND; }
-        |   <MICROSECOND> { unit = TimeUnit.MICROSECOND; }
-        |   unit = TimeUnit()
-        )
-        { args = startList(new SqlIntervalQualifier(unit, null, getPos())); }
         <FROM>
-        e = Expression(ExprContext.ACCEPT_SUB_QUERY) { args.add(e); }
+        AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
         <RPAREN> {
             return SqlStdOperatorTable.EXTRACT.createCall(s.end(this), args);
         }
@@ -5782,48 +6032,60 @@ SqlNode BuiltinFunctionCall() :
         // FIXME jvs 31-Aug-2006:  FRG-192:  This should be
         // Expression(ExprContext.ACCEPT_SUB_QUERY), but that doesn't work
         // because it matches the other kind of IN.
-        e = AtomicRowExpression() { args = startList(e); }
+        e = AtomicRowExpression() { args.add(e); }
         <IN>
-        e = Expression(ExprContext.ACCEPT_SUB_QUERY) { args.add(e);}
-        [
-            <FROM>
-            e = Expression(ExprContext.ACCEPT_SUB_QUERY) { args.add(e); }
-        ]
+        AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+        [ <FROM> AddExpression(args, ExprContext.ACCEPT_SUB_QUERY) ]
         <RPAREN> {
             return SqlStdOperatorTable.POSITION.createCall(s.end(this), args);
         }
     |
         <CONVERT> { s = span(); }
         <LPAREN>
-        e = Expression(ExprContext.ACCEPT_SUB_QUERY) {
-            args = startList(e);
-        }
-        <USING> name = SimpleIdentifier() {
-            args.add(name);
-        }
-        <RPAREN> {
-            return SqlStdOperatorTable.CONVERT.createCall(s.end(this), args);
-        }
+        (
+          // CONVERT in the form of CONVERT(x USING y)
+
+          // "AddExpression" matches INTERVAL,
+          // which can also be 1st token in args of MSSQL CONVERT
+          // So lookahead another token (to match <USING> vs. <COMMA>)
+          LOOKAHEAD(2)
+          AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+          <USING> name = SimpleIdentifier() { args.add(name); }
+          <RPAREN> {
+              return SqlStdOperatorTable.CONVERT.createCall(s.end(this), args);
+          }
+        | // mssql CONVERT(type, val [,style])
+          (
+            dt = DataType() { args.add(dt); }
+            |
+            <INTERVAL> e = IntervalQualifier() { args.add(e); }
+          )
+          <COMMA>
+          AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+          [
+            <COMMA>
+            (
+              style = UnsignedNumericLiteral() { args.add(style); }
+              |
+              <NULL> { args.add(SqlLiteral.createNull(getPos())); }
+            )
+          ]
+          <RPAREN> {
+            return SqlLibraryOperators.MSSQL_CONVERT.createCall(s.end(this), args);
+          }
+        )
     |
         <TRANSLATE> { s = span(); }
         <LPAREN>
-        e = Expression(ExprContext.ACCEPT_SUB_QUERY) {
-            args = startList(e);
-        }
+        AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
         (
-            <USING> name = SimpleIdentifier() {
-                args.add(name);
-            }
+            <USING> name = SimpleIdentifier() { args.add(name); }
             <RPAREN> {
                 return SqlStdOperatorTable.TRANSLATE.createCall(s.end(this),
                     args);
             }
         |
-            (
-                <COMMA> e = Expression(ExprContext.ACCEPT_SUB_QUERY) {
-                    args.add(e);
-                }
-            )*
+            ( <COMMA> AddExpression(args, ExprContext.ACCEPT_SUB_QUERY) )*
             <RPAREN> {
                 return SqlLibraryOperators.TRANSLATE3.createCall(s.end(this),
                     args);
@@ -5831,20 +6093,10 @@ SqlNode BuiltinFunctionCall() :
         )
     |
         <OVERLAY> { s = span(); }
-        <LPAREN> e = Expression(ExprContext.ACCEPT_SUB_QUERY) {
-            args = startList(e);
-        }
-        <PLACING> e = Expression(ExprContext.ACCEPT_SUB_QUERY) {
-            args.add(e);
-        }
-        <FROM> e = Expression(ExprContext.ACCEPT_SUB_QUERY) {
-            args.add(e);
-        }
-        [
-            <FOR> e = Expression(ExprContext.ACCEPT_SUB_QUERY) {
-                args.add(e);
-            }
-        ]
+        <LPAREN> AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+        <PLACING> AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+        <FROM> AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+        [ <FOR> AddExpression(args, ExprContext.ACCEPT_SUB_QUERY) ]
         <RPAREN> {
             return SqlStdOperatorTable.OVERLAY.createCall(s.end(this), args);
         }
@@ -5861,15 +6113,12 @@ SqlNode BuiltinFunctionCall() :
     |
         <SUBSTRING> { s = span(); }
         <LPAREN>
-        e = Expression(ExprContext.ACCEPT_SUB_QUERY)
-        { args = startList(e); }
+        AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
         ( <FROM> | <COMMA>)
-        e = Expression(ExprContext.ACCEPT_SUB_QUERY)
-        { args.add(e); }
+        AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
         [
             (<FOR> | <COMMA>)
-            e = Expression(ExprContext.ACCEPT_SUB_QUERY)
-            { args.add(e); }
+            AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
         ]
         <RPAREN> {
             return SqlStdOperatorTable.SUBSTRING.createCall(
@@ -5915,7 +6164,7 @@ SqlNode BuiltinFunctionCall() :
                     if (flag == null) {
                         flag = SqlTrimFunction.Flag.BOTH.symbol(SqlParserPos.ZERO);
                     }
-                    args = startList(flag);
+                    args.add(flag);
                     args.add(null); // no trim chars
                     args.add(trimChars); // reinterpret trimChars as source
                     return SqlStdOperatorTable.TRIM.createCall(s.end(this),
@@ -5927,18 +6176,36 @@ SqlNode BuiltinFunctionCall() :
             if (flag == null) {
                 flag = SqlTrimFunction.Flag.BOTH.symbol(SqlParserPos.ZERO);
             }
-            args = startList(flag);
+            args.add(flag);
             args.add(trimChars);
             args.add(e);
         }
         <RPAREN> {
             return SqlStdOperatorTable.TRIM.createCall(s.end(this), args);
         }
+    |
+        node = DateTimeConstructorCall() { return node; }
+    |
+        node = DateDiffFunctionCall() { return node; }
+    |
+        node = DateTruncFunctionCall() { return node; }
+    |
+        node = DatetimeTruncFunctionCall() { return node; }
     |
         node = TimestampAddFunctionCall() { return node; }
+    |
+        node = DatetimeDiffFunctionCall() { return node; }
     |
         node = TimestampDiffFunctionCall() { return node; }
     |
+        node = TimestampDiff3FunctionCall() { return node; }
+    |
+        node = TimestampTruncFunctionCall() { return node; }
+    |
+        node = TimeDiffFunctionCall() { return node; }
+    |
+        node = TimeTruncFunctionCall() { return node; }
+    |
 <#list (parser.builtinFunctionCallMethods!default.parser.builtinFunctionCallMethods) as method>
         node = ${method} { return node; }
     |
@@ -5965,7 +6232,6 @@ SqlNode BuiltinFunctionCall() :
 
 SqlJsonEncoding JsonRepresentation() :
 {
-
 }
 {
     <JSON>
@@ -5974,9 +6240,9 @@ SqlJsonEncoding JsonRepresentation() :
         LOOKAHEAD(2) <ENCODING>
         (
             <UTF8> { return SqlJsonEncoding.UTF8; }
-            |
+        |
             <UTF16> { return SqlJsonEncoding.UTF16; }
-            |
+        |
             <UTF32> { return SqlJsonEncoding.UTF32; }
         )
     ]
@@ -5987,7 +6253,6 @@ SqlJsonEncoding JsonRepresentation() :
 
 void JsonInputClause() :
 {
-
 }
 {
     <FORMAT> JsonRepresentation()
@@ -6028,18 +6293,12 @@ SqlNode JsonPathSpec() :
 List<SqlNode> JsonApiCommonSyntax() :
 {
     SqlNode e;
-    List<SqlNode> args = new ArrayList<SqlNode>();
+    final List<SqlNode> args = new ArrayList<SqlNode>();
 }
 {
-    e = Expression(ExprContext.ACCEPT_NON_QUERY) {
-        args.add(e);
-    }
-    (
-        <COMMA>
-        e = Expression(ExprContext.ACCEPT_NON_QUERY) {
-            args.add(e);
-        }
-    )
+    AddExpression(args, ExprContext.ACCEPT_NON_QUERY)
+    <COMMA>
+    AddExpression(args, ExprContext.ACCEPT_NON_QUERY)
     [
         // We currently don't support JSON passing clause, leave the java code blocks no-op
         <PASSING> e = Expression(ExprContext.ACCEPT_NON_QUERY) {
@@ -6101,7 +6360,6 @@ SqlCall JsonExistsFunctionCall() :
 List<SqlNode> JsonValueEmptyOrErrorBehavior() :
 {
     final List<SqlNode> list = new ArrayList<SqlNode>();
-    final SqlNode e;
 }
 {
     (
@@ -6113,10 +6371,10 @@ List<SqlNode> JsonValueEmptyOrErrorBehavior() :
             list.add(SqlJsonValueEmptyOrErrorBehavior.NULL.symbol(getPos()));
         }
     |
-        <DEFAULT_> e = Expression(ExprContext.ACCEPT_NON_QUERY) {
+        <DEFAULT_> {
             list.add(SqlJsonValueEmptyOrErrorBehavior.DEFAULT.symbol(getPos()));
-            list.add(e);
         }
+        AddExpression(list, ExprContext.ACCEPT_NON_QUERY)
     )
     <ON>
     (
@@ -6163,7 +6421,6 @@ SqlCall JsonValueFunctionCall() :
 List<SqlNode> JsonQueryEmptyOrErrorBehavior() :
 {
     final List<SqlNode> list = new ArrayList<SqlNode>();
-    SqlNode e;
 }
 {
     (
@@ -6199,7 +6456,6 @@ List<SqlNode> JsonQueryEmptyOrErrorBehavior() :
 
 SqlNode JsonQueryWrapperBehavior() :
 {
-    SqlNode e;
 }
 {
     <WITHOUT> [<ARRAY>] {
@@ -6267,7 +6523,7 @@ SqlNode JsonName() :
 List<SqlNode> JsonNameAndValue() :
 {
     final List<SqlNode> list = new ArrayList<SqlNode>();
-    SqlNode e;
+    final SqlNode e;
     boolean kvMode = false;
 }
 {
@@ -6287,9 +6543,7 @@ List<SqlNode> JsonNameAndValue() :
             }
         }
     )
-    e = Expression(ExprContext.ACCEPT_NON_QUERY) {
-        list.add(e);
-    }
+    AddExpression(list, ExprContext.ACCEPT_NON_QUERY)
     {
         return list;
     }
@@ -6380,15 +6634,8 @@ SqlCall JsonArrayFunctionCall() :
     <JSON_ARRAY> { span = span(); }
     <LPAREN> [
         LOOKAHEAD(2)
-        e = Expression(ExprContext.ACCEPT_NON_QUERY) {
-            elements.add(e);
-        }
-        (
-            <COMMA>
-            e = Expression(ExprContext.ACCEPT_NON_QUERY) {
-                elements.add(e);
-            }
-        )*
+        AddExpression(elements, ExprContext.ACCEPT_NON_QUERY)
+        ( <COMMA> AddExpression(elements, ExprContext.ACCEPT_NON_QUERY) )*
     ]
     [
         e = JsonConstructorNullClause() {
@@ -6408,25 +6655,17 @@ SqlNodeList JsonArrayAggOrderByClause() :
     final SqlNodeList orderList;
 }
 {
-    (
-        orderList = OrderBy(true)
-    |
-        { orderList = null; }
-    )
-    {
-        return orderList;
-    }
+    orderList = OrderBy(true)
+    { return orderList; }
 }
 
 SqlCall JsonArrayAggFunctionCall() :
 {
     final SqlNode valueExpr;
     final SqlNodeList orderList;
-    List<SqlNode> list;
     final Span span;
-    SqlJsonConstructorNullClause nullClause =
-        SqlJsonConstructorNullClause.ABSENT_ON_NULL;
-    SqlNode e = null;
+    final SqlJsonConstructorNullClause nullClause;
+    SqlNode e;
     final SqlNode aggCall;
 }
 {
@@ -6434,12 +6673,13 @@ SqlCall JsonArrayAggFunctionCall() :
     <LPAREN> e = Expression(ExprContext.ACCEPT_NON_QUERY) {
         valueExpr = e;
     }
-    orderList = JsonArrayAggOrderByClause()
-    [
+    ( orderList = JsonArrayAggOrderByClause() | { orderList = null; } )
+    (
         e = JsonConstructorNullClause() {
             nullClause = (SqlJsonConstructorNullClause) ((SqlLiteral) e).getValue();
         }
-    ]
+    |   { nullClause = SqlJsonConstructorNullClause.ABSENT_ON_NULL; }
+    )
     <RPAREN>
     {
         aggCall = SqlStdOperatorTable.JSON_ARRAYAGG.with(nullClause)
@@ -6464,27 +6704,45 @@ SqlCall JsonArrayAggFunctionCall() :
     }
 }
 
+/**
+ * Parses a call to BigQuery's DATE_DIFF.
+ */
+SqlCall DateDiffFunctionCall() :
+{
+    final List<SqlNode> args = new ArrayList<SqlNode>();
+    final Span s;
+    final SqlIntervalQualifier unit;
+}
+{
+    <DATE_DIFF> { s = span(); }
+    <LPAREN>
+    AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+    <COMMA>
+    AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+    <COMMA>
+    unit = TimeUnitOrName() { args.add(unit); }
+    <RPAREN> {
+        return SqlLibraryOperators.DATE_DIFF.createCall(s.end(this), args);
+    }
+}
+
 /**
  * Parses a call to TIMESTAMPADD.
  */
 SqlCall TimestampAddFunctionCall() :
 {
-    List<SqlNode> args;
-    SqlNode e;
+    final List<SqlNode> args = new ArrayList<SqlNode>();
     final Span s;
-    TimeUnit interval;
-    SqlNode node;
+    final SqlIntervalQualifier unit;
 }
 {
     <TIMESTAMPADD> { s = span(); }
     <LPAREN>
-    interval = TimestampInterval() {
-        args = startList(SqlLiteral.createSymbol(interval, getPos()));
-    }
+    unit = TimeUnitOrName() { args.add(unit); }
     <COMMA>
-    e = Expression(ExprContext.ACCEPT_SUB_QUERY) { args.add(e); }
+    AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
     <COMMA>
-    e = Expression(ExprContext.ACCEPT_SUB_QUERY) { args.add(e); }
+    AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
     <RPAREN> {
         return SqlStdOperatorTable.TIMESTAMP_ADD.createCall(
             s.end(this), args);
@@ -6496,33 +6754,189 @@ SqlCall TimestampAddFunctionCall() :
  */
 SqlCall TimestampDiffFunctionCall() :
 {
-    List<SqlNode> args;
-    SqlNode e;
+    final List<SqlNode> args = new ArrayList<SqlNode>();
     final Span s;
-    TimeUnit interval;
-    SqlNode node;
+    final SqlIntervalQualifier unit;
 }
 {
     <TIMESTAMPDIFF> { s = span(); }
     <LPAREN>
-    interval = TimestampInterval() {
-        args = startList(SqlLiteral.createSymbol(interval, getPos()));
-    }
+    unit = TimeUnitOrName() { args.add(unit); }
     <COMMA>
-    e = Expression(ExprContext.ACCEPT_SUB_QUERY) { args.add(e); }
+    AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
     <COMMA>
-    e = Expression(ExprContext.ACCEPT_SUB_QUERY) { args.add(e); }
+    AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
     <RPAREN> {
         return SqlStdOperatorTable.TIMESTAMP_DIFF.createCall(
             s.end(this), args);
     }
 }
 
+/**
+ * Parses a call to BigQuery's TIMESTAMP_DIFF.
+ *
+ * <p>The difference between TIMESTAMPDIFF and TIMESTAMP_DIFF is the ordering of
+ * the parameters and the arrangement of the subtraction.
+ * TIMESTAMPDIFF uses (unit, timestamp1, timestamp2) with (t2 - t1), while
+ * TIMESTAMP_DIFF uses (timestamp1, timestamp2, unit) with (t1 - t2).
+ */
+SqlCall TimestampDiff3FunctionCall() :
+{
+    final List<SqlNode> args = new ArrayList<SqlNode>();
+    final Span s;
+    final SqlIntervalQualifier unit;
+}
+{
+    <TIMESTAMP_DIFF> { s = span(); }
+    <LPAREN>
+    AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+    <COMMA>
+    AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+    <COMMA>
+    unit = TimeUnitOrName() { args.add(unit); }
+    <RPAREN> {
+        return SqlLibraryOperators.TIMESTAMP_DIFF3.createCall(s.end(this), args);
+    }
+}
+
+/**
+ * Parses BigQuery's built-in DATETIME_DIFF() function.
+ */
+SqlCall DatetimeDiffFunctionCall() :
+{
+    final List<SqlNode> args = new ArrayList<SqlNode>();
+    final Span s;
+    final SqlIntervalQualifier unit;
+}
+{
+    <DATETIME_DIFF> { s = span(); }
+    <LPAREN>
+    AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+    <COMMA>
+    AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+    <COMMA>
+    unit = TimeUnitOrName() { args.add(unit); }
+    <RPAREN> {
+        return SqlLibraryOperators.DATETIME_DIFF.createCall(s.end(this), args);
+    }
+}
+
+/**
+ * Parses a call to DATE_TRUNC.
+ */
+SqlCall DateTruncFunctionCall() :
+{
+    final List<SqlNode> args = new ArrayList<SqlNode>();
+    final Span s;
+    final SqlIntervalQualifier unit;
+}
+{
+    <DATE_TRUNC> { s = span(); }
+    <LPAREN>
+    AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+    <COMMA>
+    // A choice of arguments allows us to support both
+    // the BigQuery variant, e.g. "DATE_TRUNC(d, YEAR)",
+    // and the Redshift variant, e.g. "DATE_TRUNC('year', DATE '2008-09-08')".
+    (
+        LOOKAHEAD(2)
+        unit = TimeUnit() { args.add(unit); }
+    |
+        AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+    )
+    <RPAREN> {
+        return SqlLibraryOperators.DATE_TRUNC.createCall(s.end(this), args);
+    }
+}
+
+/**
+ * Parses a call to TIMESTAMP_TRUNC.
+ */
+SqlCall TimestampTruncFunctionCall() :
+{
+    final List<SqlNode> args = new ArrayList<SqlNode>();
+    final Span s;
+    final SqlIntervalQualifier unit;
+}
+{
+    <TIMESTAMP_TRUNC> { s = span(); }
+    <LPAREN>
+    AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+    <COMMA>
+    unit = TimeUnitOrName() { args.add(unit); }
+    <RPAREN> {
+        return SqlLibraryOperators.TIMESTAMP_TRUNC.createCall(s.end(this), args);
+    }
+}
+
+/**
+ * Parses a call to BigQuery's TIME_DIFF.
+ */
+SqlCall TimeDiffFunctionCall() :
+{
+    final List<SqlNode> args = new ArrayList<SqlNode>();
+    final Span s;
+    final SqlIntervalQualifier unit;
+}
+{
+    <TIME_DIFF> { s = span(); }
+    <LPAREN>
+    AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+    <COMMA>
+    AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+    <COMMA>
+    unit = TimeUnitOrName() { args.add(unit); }
+    <RPAREN> {
+        return SqlLibraryOperators.TIME_DIFF.createCall(s.end(this), args);
+    }
+}
+
+/**
+ * Parses a call to DATETIME_TRUNC.
+ */
+SqlNode DatetimeTruncFunctionCall() :
+{
+    final List<SqlNode> args = new ArrayList<SqlNode>();
+    final Span s;
+    final SqlIntervalQualifier unit;
+    final SqlNode literal;
+}
+{
+    <DATETIME_TRUNC> { s = span(); }
+    <LPAREN>
+    AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+    <COMMA>
+    unit = TimeUnitOrName() { args.add(unit); }
+    <RPAREN> {
+        return SqlLibraryOperators.DATETIME_TRUNC.createCall(s.end(this), args);
+    }
+}
+
+/**
+ * Parses a call to TIME_TRUNC.
+ */
+SqlCall TimeTruncFunctionCall() :
+{
+    final List<SqlNode> args = new ArrayList<SqlNode>();
+    final Span s;
+    final SqlIntervalQualifier unit;
+}
+{
+    <TIME_TRUNC> { s = span(); }
+    <LPAREN>
+    AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+    <COMMA>
+    unit = TimeUnitOrName() { args.add(unit); }
+    <RPAREN> {
+        return SqlLibraryOperators.TIME_TRUNC.createCall(s.end(this), args);
+    }
+}
+
 /**
  * Parses a call to a grouping function inside the GROUP BY clause,
  * for example {@code TUMBLE(rowtime, INTERVAL '1' MINUTE)}.
  */
-SqlCall GroupByWindowingCall():
+SqlCall GroupByWindowingCall() :
 {
     final Span s;
     final List<SqlNode> args;
@@ -6530,24 +6944,13 @@ SqlCall GroupByWindowingCall():
 }
 {
     (
-        <TUMBLE>
-        {
-            op = SqlStdOperatorTable.TUMBLE_OLD;
-        }
+        <TUMBLE> { op = SqlStdOperatorTable.TUMBLE_OLD; }
     |
-        <HOP>
-        {
-            op = SqlStdOperatorTable.HOP_OLD;
-        }
+        <HOP> { op = SqlStdOperatorTable.HOP_OLD; }
     |
-        <SESSION>
-        {
-            op = SqlStdOperatorTable.SESSION_OLD;
-        }
+        <SESSION> { op = SqlStdOperatorTable.SESSION_OLD; }
     )
-    {
-        s = span();
-    }
+    { s = span(); }
     args = UnquantifiedFunctionParameterList(ExprContext.ACCEPT_SUB_QUERY) {
         return op.createCall(s.end(this), args);
     }
@@ -6603,16 +7006,15 @@ SqlCall MatchRecognizeNavigationLogical() :
     SqlCall func;
     final SqlOperator funcOp;
     final SqlOperator runningOp;
-    SqlNode arg0;
-    SqlNode arg1 = SqlLiteral.createExactNumeric("0", SqlParserPos.ZERO);
+    final List<SqlNode> args = new ArrayList<SqlNode>();
+    SqlNode e;
 }
 {
     (
         <RUNNING> { runningOp = SqlStdOperatorTable.RUNNING; s.add(this); }
     |
         <FINAL> { runningOp = SqlStdOperatorTable.FINAL; s.add(this); }
-    |
-        { runningOp = null; }
+    |   { runningOp = null; }
     )
     (
         <FIRST> { funcOp = SqlStdOperatorTable.FIRST; }
@@ -6621,10 +7023,14 @@ SqlCall MatchRecognizeNavigationLogical() :
     )
     { s.add(this); }
     <LPAREN>
-    arg0 = Expression(ExprContext.ACCEPT_SUB_QUERY)
-    [ <COMMA> arg1 = NumericLiteral() ]
+    AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+    (
+        <COMMA> e = NumericLiteral() { args.add(e); }
+    |
+        { args.add(LITERAL_ZERO); }
+    )
     <RPAREN> {
-        func = funcOp.createCall(s.end(this), arg0, arg1);
+        func = funcOp.createCall(s.end(this), args);
         if (runningOp != null) {
             return runningOp.createCall(s.end(this), func);
         } else {
@@ -6636,10 +7042,9 @@ SqlCall MatchRecognizeNavigationLogical() :
 SqlCall MatchRecognizeNavigationPhysical() :
 {
     final Span s;
-    SqlCall func;
-    SqlOperator funcOp;
-    SqlNode arg0;
-    SqlNode arg1 = SqlLiteral.createExactNumeric("1", SqlParserPos.ZERO);
+    final SqlOperator funcOp;
+    final List<SqlNode> args = new ArrayList<SqlNode>();
+    SqlNode e;
 }
 {
     (
@@ -6649,10 +7054,14 @@ SqlCall MatchRecognizeNavigationPhysical() :
     )
     { s = span(); }
     <LPAREN>
-    arg0 = Expression(ExprContext.ACCEPT_SUB_QUERY)
-    [ <COMMA> arg1 = NumericLiteral() ]
+    AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+    (
+        <COMMA> e = NumericLiteral() { args.add(e); }
+    |
+        { args.add(LITERAL_ONE); }
+    )
     <RPAREN> {
-        return funcOp.createCall(s.end(this), arg0, arg1);
+        return funcOp.createCall(s.end(this), args);
     }
 }
 
@@ -6732,7 +7141,6 @@ SqlNode NamedFunctionCall() :
     final SqlNode filter;
     final Span overSpan;
     final SqlNode over;
-    final Span withinGroupSpan;
 }
 {
     (
@@ -6798,12 +7206,12 @@ SqlCall NamedCall() :
     }
     (
         LOOKAHEAD(2) <LPAREN> <STAR> {
-            args = startList(SqlIdentifier.star(getPos()));
+            args = ImmutableList.of(SqlIdentifier.star(getPos()));
         }
         <RPAREN>
     |
         LOOKAHEAD(2) <LPAREN> <RPAREN> {
-            args = Collections.emptyList();
+            args = ImmutableList.of();
         }
     |
         args = FunctionParameterList(ExprContext.ACCEPT_SUB_QUERY) {
@@ -6822,19 +7230,16 @@ SqlCall NamedCall() :
 SqlNode StandardFloorCeilOptions(Span s, boolean floorFlag) :
 {
     SqlNode e;
-    final List<SqlNode> args;
-    TimeUnit unit;
+    final List<SqlNode> args = new ArrayList<SqlNode>();
+    final SqlIntervalQualifier unit;
     SqlCall function;
     final Span s1;
 }
 {
-    <LPAREN> e = Expression(ExprContext.ACCEPT_SUB_QUERY) {
-        args = startList(e);
-    }
+    <LPAREN> AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
     (
-        <TO>
-        unit = TimeUnit() {
-            args.add(new SqlIntervalQualifier(unit, null, getPos()));
+        <TO> unit = TimeUnitOrName() {
+            args.add(unit);
         }
     )?
     <RPAREN> {
@@ -6904,6 +7309,7 @@ SqlIdentifier ReservedFunctionName() :
     |   <AVG>
     |   <CARDINALITY>
     |   <CEILING>
+    |   <CHAR>
     |   <CHAR_LENGTH>
     |   <CHARACTER_LENGTH>
     |   <COALESCE>
@@ -7013,11 +7419,53 @@ SqlNode JdbcFunctionCall() :
         s = span();
     }
     (
+        LOOKAHEAD(1)
+        call = DateDiffFunctionCall() {
+            name = call.getOperator().getName();
+            args = new SqlNodeList(call.getOperandList(), getPos());
+        }
+    |
+        LOOKAHEAD(1)
+        call = DatetimeDiffFunctionCall() {
+            name = call.getOperator().getName();
+            args = new SqlNodeList(call.getOperandList(), getPos());
+        }
+    |
         LOOKAHEAD(1)
         call = TimestampAddFunctionCall() {
             name = call.getOperator().getName();
             args = new SqlNodeList(call.getOperandList(), getPos());
         }
+    |
+        LOOKAHEAD(1)
+        call = DateTruncFunctionCall() {
+            name = call.getOperator().getName();
+            args = new SqlNodeList(call.getOperandList(), getPos());
+        }
+    |
+        LOOKAHEAD(1)
+        call = TimestampTruncFunctionCall() {
+            name = call.getOperator().getName();
+            args = new SqlNodeList(call.getOperandList(), getPos());
+        }
+    |
+        LOOKAHEAD(1)
+        call = TimeTruncFunctionCall() {
+            name = call.getOperator().getName();
+            args = new SqlNodeList(call.getOperandList(), getPos());
+        }
+    |
+        LOOKAHEAD(1)
+        call = TimestampDiff3FunctionCall() {
+            name = call.getOperator().getName();
+            args = new SqlNodeList(call.getOperandList(), getPos());
+        }
+    |
+        LOOKAHEAD(1)
+        call = TimeDiffFunctionCall() {
+            name = call.getOperator().getName();
+            args = new SqlNodeList(call.getOperandList(), getPos());
+        }
     |
         LOOKAHEAD(3)
         call = TimestampDiffFunctionCall() {
@@ -7387,9 +7835,16 @@ SqlPostfixOperator PostfixRowOperator() :
 |   < DATA: "DATA" >
 |   < DATABASE: "DATABASE" >
 |   < DATE: "DATE" >
+|   < DATE_DIFF: "DATE_DIFF" >
+|   < DATE_TRUNC: "DATE_TRUNC" >
+|   < DATETIME: "DATETIME" >
+|   < DATETIME_DIFF: "DATETIME_DIFF" >
 |   < DATETIME_INTERVAL_CODE: "DATETIME_INTERVAL_CODE" >
 |   < DATETIME_INTERVAL_PRECISION: "DATETIME_INTERVAL_PRECISION" >
+|   < DATETIME_TRUNC: "DATETIME_TRUNC" >
 |   < DAY: "DAY" >
+|   < DAYOFWEEK: "DAYOFWEEK" >
+|   < DAYOFYEAR: "DAYOFYEAR" >
 |   < DAYS: "DAYS" >
 |   < DEALLOCATE: "DEALLOCATE" >
 |   < DEC: "DEC" >
@@ -7471,6 +7926,7 @@ SqlPostfixOperator PostfixRowOperator() :
 |   < FRAC_SECOND: "FRAC_SECOND" >
 |   < FRAME_ROW: "FRAME_ROW" >
 |   < FREE: "FREE" >
+|   < FRIDAY: "FRIDAY" >
 |   < FROM: "FROM" > { beforeTableName(); }
 |   < FULL: "FULL" >
 |   < FUNCTION: "FUNCTION" >
@@ -7589,6 +8045,7 @@ SqlPostfixOperator PostfixRowOperator() :
 |   < MOD: "MOD" >
 |   < MODIFIES: "MODIFIES" >
 |   < MODULE: "MODULE" >
+|   < MONDAY: "MONDAY" >
 |   < MONTH: "MONTH" >
 |   < MONTHS: "MONTHS" >
 |   < MORE_: "MORE" >
@@ -7685,7 +8142,9 @@ SqlPostfixOperator PostfixRowOperator() :
 |   < PRIVILEGES: "PRIVILEGES" >
 |   < PROCEDURE: "PROCEDURE" >
 |   < PUBLIC: "PUBLIC" >
+|   < QUALIFY: "QUALIFY" >
 |   < QUARTER: "QUARTER" >
+|   < QUARTERS: "QUARTERS" >
 |   < RANGE: "RANGE" >
 |   < RANK: "RANK" >
 |   < READ: "READ" >
@@ -7735,6 +8194,8 @@ SqlPostfixOperator PostfixRowOperator() :
 |   < ROW_NUMBER: "ROW_NUMBER" >
 |   < ROWS: "ROWS" >
 |   < RUNNING: "RUNNING" >
+|   < SAFE_CAST: "SAFE_CAST" >
+|   < SATURDAY: "SATURDAY" >
 |   < SAVEPOINT: "SAVEPOINT" >
 |   < SCALAR: "SCALAR" >
 |   < SCALE: "SCALE" >
@@ -7848,6 +8309,7 @@ SqlPostfixOperator PostfixRowOperator() :
 |   < SUBSTRING_REGEX: "SUBSTRING_REGEX" >
 |   < SUCCEEDS: "SUCCEEDS" >
 |   < SUM: "SUM" >
+|   < SUNDAY: "SUNDAY" >
 |   < SYMMETRIC: "SYMMETRIC" >
 |   < SYSTEM: "SYSTEM" >
 |   < SYSTEM_TIME: "SYSTEM_TIME" >
@@ -7857,11 +8319,16 @@ SqlPostfixOperator PostfixRowOperator() :
 |   < TABLESAMPLE: "TABLESAMPLE" >
 |   < TEMPORARY: "TEMPORARY" >
 |   < THEN: "THEN" >
+|   < THURSDAY: "THURSDAY" >
 |   < TIES: "TIES" >
 |   < TIME: "TIME" >
+|   < TIME_DIFF: "TIME_DIFF" >
+|   < TIME_TRUNC: "TIME_TRUNC" >
 |   < TIMESTAMP: "TIMESTAMP" >
 |   < TIMESTAMPADD: "TIMESTAMPADD" >
 |   < TIMESTAMPDIFF: "TIMESTAMPDIFF" >
+|   < TIMESTAMP_DIFF: "TIMESTAMP_DIFF" >
+|   < TIMESTAMP_TRUNC: "TIMESTAMP_TRUNC" >
 |   < TIMEZONE_HOUR: "TIMEZONE_HOUR" >
 |   < TIMEZONE_MINUTE: "TIMEZONE_MINUTE" >
 |   < TINYINT: "TINYINT" >
@@ -7886,6 +8353,7 @@ SqlPostfixOperator PostfixRowOperator() :
 |   < TRIM_ARRAY: "TRIM_ARRAY" >
 |   < TRUE: "TRUE" >
 |   < TRUNCATE: "TRUNCATE" >
+|   < TUESDAY: "TUESDAY" >
 |   < TUMBLE: "TUMBLE" >
 |   < TYPE: "TYPE" >
 |   < UESCAPE: "UESCAPE" >
@@ -7923,7 +8391,9 @@ SqlPostfixOperator PostfixRowOperator() :
 |   < VERSION: "VERSION" >
 |   < VERSIONING: "VERSIONING" >
 |   < VIEW: "VIEW" >
+|   < WEDNESDAY: "WEDNESDAY" >
 |   < WEEK: "WEEK" >
+|   < WEEKS: "WEEKS" >
 |   < WHEN: "WHEN" >
 |   < WHENEVER: "WHENEVER" >
 |   < WHERE: "WHERE" >
@@ -8057,6 +8527,8 @@ void NonReservedKeyWord2of3() :
     < PREFIXED_STRING_LITERAL: ("_" <CHARSETNAME> | "N") <QUOTED_STRING> >
 |
     < UNICODE_STRING_LITERAL: "U" "&" <QUOTED_STRING> >
+|
+    < C_STYLE_ESCAPED_STRING_LITERAL: "E" <QUOTE> ( (~["'", "\\"]) | ("\\" ~[]) | "''")* <QUOTE> >
 |
     < #CHARSETNAME: (["a"-"z","A"-"Z","0"-"9"])
     (["a"-"z","A"-"Z","0"-"9",":",".","-","_"])*
diff --git a/core/src/main/java/org/apache/calcite/DataContext.java b/core/src/main/java/org/apache/calcite/DataContext.java
index a579b0abc32..9632b361738 100644
--- a/core/src/main/java/org/apache/calcite/DataContext.java
+++ b/core/src/main/java/org/apache/calcite/DataContext.java
@@ -20,6 +20,7 @@
 import org.apache.calcite.linq4j.QueryProvider;
 import org.apache.calcite.linq4j.tree.Expressions;
 import org.apache.calcite.linq4j.tree.ParameterExpression;
+import org.apache.calcite.rel.type.TimeFrameSet;
 import org.apache.calcite.schema.SchemaPlus;
 import org.apache.calcite.sql.advise.SqlAdvisor;
 
@@ -117,6 +118,11 @@ enum Variable {
      * time zone. */
     TIME_ZONE("timeZone", TimeZone.class),
 
+    /** Set of built-in and custom time frames for use in functions such as
+     * {@code FLOOR} and {@code EXTRACT}. Required; defaults to
+     * {@link org.apache.calcite.rel.type.TimeFrames#CORE}. */
+    TIME_FRAME_SET("timeFrameSet", TimeFrameSet.class),
+
     /** The query user.
      *
      * <p>Default value is "sa". */
diff --git a/core/src/main/java/org/apache/calcite/adapter/clone/ColumnLoader.java b/core/src/main/java/org/apache/calcite/adapter/clone/ColumnLoader.java
index 006698a3763..3d78f3548ba 100644
--- a/core/src/main/java/org/apache/calcite/adapter/clone/ColumnLoader.java
+++ b/core/src/main/java/org/apache/calcite/adapter/clone/ColumnLoader.java
@@ -249,8 +249,9 @@ private void load(final RelDataType elementType,
       switch (rep) {
       case OBJECT:
       case JAVA_SQL_TIMESTAMP:
-        final List<@Nullable Long> longs = Util.transform((List<@Nullable Timestamp>) list,
-            (Timestamp t) -> t == null ? null : t.getTime());
+        final List<@Nullable Long> longs =
+            Util.transform((List<@Nullable Timestamp>) list,
+                (Timestamp t) -> t == null ? null : t.getTime());
         return longs;
       default:
         break;
@@ -261,8 +262,8 @@ private void load(final RelDataType elementType,
       case OBJECT:
       case JAVA_SQL_TIME:
         return Util.<@Nullable Time, @Nullable Integer>transform(
-            (List<@Nullable Time>) list, (Time t) -> t == null
-                ? null
+            (List<@Nullable Time>) list,
+            (Time t) -> t == null ? null
                 : (int) (t.getTime() % DateTimeUtils.MILLIS_PER_DAY));
       default:
         break;
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumUtils.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumUtils.java
index 4680d7a8dc0..a92cc982022 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumUtils.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumUtils.java
@@ -540,10 +540,11 @@ public static Expression convert(Expression operand, Type fromType,
           // Try to call "toString()" method
           // E.g. from "Integer" to "String"
           // Generate "x == null ? null : x.toString()"
-          result = Expressions.condition(
-              Expressions.equal(operand, RexImpTable.NULL_EXPR),
-              RexImpTable.NULL_EXPR,
-              Expressions.call(operand, "toString"));
+          result =
+              Expressions.condition(
+                  Expressions.equal(operand, RexImpTable.NULL_EXPR),
+                  RexImpTable.NULL_EXPR,
+                  Expressions.call(operand, "toString"));
         } catch (RuntimeException e) {
           // For some special cases, e.g., "BuiltInMethod.LESSER",
           // its return type is generic ("Comparable"), which contains
@@ -820,31 +821,24 @@ static Expression tumblingWindowSelector(
     // Find the fixed window for a timestamp given a window size and an offset, and return the
     // window start.
     // wmColExprToLong - (wmColExprToLong + windowSizeMillis - offsetMillis) % windowSizeMillis
-    Expression windowStartExpr = Expressions.subtract(
-        wmColExprToLong,
-        Expressions.modulo(
-            Expressions.add(
-                wmColExprToLong,
-            Expressions.subtract(
-                windowSizeExpr,
-                offsetExpr
-            )),
+    Expression windowStartExpr =
+        Expressions.subtract(wmColExprToLong,
+            Expressions.modulo(
+                Expressions.add(wmColExprToLong,
+                    Expressions.subtract(windowSizeExpr, offsetExpr)),
             windowSizeExpr));
 
     expressions.add(windowStartExpr);
 
     // The window end equals to the window start plus window size.
     // windowStartMillis + sizeMillis
-    Expression windowEndExpr = Expressions.add(
-        windowStartExpr,
-        windowSizeExpr);
+    Expression windowEndExpr =
+        Expressions.add(windowStartExpr, windowSizeExpr);
 
     expressions.add(windowEndExpr);
 
-    return Expressions.lambda(
-        Function1.class,
-        outputPhysType.record(expressions),
-        parameter);
+    return Expressions.lambda(Function1.class,
+        outputPhysType.record(expressions), parameter);
   }
 
   /**
@@ -930,10 +924,11 @@ private void initialize() {
       for (@Nullable Object[] element : elements) {
         SortedMultiMap<Pair<Long, Long>, @Nullable Object[]> session =
             sessionKeyMap.computeIfAbsent(element[indexOfKeyColumn], k -> new SortedMultiMap<>());
-        Object watermark = requireNonNull(element[indexOfWatermarkedColumn],
-            "element[indexOfWatermarkedColumn]");
-        Pair<Long, Long> initWindow = computeInitWindow(
-            SqlFunctions.toLong(watermark), gap);
+        Object watermark =
+            requireNonNull(element[indexOfWatermarkedColumn],
+                "element[indexOfWatermarkedColumn]");
+        Pair<Long, Long> initWindow =
+            computeInitWindow(SqlFunctions.toLong(watermark), gap);
         session.putMulti(initWindow, element);
       }
 
@@ -1043,10 +1038,12 @@ private static class HopEnumerator implements Enumerator<@Nullable Object[]> {
         return takeOne();
       } else {
         @Nullable Object[] current = inputEnumerator.current();
-        Object watermark = requireNonNull(current[indexOfWatermarkedColumn],
-            "element[indexOfWatermarkedColumn]");
-        List<Pair<Long, Long>> windows = hopWindows(SqlFunctions.toLong(watermark),
-            emitFrequency, windowSize, offset);
+        Object watermark =
+            requireNonNull(current[indexOfWatermarkedColumn],
+                "element[indexOfWatermarkedColumn]");
+        List<Pair<Long, Long>> windows =
+            hopWindows(SqlFunctions.toLong(watermark), emitFrequency,
+                windowSize, offset);
         for (Pair<Long, Long> window : windows) {
           @Nullable Object[] curWithWindow = new Object[current.length + 2];
           System.arraycopy(current, 0, curWithWindow, 0, current.length);
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableAggregate.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableAggregate.java
index 719a39c1869..d38b26c333c 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableAggregate.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableAggregate.java
@@ -195,8 +195,8 @@ public EnumerableAggregate(RelOptCluster cluster, RelTraitSet traitSet,
     final List<Expression> initExpressions = new ArrayList<>();
     final BlockBuilder initBlock = new BlockBuilder();
 
-    final List<Type> aggStateTypes = createAggStateTypes(
-        initExpressions, initBlock, aggs, typeFactory);
+    final List<Type> aggStateTypes =
+        createAggStateTypes(initExpressions, initBlock, aggs, typeFactory);
 
     final PhysType accPhysType =
         PhysTypeImpl.of(typeFactory,
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableAggregateBase.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableAggregateBase.java
index 5ce800c990a..3d0ab7e8954 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableAggregateBase.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableAggregateBase.java
@@ -128,8 +128,8 @@ protected void implementLambdaFactory(BlockBuilder builder,
       Expression accumulatorInitializer, boolean hasOrderedCall,
       ParameterExpression lambdaFactory) {
     if (hasOrderedCall) {
-      ParameterExpression pe = Expressions.parameter(List.class,
-          builder.newName("lazyAccumulators"));
+      ParameterExpression pe =
+          Expressions.parameter(List.class, builder.newName("lazyAccumulators"));
       builder.add(
           Expressions.declare(0, pe, Expressions.new_(LinkedList.class)));
 
@@ -163,8 +163,8 @@ protected void implementLambdaFactory(BlockBuilder builder,
                   accumulatorInitializer, pe)));
     } else {
       // when hasOrderedCall == false
-      ParameterExpression pe = Expressions.parameter(List.class,
-          builder.newName("accumulatorAdders"));
+      ParameterExpression pe =
+          Expressions.parameter(List.class, builder.newName("accumulatorAdders"));
       builder.add(
           Expressions.declare(0, pe, Expressions.new_(LinkedList.class)));
 
@@ -283,11 +283,13 @@ protected void createAccumulatorAdders(
             }
           };
 
-      agg.implementor.implementAdd(requireNonNull(agg.context, "agg.context"), addContext);
+      agg.implementor.implementAdd(requireNonNull(agg.context, "agg.context"),
+          addContext);
       builder2.add(accExpr);
-      agg.accumulatorAdder = builder.append("accumulatorAdder",
-          Expressions.lambda(Function2.class, builder2.toBlock(), accExpr,
-              inParameter));
+      agg.accumulatorAdder =
+          builder.append("accumulatorAdder",
+              Expressions.lambda(Function2.class, builder2.toBlock(), accExpr,
+                  inParameter));
     }
   }
 
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableBatchNestedLoopJoin.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableBatchNestedLoopJoin.java
index 15e211a1549..94ef9c32133 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableBatchNestedLoopJoin.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableBatchNestedLoopJoin.java
@@ -175,15 +175,13 @@ public static EnumerableBatchNestedLoopJoin create(
         corrArg =
             Expressions.parameter(Modifier.FINAL,
                 corrVarType, corrVar.get(c));
-        final DeclarationStatement decl = Expressions.declare(
-            Modifier.FINAL,
-            corrArg,
-            Expressions.convert_(
-                Expressions.call(
-                    corrArgList,
-                    BuiltInMethod.LIST_GET.method,
-                    Expressions.constant(c)),
-                corrVarType));
+        final DeclarationStatement decl =
+            Expressions.declare(Modifier.FINAL, corrArg,
+                Expressions.convert_(
+                    Expressions.call(corrArgList,
+                        BuiltInMethod.LIST_GET.method,
+                        Expressions.constant(c)),
+                    corrVarType));
         corrBlock.add(decl);
         implementor.registerCorrelVariable(corrVar.get(c), corrArg,
             corrBlock, leftResult.physType);
@@ -193,13 +191,11 @@ public static EnumerableBatchNestedLoopJoin create(
         corrArg =
             Expressions.parameter(Modifier.FINAL,
                 Primitive.box(corrVarType), "$box" + corrVar.get(c));
-        final DeclarationStatement decl = Expressions.declare(
-            Modifier.FINAL,
-            corrArg,
-            Expressions.call(
-                corrArgList,
-                BuiltInMethod.LIST_GET.method,
-                Expressions.constant(c)));
+        final DeclarationStatement decl =
+            Expressions.declare(Modifier.FINAL, corrArg,
+                Expressions.call(corrArgList,
+                    BuiltInMethod.LIST_GET.method,
+                    Expressions.constant(c)));
         corrBlock.add(decl);
         final ParameterExpression corrRef =
             (ParameterExpression) corrBlock.append(corrVar.get(c),
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableBindable.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableBindable.java
index 00759f5933b..666e8802d41 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableBindable.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableBindable.java
@@ -65,8 +65,9 @@ protected EnumerableBindable(RelOptCluster cluster, RelNode input) {
 
   @Override public Enumerable<@Nullable Object[]> bind(DataContext dataContext) {
     final ImmutableMap<String, Object> map = ImmutableMap.of();
-    final Bindable bindable = EnumerableInterpretable.toBindable(map, null,
-        (EnumerableRel) getInput(), EnumerableRel.Prefer.ARRAY);
+    final Bindable bindable =
+        EnumerableInterpretable.toBindable(map, null,
+            (EnumerableRel) getInput(), EnumerableRel.Prefer.ARRAY);
     final ArrayBindable arrayBindable = EnumerableInterpretable.box(bindable);
     return arrayBindable.bind(dataContext);
   }
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableCalc.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableCalc.java
index 3c872a1591e..e1b1cdcb291 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableCalc.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableCalc.java
@@ -266,8 +266,8 @@ public static EnumerableCalc create(final RelNode input,
 
   @Override public @Nullable Pair<RelTraitSet, List<RelTraitSet>> passThroughTraits(
       final RelTraitSet required) {
-    final List<RexNode> exps = Util.transform(program.getProjectList(),
-        program::expandLocalRef);
+    final List<RexNode> exps =
+        Util.transform(program.getProjectList(), program::expandLocalRef);
 
     return EnumerableTraitsUtils.passThroughTraitsForProject(required, exps,
         input.getRowType(), input.getCluster().getTypeFactory(), traitSet);
@@ -275,8 +275,8 @@ public static EnumerableCalc create(final RelNode input,
 
   @Override public @Nullable Pair<RelTraitSet, List<RelTraitSet>> deriveTraits(
       final RelTraitSet childTraits, final int childId) {
-    final List<RexNode> exps = Util.transform(program.getProjectList(),
-        program::expandLocalRef);
+    final List<RexNode> exps =
+        Util.transform(program.getProjectList(), program::expandLocalRef);
 
     return EnumerableTraitsUtils.deriveTraitsForProject(childTraits, childId, exps,
         input.getRowType(), input.getCluster().getTypeFactory(), traitSet);
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableCollect.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableCollect.java
index da50dff6174..64ead331670 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableCollect.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableCollect.java
@@ -25,8 +25,11 @@
 import org.apache.calcite.rel.core.Collect;
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.sql.type.SqlTypeName;
+import org.apache.calcite.sql.type.SqlTypeUtil;
 import org.apache.calcite.util.BuiltInMethod;
 
+import static java.util.Objects.requireNonNull;
+
 /** Implementation of {@link org.apache.calcite.rel.core.Collect} in
  * {@link org.apache.calcite.adapter.enumerable.EnumerableConvention enumerable calling convention}. */
 public class EnumerableCollect extends Collect implements EnumerableRel {
@@ -91,15 +94,24 @@ public static Collect create(RelNode input, RelDataType rowType) {
     Expression child_ =
         builder.append(
             "child", result.block);
-    // In the internal representation of multisets , every element must be a record. In case the
-    // result above is a scalar type we have to wrap it around a physical type capable of
-    // representing records. For this reason the following conversion is necessary.
-    // REVIEW zabetak January 7, 2019: If we can ensure that the input to this operator
-    // has the correct physical type (e.g., respecting the Prefer.ARRAY above) then this conversion
-    // can be removed.
-    Expression conv_ =
-        builder.append(
-            "converted", result.physType.convertTo(child_, JavaRowFormat.ARRAY));
+
+    RelDataType collectionComponentType =
+        requireNonNull(rowType().getFieldList().get(0).getType().getComponentType());
+    RelDataType childRecordType = result.physType.getRowType().getFieldList().get(0).getType();
+
+    Expression conv_ = child_;
+    if (!SqlTypeUtil.sameNamedType(collectionComponentType, childRecordType)) {
+      // In the internal representation of multisets , every element must be a record. In case the
+      // result above is a scalar type we have to wrap it around a physical type capable of
+      // representing records. For this reason the following conversion is necessary.
+      // REVIEW zabetak January 7, 2019: If we can ensure that the input to this operator
+      // has the correct physical type (e.g., respecting the Prefer.ARRAY above)
+      // then this conversion can be removed.
+      conv_ =
+          builder.append(
+              "converted", result.physType.convertTo(child_, JavaRowFormat.ARRAY));
+    }
+
     Expression list_ =
         builder.append("list",
             Expressions.call(conv_,
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableConvention.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableConvention.java
index f2dcbc5e77b..38678cf2984 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableConvention.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableConvention.java
@@ -60,9 +60,9 @@ public enum EnumerableConvention implements Convention {
       final RelTraitSet required) {
     RelNode rel = input;
     if (input.getConvention() != INSTANCE) {
-      rel = ConventionTraitDef.INSTANCE.convert(
-          input.getCluster().getPlanner(),
-          input, INSTANCE, true);
+      rel =
+          ConventionTraitDef.INSTANCE.convert(input.getCluster().getPlanner(),
+              input, INSTANCE, true);
       requireNonNull(rel,
           () -> "Unable to convert input to " + INSTANCE + ", input = " + input);
     }
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableCorrelate.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableCorrelate.java
index efb02679956..e5adff42d9d 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableCorrelate.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableCorrelate.java
@@ -128,8 +128,9 @@ public static EnumerableCorrelate create(
       corrArg =
           Expressions.parameter(Modifier.FINAL,
               Primitive.box(corrVarType), "$box" + getCorrelVariable());
-      corrRef = (ParameterExpression) corrBlock.append(getCorrelVariable(),
-          Expressions.unbox(corrArg));
+      corrRef =
+          (ParameterExpression) corrBlock.append(getCorrelVariable(),
+              Expressions.unbox(corrArg));
     }
 
     implementor.registerCorrelVariable(getCorrelVariable(), corrRef,
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableHashJoin.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableHashJoin.java
index eb73acdf6e9..259fb685032 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableHashJoin.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableHashJoin.java
@@ -200,11 +200,14 @@ private Result implementHashSemiJoin(EnumerableRelImplementor implementor, Prefe
             joinInfo.leftKeys, JavaRowFormat.LIST);
     Expression predicate = Expressions.constant(null);
     if (!joinInfo.nonEquiConditions.isEmpty()) {
-      RexNode nonEquiCondition = RexUtil.composeConjunction(
-          getCluster().getRexBuilder(), joinInfo.nonEquiConditions, true);
+      RexNode nonEquiCondition =
+          RexUtil.composeConjunction(getCluster().getRexBuilder(),
+              joinInfo.nonEquiConditions, true);
       if (nonEquiCondition != null) {
-        predicate = EnumUtils.generatePredicate(implementor, getCluster().getRexBuilder(),
-            left, right, leftResult.physType, rightResult.physType, nonEquiCondition);
+        predicate =
+            EnumUtils.generatePredicate(implementor,
+                getCluster().getRexBuilder(), left, right, leftResult.physType,
+                rightResult.physType, nonEquiCondition);
       }
     }
     return implementor.result(
@@ -243,11 +246,14 @@ private Result implementHashJoin(EnumerableRelImplementor implementor, Prefer pr
             joinInfo.leftKeys, JavaRowFormat.LIST);
     Expression predicate = Expressions.constant(null);
     if (!joinInfo.nonEquiConditions.isEmpty()) {
-      RexNode nonEquiCondition = RexUtil.composeConjunction(
-          getCluster().getRexBuilder(), joinInfo.nonEquiConditions, true);
+      RexNode nonEquiCondition =
+          RexUtil.composeConjunction(getCluster().getRexBuilder(),
+              joinInfo.nonEquiConditions, true);
       if (nonEquiCondition != null) {
-        predicate = EnumUtils.generatePredicate(implementor, getCluster().getRexBuilder(),
-            left, right, leftResult.physType, rightResult.physType, nonEquiCondition);
+        predicate =
+            EnumUtils.generatePredicate(implementor,
+                getCluster().getRexBuilder(), left, right, leftResult.physType,
+                rightResult.physType, nonEquiCondition);
       }
     }
     return implementor.result(
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableInterpretable.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableInterpretable.java
index 73079b1b47f..922687df40d 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableInterpretable.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableInterpretable.java
@@ -42,7 +42,6 @@
 import org.apache.calcite.runtime.Bindable;
 import org.apache.calcite.runtime.Hook;
 import org.apache.calcite.runtime.Typed;
-import org.apache.calcite.runtime.Utilities;
 import org.apache.calcite.util.Util;
 
 import com.google.common.cache.Cache;
@@ -51,11 +50,10 @@
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.codehaus.commons.compiler.CompileException;
 import org.codehaus.commons.compiler.CompilerFactoryFactory;
-import org.codehaus.commons.compiler.IClassBodyEvaluator;
 import org.codehaus.commons.compiler.ICompilerFactory;
+import org.codehaus.commons.compiler.ISimpleCompiler;
 
-import java.io.IOException;
-import java.io.StringReader;
+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Modifier;
 import java.util.List;
 import java.util.Map;
@@ -82,9 +80,9 @@ protected EnumerableInterpretable(RelOptCluster cluster, RelNode input) {
   }
 
   @Override public Node implement(final InterpreterImplementor implementor) {
-    final Bindable bindable = toBindable(implementor.internalParameters,
-            implementor.spark, (EnumerableRel) getInput(),
-        EnumerableRel.Prefer.ARRAY);
+    final Bindable bindable =
+        toBindable(implementor.internalParameters, implementor.spark,
+            (EnumerableRel) getInput(), EnumerableRel.Prefer.ARRAY);
     final ArrayBindable arrayBindable = box(bindable);
     final Enumerable<@Nullable Object[]> enumerable =
         arrayBindable.bind(implementor.dataContext);
@@ -132,8 +130,9 @@ public static Bindable toBindable(Map<String, Object> parameters,
     }
   }
 
-  static Bindable getBindable(ClassDeclaration expr, String s, int fieldCount)
-      throws CompileException, IOException, ExecutionException {
+  static Bindable getBindable(ClassDeclaration expr, String classBody, int fieldCount)
+      throws CompileException, ExecutionException, ClassNotFoundException,
+      InvocationTargetException, InstantiationException, IllegalAccessException {
     ICompilerFactory compilerFactory;
     ClassLoader classLoader =
         Objects.requireNonNull(EnumerableInterpretable.class.getClassLoader(), "classLoader");
@@ -143,27 +142,40 @@ static Bindable getBindable(ClassDeclaration expr, String s, int fieldCount)
       throw new IllegalStateException(
           "Unable to instantiate java compiler", e);
     }
-    final IClassBodyEvaluator cbe = compilerFactory.newClassBodyEvaluator();
-    cbe.setClassName(expr.name);
-    cbe.setExtendedClass(Utilities.class);
-    cbe.setImplementedInterfaces(
-        fieldCount == 1
-            ? new Class[] {Bindable.class, Typed.class}
-            : new Class[] {ArrayBindable.class});
-    cbe.setParentClassLoader(classLoader);
+    final ISimpleCompiler compiler = compilerFactory.newSimpleCompiler();
+    compiler.setParentClassLoader(classLoader);
+    final String s = "public final class " + expr.name + " implements "
+        + (fieldCount == 1
+          ? Bindable.class.getCanonicalName() + ", " + Typed.class.getCanonicalName()
+          : ArrayBindable.class.getCanonicalName())
+        + " {\n"
+        + classBody
+        + "\n"
+        + "}";
+
     if (CalciteSystemProperty.DEBUG.value()) {
       // Add line numbers to the generated janino class
-      cbe.setDebuggingInformation(true, true, true);
+      compiler.setDebuggingInformation(true, true, true);
     }
 
     if (CalciteSystemProperty.BINDABLE_CACHE_MAX_SIZE.value() != 0) {
       StaticFieldDetector detector = new StaticFieldDetector();
       expr.accept(detector);
       if (!detector.containsStaticField) {
-        return BINDABLE_CACHE.get(s, () -> (Bindable) cbe.createInstance(new StringReader(s)));
+        return BINDABLE_CACHE.get(classBody, () ->  compileToBindable(expr.name, s, compiler));
       }
     }
-    return (Bindable) cbe.createInstance(new StringReader(s));
+    return compileToBindable(expr.name, s, compiler);
+  }
+
+  private static Bindable<?> compileToBindable(String className, String s, ISimpleCompiler compiler)
+      throws CompileException, ClassNotFoundException, InvocationTargetException,
+      InstantiationException, IllegalAccessException {
+    compiler.cook(s);
+    return (Bindable<?>) compiler.getClassLoader()
+        .loadClass(className)
+        .getDeclaredConstructors()[0]
+        .newInstance();
   }
 
   /**
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableInterpreter.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableInterpreter.java
index 3654e9735a1..ae2c88b3e93 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableInterpreter.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableInterpreter.java
@@ -94,10 +94,10 @@ public static EnumerableInterpreter create(RelNode input, double factor) {
     final BlockBuilder builder = new BlockBuilder();
     final PhysType physType =
         PhysTypeImpl.of(typeFactory, getRowType(), JavaRowFormat.ARRAY);
-    final Expression interpreter_ = builder.append("interpreter",
-        Expressions.new_(Interpreter.class,
-            implementor.getRootExpression(),
-            implementor.stash(getInput(), RelNode.class)));
+    final Expression interpreter_ =
+        builder.append("interpreter",
+            Expressions.new_(Interpreter.class, implementor.getRootExpression(),
+                implementor.stash(getInput(), RelNode.class)));
     final Expression sliced_ =
         getRowType().getFieldCount() == 1
             ? Expressions.call(BuiltInMethod.SLICE0.method, interpreter_)
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableLimit.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableLimit.java
index 3b1694f7f2e..5958e5d633f 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableLimit.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableLimit.java
@@ -97,33 +97,24 @@ public static EnumerableLimit create(final RelNode input, @Nullable RexNode offs
     final EnumerableRel child = (EnumerableRel) getInput();
     final Result result = implementor.visitChild(this, 0, child, pref);
     final PhysType physType =
-        PhysTypeImpl.of(
-            implementor.getTypeFactory(),
-            getRowType(),
+        PhysTypeImpl.of(implementor.getTypeFactory(), getRowType(),
             result.format);
 
     Expression v = builder.append("child", result.block);
     if (offset != null) {
-      v = builder.append(
-          "offset",
-          Expressions.call(
-              v,
-              BuiltInMethod.SKIP.method,
-              getExpression(offset)));
+      v =
+          builder.append("offset",
+              Expressions.call(v, BuiltInMethod.SKIP.method,
+                  getExpression(offset)));
     }
     if (fetch != null) {
-      v = builder.append(
-          "fetch",
-          Expressions.call(
-              v,
-              BuiltInMethod.TAKE.method,
-              getExpression(fetch)));
+      v =
+          builder.append("fetch",
+              Expressions.call(v, BuiltInMethod.TAKE.method,
+                  getExpression(fetch)));
     }
 
-    builder.add(
-        Expressions.return_(
-            null,
-            v));
+    builder.add(Expressions.return_(null, v));
     return implementor.result(physType, builder.toBlock());
   }
 
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableLimitRule.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableLimitRule.java
index 78e66d52478..4f84bd92cb4 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableLimitRule.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableLimitRule.java
@@ -52,12 +52,8 @@ protected EnumerableLimitRule(Config config) {
     RelNode input = sort.getInput();
     if (!sort.getCollation().getFieldCollations().isEmpty()) {
       // Create a sort with the same sort key, but no offset or fetch.
-      input = sort.copy(
-          sort.getTraitSet(),
-          input,
-          sort.getCollation(),
-          null,
-          null);
+      input =
+          sort.copy(sort.getTraitSet(), input, sort.getCollation(), null, null);
     }
     call.transformTo(
         EnumerableLimit.create(
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableLimitSort.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableLimitSort.java
index 0ae97238d95..8b7a2706fbb 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableLimitSort.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableLimitSort.java
@@ -63,8 +63,8 @@ public static EnumerableLimitSort create(
       @Nullable RexNode offset,
       @Nullable RexNode fetch) {
     final RelOptCluster cluster = input.getCluster();
-    final RelTraitSet traitSet = cluster.traitSetOf(EnumerableConvention.INSTANCE).replace(
-        collation);
+    final RelTraitSet traitSet =
+        cluster.traitSetOf(EnumerableConvention.INSTANCE).replace(collation);
     return new EnumerableLimitSort(cluster, traitSet, input, collation, offset, fetch);
   }
 
@@ -87,10 +87,9 @@ public static EnumerableLimitSort create(
     final BlockBuilder builder = new BlockBuilder();
     final EnumerableRel child = (EnumerableRel) this.getInput();
     final Result result = implementor.visitChild(this, 0, child, pref);
-    final PhysType physType = PhysTypeImpl.of(
-        implementor.getTypeFactory(),
-        this.getRowType(),
-        result.format);
+    final PhysType physType =
+        PhysTypeImpl.of(implementor.getTypeFactory(), this.getRowType(),
+            result.format);
     final Expression childExp = builder.append("child", result.block);
 
     final PhysType inputPhysType = result.physType;
@@ -119,8 +118,7 @@ public static EnumerableLimitSort create(
                             Expressions.constant(offsetVal)))
                     .appendIfNotNull(
                         builder.appendIfNotNull("fetch",
-                            Expressions.constant(fetchVal)))
-            )));
+                            Expressions.constant(fetchVal))))));
     return implementor.result(physType, builder.toBlock());
   }
 }
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableLimitSortRule.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableLimitSortRule.java
index 14e6e65361e..6ea7e55115f 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableLimitSortRule.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableLimitSortRule.java
@@ -41,11 +41,11 @@ public EnumerableLimitSortRule(Config config) {
   @Override public void onMatch(RelOptRuleCall call) {
     final Sort sort = call.rel(0);
     RelNode input = sort.getInput();
-    final Sort o = EnumerableLimitSort.create(
-        convert(input, input.getTraitSet().replace(EnumerableConvention.INSTANCE)),
-        sort.getCollation(),
-        sort.offset, sort.fetch
-    );
+    final Sort o =
+        EnumerableLimitSort.create(
+            convert(input,
+                input.getTraitSet().replace(EnumerableConvention.INSTANCE)),
+            sort.getCollation(), sort.offset, sort.fetch);
 
     call.transformTo(o);
   }
@@ -53,8 +53,12 @@ public EnumerableLimitSortRule(Config config) {
   /** Rule configuration. */
   @Value.Immutable
   public interface Config extends RelRule.Config {
-    Config DEFAULT = ImmutableEnumerableLimitSortRule.Config.of().withOperandSupplier(
-        b0 -> b0.operand(LogicalSort.class).predicate(sort -> sort.fetch != null).anyInputs());
+    Config DEFAULT =
+        ImmutableEnumerableLimitSortRule.Config.of()
+            .withOperandSupplier(b0 ->
+                b0.operand(LogicalSort.class)
+                    .predicate(sort -> sort.fetch != null)
+                    .anyInputs());
 
     @Override default EnumerableLimitSortRule toRule() {
       return new EnumerableLimitSortRule(this);
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableMatch.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableMatch.java
index 4e2e5cbdce0..2fdd2b41ec9 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableMatch.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableMatch.java
@@ -189,11 +189,12 @@ private Expression implementEmitter(EnumerableRelImplementor implementor,
       rexProgramBuilder.addProject(entry.getValue(), entry.getKey());
     }
 
-    final RexToLixTranslator translator = RexToLixTranslator.forAggregation(
-        (JavaTypeFactory) getCluster().getTypeFactory(),
-        builder2,
-        new PassedRowsInputGetter(row_, rows_, inputPhysType),
-        implementor.getConformance());
+    final RexToLixTranslator translator =
+        RexToLixTranslator.forAggregation(
+            (JavaTypeFactory) getCluster().getTypeFactory(),
+            builder2,
+            new PassedRowsInputGetter(row_, rows_, inputPhysType),
+            implementor.getConformance());
 
     final ParameterExpression result_ =
         Expressions.parameter(physType.getJavaRowType());
@@ -283,13 +284,16 @@ private static Expression implementMeasure(RexToLixTranslator translator,
 
   private Expression implementMatcher(EnumerableRelImplementor implementor,
       PhysType physType, BlockBuilder builder, ParameterExpression row_) {
-    final Expression patternBuilder_ = builder.append("patternBuilder",
-        Expressions.call(BuiltInMethod.PATTERN_BUILDER.method));
-    final Expression automaton_ = builder.append("automaton",
-        Expressions.call(implementPattern(patternBuilder_, pattern),
-            BuiltInMethod.PATTERN_TO_AUTOMATON.method));
-    Expression matcherBuilder_ = builder.append("matcherBuilder",
-        Expressions.call(BuiltInMethod.MATCHER_BUILDER.method, automaton_));
+    final Expression patternBuilder_ =
+        builder.append("patternBuilder",
+            Expressions.call(BuiltInMethod.PATTERN_BUILDER.method));
+    final Expression automaton_ =
+        builder.append("automaton",
+            Expressions.call(implementPattern(patternBuilder_, pattern),
+                BuiltInMethod.PATTERN_TO_AUTOMATON.method));
+    Expression matcherBuilder_ =
+        builder.append("matcherBuilder",
+            Expressions.call(BuiltInMethod.MATCHER_BUILDER.method, automaton_));
     final BlockBuilder builder2 = new BlockBuilder();
 
 
@@ -318,10 +322,11 @@ private Expression implementMatcher(EnumerableRelImplementor implementor,
       final Expression predicate_ =
           implementPredicate(physType, row_, builder2.toBlock());
 
-      matcherBuilder_ = Expressions.call(matcherBuilder_,
-          BuiltInMethod.MATCHER_BUILDER_ADD.method,
-          Expressions.constant(entry.getKey()),
-          predicate_);
+      matcherBuilder_ =
+          Expressions.call(matcherBuilder_,
+              BuiltInMethod.MATCHER_BUILDER_ADD.method,
+              Expressions.constant(entry.getKey()),
+              predicate_);
     }
     return builder.append("matcher",
         Expressions.call(matcherBuilder_,
@@ -332,8 +337,9 @@ private Expression implementMatcher(EnumerableRelImplementor implementor,
   private static Expression implementPredicate(PhysType physType,
       ParameterExpression rows_, BlockStatement body) {
     final List<MemberDeclaration> memberDeclarations = new ArrayList<>();
-    ParameterExpression row_ = Expressions.parameter(
-        Types.of(MemoryFactory.Memory.class,
+    ParameterExpression row_ =
+        Expressions.parameter(
+            Types.of(MemoryFactory.Memory.class,
             physType.getJavaRowType()), "row_");
     Expressions.assign(row_,
         Expressions.call(rows_, BuiltInMethod.MEMORY_GET0.method));
@@ -396,8 +402,9 @@ private static Expression implementPattern(Expression patternBuilder_,
       for (Ord<RexNode> operand : Ord.zip(concat.operands)) {
         patternBuilder_ = implementPattern(patternBuilder_, operand.e);
         if (operand.i > 0) {
-          patternBuilder_ = Expressions.call(patternBuilder_,
-              BuiltInMethod.PATTERN_BUILDER_SEQ.method);
+          patternBuilder_ =
+              Expressions.call(patternBuilder_,
+                  BuiltInMethod.PATTERN_BUILDER_SEQ.method);
         }
       }
       return patternBuilder_;
@@ -432,14 +439,16 @@ public int getFuture() {
       switch (call.op.kind) {
       case PREV:
         operand = (RexLiteral) call.getOperands().get(1);
-        final int prev = requireNonNull(operand.getValueAs(Integer.class),
-            () -> "operand in " + call);
+        final int prev =
+            requireNonNull(operand.getValueAs(Integer.class),
+                () -> "operand in " + call);
         this.history = Math.max(this.history, prev);
         break;
       case NEXT:
         operand = (RexLiteral) call.getOperands().get(1);
-        final int next = requireNonNull(operand.getValueAs(Integer.class),
-            () -> "operand in " + call);
+        final int next =
+            requireNonNull(operand.getValueAs(Integer.class),
+                () -> "operand in " + call);
         this.future = Math.max(this.future, next);
         break;
       default:
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableMergeJoin.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableMergeJoin.java
index 4794b4a81a0..caa6509921f 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableMergeJoin.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableMergeJoin.java
@@ -284,8 +284,8 @@ private static List<RelCollation> getCollations(RelTraitSet traits) {
 
     ImmutableIntList sourceKeys = childId == 0 ? joinInfo.leftKeys : joinInfo.rightKeys;
     ImmutableBitSet keySet = ImmutableBitSet.of(sourceKeys);
-    ImmutableBitSet childCollationKeys = ImmutableBitSet.of(
-        RelCollations.ordinals(collation));
+    ImmutableBitSet childCollationKeys =
+        ImmutableBitSet.of(RelCollations.ordinals(collation));
     if (!childCollationKeys.equals(keySet)) {
       return null;
     }
@@ -323,9 +323,10 @@ private Mappings.TargetMapping buildMapping(boolean left2Right) {
       keyMap.put(sourceKeys.get(i), targetKeys.get(i));
     }
 
-    Mappings.TargetMapping mapping = Mappings.target(keyMap,
-        (left2Right ? left : right).getRowType().getFieldCount(),
-        (left2Right ? right : left).getRowType().getFieldCount());
+    Mappings.TargetMapping mapping =
+        Mappings.target(keyMap,
+            (left2Right ? left : right).getRowType().getFieldCount(),
+            (left2Right ? right : left).getRowType().getFieldCount());
     return mapping;
   }
 
@@ -427,9 +428,11 @@ public static EnumerableMergeJoin create(RelNode left, RelNode right,
     for (Pair<Integer, Integer> pair : Pair.zip(joinInfo.leftKeys, joinInfo.rightKeys)) {
       RelDataType leftType = left.getRowType().getFieldList().get(pair.left).getType();
       RelDataType rightType = right.getRowType().getFieldList().get(pair.right).getType();
-      final RelDataType keyType = requireNonNull(
-          typeFactory.leastRestrictive(ImmutableList.of(leftType, rightType)),
-          () -> "leastRestrictive returns null for " + leftType + " and " + rightType);
+      final RelDataType keyType =
+          requireNonNull(
+              typeFactory.leastRestrictive(ImmutableList.of(leftType, rightType)),
+              () -> "leastRestrictive returns null for " + leftType
+                  + " and " + rightType);
       final Type keyClass = typeFactory.getJavaClass(keyType);
       leftExpressions.add(
           EnumUtils.convert(
@@ -440,11 +443,14 @@ public static EnumerableMergeJoin create(RelNode left, RelNode right,
     }
     Expression predicate = Expressions.constant(null);
     if (!joinInfo.nonEquiConditions.isEmpty()) {
-      final RexNode nonEquiCondition = RexUtil.composeConjunction(
-          getCluster().getRexBuilder(), joinInfo.nonEquiConditions, true);
+      final RexNode nonEquiCondition =
+          RexUtil.composeConjunction(getCluster().getRexBuilder(),
+              joinInfo.nonEquiConditions, true);
       if (nonEquiCondition != null) {
-        predicate = EnumUtils.generatePredicate(implementor, getCluster().getRexBuilder(),
-            left, right, leftResult.physType, rightResult.physType, nonEquiCondition);
+        predicate =
+            EnumUtils.generatePredicate(implementor,
+                getCluster().getRexBuilder(), left, right, leftResult.physType,
+                rightResult.physType, nonEquiCondition);
       }
     }
     final PhysType leftKeyPhysType =
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableMergeJoinRule.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableMergeJoinRule.java
index f69d1c55b0a..406152da6ca 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableMergeJoinRule.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableMergeJoinRule.java
@@ -92,7 +92,6 @@ protected EnumerableMergeJoinRule(Config config) {
     final RelNode left = newInputs.get(0);
     final RelNode right = newInputs.get(1);
     final RelOptCluster cluster = join.getCluster();
-    RelNode newRel;
 
     RelTraitSet traitSet = join.getTraitSet()
         .replace(EnumerableConvention.INSTANCE);
@@ -111,13 +110,7 @@ protected EnumerableMergeJoinRule(Config config) {
       final RexNode nonEqui = RexUtil.composeConjunction(rexBuilder, info.nonEquiConditions);
       condition = RexUtil.composeConjunction(rexBuilder, Arrays.asList(equi, nonEqui));
     }
-    newRel = new EnumerableMergeJoin(cluster,
-        traitSet,
-        left,
-        right,
-        condition,
-        join.getVariablesSet(),
-        join.getJoinType());
-    return newRel;
+    return new EnumerableMergeJoin(cluster, traitSet, left, right, condition,
+        join.getVariablesSet(), join.getJoinType());
   }
 }
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableMergeUnion.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableMergeUnion.java
index b5a617a52a4..637a454c213 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableMergeUnion.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableMergeUnion.java
@@ -34,12 +34,13 @@
 
 /** Implementation of {@link org.apache.calcite.rel.core.Union} in
  * {@link org.apache.calcite.adapter.enumerable.EnumerableConvention enumerable calling convention}.
- * Performs a union (or union all) of all its inputs (which must be already sorted),
- * respecting the order. */
+ *
+ * <p>Performs a union (or union all) of all its inputs (which must be already
+ * sorted), respecting the order. */
 public class EnumerableMergeUnion extends EnumerableUnion {
 
-  protected EnumerableMergeUnion(RelOptCluster cluster, RelTraitSet traitSet, List<RelNode> inputs,
-      boolean all) {
+  protected EnumerableMergeUnion(RelOptCluster cluster, RelTraitSet traitSet,
+      List<RelNode> inputs, boolean all) {
     super(cluster, traitSet, inputs, all);
     final RelCollation collation = traitSet.getCollation();
     if (collation == null || collation.getFieldCollations().isEmpty()) {
@@ -48,33 +49,37 @@ protected EnumerableMergeUnion(RelOptCluster cluster, RelTraitSet traitSet, List
     for (RelNode input : inputs) {
       final RelCollation inputCollation = input.getTraitSet().getCollation();
       if (inputCollation == null || !inputCollation.satisfies(collation)) {
-        throw new IllegalArgumentException("EnumerableMergeUnion input does not satisfy collation. "
-            + "EnumerableMergeUnion collation: " + collation + ". Input collation: "
-            + inputCollation + ". Input: " + input);
+        throw new IllegalArgumentException("EnumerableMergeUnion input does "
+            + "not satisfy collation. EnumerableMergeUnion collation: "
+            + collation + ". Input collation: " + inputCollation + ". Input: "
+            + input);
       }
     }
   }
 
-  public static EnumerableMergeUnion create(RelCollation collation, List<RelNode> inputs,
-      boolean all) {
+  public static EnumerableMergeUnion create(RelCollation collation,
+      List<RelNode> inputs, boolean all) {
     final RelOptCluster cluster = inputs.get(0).getCluster();
-    final RelTraitSet traitSet = cluster.traitSetOf(EnumerableConvention.INSTANCE).replace(
-        collation);
+    final RelTraitSet traitSet =
+        cluster.traitSetOf(EnumerableConvention.INSTANCE).replace(collation);
     return new EnumerableMergeUnion(cluster, traitSet, inputs, all);
   }
 
-  @Override public EnumerableMergeUnion copy(RelTraitSet traitSet, List<RelNode> inputs,
-      boolean all) {
+  @Override public EnumerableMergeUnion copy(RelTraitSet traitSet,
+      List<RelNode> inputs, boolean all) {
     return new EnumerableMergeUnion(getCluster(), traitSet, inputs, all);
   }
 
-  @Override public Result implement(EnumerableRelImplementor implementor, Prefer pref) {
+  @Override public Result implement(EnumerableRelImplementor implementor,
+      Prefer pref) {
     final BlockBuilder builder = new BlockBuilder();
 
-    final ParameterExpression inputListExp = Expressions.parameter(
-        List.class,
-        builder.newName("mergeUnionInputs" + Integer.toUnsignedString(this.getId())));
-    builder.add(Expressions.declare(0, inputListExp, Expressions.new_(ArrayList.class)));
+    final ParameterExpression inputListExp =
+        Expressions.parameter(List.class,
+            builder.newName("mergeUnionInputs"
+                + Integer.toUnsignedString(this.getId())));
+    builder.add(
+        Expressions.declare(0, inputListExp, Expressions.new_(ArrayList.class)));
 
     for (Ord<RelNode> ord : Ord.zip(inputs)) {
       final EnumerableRel input = (EnumerableRel) ord.e;
@@ -82,13 +87,13 @@ public static EnumerableMergeUnion create(RelCollation collation, List<RelNode>
       final Expression childExp = builder.append("child" + ord.i, result.block);
       builder.add(
           Expressions.statement(
-              Expressions.call(inputListExp, BuiltInMethod.COLLECTION_ADD.method, childExp)));
+              Expressions.call(inputListExp,
+                  BuiltInMethod.COLLECTION_ADD.method, childExp)));
     }
 
-    final PhysType physType = PhysTypeImpl.of(
-        implementor.getTypeFactory(),
-        getRowType(),
-        pref.prefer(JavaRowFormat.CUSTOM));
+    final PhysType physType =
+        PhysTypeImpl.of(implementor.getTypeFactory(), getRowType(),
+            pref.prefer(JavaRowFormat.CUSTOM));
 
     final RelCollation collation = getTraitSet().getCollation();
     if (collation == null || collation.getFieldCollations().isEmpty()) {
@@ -100,17 +105,14 @@ public static EnumerableMergeUnion create(RelCollation collation, List<RelNode>
     final Expression sortKeySelector = pair.left;
     final Expression sortComparator = pair.right;
 
-    final Expression equalityComparator = Util.first(
-        physType.comparer(),
-        Expressions.call(BuiltInMethod.IDENTITY_COMPARER.method));
+    final Expression equalityComparator =
+        Util.first(physType.comparer(),
+            Expressions.call(BuiltInMethod.IDENTITY_COMPARER.method));
 
-    final Expression unionExp = Expressions.call(
-        BuiltInMethod.MERGE_UNION.method,
-        inputListExp,
-        sortKeySelector,
-        sortComparator,
-        Expressions.constant(all, boolean.class),
-        equalityComparator);
+    final Expression unionExp =
+        Expressions.call(BuiltInMethod.MERGE_UNION.method, inputListExp,
+            sortKeySelector, sortComparator,
+            Expressions.constant(all, boolean.class), equalityComparator);
     builder.add(unionExp);
 
     return implementor.result(physType, builder.toBlock());
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableMergeUnionRule.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableMergeUnionRule.java
index 2976f3e6dc4..47982dde835 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableMergeUnionRule.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableMergeUnionRule.java
@@ -91,8 +91,9 @@ public EnumerableMergeUnionRule(Config config) {
       if (sort.offset == null) {
         inputFetch = sort.fetch;
       } else if (sort.fetch instanceof RexLiteral && sort.offset instanceof RexLiteral) {
-        inputFetch = call.builder().literal(
-            RexLiteral.intValue(sort.fetch) + RexLiteral.intValue(sort.offset));
+        inputFetch =
+            call.builder().literal(RexLiteral.intValue(sort.fetch)
+                + RexLiteral.intValue(sort.offset));
       }
     }
 
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableNestedLoopJoin.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableNestedLoopJoin.java
index bd0d28827cb..6b1bf40cf77 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableNestedLoopJoin.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableNestedLoopJoin.java
@@ -138,8 +138,7 @@ public static EnumerableNestedLoopJoin create(
   @Override public @Nullable Pair<RelTraitSet, List<RelTraitSet>> deriveTraits(
       final RelTraitSet childTraits, final int childId) {
     return EnumerableTraitsUtils.deriveTraitsForJoin(
-        childTraits, childId, joinType, traitSet, right.getTraitSet()
-    );
+        childTraits, childId, joinType, traitSet, right.getTraitSet());
   }
 
   @Override public DeriveMode getDeriveMode() {
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableProject.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableProject.java
index 4bc516c520a..8b4c0c5ded5 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableProject.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableProject.java
@@ -29,6 +29,7 @@
 import org.apache.calcite.util.Util;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 
@@ -54,7 +55,7 @@ public EnumerableProject(
       RelNode input,
       List<? extends RexNode> projects,
       RelDataType rowType) {
-    super(cluster, traitSet, ImmutableList.of(), input, projects, rowType);
+    super(cluster, traitSet, ImmutableList.of(), input, projects, rowType, ImmutableSet.of());
     assert getConvention() instanceof EnumerableConvention;
   }
 
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableProjectRule.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableProjectRule.java
index b1b69220a62..3bd8e697bb2 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableProjectRule.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableProjectRule.java
@@ -17,6 +17,7 @@
 package org.apache.calcite.adapter.enumerable;
 
 import org.apache.calcite.plan.Convention;
+import org.apache.calcite.plan.RelOptRuleCall;
 import org.apache.calcite.rel.RelNode;
 import org.apache.calcite.rel.convert.ConverterRule;
 import org.apache.calcite.rel.core.Project;
@@ -42,6 +43,11 @@ protected EnumerableProjectRule(Config config) {
     super(config);
   }
 
+  @Override public boolean matches(RelOptRuleCall call) {
+    Project project = call.rel(0);
+    return project.getVariablesSet().isEmpty();
+  }
+
   @Override public RelNode convert(RelNode rel) {
     final Project project = (Project) rel;
     return EnumerableProject.create(
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableRelFactories.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableRelFactories.java
index ad109c44d0b..05c08901898 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableRelFactories.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableRelFactories.java
@@ -26,6 +26,8 @@
 import org.apache.calcite.rex.RexUtil;
 import org.apache.calcite.sql.validate.SqlValidatorUtil;
 
+import com.google.common.base.Preconditions;
+
 import org.checkerframework.checker.nullness.qual.Nullable;
 
 import java.util.List;
@@ -68,7 +70,10 @@ private static class ProjectFactoryImpl
       implements org.apache.calcite.rel.core.RelFactories.ProjectFactory {
     @Override public RelNode createProject(RelNode input, List<RelHint> hints,
         List<? extends RexNode> childExprs,
-        @Nullable List<? extends @Nullable String> fieldNames) {
+        @Nullable List<? extends @Nullable String> fieldNames,
+        Set<CorrelationId> variablesSet) {
+      Preconditions.checkArgument(variablesSet.isEmpty(),
+          "EnumerableProject does not allow variables");
       final RelDataType rowType =
           RexUtil.createStructType(input.getCluster().getTypeFactory(), childExprs,
               fieldNames, SqlValidatorUtil.F_SUGGESTER);
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableRelImplementor.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableRelImplementor.java
index 34386cd0306..53d0296f7a6 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableRelImplementor.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableRelImplementor.java
@@ -50,6 +50,7 @@
 import org.apache.calcite.util.BuiltInMethod;
 
 import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Equivalence;
 import com.google.common.collect.Collections2;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Iterables;
@@ -64,7 +65,7 @@
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
-import java.util.IdentityHashMap;
+import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
@@ -80,8 +81,10 @@ public class EnumerableRelImplementor extends JavaRelImplementor {
   public final Map<String, Object> map;
   private final Map<String, RexToLixTranslator.InputGetter> corrVars =
       new HashMap<>();
-  private final IdentityHashMap<Object, ParameterExpression> stashedParameters =
-      new IdentityHashMap<>();
+  private static final Equivalence<Object> IDENTITY = Equivalence.identity();
+  // A combination of IdentityHashMap + LinkedHashMap to ensure deterministic order
+  private final Map<Equivalence.Wrapper<Object>, ParameterExpression> stashedParameters =
+      new LinkedHashMap<>();
 
   @SuppressWarnings("methodref.receiver.bound.invalid")
   protected final Function1<String, RexToLixTranslator.InputGetter> allCorrelateVariables =
@@ -123,8 +126,10 @@ public ClassDeclaration implementRoot(EnumerableRel rootRel,
         Expression e = null;
         for (Statement statement : result.block.statements) {
           if (statement instanceof GotoStatement) {
-            e = bb.append("v",
-                requireNonNull(((GotoStatement) statement).expression, "expression"));
+            final GotoStatement gotoStatement = (GotoStatement) statement;
+            e =
+                bb.append("v",
+                    requireNonNull(gotoStatement.expression, "expression"));
           } else {
             bb.add(statement);
           }
@@ -134,8 +139,9 @@ public ClassDeclaration implementRoot(EnumerableRel rootRel,
               Expressions.return_(null,
                   Expressions.call(null, BuiltInMethod.SLICE0.method, e)));
         }
-        result = new EnumerableRel.Result(bb.toBlock(), result.physType,
-            JavaRowFormat.SCALAR);
+        result =
+            new EnumerableRel.Result(bb.toBlock(), result.physType,
+                JavaRowFormat.SCALAR);
       }
       break;
     default:
@@ -157,14 +163,11 @@ public ClassDeclaration implementRoot(EnumerableRel rootRel,
                         Expressions.constant(input.name)),
                     input.type)));
 
-    final BlockStatement block = Expressions.block(
-        Iterables.concat(
-            stashed,
-            result.block.statements));
+    final BlockStatement block =
+        Expressions.block(
+            Iterables.concat(stashed, result.block.statements));
     memberDeclarations.add(
-        Expressions.methodDecl(
-            Modifier.PUBLIC,
-            Enumerable.class,
+        Expressions.methodDecl(Modifier.PUBLIC, Enumerable.class,
             BuiltInMethod.BINDABLE_BIND.method.getName(),
             Expressions.list(DataContext.ROOT),
             block));
@@ -330,10 +333,10 @@ private static ClassDeclaration classDecl(
         final Method method = (field.nullable()
             ? BuiltInMethod.COMPARE_NULLS_LAST
             : BuiltInMethod.COMPARE).method;
-        compareCall = Expressions.call(method.getDeclaringClass(),
-            method.getName(),
-            Expressions.field(thisParameter, field),
-            Expressions.field(thatParameter, field));
+        compareCall =
+            Expressions.call(method.getDeclaringClass(), method.getName(),
+                Expressions.field(thisParameter, field),
+                Expressions.field(thatParameter, field));
       } catch (RuntimeException e) {
         if (e.getCause() instanceof NoSuchMethodException) {
           // Just ignore the field in compareTo
@@ -439,7 +442,8 @@ public <T> Expression stash(T input, Class<? super T> clazz) {
         || input instanceof Double) {
       return Expressions.constant(input, clazz);
     }
-    ParameterExpression cached = stashedParameters.get(input);
+    final Equivalence.Wrapper<Object> key = IDENTITY.wrap(input);
+    ParameterExpression cached = stashedParameters.get(key);
     if (cached != null) {
       return cached;
     }
@@ -448,7 +452,7 @@ public <T> Expression stash(T input, Class<? super T> clazz) {
     final String name = "v" + map.size() + "stashed";
     final ParameterExpression x = Expressions.variable(clazz, name);
     map.put(name, input);
-    stashedParameters.put(input, x);
+    stashedParameters.put(key, x);
     return x;
   }
 
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableRepeatUnion.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableRepeatUnion.java
index c6e3fda0be9..2cee0be2c46 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableRepeatUnion.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableRepeatUnion.java
@@ -33,7 +33,10 @@
 import org.checkerframework.checker.nullness.qual.Nullable;
 
 import java.util.List;
-import java.util.Objects;
+
+import static org.apache.calcite.util.Util.last;
+
+import static java.util.Objects.requireNonNull;
 
 /**
  * Implementation of {@link RepeatUnion} in
@@ -71,11 +74,11 @@ public class EnumerableRepeatUnion extends RepeatUnion implements EnumerableRel
     Expression cleanUpFunctionExp = Expressions.constant(null);
     if (transientTable != null) {
       // root.getRootSchema().add(tableName, table);
-      Expression tableExp = implementor.stash(
-          Objects.requireNonNull(transientTable.unwrap(TransientTable.class)),
-          TransientTable.class);
-      String tableName =
-          transientTable.getQualifiedName().get(transientTable.getQualifiedName().size() - 1);
+      Expression tableExp =
+          implementor.stash(
+              requireNonNull(transientTable.unwrap(TransientTable.class)),
+              TransientTable.class);
+      String tableName = last(transientTable.getQualifiedName());
       Expression tableNameExp = Expressions.constant(tableName, String.class);
       builder.append(
           Expressions.call(
@@ -86,12 +89,12 @@ public class EnumerableRepeatUnion extends RepeatUnion implements EnumerableRel
               tableNameExp,
               tableExp));
       // root.getRootSchema().removeTable(tableName);
-      cleanUpFunctionExp = Expressions.lambda(Function0.class,
-          Expressions.call(
+      cleanUpFunctionExp =
+          Expressions.lambda(Function0.class,
               Expressions.call(
-                  implementor.getRootExpression(),
-                  BuiltInMethod.DATA_CONTEXT_GET_ROOT_SCHEMA.method),
-              BuiltInMethod.SCHEMA_PLUS_REMOVE_TABLE.method, tableNameExp));
+                  Expressions.call(implementor.getRootExpression(),
+                      BuiltInMethod.DATA_CONTEXT_GET_ROOT_SCHEMA.method),
+                  BuiltInMethod.SCHEMA_PLUS_REMOVE_TABLE.method, tableNameExp));
     }
 
     Result seedResult = implementor.visitChild(this, 0, (EnumerableRel) seed, pref);
@@ -100,19 +103,19 @@ public class EnumerableRepeatUnion extends RepeatUnion implements EnumerableRel
     Expression seedExp = builder.append("seed", seedResult.block);
     Expression iterativeExp = builder.append("iteration", iterationResult.block);
 
-    PhysType physType = PhysTypeImpl.of(
-        implementor.getTypeFactory(),
-        getRowType(),
-        pref.prefer(seedResult.format));
-
-    Expression unionExp = Expressions.call(
-        BuiltInMethod.REPEAT_UNION.method,
-        seedExp,
-        iterativeExp,
-        Expressions.constant(iterationLimit, int.class),
-        Expressions.constant(all, boolean.class),
-        Util.first(physType.comparer(), Expressions.call(BuiltInMethod.IDENTITY_COMPARER.method)),
-        cleanUpFunctionExp);
+    PhysType physType =
+        PhysTypeImpl.of(implementor.getTypeFactory(), getRowType(),
+            pref.prefer(seedResult.format));
+
+    Expression unionExp =
+        Expressions.call(BuiltInMethod.REPEAT_UNION.method,
+            seedExp,
+            iterativeExp,
+            Expressions.constant(iterationLimit, int.class),
+            Expressions.constant(all, boolean.class),
+            Util.first(physType.comparer(),
+                Expressions.call(BuiltInMethod.IDENTITY_COMPARER.method)),
+            cleanUpFunctionExp);
     builder.add(unionExp);
 
     return implementor.result(physType, builder.toBlock());
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableRules.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableRules.java
index 17a7465c06e..d12a31e7176 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableRules.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableRules.java
@@ -203,30 +203,30 @@ private EnumerableRules() {
       EnumerableInterpreterRule.DEFAULT_CONFIG
           .toRule(EnumerableInterpreterRule.class);
 
-  public static final List<RelOptRule> ENUMERABLE_RULES = ImmutableList.of(
-      EnumerableRules.ENUMERABLE_JOIN_RULE,
-      EnumerableRules.ENUMERABLE_MERGE_JOIN_RULE,
-      EnumerableRules.ENUMERABLE_CORRELATE_RULE,
-      EnumerableRules.ENUMERABLE_PROJECT_RULE,
-      EnumerableRules.ENUMERABLE_FILTER_RULE,
-      EnumerableRules.ENUMERABLE_CALC_RULE,
-      EnumerableRules.ENUMERABLE_AGGREGATE_RULE,
-      EnumerableRules.ENUMERABLE_SORT_RULE,
-      EnumerableRules.ENUMERABLE_LIMIT_RULE,
-      EnumerableRules.ENUMERABLE_COLLECT_RULE,
-      EnumerableRules.ENUMERABLE_UNCOLLECT_RULE,
-      EnumerableRules.ENUMERABLE_MERGE_UNION_RULE,
-      EnumerableRules.ENUMERABLE_UNION_RULE,
-      EnumerableRules.ENUMERABLE_REPEAT_UNION_RULE,
-      EnumerableRules.ENUMERABLE_TABLE_SPOOL_RULE,
-      EnumerableRules.ENUMERABLE_INTERSECT_RULE,
-      EnumerableRules.ENUMERABLE_MINUS_RULE,
-      EnumerableRules.ENUMERABLE_TABLE_MODIFICATION_RULE,
-      EnumerableRules.ENUMERABLE_VALUES_RULE,
-      EnumerableRules.ENUMERABLE_WINDOW_RULE,
-      EnumerableRules.ENUMERABLE_TABLE_SCAN_RULE,
-      EnumerableRules.ENUMERABLE_TABLE_FUNCTION_SCAN_RULE,
-      EnumerableRules.ENUMERABLE_MATCH_RULE);
+  public static final List<RelOptRule> ENUMERABLE_RULES =
+      ImmutableList.of(EnumerableRules.ENUMERABLE_JOIN_RULE,
+          EnumerableRules.ENUMERABLE_MERGE_JOIN_RULE,
+          EnumerableRules.ENUMERABLE_CORRELATE_RULE,
+          EnumerableRules.ENUMERABLE_PROJECT_RULE,
+          EnumerableRules.ENUMERABLE_FILTER_RULE,
+          EnumerableRules.ENUMERABLE_CALC_RULE,
+          EnumerableRules.ENUMERABLE_AGGREGATE_RULE,
+          EnumerableRules.ENUMERABLE_SORT_RULE,
+          EnumerableRules.ENUMERABLE_LIMIT_RULE,
+          EnumerableRules.ENUMERABLE_COLLECT_RULE,
+          EnumerableRules.ENUMERABLE_UNCOLLECT_RULE,
+          EnumerableRules.ENUMERABLE_MERGE_UNION_RULE,
+          EnumerableRules.ENUMERABLE_UNION_RULE,
+          EnumerableRules.ENUMERABLE_REPEAT_UNION_RULE,
+          EnumerableRules.ENUMERABLE_TABLE_SPOOL_RULE,
+          EnumerableRules.ENUMERABLE_INTERSECT_RULE,
+          EnumerableRules.ENUMERABLE_MINUS_RULE,
+          EnumerableRules.ENUMERABLE_TABLE_MODIFICATION_RULE,
+          EnumerableRules.ENUMERABLE_VALUES_RULE,
+          EnumerableRules.ENUMERABLE_WINDOW_RULE,
+          EnumerableRules.ENUMERABLE_TABLE_SCAN_RULE,
+          EnumerableRules.ENUMERABLE_TABLE_FUNCTION_SCAN_RULE,
+          EnumerableRules.ENUMERABLE_MATCH_RULE);
 
   public static List<RelOptRule> rules() {
     return ENUMERABLE_RULES;
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableSortedAggregate.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableSortedAggregate.java
index 2f03b3552c4..f28a6bbd87d 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableSortedAggregate.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableSortedAggregate.java
@@ -78,13 +78,14 @@ public EnumerableSortedAggregate(
     }
 
     RelTraitSet inputTraits = getInput().getTraitSet();
-    RelCollation collation = requireNonNull(required.getCollation(),
-        () -> "collation trait is null, required traits are " + required);
+    RelCollation collation =
+        requireNonNull(required.getCollation(),
+            () -> "collation trait is null, required traits are " + required);
     ImmutableBitSet requiredKeys = ImmutableBitSet.of(RelCollations.ordinals(collation));
     ImmutableBitSet groupKeys = ImmutableBitSet.range(groupSet.cardinality());
 
-    Mappings.TargetMapping mapping = Mappings.source(groupSet.toList(),
-        input.getRowType().getFieldCount());
+    Mappings.TargetMapping mapping =
+        Mappings.source(groupSet.toList(), input.getRowType().getFieldCount());
 
     if (requiredKeys.equals(groupKeys)) {
       RelCollation inputCollation = RexUtil.apply(mapping, collation);
@@ -147,8 +148,8 @@ public EnumerableSortedAggregate(
     final List<Expression> initExpressions = new ArrayList<>();
     final BlockBuilder initBlock = new BlockBuilder();
 
-    final List<Type> aggStateTypes = createAggStateTypes(
-        initExpressions, initBlock, aggs, typeFactory);
+    final List<Type> aggStateTypes =
+        createAggStateTypes(initExpressions, initBlock, aggs, typeFactory);
 
     final PhysType accPhysType =
         PhysTypeImpl.of(typeFactory,
@@ -208,21 +209,20 @@ public EnumerableSortedAggregate(
 
     final Expression keySelector_ =
         builder.append("keySelector",
-            inputPhysType.generateSelector(parameter,
-                groupSet.asList(),
+            inputPhysType.generateSelector(parameter, groupSet.asList(),
                 keyPhysType.getFormat()));
     // Generate the appropriate key Comparator. In the case of NULL values
     // in group keys, the comparator must be able to support NULL values by giving a
     // consistent sort ordering.
-    final Expression comparator = keyPhysType.generateComparator(
-        requireNonNull(getTraitSet().getCollation(),
-            () -> "getTraitSet().getCollation() is null, current traits are " + getTraitSet()));
+    final Expression comparator =
+        keyPhysType.generateComparator(
+            requireNonNull(getTraitSet().getCollation(),
+                () -> "getTraitSet().getCollation() is null; traits are "
+                    + getTraitSet()));
 
     final Expression resultSelector_ =
         builder.append("resultSelector",
-            Expressions.lambda(Function2.class,
-                resultBlock.toBlock(),
-                key_,
+            Expressions.lambda(Function2.class, resultBlock.toBlock(), key_,
                 acc_));
 
     builder.add(
@@ -236,8 +236,7 @@ public EnumerableSortedAggregate(
                         BuiltInMethod.AGG_LAMBDA_FACTORY_ACC_ADDER.method),
                     Expressions.call(lambdaFactory,
                         BuiltInMethod.AGG_LAMBDA_FACTORY_ACC_RESULT_SELECTOR.method,
-                        resultSelector_), comparator)
-                    )));
+                        resultSelector_), comparator))));
 
     return implementor.result(physType, builder.toBlock());
   }
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableSortedAggregateRule.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableSortedAggregateRule.java
index 31e401dc7bc..30f76e28def 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableSortedAggregateRule.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableSortedAggregateRule.java
@@ -56,9 +56,10 @@ protected EnumerableSortedAggregateRule(Config config) {
             RelCollations.of(
                 ImmutableIntList.copyOf(
             agg.getGroupSet().asList())));
-    final RelTraitSet selfTraits = inputTraits.replace(
-        RelCollations.of(
-        ImmutableIntList.identity(agg.getGroupSet().cardinality())));
+    final RelTraitSet selfTraits =
+        inputTraits.replace(
+            RelCollations.of(
+                ImmutableIntList.identity(agg.getGroupSet().cardinality())));
     return new EnumerableSortedAggregate(
         rel.getCluster(),
         selfTraits,
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableTableFunctionScan.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableTableFunctionScan.java
index 872856fa30c..c9a74e8ae6c 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableTableFunctionScan.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableTableFunctionScan.java
@@ -122,9 +122,10 @@ private Result defaultTableFunctionImplement(
     final PhysType physType =
         PhysTypeImpl.of(implementor.getTypeFactory(), getRowType(), format,
             false);
-    RexToLixTranslator t = RexToLixTranslator.forAggregation(
-        (JavaTypeFactory) getCluster().getTypeFactory(), bb, null,
-        implementor.getConformance());
+    RexToLixTranslator t =
+        RexToLixTranslator.forAggregation(
+            (JavaTypeFactory) getCluster().getTypeFactory(),
+            bb, null, implementor.getConformance());
     t = t.setCorrelates(implementor.allCorrelateVariables);
     bb.add(Expressions.return_(null, t.translate(getCall())));
     return implementor.result(physType, bb.toBlock());
@@ -137,10 +138,10 @@ private Result tvfImplementorBasedImplement(
     final EnumerableRel child = (EnumerableRel) getInputs().get(0);
     final Result result =
         implementor.visitChild(this, 0, child, pref);
-    final PhysType physType = PhysTypeImpl.of(
-        typeFactory, getRowType(), pref.prefer(result.format));
-    final Expression inputEnumerable = builder.append(
-        "_input", result.block, false);
+    final PhysType physType =
+        PhysTypeImpl.of(typeFactory, getRowType(), pref.prefer(result.format));
+    final Expression inputEnumerable =
+        builder.append("_input", result.block, false);
     final SqlConformance conformance =
         (SqlConformance) implementor.map.getOrDefault("_conformance",
             SqlConformanceEnum.DEFAULT);
@@ -154,9 +155,7 @@ private Result tvfImplementorBasedImplement(
             (RexCall) getCall(),
             inputEnumerable,
             result.physType,
-            physType
-        )
-    );
+            physType));
 
     return implementor.result(physType, builder.toBlock());
   }
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableTableModify.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableTableModify.java
index d0084fc7472..d6c90083f0b 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableTableModify.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableTableModify.java
@@ -74,8 +74,8 @@ public EnumerableTableModify(RelOptCluster cluster, RelTraitSet traits,
 
   @Override public Result implement(EnumerableRelImplementor implementor, Prefer pref) {
     final BlockBuilder builder = new BlockBuilder();
-    final Result result = implementor.visitChild(
-        this, 0, (EnumerableRel) getInput(), pref);
+    final Result result =
+        implementor.visitChild(this, 0, (EnumerableRel) getInput(), pref);
     Expression childExp =
         builder.append(
             "child", result.block);
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableTableScan.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableTableScan.java
index 3f3d95f9f29..9df232f59d1 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableTableScan.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableTableScan.java
@@ -266,8 +266,9 @@ private Expression fieldExpression(ParameterExpression row_, int i,
     switch (relFieldType.getSqlTypeName()) {
     case ARRAY:
     case MULTISET:
-      final RelDataType fieldType = requireNonNull(relFieldType.getComponentType(),
-          () -> "relFieldType.getComponentType() for " + relFieldType);
+      final RelDataType fieldType =
+          requireNonNull(relFieldType.getComponentType(),
+              () -> "relFieldType.getComponentType() for " + relFieldType);
       if (fieldType.isStruct()) {
         // We can't represent a multiset or array as a List<Employee>, because
         // the consumer does not know the element type.
@@ -275,10 +276,10 @@ private Expression fieldExpression(ParameterExpression row_, int i,
         // We need to convert to a List<List>.
         final JavaTypeFactory typeFactory =
                 (JavaTypeFactory) getCluster().getTypeFactory();
-        final PhysType elementPhysType = PhysTypeImpl.of(
-                typeFactory, fieldType, JavaRowFormat.CUSTOM);
+        final PhysType elementPhysType =
+            PhysTypeImpl.of(typeFactory, fieldType, JavaRowFormat.CUSTOM);
         final MethodCallExpression e2 =
-                Expressions.call(BuiltInMethod.AS_ENUMERABLE2.method, e);
+            Expressions.call(BuiltInMethod.AS_ENUMERABLE2.method, e);
         final Expression e3 = elementPhysType.convertTo(e2, JavaRowFormat.LIST);
         return Expressions.call(e3, BuiltInMethod.ENUMERABLE_TO_LIST.method);
       } else {
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableTableSpool.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableTableSpool.java
index ecee69ac605..f272376cade 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableTableSpool.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableTableSpool.java
@@ -78,30 +78,28 @@ public static EnumerableTableSpool create(RelNode input, Type readType,
     Result inputResult = implementor.visitChild(this, 0, (EnumerableRel) input, pref);
 
     String tableName = table.getQualifiedName().get(table.getQualifiedName().size() - 1);
-    Expression tableExp = Expressions.convert_(
-        Expressions.call(
+    Expression tableExp =
+        Expressions.convert_(
             Expressions.call(
-                implementor.getRootExpression(),
-                BuiltInMethod.DATA_CONTEXT_GET_ROOT_SCHEMA.method),
-            BuiltInMethod.SCHEMA_GET_TABLE.method,
-            Expressions.constant(tableName, String.class)),
-        ModifiableTable.class);
-    Expression collectionExp = Expressions.call(
-        tableExp,
-        BuiltInMethod.MODIFIABLE_TABLE_GET_MODIFIABLE_COLLECTION.method);
+                Expressions.call(implementor.getRootExpression(),
+                    BuiltInMethod.DATA_CONTEXT_GET_ROOT_SCHEMA.method),
+                BuiltInMethod.SCHEMA_GET_TABLE.method,
+                Expressions.constant(tableName, String.class)),
+            ModifiableTable.class);
+    Expression collectionExp =
+        Expressions.call(tableExp,
+            BuiltInMethod.MODIFIABLE_TABLE_GET_MODIFIABLE_COLLECTION.method);
 
     Expression inputExp = builder.append("input", inputResult.block);
 
-    Expression spoolExp = Expressions.call(
-        BuiltInMethod.LAZY_COLLECTION_SPOOL.method,
-        collectionExp,
-        inputExp);
+    Expression spoolExp =
+        Expressions.call(BuiltInMethod.LAZY_COLLECTION_SPOOL.method,
+            collectionExp, inputExp);
     builder.add(spoolExp);
 
-    PhysType physType = PhysTypeImpl.of(
-        implementor.getTypeFactory(),
-        getRowType(),
-        pref.prefer(inputResult.format));
+    PhysType physType =
+        PhysTypeImpl.of(implementor.getTypeFactory(),
+            getRowType(), pref.prefer(inputResult.format));
     return implementor.result(physType, builder.toBlock());
   }
 
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableTraitsUtils.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableTraitsUtils.java
index 3fddfbd2fd6..b716cb55465 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableTraitsUtils.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableTraitsUtils.java
@@ -117,8 +117,7 @@ private static boolean isCollationOnTrivialExpr(
       return null;
     }
 
-    final int maxField = Math.max(exps.size(),
-        inputRowType.getFieldCount());
+    final int maxField = Math.max(exps.size(), inputRowType.getFieldCount());
     Mappings.TargetMapping mapping = Mappings
         .create(MappingType.FUNCTION, maxField, maxField);
     for (Ord<RexNode> node : Ord.zip(exps)) {
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableUncollectRule.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableUncollectRule.java
index 9f33b711402..9079964897d 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableUncollectRule.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableUncollectRule.java
@@ -45,8 +45,9 @@ protected EnumerableUncollectRule(Config config) {
     final RelTraitSet traitSet =
         uncollect.getTraitSet().replace(EnumerableConvention.INSTANCE);
     final RelNode input = uncollect.getInput();
-    final RelNode newInput = convert(input,
-        input.getTraitSet().replace(EnumerableConvention.INSTANCE));
+    final RelNode newInput =
+        convert(input,
+            input.getTraitSet().replace(EnumerableConvention.INSTANCE));
     return EnumerableUncollect.create(traitSet, newInput,
         uncollect.withOrdinality);
   }
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableUnionRule.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableUnionRule.java
index fc0b94dc4fe..7a3dddbd5dc 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableUnionRule.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableUnionRule.java
@@ -48,8 +48,8 @@ protected EnumerableUnionRule(Config config) {
     final Union union = (Union) rel;
     final EnumerableConvention out = EnumerableConvention.INSTANCE;
     final RelTraitSet traitSet = rel.getCluster().traitSet().replace(out);
-    final List<RelNode> newInputs = Util.transform(
-        union.getInputs(), n -> convert(n, traitSet));
+    final List<RelNode> newInputs =
+        Util.transform(union.getInputs(), n -> convert(n, traitSet));
     return new EnumerableUnion(rel.getCluster(), traitSet,
         newInputs, union.all);
   }
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableValuesRule.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableValuesRule.java
index 9314b2e973e..c8edd864e71 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableValuesRule.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableValuesRule.java
@@ -40,8 +40,9 @@ protected EnumerableValuesRule(Config config) {
 
   @Override public RelNode convert(RelNode rel) {
     final Values logicalValues = (Values) rel;
-    final EnumerableValues enumerableValues = EnumerableValues.create(
-        logicalValues.getCluster(), logicalValues.getRowType(), logicalValues.getTuples());
+    final EnumerableValues enumerableValues =
+        EnumerableValues.create(logicalValues.getCluster(),
+            logicalValues.getRowType(), logicalValues.getTuples());
     return enumerableValues.copy(
         logicalValues.getTraitSet().replace(EnumerableConvention.INSTANCE),
         enumerableValues.getInputs());
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableWindow.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableWindow.java
index f6dc230d8a2..8b00799c043 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableWindow.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/EnumerableWindow.java
@@ -207,10 +207,8 @@ private static void sampleOfTheGeneratedWindowedAggregate() {
       //      }
       //    };
       final Expression comparator_ =
-          builder.append(
-              "comparator",
-              inputPhysType.generateComparator(
-                  group.collation()));
+          builder.append("comparator",
+              inputPhysType.generateComparator(group.collation()));
 
       Pair<Expression, Expression> partitionIterator =
           getPartitionIterator(builder, source_, inputPhysType, group,
@@ -232,23 +230,21 @@ private static void sampleOfTheGeneratedWindowedAggregate() {
       final RelDataTypeFactory.Builder typeBuilder = typeFactory.builder();
       typeBuilder.addAll(inputPhysType.getRowType().getFieldList());
       for (AggImpState agg : aggs) {
-        // CALCITE-4326
-        String name = requireNonNull(agg.call.name,
-            () -> "agg.call.name for " + agg.call);
+        // [CALCITE-4326] NullPointerException possible in EnumerableWindow when
+        // agg.call.name is null
+        String name =
+            requireNonNull(agg.call.name, () -> "agg.call.name for " + agg.call);
         typeBuilder.add(name, agg.call.type);
       }
       RelDataType outputRowType = typeBuilder.build();
       final PhysType outputPhysType =
-          PhysTypeImpl.of(
-              typeFactory, outputRowType, pref.prefer(result.format));
+          PhysTypeImpl.of(typeFactory, outputRowType, pref.prefer(result.format));
 
       final Expression list_ =
-          builder.append(
-              "list",
-              Expressions.new_(
-                  ArrayList.class,
-                  Expressions.call(
-                      collectionExpr, BuiltInMethod.COLLECTION_SIZE.method)),
+          builder.append("list",
+              Expressions.new_(ArrayList.class,
+                  Expressions.call(collectionExpr,
+                      BuiltInMethod.COLLECTION_SIZE.method)),
               false);
 
       Pair<@Nullable Expression, @Nullable Expression> collationKey =
@@ -257,11 +253,9 @@ private static void sampleOfTheGeneratedWindowedAggregate() {
       Expression keyComparator = collationKey.right;
       final BlockBuilder builder3 = new BlockBuilder();
       final Expression rows_ =
-          builder3.append(
-              "rows",
+          builder3.append("rows",
               Expressions.convert_(
-                  Expressions.call(
-                      iterator_, BuiltInMethod.ITERATOR_NEXT.method),
+                  Expressions.call(iterator_, BuiltInMethod.ITERATOR_NEXT.method),
                   Object[].class),
               false);
 
@@ -279,10 +273,8 @@ private static void sampleOfTheGeneratedWindowedAggregate() {
           Expressions.parameter(int.class, builder4.newName("i"));
 
       final Expression row_ =
-          builder4.append(
-              "row",
-              EnumUtils.convert(
-                  Expressions.arrayIndex(rows_, i_),
+          builder4.append("row",
+              EnumUtils.convert(Expressions.arrayIndex(rows_, i_),
                   inputPhysType.getJavaRowType()));
 
       final RexToLixTranslator.InputGetter inputGetter =
@@ -299,8 +291,7 @@ private static void sampleOfTheGeneratedWindowedAggregate() {
           inputPhysType.getRowType().getFieldCount();
       for (int i = 0; i < fieldCountWithAggResults; i++) {
         outputRow.add(
-            inputPhysType.fieldReference(
-                row_, i,
+            inputPhysType.fieldReference(row_, i,
                 outputPhysType.getJavaFieldType(i)));
       }
 
@@ -312,16 +303,18 @@ private static void sampleOfTheGeneratedWindowedAggregate() {
       final Expression minX = Expressions.constant(0);
       final Expression partitionRowCount =
           builder3.append("partRows", Expressions.field(rows_, "length"));
-      final Expression maxX = builder3.append("maxX",
-          Expressions.subtract(
-              partitionRowCount, Expressions.constant(1)));
-
-      final Expression startUnchecked = builder4.append("start",
-          translateBound(translator, i_, row_, minX, maxX, rows_,
-              group, true, inputPhysType, keySelector, keyComparator));
-      final Expression endUnchecked = builder4.append("end",
-          translateBound(translator, i_, row_, minX, maxX, rows_,
-              group, false, inputPhysType, keySelector, keyComparator));
+      final Expression maxX =
+          builder3.append("maxX",
+              Expressions.subtract(partitionRowCount, Expressions.constant(1)));
+
+      final Expression startUnchecked =
+          builder4.append("start",
+              translateBound(translator, i_, row_, minX, maxX, rows_,
+                  group, true, inputPhysType, keySelector, keyComparator));
+      final Expression endUnchecked =
+          builder4.append("end",
+              translateBound(translator, i_, row_, minX, maxX, rows_,
+                  group, false, inputPhysType, keySelector, keyComparator));
 
       final Expression startX;
       final Expression endX;
@@ -344,15 +337,15 @@ private static void sampleOfTheGeneratedWindowedAggregate() {
                     Expressions.call(null, BuiltInMethod.MATH_MIN.method,
                         endUnchecked, maxX));
 
-        ParameterExpression startPe = Expressions.parameter(0, int.class,
-            builder4.newName("startChecked"));
-        ParameterExpression endPe = Expressions.parameter(0, int.class,
-            builder4.newName("endChecked"));
+        ParameterExpression startPe =
+            Expressions.parameter(0, int.class, builder4.newName("startChecked"));
+        ParameterExpression endPe =
+            Expressions.parameter(0, int.class, builder4.newName("endChecked"));
         builder4.add(Expressions.declare(Modifier.FINAL, startPe, null));
         builder4.add(Expressions.declare(Modifier.FINAL, endPe, null));
 
-        hasRows = builder4.append("hasRows",
-            Expressions.lessThanOrEqual(startTmp, endTmp));
+        hasRows =
+            builder4.append("hasRows", Expressions.lessThanOrEqual(startTmp, endTmp));
         builder4.add(
             Expressions.ifThenElse(hasRows,
                 Expressions.block(
@@ -371,9 +364,9 @@ private static void sampleOfTheGeneratedWindowedAggregate() {
 
       final BlockBuilder builder5 = new BlockBuilder(true, builder4);
 
-      BinaryExpression rowCountWhenNonEmpty = Expressions.add(
-          startX == minX ? endX : Expressions.subtract(endX, startX),
-          Expressions.constant(1));
+      BinaryExpression rowCountWhenNonEmpty =
+          Expressions.add(startX == minX ? endX : Expressions.subtract(endX, startX),
+              Expressions.constant(1));
 
       final Expression frameRowCount;
 
@@ -387,8 +380,8 @@ private static void sampleOfTheGeneratedWindowedAggregate() {
                     Expressions.constant(0)));
       }
 
-      ParameterExpression actualStart = Expressions.parameter(
-          0, int.class, builder5.newName("actualStart"));
+      ParameterExpression actualStart =
+          Expressions.parameter(0, int.class, builder5.newName("actualStart"));
 
       final BlockBuilder builder6 = new BlockBuilder(true, builder5);
       builder6.add(
@@ -405,9 +398,9 @@ private static void sampleOfTheGeneratedWindowedAggregate() {
           group.lowerBound.isUnbounded() && group.lowerBound.isPreceding()
           ? Expressions.constant(false)
           : Expressions.notEqual(startX, prevStart);
-      Expression needRecomputeWindow = Expressions.orElse(
-          lowerBoundCanChange,
-          Expressions.lessThan(endX, prevEnd));
+      Expression needRecomputeWindow =
+          Expressions.orElse(lowerBoundCanChange,
+              Expressions.lessThan(endX, prevEnd));
 
       BlockStatement resetWindowState = builder6.toBlock();
       if (resetWindowState.statements.size() == 1) {
@@ -423,7 +416,7 @@ private static void sampleOfTheGeneratedWindowedAggregate() {
                 resetWindowState,
                 Expressions.statement(
                     Expressions.assign(actualStart,
-                    Expressions.add(prevEnd, Expressions.constant(1))))));
+                        Expressions.add(prevEnd, Expressions.constant(1))))));
       }
 
       if (lowerBoundCanChange instanceof BinaryExpression) {
@@ -449,9 +442,7 @@ private static void sampleOfTheGeneratedWindowedAggregate() {
       final Function<AggImpState, List<RexNode>> rexArguments = agg -> {
         List<Integer> argList = agg.call.getArgList();
         List<RelDataType> inputTypes =
-            EnumUtils.fieldRowTypes(
-                result.physType.getRowType(),
-                constants,
+            EnumUtils.fieldRowTypes(result.physType.getRowType(), constants,
                 argList);
         List<RexNode> args = new ArrayList<>(inputTypes.size());
         for (int i = 0; i < argList.size(); i++) {
@@ -466,11 +457,11 @@ private static void sampleOfTheGeneratedWindowedAggregate() {
       BlockStatement forBlock = builder7.toBlock();
       if (!forBlock.statements.isEmpty()) {
         // For instance, row_number does not use for loop to compute the value
-        Statement forAggLoop = Expressions.for_(
-            Arrays.asList(jDecl),
-            Expressions.lessThanOrEqual(jDecl.parameter, endX),
-            Expressions.preIncrementAssign(jDecl.parameter),
-            forBlock);
+        Statement forAggLoop =
+            Expressions.for_(Arrays.asList(jDecl),
+                Expressions.lessThanOrEqual(jDecl.parameter, endX),
+                Expressions.preIncrementAssign(jDecl.parameter),
+                forBlock);
         if (!hasRows.equals(Expressions.constant(true))) {
           forAggLoop = Expressions.ifThen(hasRows, forAggLoop);
         }
@@ -491,39 +482,29 @@ private static void sampleOfTheGeneratedWindowedAggregate() {
 
       builder4.add(
           Expressions.statement(
-              Expressions.call(
-                  list_,
-                  BuiltInMethod.COLLECTION_ADD.method,
+              Expressions.call(list_, BuiltInMethod.COLLECTION_ADD.method,
                   outputPhysType.record(outputRow))));
 
       builder3.add(
           Expressions.for_(
               Expressions.declare(0, i_, Expressions.constant(0)),
-              Expressions.lessThan(
-                  i_,
-                  Expressions.field(rows_, "length")),
+              Expressions.lessThan(i_, Expressions.field(rows_, "length")),
               Expressions.preIncrementAssign(i_),
               builder4.toBlock()));
 
       builder.add(
           Expressions.while_(
-              Expressions.call(
-                  iterator_,
-                  BuiltInMethod.ITERATOR_HAS_NEXT.method),
+              Expressions.call(iterator_, BuiltInMethod.ITERATOR_HAS_NEXT.method),
               builder3.toBlock()));
       builder.add(
           Expressions.statement(
-              Expressions.call(
-                  collectionExpr,
-                  BuiltInMethod.MAP_CLEAR.method)));
+              Expressions.call(collectionExpr, BuiltInMethod.MAP_CLEAR.method)));
 
       // We're not assigning to "source". For each group, create a new
       // final variable called "source" or "sourceN".
       source_ =
-          builder.append(
-              "source",
-              Expressions.call(
-                  BuiltInMethod.AS_ENUMERABLE.method, list_));
+          builder.append("source",
+              Expressions.call(BuiltInMethod.AS_ENUMERABLE.method, list_));
 
       inputPhysType = outputPhysType;
     }
@@ -587,14 +568,11 @@ private Expression checkBounds(Expression rowIndex,
           return hasRows;
         }
 
-        //noinspection UnnecessaryLocalVariable
-        Expression res = block.append("rowInFrame",
+        return block.append("rowInFrame",
             Expressions.foldAnd(
                 ImmutableList.of(hasRows,
                     Expressions.greaterThanOrEqual(rowIndex, minIndex),
                     Expressions.lessThanOrEqual(rowIndex, maxIndex))));
-
-        return res;
       }
 
       @Override public Expression rowInFrame(Expression rowIndex) {
@@ -612,8 +590,7 @@ private Expression checkBounds(Expression rowIndex,
       }
 
       public Expression getRow(Expression rowIndex) {
-        return block.append(
-            "jRow",
+        return block.append("jRow",
             EnumUtils.convert(
                 Expressions.arrayIndex(rows_, rowIndex),
                 inputPhysType.getJavaRowType()));
@@ -674,26 +651,23 @@ private static Pair<Expression, Expression> getPartitionIterator(
       //       SortedMultiMap.singletonArrayIterator(comparator, tempList);
       //   final List<Xxx> list = new ArrayList<Xxx>(tempList.size());
 
-      final Expression tempList_ = builder.append(
-          "tempList",
-          Expressions.convert_(
-              Expressions.call(
-                  source_,
-                  BuiltInMethod.INTO.method,
-                  Expressions.new_(ArrayList.class)),
-              List.class));
+      final Expression tempList_ =
+          builder.append("tempList",
+              Expressions.convert_(
+                  Expressions.call(source_,
+                      BuiltInMethod.INTO.method,
+                      Expressions.new_(ArrayList.class)),
+                  List.class),
+              false);
       return Pair.of(tempList_,
-          builder.append(
-            "iterator",
-            Expressions.call(
-                null,
-                BuiltInMethod.SORTED_MULTI_MAP_SINGLETON.method,
-                comparator_,
-                tempList_)));
+          builder.append("iterator",
+              Expressions.call(null,
+                  BuiltInMethod.SORTED_MULTI_MAP_SINGLETON.method,
+                  comparator_,
+                  tempList_)));
     }
     Expression multiMap_ =
-        builder.append(
-            "multiMap", Expressions.new_(SortedMultiMap.class));
+        builder.append("multiMap", Expressions.new_(SortedMultiMap.class));
     final BlockBuilder builder2 = new BlockBuilder();
     final ParameterExpression v_ =
         Expressions.parameter(inputPhysType.getJavaRowType(),
@@ -726,29 +700,19 @@ private static Pair<Expression, Expression> getPartitionIterator(
     }
     builder2.add(
         Expressions.statement(
-            Expressions.call(
-                multiMap_,
-                BuiltInMethod.SORTED_MULTI_MAP_PUT_MULTI.method,
-                key_,
-                v_)));
+            Expressions.call(multiMap_,
+                BuiltInMethod.SORTED_MULTI_MAP_PUT_MULTI.method, key_, v_)));
     builder2.add(
-        Expressions.return_(
-            null, Expressions.constant(null)));
+        Expressions.return_(null, Expressions.constant(null)));
 
     builder.add(
         Expressions.statement(
-            Expressions.call(
-                source_,
-                BuiltInMethod.ENUMERABLE_FOREACH.method,
-                Expressions.lambda(
-                    builder2.toBlock(), v_))));
+            Expressions.call(source_, BuiltInMethod.ENUMERABLE_FOREACH.method,
+                Expressions.lambda(builder2.toBlock(), v_))));
 
     return Pair.of(multiMap_,
-      builder.append(
-        "iterator",
-        Expressions.call(
-            multiMap_,
-            BuiltInMethod.SORTED_MULTI_MAP_ARRAYS.method,
+      builder.append("iterator",
+        Expressions.call(multiMap_, BuiltInMethod.SORTED_MULTI_MAP_ARRAYS.method,
             comparator_)));
   }
 
@@ -837,9 +801,9 @@ private void declareAndResetState(final JavaTypeFactory typeFactory,
       if (Primitive.is(aggHolderType) && !Primitive.is(aggStorageType)) {
         aggHolderType = Primitive.box(aggHolderType);
       }
-      ParameterExpression aggRes = Expressions.parameter(0,
-          aggHolderType,
-          builder.newName(aggName + "w" + windowIdx));
+      ParameterExpression aggRes =
+          Expressions.parameter(0, aggHolderType,
+              builder.newName(aggName + "w" + windowIdx));
 
       builder.add(
           Expressions.declare(0, aggRes,
@@ -899,19 +863,22 @@ private static boolean implementResult(List<AggImpState> aggs,
         continue;
       }
       nonEmpty = true;
-      Expression res = agg.implementor.implementResult(requireNonNull(agg.context, "agg.context"),
-          new WinAggResultContextImpl(builder, requireNonNull(agg.state, "agg.state"), frame) {
-            @Override public List<RexNode> rexArguments() {
-              return rexArguments.apply(agg);
-            }
-          });
+      Expression res =
+          agg.implementor.implementResult(
+              requireNonNull(agg.context, "agg.context"),
+              new WinAggResultContextImpl(builder,
+                  requireNonNull(agg.state, "agg.state"), frame) {
+                @Override public List<RexNode> rexArguments() {
+                  return rexArguments.apply(agg);
+                }
+              });
       // Several count(a) and count(b) might share the result
-      Expression result = requireNonNull(agg.result,
-          () -> "agg.result for " + agg.call);
-      Expression aggRes = builder.append("a" + agg.aggIdx + "res",
-          EnumUtils.convert(res, result.getType()));
-      builder.add(
-          Expressions.statement(Expressions.assign(result, aggRes)));
+      Expression result =
+          requireNonNull(agg.result, () -> "agg.result for " + agg.call);
+      Expression aggRes =
+          builder.append("a" + agg.aggIdx + "res",
+              EnumUtils.convert(res, result.getType()));
+      builder.add(Expressions.statement(Expressions.assign(result, aggRes)));
     }
     return nonEmpty;
   }
@@ -976,8 +943,8 @@ private static Expression translateBound(RexToLixTranslator translator,
     if (bound.getOffset() == null) {
       desiredKeyType = Primitive.box(desiredKeyType);
     }
-    Expression val = translator.translate(
-        new RexInputRef(orderKey, keyType), desiredKeyType);
+    Expression val =
+        translator.translate(new RexInputRef(orderKey, keyType), desiredKeyType);
     if (!bound.isCurrentRow()) {
       RexNode node = bound.getOffset();
       Expression offs = translator.translate(node);
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/JavaRowFormat.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/JavaRowFormat.java
index 8b76e592ea8..4810b04deac 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/JavaRowFormat.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/JavaRowFormat.java
@@ -27,6 +27,7 @@
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.runtime.FlatLists;
 import org.apache.calcite.runtime.Unit;
+import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.util.BuiltInMethod;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
@@ -82,6 +83,11 @@ public enum JavaRowFormat {
         JavaTypeFactory typeFactory,
         RelDataType type) {
       assert type.getFieldCount() == 1;
+      RelDataType field0Type = type.getFieldList().get(0).getType();
+      // nested ROW type is always represented as array.
+      if (field0Type.getSqlTypeName() == SqlTypeName.ROW) {
+        return Object[].class;
+      }
       return typeFactory.getJavaClass(
           type.getFieldList().get(0).getType());
     }
@@ -179,10 +185,11 @@ public enum JavaRowFormat {
       }
     }
 
-    @Override public Expression field(Expression expression, int field, @Nullable Type fromType,
-        Type fieldType) {
-      final MethodCallExpression e = Expressions.call(expression,
-          BuiltInMethod.LIST_GET.method, Expressions.constant(field));
+    @Override public Expression field(Expression expression, int field,
+        @Nullable Type fromType, Type fieldType) {
+      final MethodCallExpression e =
+          Expressions.call(expression, BuiltInMethod.LIST_GET.method,
+              Expressions.constant(field));
       if (fromType == null) {
         fromType = e.getType();
       }
@@ -208,10 +215,11 @@ public enum JavaRowFormat {
       return Expressions.call(BuiltInMethod.ROW_AS_COPY.method, expressions);
     }
 
-    @Override public Expression field(Expression expression, int field, @Nullable Type fromType,
-        Type fieldType) {
-      final Expression e = Expressions.call(expression,
-          BuiltInMethod.ROW_VALUE.method, Expressions.constant(field));
+    @Override public Expression field(Expression expression, int field,
+        @Nullable Type fromType, Type fieldType) {
+      final Expression e =
+          Expressions.call(expression,
+              BuiltInMethod.ROW_VALUE.method, Expressions.constant(field));
       if (fromType == null) {
         fromType = e.getType();
       }
@@ -239,10 +247,10 @@ public enum JavaRowFormat {
       return Expressions.call(BuiltInMethod.ARRAY_COMPARER.method);
     }
 
-    @Override public Expression field(Expression expression, int field, @Nullable Type fromType,
-        Type fieldType) {
-      final IndexExpression e = Expressions.arrayIndex(expression,
-          Expressions.constant(field));
+    @Override public Expression field(Expression expression, int field,
+        @Nullable Type fromType, Type fieldType) {
+      final IndexExpression e =
+          Expressions.arrayIndex(expression, Expressions.constant(field));
       if (fromType == null) {
         fromType = e.getType();
       }
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/MatchUtils.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/MatchUtils.java
index 5c3120dfe47..52c917b570a 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/MatchUtils.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/MatchUtils.java
@@ -27,7 +27,7 @@ private MatchUtils() {
   }
 
   /**
-   * Returns the row with the highest index whose corresponding symbol matches, null otherwese.
+   * Returns the row with the highest index whose corresponding symbol matches, null otherwise.
    * @param symbol Target Symbol
    * @param rows List of passed rows
    * @param symbols Corresponding symbols to rows
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/PhysTypeImpl.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/PhysTypeImpl.java
index ad57cf3dc71..966b0503bf0 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/PhysTypeImpl.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/PhysTypeImpl.java
@@ -258,9 +258,12 @@ static PhysType of(
     // The conversion must be strict so optimizations of the targetFormat should not be performed
     // by the code that follows. If necessary the target format can be optimized before calling
     // this method.
-    PhysType targetPhysType = PhysTypeImpl.of(typeFactory, rowType, targetFormat, false);
-    final Expression selector = Expressions.lambda(Function1.class,
-        targetPhysType.record(fieldReferences(o_, Util.range(fieldCount))), o_);
+    PhysType targetPhysType =
+        PhysTypeImpl.of(typeFactory, rowType, targetFormat, false);
+    final Expression selector =
+        Expressions.lambda(Function1.class,
+            targetPhysType.record(fieldReferences(o_, Util.range(fieldCount))),
+            o_);
     return Expressions.call(exp, BuiltInMethod.SELECT.method, selector);
   }
 
@@ -522,8 +525,9 @@ static PhysType of(
 
   @Override public PhysType component(int fieldOrdinal) {
     final RelDataTypeField field = rowType.getFieldList().get(fieldOrdinal);
-    RelDataType componentType = requireNonNull(field.getType().getComponentType(),
-        () -> "field.getType().getComponentType() for " + field);
+    RelDataType componentType =
+        requireNonNull(field.getType().getComponentType(),
+            () -> "field.getType().getComponentType() for " + field);
     return PhysTypeImpl.of(typeFactory,
         toStruct(componentType), format, false);
   }
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 9738523f2cb..b6832169722 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
@@ -29,6 +29,7 @@
 import org.apache.calcite.linq4j.tree.Expression;
 import org.apache.calcite.linq4j.tree.ExpressionType;
 import org.apache.calcite.linq4j.tree.Expressions;
+import org.apache.calcite.linq4j.tree.FunctionExpression;
 import org.apache.calcite.linq4j.tree.MemberExpression;
 import org.apache.calcite.linq4j.tree.MethodCallExpression;
 import org.apache.calcite.linq4j.tree.NewExpression;
@@ -60,6 +61,7 @@
 import org.apache.calcite.sql.SqlWindowTableFunction;
 import org.apache.calcite.sql.fun.SqlJsonArrayAggAggFunction;
 import org.apache.calcite.sql.fun.SqlJsonObjectAggAggFunction;
+import org.apache.calcite.sql.fun.SqlQuantifyOperator;
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
 import org.apache.calcite.sql.fun.SqlTrimFunction;
 import org.apache.calcite.sql.type.SqlTypeName;
@@ -72,6 +74,7 @@
 import org.apache.calcite.util.Util;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Iterables;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
@@ -115,48 +118,75 @@
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.ARRAY_REVERSE;
 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.CHAR;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.CHR;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.COMPRESS;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.CONCAT2;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.CONCAT_FUNCTION;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.COSH;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.DATE;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.DATEADD;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.DATETIME;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.DATETIME_TRUNC;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.DATE_FROM_UNIX_DATE;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.DATE_TRUNC;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.DAYNAME;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.DIFFERENCE;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.ENDS_WITH;
 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.FORMAT_DATE;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.FORMAT_DATETIME;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.FORMAT_TIME;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.FORMAT_TIMESTAMP;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.FROM_BASE64;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.ILIKE;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.JSON_DEPTH;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.JSON_INSERT;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.JSON_KEYS;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.JSON_LENGTH;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.JSON_PRETTY;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.JSON_REMOVE;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.JSON_REPLACE;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.JSON_SET;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.JSON_STORAGE_SIZE;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.JSON_TYPE;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.LEFT;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.LOG;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.LOGICAL_AND;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.LOGICAL_OR;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.LPAD;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.MAX_BY;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.MD5;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.MIN_BY;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.MONTHNAME;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.POW;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.REGEXP_REPLACE;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.REPEAT;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.REVERSE;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.RIGHT;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.RLIKE;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.RPAD;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.SAFE_CAST;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.SHA1;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.SINH;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.SOUNDEX;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.SPACE;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.SPLIT;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.STARTS_WITH;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.STRCMP;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.TANH;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.TIME;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.TIMESTAMP;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.TIMESTAMP_MICROS;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.TIMESTAMP_MILLIS;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.TIMESTAMP_SECONDS;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.TIMESTAMP_TRUNC;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.TIME_TRUNC;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.TO_BASE64;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.TRANSLATE3;
+import static org.apache.calcite.sql.fun.SqlLibraryOperators.TRUNC;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.UNIX_DATE;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.UNIX_MICROS;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.UNIX_MILLIS;
@@ -164,8 +194,16 @@
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.XML_TRANSFORM;
 import static org.apache.calcite.sql.fun.SqlStdOperatorTable.ABS;
 import static org.apache.calcite.sql.fun.SqlStdOperatorTable.ACOS;
+import static org.apache.calcite.sql.fun.SqlStdOperatorTable.ALL_EQ;
+import static org.apache.calcite.sql.fun.SqlStdOperatorTable.ALL_GE;
+import static org.apache.calcite.sql.fun.SqlStdOperatorTable.ALL_GT;
+import static org.apache.calcite.sql.fun.SqlStdOperatorTable.ALL_LE;
+import static org.apache.calcite.sql.fun.SqlStdOperatorTable.ALL_LT;
+import static org.apache.calcite.sql.fun.SqlStdOperatorTable.ALL_NE;
 import static org.apache.calcite.sql.fun.SqlStdOperatorTable.AND;
 import static org.apache.calcite.sql.fun.SqlStdOperatorTable.ANY_VALUE;
+import static org.apache.calcite.sql.fun.SqlStdOperatorTable.ARG_MAX;
+import static org.apache.calcite.sql.fun.SqlStdOperatorTable.ARG_MIN;
 import static org.apache.calcite.sql.fun.SqlStdOperatorTable.ARRAY_VALUE_CONSTRUCTOR;
 import static org.apache.calcite.sql.fun.SqlStdOperatorTable.ASCII;
 import static org.apache.calcite.sql.fun.SqlStdOperatorTable.ASIN;
@@ -304,6 +342,12 @@
 import static org.apache.calcite.sql.fun.SqlStdOperatorTable.SINGLE_VALUE;
 import static org.apache.calcite.sql.fun.SqlStdOperatorTable.SLICE;
 import static org.apache.calcite.sql.fun.SqlStdOperatorTable.SOME;
+import static org.apache.calcite.sql.fun.SqlStdOperatorTable.SOME_EQ;
+import static org.apache.calcite.sql.fun.SqlStdOperatorTable.SOME_GE;
+import static org.apache.calcite.sql.fun.SqlStdOperatorTable.SOME_GT;
+import static org.apache.calcite.sql.fun.SqlStdOperatorTable.SOME_LE;
+import static org.apache.calcite.sql.fun.SqlStdOperatorTable.SOME_LT;
+import static org.apache.calcite.sql.fun.SqlStdOperatorTable.SOME_NE;
 import static org.apache.calcite.sql.fun.SqlStdOperatorTable.STRUCT_ACCESS;
 import static org.apache.calcite.sql.fun.SqlStdOperatorTable.SUBMULTISET_OF;
 import static org.apache.calcite.sql.fun.SqlStdOperatorTable.SUBSTRING;
@@ -311,6 +355,8 @@
 import static org.apache.calcite.sql.fun.SqlStdOperatorTable.SUM0;
 import static org.apache.calcite.sql.fun.SqlStdOperatorTable.SYSTEM_USER;
 import static org.apache.calcite.sql.fun.SqlStdOperatorTable.TAN;
+import static org.apache.calcite.sql.fun.SqlStdOperatorTable.TIMESTAMP_ADD;
+import static org.apache.calcite.sql.fun.SqlStdOperatorTable.TIMESTAMP_DIFF;
 import static org.apache.calcite.sql.fun.SqlStdOperatorTable.TRIM;
 import static org.apache.calcite.sql.fun.SqlStdOperatorTable.TRUNCATE;
 import static org.apache.calcite.sql.fun.SqlStdOperatorTable.TUMBLE;
@@ -323,9 +369,13 @@
 
 /**
  * Contains implementations of Rex operators as Java code.
+ *
+ * <p>Immutable.
  */
 public class RexImpTable {
-  public static final RexImpTable INSTANCE = new RexImpTable();
+  /** The singleton instance. */
+  public static final RexImpTable INSTANCE =
+      new RexImpTable(new Builder().populate());
 
   public static final ConstantExpression NULL_EXPR =
       Expressions.constant(null);
@@ -340,388 +390,507 @@ public class RexImpTable {
   public static final MemberExpression BOXED_TRUE_EXPR =
       Expressions.field(null, Boolean.class, "TRUE");
 
-  private final Map<SqlOperator, RexCallImplementor> map = new HashMap<>();
-  private final Map<SqlAggFunction, Supplier<? extends AggImplementor>> aggMap =
-      new HashMap<>();
-  private final Map<SqlAggFunction, Supplier<? extends WinAggImplementor>> winAggMap =
-      new HashMap<>();
-  private final Map<SqlMatchFunction, Supplier<? extends MatchImplementor>> matchMap =
-      new HashMap<>();
-  private final Map<SqlOperator, Supplier<? extends TableFunctionCallImplementor>>
-      tvfImplementorMap = new HashMap<>();
-
-  @SuppressWarnings("method.invocation.invalid")
-  RexImpTable() {
-    defineMethod(THROW_UNLESS, BuiltInMethod.THROW_UNLESS.method, NullPolicy.NONE);
-    defineMethod(ROW, BuiltInMethod.ARRAY.method, NullPolicy.ALL);
-    defineMethod(UPPER, BuiltInMethod.UPPER.method, NullPolicy.STRICT);
-    defineMethod(LOWER, BuiltInMethod.LOWER.method, NullPolicy.STRICT);
-    defineMethod(INITCAP,  BuiltInMethod.INITCAP.method, NullPolicy.STRICT);
-    defineMethod(TO_BASE64, BuiltInMethod.TO_BASE64.method, NullPolicy.STRICT);
-    defineMethod(FROM_BASE64, BuiltInMethod.FROM_BASE64.method, NullPolicy.STRICT);
-    defineMethod(MD5, BuiltInMethod.MD5.method, NullPolicy.STRICT);
-    defineMethod(SHA1, BuiltInMethod.SHA1.method, NullPolicy.STRICT);
-    defineMethod(SUBSTRING, BuiltInMethod.SUBSTRING.method, NullPolicy.STRICT);
-    defineMethod(LEFT, BuiltInMethod.LEFT.method, NullPolicy.ANY);
-    defineMethod(RIGHT, BuiltInMethod.RIGHT.method, NullPolicy.ANY);
-    defineMethod(REPLACE, BuiltInMethod.REPLACE.method, NullPolicy.STRICT);
-    defineMethod(TRANSLATE3, BuiltInMethod.TRANSLATE3.method, NullPolicy.STRICT);
-    defineMethod(CHR, "chr", NullPolicy.STRICT);
-    defineMethod(CHARACTER_LENGTH, BuiltInMethod.CHAR_LENGTH.method,
-        NullPolicy.STRICT);
-    defineMethod(CHAR_LENGTH, BuiltInMethod.CHAR_LENGTH.method,
-        NullPolicy.STRICT);
-    defineMethod(OCTET_LENGTH, BuiltInMethod.OCTET_LENGTH.method,
-        NullPolicy.STRICT);
-    map.put(CONCAT, new ConcatImplementor());
-    defineMethod(CONCAT_FUNCTION, BuiltInMethod.MULTI_STRING_CONCAT.method,
-        NullPolicy.STRICT);
-    defineMethod(CONCAT2, BuiltInMethod.STRING_CONCAT.method, NullPolicy.STRICT);
-    defineMethod(OVERLAY, BuiltInMethod.OVERLAY.method, NullPolicy.STRICT);
-    defineMethod(POSITION, BuiltInMethod.POSITION.method, NullPolicy.STRICT);
-    defineMethod(ASCII, BuiltInMethod.ASCII.method, NullPolicy.STRICT);
-    defineMethod(REPEAT, BuiltInMethod.REPEAT.method, NullPolicy.STRICT);
-    defineMethod(SPACE, BuiltInMethod.SPACE.method, NullPolicy.STRICT);
-    defineMethod(STRCMP, BuiltInMethod.STRCMP.method, NullPolicy.STRICT);
-    defineMethod(SOUNDEX, BuiltInMethod.SOUNDEX.method, NullPolicy.STRICT);
-    defineMethod(DIFFERENCE, BuiltInMethod.DIFFERENCE.method, NullPolicy.STRICT);
-    defineMethod(REVERSE, BuiltInMethod.REVERSE.method, NullPolicy.STRICT);
-
-    map.put(TRIM, new TrimImplementor());
-
-    // logical
-    map.put(AND, new LogicalAndImplementor());
-    map.put(OR, new LogicalOrImplementor());
-    map.put(NOT, new LogicalNotImplementor());
-
-    // comparisons
-    defineBinary(LESS_THAN, LessThan, NullPolicy.STRICT, "lt");
-    defineBinary(LESS_THAN_OR_EQUAL, LessThanOrEqual, NullPolicy.STRICT, "le");
-    defineBinary(GREATER_THAN, GreaterThan, NullPolicy.STRICT, "gt");
-    defineBinary(GREATER_THAN_OR_EQUAL, GreaterThanOrEqual, NullPolicy.STRICT,
-        "ge");
-    defineBinary(EQUALS, Equal, NullPolicy.STRICT, "eq");
-    defineBinary(NOT_EQUALS, NotEqual, NullPolicy.STRICT, "ne");
-
-    // arithmetic
-    defineBinary(PLUS, Add, NullPolicy.STRICT, "plus");
-    defineBinary(MINUS, Subtract, NullPolicy.STRICT, "minus");
-    defineBinary(MULTIPLY, Multiply, NullPolicy.STRICT, "multiply");
-    defineBinary(DIVIDE, Divide, NullPolicy.STRICT, "divide");
-    defineBinary(DIVIDE_INTEGER, Divide, NullPolicy.STRICT, "divide");
-    defineUnary(UNARY_MINUS, Negate, NullPolicy.STRICT,
-        BuiltInMethod.BIG_DECIMAL_NEGATE.getMethodName());
-    defineUnary(UNARY_PLUS, UnaryPlus, NullPolicy.STRICT, null);
-
-    defineMethod(MOD, "mod", NullPolicy.STRICT);
-    defineMethod(EXP, "exp", NullPolicy.STRICT);
-    defineMethod(POWER, "power", NullPolicy.STRICT);
-    defineMethod(LN, "ln", NullPolicy.STRICT);
-    defineMethod(LOG10, "log10", NullPolicy.STRICT);
-    defineMethod(ABS, "abs", NullPolicy.STRICT);
-
-    map.put(RAND, new RandImplementor());
-    map.put(RAND_INTEGER, new RandIntegerImplementor());
-
-    defineMethod(ACOS, "acos", NullPolicy.STRICT);
-    defineMethod(ASIN, "asin", NullPolicy.STRICT);
-    defineMethod(ATAN, "atan", NullPolicy.STRICT);
-    defineMethod(ATAN2, "atan2", NullPolicy.STRICT);
-    defineMethod(CBRT, "cbrt", NullPolicy.STRICT);
-    defineMethod(COS, "cos", NullPolicy.STRICT);
-    defineMethod(COSH, "cosh", NullPolicy.STRICT);
-    defineMethod(COT, "cot", NullPolicy.STRICT);
-    defineMethod(DEGREES, "degrees", NullPolicy.STRICT);
-    defineMethod(RADIANS, "radians", NullPolicy.STRICT);
-    defineMethod(ROUND, "sround", NullPolicy.STRICT);
-    defineMethod(SIGN, "sign", NullPolicy.STRICT);
-    defineMethod(SIN, "sin", NullPolicy.STRICT);
-    defineMethod(SINH, "sinh", NullPolicy.STRICT);
-    defineMethod(TAN, "tan", NullPolicy.STRICT);
-    defineMethod(TANH, "tanh", NullPolicy.STRICT);
-    defineMethod(TRUNCATE, "struncate", NullPolicy.STRICT);
-
-    map.put(PI, new PiImplementor());
-
-    // datetime
-    map.put(DATETIME_PLUS, new DatetimeArithmeticImplementor());
-    map.put(MINUS_DATE, new DatetimeArithmeticImplementor());
-    map.put(EXTRACT, new ExtractImplementor());
-    map.put(FLOOR,
-        new FloorImplementor(BuiltInMethod.FLOOR.method.getName(),
-            BuiltInMethod.UNIX_TIMESTAMP_FLOOR.method,
-            BuiltInMethod.UNIX_DATE_FLOOR.method));
-    map.put(CEIL,
-        new FloorImplementor(BuiltInMethod.CEIL.method.getName(),
-            BuiltInMethod.UNIX_TIMESTAMP_CEIL.method,
-            BuiltInMethod.UNIX_DATE_CEIL.method));
-
-    defineMethod(LAST_DAY, "lastDay", NullPolicy.STRICT);
-    map.put(DAYNAME,
-        new PeriodNameImplementor("dayName",
-            BuiltInMethod.DAYNAME_WITH_TIMESTAMP,
-            BuiltInMethod.DAYNAME_WITH_DATE));
-    map.put(MONTHNAME,
-        new PeriodNameImplementor("monthName",
-            BuiltInMethod.MONTHNAME_WITH_TIMESTAMP,
-            BuiltInMethod.MONTHNAME_WITH_DATE));
-    defineMethod(TIMESTAMP_SECONDS, "timestampSeconds", NullPolicy.STRICT);
-    defineMethod(TIMESTAMP_MILLIS, "timestampMillis", NullPolicy.STRICT);
-    defineMethod(TIMESTAMP_MICROS, "timestampMicros", NullPolicy.STRICT);
-    defineMethod(UNIX_SECONDS, "unixSeconds", NullPolicy.STRICT);
-    defineMethod(UNIX_MILLIS, "unixMillis", NullPolicy.STRICT);
-    defineMethod(UNIX_MICROS, "unixMicros", NullPolicy.STRICT);
-    defineMethod(DATE_FROM_UNIX_DATE, "dateFromUnixDate", NullPolicy.STRICT);
-    defineMethod(UNIX_DATE, "unixDate", NullPolicy.STRICT);
-
-    map.put(IS_NULL, new IsNullImplementor());
-    map.put(IS_NOT_NULL, new IsNotNullImplementor());
-    map.put(IS_TRUE, new IsTrueImplementor());
-    map.put(IS_NOT_TRUE, new IsNotTrueImplementor());
-    map.put(IS_FALSE, new IsFalseImplementor());
-    map.put(IS_NOT_FALSE, new IsNotFalseImplementor());
-
-    // LIKE, ILIKE and SIMILAR
-    map.put(LIKE,
-        new MethodImplementor(BuiltInMethod.LIKE.method, NullPolicy.STRICT,
-            false));
-    map.put(ILIKE,
-        new MethodImplementor(BuiltInMethod.ILIKE.method, NullPolicy.STRICT,
-            false));
-    map.put(RLIKE,
-        new MethodImplementor(BuiltInMethod.RLIKE.method, NullPolicy.STRICT,
-            false));
-    map.put(SIMILAR_TO,
-        new MethodImplementor(BuiltInMethod.SIMILAR.method, NullPolicy.STRICT,
-        false));
-
-    // POSIX REGEX
-    final MethodImplementor posixRegexImplementorCaseSensitive =
-        new PosixRegexMethodImplementor(true);
-    final MethodImplementor posixRegexImplementorCaseInsensitive =
-        new PosixRegexMethodImplementor(false);
-    map.put(SqlStdOperatorTable.POSIX_REGEX_CASE_INSENSITIVE,
-        posixRegexImplementorCaseInsensitive);
-    map.put(SqlStdOperatorTable.POSIX_REGEX_CASE_SENSITIVE,
-        posixRegexImplementorCaseSensitive);
-    map.put(SqlStdOperatorTable.NEGATED_POSIX_REGEX_CASE_INSENSITIVE,
-        NotImplementor.of(posixRegexImplementorCaseInsensitive));
-    map.put(SqlStdOperatorTable.NEGATED_POSIX_REGEX_CASE_SENSITIVE,
-        NotImplementor.of(posixRegexImplementorCaseSensitive));
-    map.put(REGEXP_REPLACE, new RegexpReplaceImplementor());
-
-    // Multisets & arrays
-    defineMethod(CARDINALITY, BuiltInMethod.COLLECTION_SIZE.method,
-        NullPolicy.STRICT);
-    defineMethod(ARRAY_LENGTH, BuiltInMethod.COLLECTION_SIZE.method,
-        NullPolicy.STRICT);
-    defineMethod(SLICE, BuiltInMethod.SLICE.method, NullPolicy.NONE);
-    defineMethod(ELEMENT, BuiltInMethod.ELEMENT.method, NullPolicy.STRICT);
-    defineMethod(STRUCT_ACCESS, BuiltInMethod.STRUCT_ACCESS.method, NullPolicy.ANY);
-    defineMethod(MEMBER_OF, BuiltInMethod.MEMBER_OF.method, NullPolicy.NONE);
-    defineMethod(ARRAY_REVERSE, BuiltInMethod.ARRAY_REVERSE.method, NullPolicy.STRICT);
-    map.put(ARRAY_CONCAT, new ArrayConcatImplementor());
-    final MethodImplementor isEmptyImplementor =
-        new MethodImplementor(BuiltInMethod.IS_EMPTY.method, NullPolicy.NONE,
-            false);
-    map.put(IS_EMPTY, isEmptyImplementor);
-    map.put(IS_NOT_EMPTY, NotImplementor.of(isEmptyImplementor));
-    final MethodImplementor isASetImplementor =
-        new MethodImplementor(BuiltInMethod.IS_A_SET.method, NullPolicy.NONE,
-            false);
-    map.put(IS_A_SET, isASetImplementor);
-    map.put(IS_NOT_A_SET, NotImplementor.of(isASetImplementor));
-    defineMethod(MULTISET_INTERSECT_DISTINCT,
-        BuiltInMethod.MULTISET_INTERSECT_DISTINCT.method, NullPolicy.NONE);
-    defineMethod(MULTISET_INTERSECT,
-        BuiltInMethod.MULTISET_INTERSECT_ALL.method, NullPolicy.NONE);
-    defineMethod(MULTISET_EXCEPT_DISTINCT,
-        BuiltInMethod.MULTISET_EXCEPT_DISTINCT.method, NullPolicy.NONE);
-    defineMethod(MULTISET_EXCEPT, BuiltInMethod.MULTISET_EXCEPT_ALL.method, NullPolicy.NONE);
-    defineMethod(MULTISET_UNION_DISTINCT,
-        BuiltInMethod.MULTISET_UNION_DISTINCT.method, NullPolicy.NONE);
-    defineMethod(MULTISET_UNION, BuiltInMethod.MULTISET_UNION_ALL.method, NullPolicy.NONE);
-    final MethodImplementor subMultisetImplementor =
-        new MethodImplementor(BuiltInMethod.SUBMULTISET_OF.method, NullPolicy.NONE, false);
-    map.put(SUBMULTISET_OF, subMultisetImplementor);
-    map.put(NOT_SUBMULTISET_OF, NotImplementor.of(subMultisetImplementor));
-
-    map.put(COALESCE, new CoalesceImplementor());
-    map.put(CAST, new CastImplementor());
-    map.put(DATE, new CastImplementor());
-
-    map.put(REINTERPRET, new ReinterpretImplementor());
-
-    final RexCallImplementor value = new ValueConstructorImplementor();
-    map.put(MAP_VALUE_CONSTRUCTOR, value);
-    map.put(ARRAY_VALUE_CONSTRUCTOR, value);
-    map.put(ITEM, new ItemImplementor());
-
-    map.put(DEFAULT, new DefaultImplementor());
-
-    // Sequences
-    defineMethod(CURRENT_VALUE, BuiltInMethod.SEQUENCE_CURRENT_VALUE.method,
-        NullPolicy.STRICT);
-    defineMethod(NEXT_VALUE, BuiltInMethod.SEQUENCE_NEXT_VALUE.method,
-        NullPolicy.STRICT);
-
-    // Compression Operators
-    defineMethod(COMPRESS, BuiltInMethod.COMPRESS.method, NullPolicy.ARG0);
-
-    // Xml Operators
-    defineMethod(EXTRACT_VALUE, BuiltInMethod.EXTRACT_VALUE.method, NullPolicy.ARG0);
-    defineMethod(XML_TRANSFORM, BuiltInMethod.XML_TRANSFORM.method, NullPolicy.ARG0);
-    defineMethod(EXTRACT_XML, BuiltInMethod.EXTRACT_XML.method, NullPolicy.ARG0);
-    defineMethod(EXISTS_NODE, BuiltInMethod.EXISTS_NODE.method, NullPolicy.ARG0);
-
-    // Json Operators
-    defineMethod(JSON_VALUE_EXPRESSION,
-        BuiltInMethod.JSON_VALUE_EXPRESSION.method, NullPolicy.STRICT);
-    defineMethod(JSON_TYPE_OPERATOR,
-        BuiltInMethod.JSON_VALUE_EXPRESSION.method, NullPolicy.STRICT);
-    defineMethod(JSON_EXISTS, BuiltInMethod.JSON_EXISTS.method, NullPolicy.ARG0);
-    map.put(JSON_VALUE,
-        new JsonValueImplementor(BuiltInMethod.JSON_VALUE.method));
-    defineMethod(JSON_QUERY, BuiltInMethod.JSON_QUERY.method, NullPolicy.ARG0);
-    defineMethod(JSON_TYPE, BuiltInMethod.JSON_TYPE.method, NullPolicy.ARG0);
-    defineMethod(JSON_DEPTH, BuiltInMethod.JSON_DEPTH.method, NullPolicy.ARG0);
-    defineMethod(JSON_KEYS, BuiltInMethod.JSON_KEYS.method, NullPolicy.ARG0);
-    defineMethod(JSON_PRETTY, BuiltInMethod.JSON_PRETTY.method, NullPolicy.ARG0);
-    defineMethod(JSON_LENGTH, BuiltInMethod.JSON_LENGTH.method, NullPolicy.ARG0);
-    defineMethod(JSON_REMOVE, BuiltInMethod.JSON_REMOVE.method, NullPolicy.ARG0);
-    defineMethod(JSON_STORAGE_SIZE, BuiltInMethod.JSON_STORAGE_SIZE.method, NullPolicy.ARG0);
-    defineMethod(JSON_OBJECT, BuiltInMethod.JSON_OBJECT.method, NullPolicy.NONE);
-    defineMethod(JSON_ARRAY, BuiltInMethod.JSON_ARRAY.method, NullPolicy.NONE);
-    aggMap.put(JSON_OBJECTAGG.with(SqlJsonConstructorNullClause.ABSENT_ON_NULL),
-        JsonObjectAggImplementor
-            .supplierFor(BuiltInMethod.JSON_OBJECTAGG_ADD.method));
-    aggMap.put(JSON_OBJECTAGG.with(SqlJsonConstructorNullClause.NULL_ON_NULL),
-        JsonObjectAggImplementor
-            .supplierFor(BuiltInMethod.JSON_OBJECTAGG_ADD.method));
-    aggMap.put(JSON_ARRAYAGG.with(SqlJsonConstructorNullClause.ABSENT_ON_NULL),
-        JsonArrayAggImplementor
-            .supplierFor(BuiltInMethod.JSON_ARRAYAGG_ADD.method));
-    aggMap.put(JSON_ARRAYAGG.with(SqlJsonConstructorNullClause.NULL_ON_NULL),
-        JsonArrayAggImplementor
-            .supplierFor(BuiltInMethod.JSON_ARRAYAGG_ADD.method));
-    map.put(IS_JSON_VALUE,
-        new MethodImplementor(BuiltInMethod.IS_JSON_VALUE.method,
-            NullPolicy.NONE, false));
-    map.put(IS_JSON_OBJECT,
-        new MethodImplementor(BuiltInMethod.IS_JSON_OBJECT.method,
-            NullPolicy.NONE, false));
-    map.put(IS_JSON_ARRAY,
-        new MethodImplementor(BuiltInMethod.IS_JSON_ARRAY.method,
-            NullPolicy.NONE, false));
-    map.put(IS_JSON_SCALAR,
-        new MethodImplementor(BuiltInMethod.IS_JSON_SCALAR.method,
-            NullPolicy.NONE, false));
-    map.put(IS_NOT_JSON_VALUE,
-        NotImplementor.of(
-            new MethodImplementor(BuiltInMethod.IS_JSON_VALUE.method,
-                NullPolicy.NONE, false)));
-    map.put(IS_NOT_JSON_OBJECT,
-        NotImplementor.of(
-            new MethodImplementor(BuiltInMethod.IS_JSON_OBJECT.method,
-                NullPolicy.NONE, false)));
-    map.put(IS_NOT_JSON_ARRAY,
-        NotImplementor.of(
-            new MethodImplementor(BuiltInMethod.IS_JSON_ARRAY.method,
-                NullPolicy.NONE, false)));
-    map.put(IS_NOT_JSON_SCALAR,
-        NotImplementor.of(
-            new MethodImplementor(BuiltInMethod.IS_JSON_SCALAR.method,
-                NullPolicy.NONE, false)));
-
-    // System functions
-    final SystemFunctionImplementor systemFunctionImplementor =
-        new SystemFunctionImplementor();
-    map.put(USER, systemFunctionImplementor);
-    map.put(CURRENT_USER, systemFunctionImplementor);
-    map.put(SESSION_USER, systemFunctionImplementor);
-    map.put(SYSTEM_USER, systemFunctionImplementor);
-    map.put(CURRENT_PATH, systemFunctionImplementor);
-    map.put(CURRENT_ROLE, systemFunctionImplementor);
-    map.put(CURRENT_CATALOG, systemFunctionImplementor);
-
-    // Current time functions
-    map.put(CURRENT_TIME, systemFunctionImplementor);
-    map.put(CURRENT_TIMESTAMP, systemFunctionImplementor);
-    map.put(CURRENT_DATE, systemFunctionImplementor);
-    map.put(LOCALTIME, systemFunctionImplementor);
-    map.put(LOCALTIMESTAMP, systemFunctionImplementor);
-
-    aggMap.put(COUNT, constructorSupplier(CountImplementor.class));
-    aggMap.put(REGR_COUNT, constructorSupplier(CountImplementor.class));
-    aggMap.put(SUM0, constructorSupplier(SumImplementor.class));
-    aggMap.put(SUM, constructorSupplier(SumImplementor.class));
-    Supplier<MinMaxImplementor> minMax =
-        constructorSupplier(MinMaxImplementor.class);
-    aggMap.put(MIN, minMax);
-    aggMap.put(MAX, minMax);
-    aggMap.put(ANY_VALUE, minMax);
-    aggMap.put(SOME, minMax);
-    aggMap.put(EVERY, minMax);
-    aggMap.put(BOOL_AND, minMax);
-    aggMap.put(BOOL_OR, minMax);
-    aggMap.put(LOGICAL_AND, minMax);
-    aggMap.put(LOGICAL_OR, minMax);
-    final Supplier<BitOpImplementor> bitop =
-        constructorSupplier(BitOpImplementor.class);
-    aggMap.put(BIT_AND, bitop);
-    aggMap.put(BIT_OR, bitop);
-    aggMap.put(BIT_XOR, bitop);
-    aggMap.put(SINGLE_VALUE, constructorSupplier(SingleValueImplementor.class));
-    aggMap.put(COLLECT, constructorSupplier(CollectImplementor.class));
-    aggMap.put(ARRAY_AGG, constructorSupplier(CollectImplementor.class));
-    aggMap.put(LISTAGG, constructorSupplier(ListaggImplementor.class));
-    aggMap.put(FUSION, constructorSupplier(FusionImplementor.class));
-    aggMap.put(MODE, constructorSupplier(ModeImplementor.class));
-    aggMap.put(ARRAY_CONCAT_AGG, constructorSupplier(FusionImplementor.class));
-    aggMap.put(INTERSECTION, constructorSupplier(IntersectionImplementor.class));
-    final Supplier<GroupingImplementor> grouping =
-        constructorSupplier(GroupingImplementor.class);
-    aggMap.put(GROUPING, grouping);
-    aggMap.put(GROUPING_ID, grouping);
-    winAggMap.put(RANK, constructorSupplier(RankImplementor.class));
-    winAggMap.put(DENSE_RANK, constructorSupplier(DenseRankImplementor.class));
-    winAggMap.put(ROW_NUMBER, constructorSupplier(RowNumberImplementor.class));
-    winAggMap.put(FIRST_VALUE,
-        constructorSupplier(FirstValueImplementor.class));
-    winAggMap.put(NTH_VALUE, constructorSupplier(NthValueImplementor.class));
-    winAggMap.put(LAST_VALUE, constructorSupplier(LastValueImplementor.class));
-    winAggMap.put(LEAD, constructorSupplier(LeadImplementor.class));
-    winAggMap.put(LAG, constructorSupplier(LagImplementor.class));
-    winAggMap.put(NTILE, constructorSupplier(NtileImplementor.class));
-    winAggMap.put(COUNT, constructorSupplier(CountWinImplementor.class));
-    winAggMap.put(REGR_COUNT, constructorSupplier(CountWinImplementor.class));
-
-    // Functions for MATCH_RECOGNIZE
-    matchMap.put(CLASSIFIER, ClassifierImplementor::new);
-    matchMap.put(LAST, LastImplementor::new);
-
-    tvfImplementorMap.put(TUMBLE, TumbleImplementor::new);
-    tvfImplementorMap.put(HOP, HopImplementor::new);
-    tvfImplementorMap.put(SESSION, SessionImplementor::new);
-  }
-
-  private static <T> Supplier<T> constructorSupplier(Class<T> klass) {
-    final Constructor<T> constructor;
-    try {
-      constructor = klass.getDeclaredConstructor();
-    } catch (NoSuchMethodException e) {
-      throw new IllegalArgumentException(
-          klass + " should implement zero arguments constructor");
-    }
-    return () -> {
+  private final ImmutableMap<SqlOperator, RexCallImplementor> map;
+  private final ImmutableMap<SqlAggFunction, Supplier<? extends AggImplementor>> aggMap;
+  private final ImmutableMap<SqlAggFunction, Supplier<? extends WinAggImplementor>> winAggMap;
+  private final ImmutableMap<SqlMatchFunction, Supplier<? extends MatchImplementor>> matchMap;
+  private final ImmutableMap<SqlOperator, Supplier<? extends TableFunctionCallImplementor>>
+      tvfImplementorMap;
+
+  private RexImpTable(Builder builder) {
+    this.map = ImmutableMap.copyOf(builder.map);
+    this.aggMap = ImmutableMap.copyOf(builder.aggMap);
+    this.winAggMap = ImmutableMap.copyOf(builder.winAggMap);
+    this.matchMap = ImmutableMap.copyOf(builder.matchMap);
+    this.tvfImplementorMap = ImmutableMap.copyOf(builder.tvfImplementorMap);
+  }
+
+  /** Holds intermediate state from which a RexImpTable can be constructed. */
+  private static class Builder {
+    private final Map<SqlOperator, RexCallImplementor> map = new HashMap<>();
+    private final Map<SqlAggFunction, Supplier<? extends AggImplementor>> aggMap =
+        new HashMap<>();
+    private final Map<SqlAggFunction, Supplier<? extends WinAggImplementor>> winAggMap =
+        new HashMap<>();
+    private final Map<SqlMatchFunction, Supplier<? extends MatchImplementor>> matchMap =
+        new HashMap<>();
+    private final Map<SqlOperator, Supplier<? extends TableFunctionCallImplementor>>
+        tvfImplementorMap = new HashMap<>();
+
+    /** Populates this Builder with implementors for all Calcite built-in and
+     * library operators. */
+    Builder populate() {
+      defineMethod(THROW_UNLESS, BuiltInMethod.THROW_UNLESS.method, NullPolicy.NONE);
+      defineMethod(ROW, BuiltInMethod.ARRAY.method, NullPolicy.ALL);
+      defineMethod(UPPER, BuiltInMethod.UPPER.method, NullPolicy.STRICT);
+      defineMethod(LOWER, BuiltInMethod.LOWER.method, NullPolicy.STRICT);
+      defineMethod(INITCAP, BuiltInMethod.INITCAP.method, NullPolicy.STRICT);
+      defineMethod(TO_BASE64, BuiltInMethod.TO_BASE64.method, NullPolicy.STRICT);
+      defineMethod(FROM_BASE64, BuiltInMethod.FROM_BASE64.method, NullPolicy.STRICT);
+      defineMethod(MD5, BuiltInMethod.MD5.method, NullPolicy.STRICT);
+      defineMethod(SHA1, BuiltInMethod.SHA1.method, NullPolicy.STRICT);
+      defineMethod(SUBSTRING, BuiltInMethod.SUBSTRING.method, NullPolicy.STRICT);
+      defineMethod(LEFT, BuiltInMethod.LEFT.method, NullPolicy.ANY);
+      defineMethod(RIGHT, BuiltInMethod.RIGHT.method, NullPolicy.ANY);
+      defineMethod(LPAD, BuiltInMethod.LPAD.method, NullPolicy.STRICT);
+      defineMethod(RPAD, BuiltInMethod.RPAD.method, NullPolicy.STRICT);
+      defineMethod(STARTS_WITH, BuiltInMethod.STARTS_WITH.method, NullPolicy.STRICT);
+      defineMethod(ENDS_WITH, BuiltInMethod.ENDS_WITH.method, NullPolicy.STRICT);
+      defineMethod(REPLACE, BuiltInMethod.REPLACE.method, NullPolicy.STRICT);
+      defineMethod(TRANSLATE3, BuiltInMethod.TRANSLATE3.method, NullPolicy.STRICT);
+      defineMethod(CHR, BuiltInMethod.CHAR_FROM_UTF8.method, NullPolicy.STRICT);
+      defineMethod(CHARACTER_LENGTH, BuiltInMethod.CHAR_LENGTH.method,
+          NullPolicy.STRICT);
+      defineMethod(CHAR_LENGTH, BuiltInMethod.CHAR_LENGTH.method,
+          NullPolicy.STRICT);
+      defineMethod(OCTET_LENGTH, BuiltInMethod.OCTET_LENGTH.method,
+          NullPolicy.STRICT);
+      map.put(CONCAT, new ConcatImplementor());
+      defineMethod(CONCAT_FUNCTION, BuiltInMethod.MULTI_STRING_CONCAT.method,
+          NullPolicy.STRICT);
+      defineMethod(CONCAT2, BuiltInMethod.STRING_CONCAT.method, NullPolicy.STRICT);
+      defineMethod(OVERLAY, BuiltInMethod.OVERLAY.method, NullPolicy.STRICT);
+      defineMethod(POSITION, BuiltInMethod.POSITION.method, NullPolicy.STRICT);
+      defineMethod(ASCII, BuiltInMethod.ASCII.method, NullPolicy.STRICT);
+      defineMethod(CHAR, BuiltInMethod.CHAR_FROM_ASCII.method,
+          NullPolicy.SEMI_STRICT);
+      defineMethod(REPEAT, BuiltInMethod.REPEAT.method, NullPolicy.STRICT);
+      defineMethod(SPACE, BuiltInMethod.SPACE.method, NullPolicy.STRICT);
+      defineMethod(STRCMP, BuiltInMethod.STRCMP.method, NullPolicy.STRICT);
+      defineMethod(SOUNDEX, BuiltInMethod.SOUNDEX.method, NullPolicy.STRICT);
+      defineMethod(DIFFERENCE, BuiltInMethod.DIFFERENCE.method, NullPolicy.STRICT);
+      defineMethod(REVERSE, BuiltInMethod.REVERSE.method, NullPolicy.STRICT);
+      defineMethod(SPLIT, "split", NullPolicy.STRICT);
+
+      map.put(TRIM, new TrimImplementor());
+
+      // logical
+      map.put(AND, new LogicalAndImplementor());
+      map.put(OR, new LogicalOrImplementor());
+      map.put(NOT, new LogicalNotImplementor());
+
+      // comparisons
+      defineBinary(LESS_THAN, LessThan, NullPolicy.STRICT, "lt");
+      defineBinary(LESS_THAN_OR_EQUAL, LessThanOrEqual, NullPolicy.STRICT, "le");
+      defineBinary(GREATER_THAN, GreaterThan, NullPolicy.STRICT, "gt");
+      defineBinary(GREATER_THAN_OR_EQUAL, GreaterThanOrEqual, NullPolicy.STRICT,
+          "ge");
+      defineBinary(EQUALS, Equal, NullPolicy.STRICT, "eq");
+      defineBinary(NOT_EQUALS, NotEqual, NullPolicy.STRICT, "ne");
+
+      // arithmetic
+      defineBinary(PLUS, Add, NullPolicy.STRICT, "plus");
+      defineBinary(MINUS, Subtract, NullPolicy.STRICT, "minus");
+      defineBinary(MULTIPLY, Multiply, NullPolicy.STRICT, "multiply");
+      defineBinary(DIVIDE, Divide, NullPolicy.STRICT, "divide");
+      defineBinary(DIVIDE_INTEGER, Divide, NullPolicy.STRICT, "divide");
+      defineUnary(UNARY_MINUS, Negate, NullPolicy.STRICT,
+          BuiltInMethod.BIG_DECIMAL_NEGATE.getMethodName());
+      defineUnary(UNARY_PLUS, UnaryPlus, NullPolicy.STRICT, null);
+
+      defineMethod(MOD, "mod", NullPolicy.STRICT);
+      defineMethod(EXP, "exp", NullPolicy.STRICT);
+      defineMethod(POWER, "power", NullPolicy.STRICT);
+      defineMethod(ABS, "abs", NullPolicy.STRICT);
+
+      map.put(LN, new LogImplementor());
+      map.put(LOG, new LogImplementor());
+      map.put(LOG10, new LogImplementor());
+
+      map.put(RAND, new RandImplementor());
+      map.put(RAND_INTEGER, new RandIntegerImplementor());
+
+      defineMethod(ACOS, "acos", NullPolicy.STRICT);
+      defineMethod(ASIN, "asin", NullPolicy.STRICT);
+      defineMethod(ATAN, "atan", NullPolicy.STRICT);
+      defineMethod(ATAN2, "atan2", NullPolicy.STRICT);
+      defineMethod(CBRT, "cbrt", NullPolicy.STRICT);
+      defineMethod(COS, "cos", NullPolicy.STRICT);
+      defineMethod(COSH, "cosh", NullPolicy.STRICT);
+      defineMethod(COT, "cot", NullPolicy.STRICT);
+      defineMethod(DEGREES, "degrees", NullPolicy.STRICT);
+      defineMethod(POW, "power", NullPolicy.STRICT);
+      defineMethod(RADIANS, "radians", NullPolicy.STRICT);
+      defineMethod(ROUND, "sround", NullPolicy.STRICT);
+      defineMethod(SIGN, "sign", NullPolicy.STRICT);
+      defineMethod(SIN, "sin", NullPolicy.STRICT);
+      defineMethod(SINH, "sinh", NullPolicy.STRICT);
+      defineMethod(TAN, "tan", NullPolicy.STRICT);
+      defineMethod(TANH, "tanh", NullPolicy.STRICT);
+      defineMethod(TRUNC, "struncate", NullPolicy.STRICT);
+      defineMethod(TRUNCATE, "struncate", NullPolicy.STRICT);
+
+      map.put(PI, new PiImplementor());
+      return populate2();
+    }
+
+    /** Second step of population. The {@code populate} method grew too large,
+     * and we factored this out. Feel free to decompose further. */
+    Builder populate2() {
+      // datetime
+      map.put(DATETIME_PLUS, new DatetimeArithmeticImplementor());
+      map.put(MINUS_DATE, new DatetimeArithmeticImplementor());
+      map.put(EXTRACT, new ExtractImplementor());
+      map.put(FLOOR,
+          new FloorImplementor(BuiltInMethod.FLOOR.method.getName(),
+              BuiltInMethod.UNIX_TIMESTAMP_FLOOR.method,
+            BuiltInMethod.UNIX_DATE_FLOOR.method,
+            BuiltInMethod.CUSTOM_TIMESTAMP_FLOOR.method,
+            BuiltInMethod.CUSTOM_DATE_FLOOR.method));
+      map.put(CEIL,
+          new FloorImplementor(BuiltInMethod.CEIL.method.getName(),
+              BuiltInMethod.UNIX_TIMESTAMP_CEIL.method,
+            BuiltInMethod.UNIX_DATE_CEIL.method,
+            BuiltInMethod.CUSTOM_TIMESTAMP_CEIL.method,
+            BuiltInMethod.CUSTOM_DATE_CEIL.method));
+      map.put(TIMESTAMP_ADD,
+          new TimestampAddImplementor("timestampAdd",
+              BuiltInMethod.CUSTOM_TIMESTAMP_ADD.method,
+              BuiltInMethod.CUSTOM_DATE_ADD.method));
+      map.put(DATEADD, map.get(TIMESTAMP_ADD));
+      map.put(TIMESTAMP_DIFF,
+          new TimestampDiffImplementor("timestampDiff",
+              BuiltInMethod.CUSTOM_TIMESTAMP_DIFF.method,
+              BuiltInMethod.CUSTOM_DATE_DIFF.method));
+
+      // TIMESTAMP_TRUNC and TIME_TRUNC methods are syntactic sugar for standard
+      // datetime FLOOR.
+      map.put(DATE_TRUNC, map.get(FLOOR));
+      map.put(TIMESTAMP_TRUNC, map.get(FLOOR));
+      map.put(TIME_TRUNC, map.get(FLOOR));
+      map.put(DATETIME_TRUNC, map.get(FLOOR));
+
+      map.put(LAST_DAY,
+          new LastDayImplementor("lastDay", BuiltInMethod.LAST_DAY));
+      map.put(DAYNAME,
+          new PeriodNameImplementor("dayName",
+              BuiltInMethod.DAYNAME_WITH_TIMESTAMP,
+              BuiltInMethod.DAYNAME_WITH_DATE));
+      map.put(MONTHNAME,
+          new PeriodNameImplementor("monthName",
+              BuiltInMethod.MONTHNAME_WITH_TIMESTAMP,
+              BuiltInMethod.MONTHNAME_WITH_DATE));
+      defineMethod(TIMESTAMP_SECONDS, "timestampSeconds", NullPolicy.STRICT);
+      defineMethod(TIMESTAMP_MILLIS, "timestampMillis", NullPolicy.STRICT);
+      defineMethod(TIMESTAMP_MICROS, "timestampMicros", NullPolicy.STRICT);
+      defineMethod(UNIX_SECONDS, "unixSeconds", NullPolicy.STRICT);
+      defineMethod(UNIX_MILLIS, "unixMillis", NullPolicy.STRICT);
+      defineMethod(UNIX_MICROS, "unixMicros", NullPolicy.STRICT);
+      defineMethod(DATE_FROM_UNIX_DATE, "dateFromUnixDate", NullPolicy.STRICT);
+      defineMethod(UNIX_DATE, "unixDate", NullPolicy.STRICT);
+
+      // Datetime constructors
+      defineMethod(DATE, "date", NullPolicy.STRICT);
+      defineMethod(DATETIME, "datetime", NullPolicy.STRICT);
+      defineMethod(TIMESTAMP, "timestamp", NullPolicy.STRICT);
+      defineMethod(TIME, "time", NullPolicy.STRICT);
+
+      // Datetime formatting methods
+      final FormatDatetimeImplementor datetimeFormatImpl = new FormatDatetimeImplementor();
+      map.put(FORMAT_TIMESTAMP, datetimeFormatImpl);
+      map.put(FORMAT_DATE, datetimeFormatImpl);
+      map.put(FORMAT_TIME, datetimeFormatImpl);
+      map.put(FORMAT_DATETIME, datetimeFormatImpl);
+
+      // Boolean operators
+      map.put(IS_NULL, new IsNullImplementor());
+      map.put(IS_NOT_NULL, new IsNotNullImplementor());
+      map.put(IS_TRUE, new IsTrueImplementor());
+      map.put(IS_NOT_TRUE, new IsNotTrueImplementor());
+      map.put(IS_FALSE, new IsFalseImplementor());
+      map.put(IS_NOT_FALSE, new IsNotFalseImplementor());
+
+      // LIKE, ILIKE and SIMILAR
+      map.put(LIKE,
+          new MethodImplementor(BuiltInMethod.LIKE.method, NullPolicy.STRICT,
+              false));
+      map.put(ILIKE,
+          new MethodImplementor(BuiltInMethod.ILIKE.method, NullPolicy.STRICT,
+              false));
+      map.put(RLIKE,
+          new MethodImplementor(BuiltInMethod.RLIKE.method, NullPolicy.STRICT,
+              false));
+      map.put(SIMILAR_TO,
+          new MethodImplementor(BuiltInMethod.SIMILAR.method, NullPolicy.STRICT,
+              false));
+
+      // POSIX REGEX
+      final MethodImplementor posixRegexImplementorCaseSensitive =
+          new PosixRegexMethodImplementor(true);
+      final MethodImplementor posixRegexImplementorCaseInsensitive =
+          new PosixRegexMethodImplementor(false);
+      map.put(SqlStdOperatorTable.POSIX_REGEX_CASE_INSENSITIVE,
+          posixRegexImplementorCaseInsensitive);
+      map.put(SqlStdOperatorTable.POSIX_REGEX_CASE_SENSITIVE,
+          posixRegexImplementorCaseSensitive);
+      map.put(SqlStdOperatorTable.NEGATED_POSIX_REGEX_CASE_INSENSITIVE,
+          NotImplementor.of(posixRegexImplementorCaseInsensitive));
+      map.put(SqlStdOperatorTable.NEGATED_POSIX_REGEX_CASE_SENSITIVE,
+          NotImplementor.of(posixRegexImplementorCaseSensitive));
+      map.put(REGEXP_REPLACE, new RegexpReplaceImplementor());
+
+      // Multisets & arrays
+      defineMethod(CARDINALITY, BuiltInMethod.COLLECTION_SIZE.method,
+          NullPolicy.STRICT);
+      defineMethod(ARRAY_LENGTH, BuiltInMethod.COLLECTION_SIZE.method,
+          NullPolicy.STRICT);
+      defineMethod(SLICE, BuiltInMethod.SLICE.method, NullPolicy.NONE);
+      defineMethod(ELEMENT, BuiltInMethod.ELEMENT.method, NullPolicy.STRICT);
+      defineMethod(STRUCT_ACCESS, BuiltInMethod.STRUCT_ACCESS.method, NullPolicy.ANY);
+      defineMethod(MEMBER_OF, BuiltInMethod.MEMBER_OF.method, NullPolicy.NONE);
+      defineMethod(ARRAY_REVERSE, BuiltInMethod.ARRAY_REVERSE.method, NullPolicy.STRICT);
+      map.put(ARRAY_CONCAT, new ArrayConcatImplementor());
+      final MethodImplementor isEmptyImplementor =
+          new MethodImplementor(BuiltInMethod.IS_EMPTY.method, NullPolicy.NONE,
+              false);
+      map.put(IS_EMPTY, isEmptyImplementor);
+      map.put(IS_NOT_EMPTY, NotImplementor.of(isEmptyImplementor));
+      final MethodImplementor isASetImplementor =
+          new MethodImplementor(BuiltInMethod.IS_A_SET.method, NullPolicy.NONE,
+              false);
+      map.put(IS_A_SET, isASetImplementor);
+      map.put(IS_NOT_A_SET, NotImplementor.of(isASetImplementor));
+      defineMethod(MULTISET_INTERSECT_DISTINCT,
+          BuiltInMethod.MULTISET_INTERSECT_DISTINCT.method, NullPolicy.NONE);
+      defineMethod(MULTISET_INTERSECT,
+          BuiltInMethod.MULTISET_INTERSECT_ALL.method, NullPolicy.NONE);
+      defineMethod(MULTISET_EXCEPT_DISTINCT,
+          BuiltInMethod.MULTISET_EXCEPT_DISTINCT.method, NullPolicy.NONE);
+      defineMethod(MULTISET_EXCEPT, BuiltInMethod.MULTISET_EXCEPT_ALL.method, NullPolicy.NONE);
+      defineMethod(MULTISET_UNION_DISTINCT,
+          BuiltInMethod.MULTISET_UNION_DISTINCT.method, NullPolicy.NONE);
+      defineMethod(MULTISET_UNION, BuiltInMethod.MULTISET_UNION_ALL.method, NullPolicy.NONE);
+      final MethodImplementor subMultisetImplementor =
+          new MethodImplementor(BuiltInMethod.SUBMULTISET_OF.method, NullPolicy.NONE, false);
+      map.put(SUBMULTISET_OF, subMultisetImplementor);
+      map.put(NOT_SUBMULTISET_OF, NotImplementor.of(subMultisetImplementor));
+
+      map.put(COALESCE, new CoalesceImplementor());
+      map.put(CAST, new CastImplementor());
+      map.put(SAFE_CAST, new CastImplementor());
+
+      map.put(REINTERPRET, new ReinterpretImplementor());
+
+      final RexCallImplementor value = new ValueConstructorImplementor();
+      map.put(MAP_VALUE_CONSTRUCTOR, value);
+      map.put(ARRAY_VALUE_CONSTRUCTOR, value);
+      map.put(ITEM, new ItemImplementor());
+
+      map.put(DEFAULT, new DefaultImplementor());
+
+      // Sequences
+      defineMethod(CURRENT_VALUE, BuiltInMethod.SEQUENCE_CURRENT_VALUE.method,
+          NullPolicy.STRICT);
+      defineMethod(NEXT_VALUE, BuiltInMethod.SEQUENCE_NEXT_VALUE.method,
+          NullPolicy.STRICT);
+
+      // Compression Operators
+      defineMethod(COMPRESS, BuiltInMethod.COMPRESS.method, NullPolicy.ARG0);
+
+      // Xml Operators
+      defineMethod(EXTRACT_VALUE, BuiltInMethod.EXTRACT_VALUE.method, NullPolicy.ARG0);
+      defineMethod(XML_TRANSFORM, BuiltInMethod.XML_TRANSFORM.method, NullPolicy.ARG0);
+      defineMethod(EXTRACT_XML, BuiltInMethod.EXTRACT_XML.method, NullPolicy.ARG0);
+      defineMethod(EXISTS_NODE, BuiltInMethod.EXISTS_NODE.method, NullPolicy.ARG0);
+
+      // Json Operators
+      defineMethod(JSON_VALUE_EXPRESSION,
+          BuiltInMethod.JSON_VALUE_EXPRESSION.method, NullPolicy.STRICT);
+      defineMethod(JSON_TYPE_OPERATOR,
+          BuiltInMethod.JSON_VALUE_EXPRESSION.method, NullPolicy.STRICT);
+      defineMethod(JSON_EXISTS, BuiltInMethod.JSON_EXISTS.method, NullPolicy.ARG0);
+      map.put(JSON_VALUE,
+          new JsonValueImplementor(BuiltInMethod.JSON_VALUE.method));
+      defineMethod(JSON_QUERY, BuiltInMethod.JSON_QUERY.method, NullPolicy.ARG0);
+      defineMethod(JSON_TYPE, BuiltInMethod.JSON_TYPE.method, NullPolicy.ARG0);
+      defineMethod(JSON_DEPTH, BuiltInMethod.JSON_DEPTH.method, NullPolicy.ARG0);
+      defineMethod(JSON_INSERT, BuiltInMethod.JSON_INSERT.method, NullPolicy.ARG0);
+      defineMethod(JSON_KEYS, BuiltInMethod.JSON_KEYS.method, NullPolicy.ARG0);
+      defineMethod(JSON_PRETTY, BuiltInMethod.JSON_PRETTY.method, NullPolicy.ARG0);
+      defineMethod(JSON_LENGTH, BuiltInMethod.JSON_LENGTH.method, NullPolicy.ARG0);
+      defineMethod(JSON_REMOVE, BuiltInMethod.JSON_REMOVE.method, NullPolicy.ARG0);
+      defineMethod(JSON_STORAGE_SIZE, BuiltInMethod.JSON_STORAGE_SIZE.method, NullPolicy.ARG0);
+      defineMethod(JSON_REPLACE, BuiltInMethod.JSON_REPLACE.method, NullPolicy.ARG0);
+      defineMethod(JSON_SET, BuiltInMethod.JSON_SET.method, NullPolicy.ARG0);
+      defineMethod(JSON_OBJECT, BuiltInMethod.JSON_OBJECT.method, NullPolicy.NONE);
+      defineMethod(JSON_ARRAY, BuiltInMethod.JSON_ARRAY.method, NullPolicy.NONE);
+      aggMap.put(JSON_OBJECTAGG.with(SqlJsonConstructorNullClause.ABSENT_ON_NULL),
+          JsonObjectAggImplementor
+              .supplierFor(BuiltInMethod.JSON_OBJECTAGG_ADD.method));
+      aggMap.put(JSON_OBJECTAGG.with(SqlJsonConstructorNullClause.NULL_ON_NULL),
+          JsonObjectAggImplementor
+              .supplierFor(BuiltInMethod.JSON_OBJECTAGG_ADD.method));
+      aggMap.put(JSON_ARRAYAGG.with(SqlJsonConstructorNullClause.ABSENT_ON_NULL),
+          JsonArrayAggImplementor
+              .supplierFor(BuiltInMethod.JSON_ARRAYAGG_ADD.method));
+      aggMap.put(JSON_ARRAYAGG.with(SqlJsonConstructorNullClause.NULL_ON_NULL),
+          JsonArrayAggImplementor
+              .supplierFor(BuiltInMethod.JSON_ARRAYAGG_ADD.method));
+      map.put(IS_JSON_VALUE,
+          new MethodImplementor(BuiltInMethod.IS_JSON_VALUE.method,
+              NullPolicy.NONE, false));
+      map.put(IS_JSON_OBJECT,
+          new MethodImplementor(BuiltInMethod.IS_JSON_OBJECT.method,
+              NullPolicy.NONE, false));
+      map.put(IS_JSON_ARRAY,
+          new MethodImplementor(BuiltInMethod.IS_JSON_ARRAY.method,
+              NullPolicy.NONE, false));
+      map.put(IS_JSON_SCALAR,
+          new MethodImplementor(BuiltInMethod.IS_JSON_SCALAR.method,
+              NullPolicy.NONE, false));
+      map.put(IS_NOT_JSON_VALUE,
+          NotImplementor.of(
+              new MethodImplementor(BuiltInMethod.IS_JSON_VALUE.method,
+                  NullPolicy.NONE, false)));
+      map.put(IS_NOT_JSON_OBJECT,
+          NotImplementor.of(
+              new MethodImplementor(BuiltInMethod.IS_JSON_OBJECT.method,
+                  NullPolicy.NONE, false)));
+      map.put(IS_NOT_JSON_ARRAY,
+          NotImplementor.of(
+              new MethodImplementor(BuiltInMethod.IS_JSON_ARRAY.method,
+                  NullPolicy.NONE, false)));
+      map.put(IS_NOT_JSON_SCALAR,
+          NotImplementor.of(
+              new MethodImplementor(BuiltInMethod.IS_JSON_SCALAR.method,
+                  NullPolicy.NONE, false)));
+
+      // System functions
+      final SystemFunctionImplementor systemFunctionImplementor =
+          new SystemFunctionImplementor();
+      map.put(USER, systemFunctionImplementor);
+      map.put(CURRENT_USER, systemFunctionImplementor);
+      map.put(SESSION_USER, systemFunctionImplementor);
+      map.put(SYSTEM_USER, systemFunctionImplementor);
+      map.put(CURRENT_PATH, systemFunctionImplementor);
+      map.put(CURRENT_ROLE, systemFunctionImplementor);
+      map.put(CURRENT_CATALOG, systemFunctionImplementor);
+
+      defineQuantify(SOME_EQ, EQUALS);
+      defineQuantify(SOME_GT, GREATER_THAN);
+      defineQuantify(SOME_GE, GREATER_THAN_OR_EQUAL);
+      defineQuantify(SOME_LE, LESS_THAN_OR_EQUAL);
+      defineQuantify(SOME_LT, LESS_THAN);
+      defineQuantify(SOME_NE, NOT_EQUALS);
+      defineQuantify(ALL_EQ, EQUALS);
+      defineQuantify(ALL_GT, GREATER_THAN);
+      defineQuantify(ALL_GE, GREATER_THAN_OR_EQUAL);
+      defineQuantify(ALL_LE, LESS_THAN_OR_EQUAL);
+      defineQuantify(ALL_LT, LESS_THAN);
+      defineQuantify(ALL_NE, NOT_EQUALS);
+
+      // Current time functions
+      map.put(CURRENT_TIME, systemFunctionImplementor);
+      map.put(CURRENT_TIMESTAMP, systemFunctionImplementor);
+      map.put(CURRENT_DATE, systemFunctionImplementor);
+      map.put(LOCALTIME, systemFunctionImplementor);
+      map.put(LOCALTIMESTAMP, systemFunctionImplementor);
+
+      aggMap.put(COUNT, constructorSupplier(CountImplementor.class));
+      aggMap.put(REGR_COUNT, constructorSupplier(CountImplementor.class));
+      aggMap.put(SUM0, constructorSupplier(SumImplementor.class));
+      aggMap.put(SUM, constructorSupplier(SumImplementor.class));
+      Supplier<MinMaxImplementor> minMax =
+          constructorSupplier(MinMaxImplementor.class);
+      aggMap.put(MIN, minMax);
+      aggMap.put(MAX, minMax);
+      aggMap.put(ARG_MIN, constructorSupplier(ArgMinMaxImplementor.class));
+      aggMap.put(ARG_MAX, constructorSupplier(ArgMinMaxImplementor.class));
+      aggMap.put(MIN_BY, constructorSupplier(ArgMinMaxImplementor.class));
+      aggMap.put(MAX_BY, constructorSupplier(ArgMinMaxImplementor.class));
+      aggMap.put(ANY_VALUE, minMax);
+      aggMap.put(SOME, minMax);
+      aggMap.put(EVERY, minMax);
+      aggMap.put(BOOL_AND, minMax);
+      aggMap.put(BOOL_OR, minMax);
+      aggMap.put(LOGICAL_AND, minMax);
+      aggMap.put(LOGICAL_OR, minMax);
+      final Supplier<BitOpImplementor> bitop =
+          constructorSupplier(BitOpImplementor.class);
+      aggMap.put(BIT_AND, bitop);
+      aggMap.put(BIT_OR, bitop);
+      aggMap.put(BIT_XOR, bitop);
+      aggMap.put(SINGLE_VALUE, constructorSupplier(SingleValueImplementor.class));
+      aggMap.put(COLLECT, constructorSupplier(CollectImplementor.class));
+      aggMap.put(ARRAY_AGG, constructorSupplier(CollectImplementor.class));
+      aggMap.put(LISTAGG, constructorSupplier(ListaggImplementor.class));
+      aggMap.put(FUSION, constructorSupplier(FusionImplementor.class));
+      aggMap.put(MODE, constructorSupplier(ModeImplementor.class));
+      aggMap.put(ARRAY_CONCAT_AGG, constructorSupplier(FusionImplementor.class));
+      aggMap.put(INTERSECTION, constructorSupplier(IntersectionImplementor.class));
+      final Supplier<GroupingImplementor> grouping =
+          constructorSupplier(GroupingImplementor.class);
+      aggMap.put(GROUPING, grouping);
+      aggMap.put(GROUPING_ID, grouping);
+      winAggMap.put(RANK, constructorSupplier(RankImplementor.class));
+      winAggMap.put(DENSE_RANK, constructorSupplier(DenseRankImplementor.class));
+      winAggMap.put(ROW_NUMBER, constructorSupplier(RowNumberImplementor.class));
+      winAggMap.put(FIRST_VALUE,
+          constructorSupplier(FirstValueImplementor.class));
+      winAggMap.put(NTH_VALUE, constructorSupplier(NthValueImplementor.class));
+      winAggMap.put(LAST_VALUE, constructorSupplier(LastValueImplementor.class));
+      winAggMap.put(LEAD, constructorSupplier(LeadImplementor.class));
+      winAggMap.put(LAG, constructorSupplier(LagImplementor.class));
+      winAggMap.put(NTILE, constructorSupplier(NtileImplementor.class));
+      winAggMap.put(COUNT, constructorSupplier(CountWinImplementor.class));
+      winAggMap.put(REGR_COUNT, constructorSupplier(CountWinImplementor.class));
+
+      // Functions for MATCH_RECOGNIZE
+      matchMap.put(CLASSIFIER, ClassifierImplementor::new);
+      matchMap.put(LAST, LastImplementor::new);
+
+      tvfImplementorMap.put(TUMBLE, TumbleImplementor::new);
+      tvfImplementorMap.put(HOP, HopImplementor::new);
+      tvfImplementorMap.put(SESSION, SessionImplementor::new);
+      return this;
+    }
+
+    private static <T> Supplier<T> constructorSupplier(Class<T> klass) {
+      final Constructor<T> constructor;
       try {
-        return constructor.newInstance();
-      } catch (InstantiationException | IllegalAccessException
-          | InvocationTargetException e) {
-        throw new IllegalStateException(
-            "Error while creating aggregate implementor " + constructor, e);
+        constructor = klass.getDeclaredConstructor();
+      } catch (NoSuchMethodException e) {
+        throw new IllegalArgumentException(
+            klass + " should implement zero arguments constructor");
       }
-    };
+      return () -> {
+        try {
+          return constructor.newInstance();
+        } catch (InstantiationException | IllegalAccessException
+            | InvocationTargetException e) {
+          throw new IllegalStateException(
+              "Error while creating aggregate implementor " + constructor, e);
+        }
+      };
+    }
+
+    private void defineMethod(SqlOperator operator, String functionName,
+        NullPolicy nullPolicy) {
+      map.put(operator,
+          new MethodNameImplementor(functionName, nullPolicy, false));
+    }
+
+    private void defineMethod(SqlOperator operator, Method method,
+        NullPolicy nullPolicy) {
+      map.put(operator, new MethodImplementor(method, nullPolicy, false));
+    }
+
+    private void defineUnary(SqlOperator operator, ExpressionType expressionType,
+        NullPolicy nullPolicy, @Nullable String backupMethodName) {
+      map.put(operator, new UnaryImplementor(expressionType, nullPolicy, backupMethodName));
+    }
+
+    private void defineBinary(SqlOperator operator, ExpressionType expressionType,
+        NullPolicy nullPolicy, String backupMethodName) {
+      map.put(operator,
+          new BinaryImplementor(nullPolicy, true, expressionType,
+              backupMethodName));
+    }
+
+    private void defineQuantify(SqlQuantifyOperator operator, SqlBinaryOperator binaryOperator) {
+      final RexCallImplementor binaryImplementor = requireNonNull(map.get(binaryOperator));
+      map.put(operator, new QuantifyCollectionImplementor(binaryOperator, binaryImplementor));
+    }
   }
 
   public static CallImplementor createImplementor(
@@ -733,45 +902,18 @@ public static CallImplementor createImplementor(
           createRexCallImplementor(implementor, nullPolicy, harmonize);
       final List<RexToLixTranslator.Result> arguments =
           translator.getCallOperandResult(call);
-      assert arguments != null;
       final RexToLixTranslator.Result result =
           rexCallImplementor.implement(translator, call, arguments);
       return nullAs.handle(result.valueVariable);
     };
   }
 
-  private void defineMethod(SqlOperator operator, String functionName,
-      NullPolicy nullPolicy) {
-    map.put(operator,
-        new MethodNameImplementor(functionName, nullPolicy, false));
-  }
-
-  private void defineMethod(SqlOperator operator, Method method,
-      NullPolicy nullPolicy) {
-    map.put(operator, new MethodImplementor(method, nullPolicy, false));
-  }
-
-  private void defineUnary(SqlOperator operator, ExpressionType expressionType,
-      NullPolicy nullPolicy, @Nullable String backupMethodName) {
-    map.put(operator, new UnaryImplementor(expressionType, nullPolicy, backupMethodName));
-  }
-
-  private void defineBinary(SqlOperator operator, ExpressionType expressionType,
-      NullPolicy nullPolicy, String backupMethodName) {
-    map.put(operator,
-        new BinaryImplementor(nullPolicy, true, expressionType,
-            backupMethodName));
-  }
-
   private static RexCallImplementor createRexCallImplementor(
       final NotNullImplementor implementor,
       final NullPolicy nullPolicy,
       final boolean harmonize) {
-    return new AbstractRexCallImplementor(nullPolicy, harmonize) {
-      @Override String getVariableName() {
-        return "not_null_udf";
-      }
-
+    return new AbstractRexCallImplementor("not_null_udf", nullPolicy,
+        harmonize) {
       @Override Expression implementSafe(RexToLixTranslator translator,
           RexCall call, List<Expression> argValueList) {
         return implementor.implement(translator, call, argValueList);
@@ -781,11 +923,7 @@ private static RexCallImplementor createRexCallImplementor(
 
   private static RexCallImplementor wrapAsRexCallImplementor(
       final CallImplementor implementor) {
-    return new AbstractRexCallImplementor(NullPolicy.NONE, false) {
-      @Override String getVariableName() {
-        return "udf";
-      }
-
+    return new AbstractRexCallImplementor("udf", NullPolicy.NONE, false) {
       @Override Expression implementSafe(RexToLixTranslator translator,
           RexCall call, List<Expression> argValueList) {
         return implementor.implement(translator, call, RexImpTable.NullAs.NULL);
@@ -880,7 +1018,7 @@ private static RelDataType toSql(RelDataTypeFactory typeFactory,
       RelDataType type) {
     if (type instanceof RelDataTypeFactoryImpl.JavaType) {
       final SqlTypeName typeName = type.getSqlTypeName();
-      if (typeName != null && typeName != SqlTypeName.OTHER) {
+      if (typeName != SqlTypeName.OTHER) {
         return typeFactory.createTypeWithNullability(
             typeFactory.createSqlType(typeName),
             type.isNullable());
@@ -1085,8 +1223,8 @@ static class SumImplementor extends StrictAggImplementor {
       if (info.returnType() == BigDecimal.class) {
         next = Expressions.call(acc, "add", add.arguments().get(0));
       } else {
-        next = Expressions.add(acc,
-            EnumUtils.convert(add.arguments().get(0), acc.type));
+        final Expression arg = EnumUtils.convert(add.arguments().get(0), acc.type);
+        next = Expressions.add(acc, arg);
       }
       accAdvance(add, acc, next);
     }
@@ -1119,15 +1257,74 @@ static class MinMaxImplementor extends StrictAggImplementor {
       final Method method = (isMin
           ? BuiltInMethod.LESSER
           : BuiltInMethod.GREATER).method;
-      Expression next = Expressions.call(
-          method.getDeclaringClass(),
-          method.getName(),
-          acc,
-          Expressions.unbox(arg));
+      Expression next =
+          Expressions.call(method.getDeclaringClass(), method.getName(),
+              acc, Expressions.unbox(arg));
       accAdvance(add, acc, next);
     }
   }
 
+  /** Implementor for the {@code ARG_MIN} and {@code ARG_MAX} aggregate
+   * functions. */
+  static class ArgMinMaxImplementor extends StrictAggImplementor {
+    @Override protected void implementNotNullReset(AggContext info,
+        AggResetContext reset) {
+      // acc[0] = null;
+      reset.currentBlock().add(
+          Expressions.statement(
+              Expressions.assign(reset.accumulator().get(0),
+                  Expressions.constant(null))));
+
+      final Type compType = info.parameterTypes().get(1);
+      final Primitive p = Primitive.of(compType);
+      final boolean isMin = info.aggregation().kind == SqlKind.ARG_MIN;
+      final Object inf = p == null ? null : (isMin ? p.max : p.min);
+      //acc[1] = isMin ? {max value} : {min value};
+      reset.currentBlock().add(
+          Expressions.statement(
+              Expressions.assign(reset.accumulator().get(1),
+                  Expressions.constant(inf, compType))));
+    }
+
+    @Override public void implementNotNullAdd(AggContext info,
+        AggAddContext add) {
+      Expression accComp = add.accumulator().get(1);
+      Expression argValue = add.arguments().get(0);
+      Expression argComp = add.arguments().get(1);
+      final Type compType = info.parameterTypes().get(1);
+      final Primitive p = Primitive.of(compType);
+      final boolean isMin = info.aggregation().kind == SqlKind.ARG_MIN;
+
+      final Method method =
+          (isMin
+              ? (p == null ? BuiltInMethod.LT_NULLABLE : BuiltInMethod.LT)
+              : (p == null ? BuiltInMethod.GT_NULLABLE : BuiltInMethod.GT))
+              .method;
+      Expression compareExpression =
+          Expressions.call(method.getDeclaringClass(),
+              method.getName(),
+              argComp,
+              accComp);
+
+      final BlockBuilder thenBlock =
+          new BlockBuilder(true, add.currentBlock());
+      thenBlock.add(
+          Expressions.statement(
+              Expressions.assign(add.accumulator().get(0), argValue)));
+      thenBlock.add(
+          Expressions.statement(
+              Expressions.assign(add.accumulator().get(1), argComp)));
+
+      add.currentBlock()
+          .add(Expressions.ifThen(compareExpression, thenBlock.toBlock()));
+    }
+
+    @Override public List<Type> getNotNullState(AggContext info) {
+      return ImmutableList.of(Object.class, // the result value
+          info.parameterTypes().get(1)); // the compare value
+    }
+  }
+
   /** Implementor for the {@code SINGLE_VALUE} aggregate function. */
   static class SingleValueImplementor implements AggImplementor {
     @Override public List<Type> getStateType(AggContext info) {
@@ -1207,11 +1404,11 @@ static class ListaggImplementor extends StrictAggImplementor {
       final Expression arg0 = add.arguments().get(0);
       final Expression arg1 = add.arguments().size() == 2
           ? add.arguments().get(1) : COMMA_EXPR;
-      final Expression result = Expressions.condition(
-          Expressions.equal(NULL_EXPR, accValue),
-          arg0,
-          Expressions.call(BuiltInMethod.STRING_CONCAT.method, accValue,
-              Expressions.call(BuiltInMethod.STRING_CONCAT.method, arg1, arg0)));
+      final Expression result =
+          Expressions.condition(Expressions.equal(NULL_EXPR, accValue),
+              arg0,
+              Expressions.call(BuiltInMethod.STRING_CONCAT.method, accValue,
+                  Expressions.call(BuiltInMethod.STRING_CONCAT.method, arg1, arg0)));
 
       add.currentBlock().add(Expressions.statement(Expressions.assign(accValue, result)));
     }
@@ -1240,9 +1437,7 @@ static class IntersectionImplementor extends StrictAggImplementor {
           Expressions.statement(
               Expressions.call(add.accumulator().get(0),
                   BuiltInMethod.COLLECTION_RETAIN_ALL.method,
-                  add.arguments().get(0))
-          )
-      );
+                  add.arguments().get(0))));
 
       add.currentBlock().add(
           Expressions.ifThenElse(
@@ -1285,8 +1480,9 @@ static class ModeImplementor extends StrictAggImplementor {
           Expressions.call(accMap, BuiltInMethod.MAP_GET_OR_DEFAULT.method, currentArg,
               Expressions.constant(0, Long.class));
       // declare and assign the occurrences number about current value
-      ParameterExpression currentNumber = Expressions.parameter(
-          Long.class, add.currentBlock().newName("currentNumber"));
+      ParameterExpression currentNumber =
+          Expressions.parameter(Long.class,
+              add.currentBlock().newName("currentNumber"));
       add.currentBlock().add(Expressions.declare(0, currentNumber, null));
       add.currentBlock().add(
           Expressions.statement(
@@ -1391,11 +1587,9 @@ static class BitOpImplementor extends StrictAggImplementor {
             + ". Only support bit_and, bit_or and bit_xor for bit aggregation function");
       }
       final Method method = builtInMethod.method;
-      Expression next = Expressions.call(
-          method.getDeclaringClass(),
-          method.getName(),
-          acc,
-          Expressions.unbox(arg));
+      Expression next =
+          Expressions.call(method.getDeclaringClass(), method.getName(),
+              acc, Expressions.unbox(arg));
       accAdvance(add, acc, next);
     }
   }
@@ -1671,17 +1865,19 @@ static class NthValueImplementor implements WinAggImplementor {
 
       List<RexNode> rexArgs = winResult.rexArguments();
 
-      ParameterExpression res = Expressions.parameter(0, info.returnType(),
-          result.currentBlock().newName("nth"));
+      ParameterExpression res =
+          Expressions.parameter(0, info.returnType(),
+              result.currentBlock().newName("nth"));
 
       RexToLixTranslator currentRowTranslator =
           winResult.rowTranslator(
               winResult.computeIndex(Expressions.constant(0), SeekType.START));
 
-      Expression dstIndex = winResult.computeIndex(
-          Expressions.subtract(
-              currentRowTranslator.translate(rexArgs.get(1), int.class),
-              Expressions.constant(1)), SeekType.START);
+      Expression dstIndex =
+          winResult.computeIndex(
+              Expressions.subtract(
+                  currentRowTranslator.translate(rexArgs.get(1), int.class),
+                  Expressions.constant(1)), SeekType.START);
 
       Expression rowInRange = winResult.rowInPartition(dstIndex);
 
@@ -1733,8 +1929,9 @@ protected LeadLagImplementor(boolean isLead) {
 
       List<RexNode> rexArgs = winResult.rexArguments();
 
-      ParameterExpression res = Expressions.parameter(0, info.returnType(),
-          result.currentBlock().newName(isLead ? "lead" : "lag"));
+      ParameterExpression res =
+          Expressions.parameter(0, info.returnType(),
+              result.currentBlock().newName(isLead ? "lead" : "lag"));
 
       Expression offset;
       RexToLixTranslator currentRowTranslator =
@@ -1742,8 +1939,7 @@ protected LeadLagImplementor(boolean isLead) {
               winResult.computeIndex(Expressions.constant(0), SeekType.SET));
       if (rexArgs.size() >= 2) {
         // lead(x, offset) or lead(x, offset, default)
-        offset = currentRowTranslator.translate(
-            rexArgs.get(1), int.class);
+        offset = currentRowTranslator.translate(rexArgs.get(1), int.class);
       } else {
         offset = Expressions.constant(1);
       }
@@ -1755,8 +1951,8 @@ protected LeadLagImplementor(boolean isLead) {
       Expression rowInRange = winResult.rowInPartition(dstIndex);
 
       BlockBuilder thenBlock = result.nestBlock();
-      Expression lagResult = winResult.rowTranslator(dstIndex).translate(
-          rexArgs.get(0), res.type);
+      Expression lagResult =
+          winResult.rowTranslator(dstIndex).translate(rexArgs.get(0), res.type);
       thenBlock.add(Expressions.statement(Expressions.assign(res, lagResult)));
       result.exitBlock();
       BlockStatement thenBranch = thenBlock.toBlock();
@@ -1815,16 +2011,12 @@ static class NtileImplementor implements WinAggImplementor {
           winResult.rowTranslator(winResult.index()).translate(
               rexArgs.get(0), int.class);
 
-      Expression ntile =
-          Expressions.add(Expressions.constant(1),
-              Expressions.divide(
-                  Expressions.multiply(
-                      tiles,
-                      Expressions.subtract(
-                          winResult.index(), winResult.startIndex())),
-                  winResult.getPartitionRowCount()));
-
-      return ntile;
+      return Expressions.add(Expressions.constant(1),
+          Expressions.divide(
+              Expressions.multiply(tiles,
+                  Expressions.subtract(winResult.index(),
+                      winResult.startIndex())),
+              winResult.getPartitionRowCount()));
     }
   }
 
@@ -1841,7 +2033,7 @@ static class RowNumberImplementor extends StrictWinAggImplementor {
 
     @Override protected Expression implementNotNullResult(
         WinAggContext info, WinAggResultContext result) {
-      // Window cannot be empty since ROWS/RANGE is not possible for ROW_NUMBER
+      // Window must not be empty since ROWS/RANGE is not possible for ROW_NUMBER
       return Expressions.add(
           Expressions.subtract(result.index(), result.startIndex()),
           Expressions.constant(1));
@@ -1940,11 +2132,7 @@ static Supplier<JsonArrayAggImplementor> supplierFor(Method m) {
   /** Implementor for the {@code TRIM} function. */
   private static class TrimImplementor extends AbstractRexCallImplementor {
     TrimImplementor() {
-      super(NullPolicy.STRICT, false);
-    }
-
-    @Override String getVariableName() {
-      return "trim";
+      super("trim", NullPolicy.STRICT, false);
     }
 
     @Override Expression implementSafe(final RexToLixTranslator translator,
@@ -1974,15 +2162,11 @@ private static class PeriodNameImplementor extends MethodNameImplementor {
 
     PeriodNameImplementor(String methodName, BuiltInMethod timestampMethod,
         BuiltInMethod dateMethod) {
-      super(methodName, NullPolicy.STRICT, false);
+      super("periodName", methodName, NullPolicy.STRICT, false);
       this.timestampMethod = timestampMethod;
       this.dateMethod = dateMethod;
     }
 
-    @Override String getVariableName() {
-      return "periodName";
-    }
-
     @Override Expression implementSafe(final RexToLixTranslator translator,
         final RexCall call, final List<Expression> argValueList) {
       Expression operand = argValueList.get(0);
@@ -2006,20 +2190,48 @@ protected Expression getExpression(RexToLixTranslator translator,
     }
   }
 
+  /** Implementor for the {@code LAST_DAY} function. */
+  private static class LastDayImplementor extends MethodNameImplementor {
+    private final BuiltInMethod dateMethod;
+
+    LastDayImplementor(String methodName, BuiltInMethod dateMethod) {
+      super(methodName, methodName, NullPolicy.STRICT, false);
+      this.dateMethod = dateMethod;
+    }
+
+    @Override Expression implementSafe(final RexToLixTranslator translator,
+        final RexCall call, final List<Expression> argValueList) {
+      Expression operand = argValueList.get(0);
+      final RelDataType type = call.operands.get(0).getType();
+      switch (type.getSqlTypeName()) {
+      case TIMESTAMP:
+        operand =
+            Expressions.call(BuiltInMethod.TIMESTAMP_TO_DATE.method, operand);
+        // fall through
+      case DATE:
+        return Expressions.call(dateMethod.method.getDeclaringClass(),
+            dateMethod.method.getName(), operand);
+      default:
+        throw new AssertionError("unknown type " + type);
+      }
+    }
+  }
+
   /** Implementor for the {@code FLOOR} and {@code CEIL} functions. */
   private static class FloorImplementor extends MethodNameImplementor {
     final Method timestampMethod;
     final Method dateMethod;
+    final Method customTimestampMethod;
+    final Method customDateMethod;
 
     FloorImplementor(String methodName, Method timestampMethod,
-        Method dateMethod) {
-      super(methodName, NullPolicy.STRICT, false);
+        Method dateMethod, Method customTimestampMethod,
+        Method customDateMethod) {
+      super("floor", methodName, NullPolicy.STRICT, false);
       this.timestampMethod = timestampMethod;
       this.dateMethod = dateMethod;
-    }
-
-    @Override String getVariableName() {
-      return "floor";
+      this.customTimestampMethod = customTimestampMethod;
+      this.customDateMethod = customDateMethod;
     }
 
     @Override Expression implementSafe(final RexToLixTranslator translator,
@@ -2040,40 +2252,47 @@ private static class FloorImplementor extends MethodNameImplementor {
         final Type type;
         final Method floorMethod;
         final boolean preFloor;
-        Expression operand = argValueList.get(0);
+        final Expression operand1 = argValueList.get(1);
+        final boolean custom = operand1.getType() == String.class;
+        Expression operand0 = argValueList.get(0);
         switch (call.getType().getSqlTypeName()) {
         case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
-          operand = Expressions.call(
-              BuiltInMethod.TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_TIMESTAMP.method,
-              operand,
-              Expressions.call(BuiltInMethod.TIME_ZONE.method, translator.getRoot()));
+          operand0 =
+              Expressions.call(BuiltInMethod.TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_TIMESTAMP.method,
+                  operand0,
+                  Expressions.call(BuiltInMethod.TIME_ZONE.method,
+                      translator.getRoot()));
           // fall through
         case TIMESTAMP:
           type = long.class;
-          floorMethod = timestampMethod;
+          floorMethod = custom ? customTimestampMethod : timestampMethod;
           preFloor = true;
           break;
         default:
           type = int.class;
-          floorMethod = dateMethod;
+          floorMethod = custom ? customDateMethod : dateMethod;
           preFloor = false;
         }
+        if (custom) {
+          return Expressions.call(floorMethod, translator.getRoot(),
+              operand1, operand0);
+        }
         final TimeUnitRange timeUnitRange =
-            (TimeUnitRange) requireNonNull(translator.getLiteralValue(argValueList.get(1)),
+            (TimeUnitRange) requireNonNull(translator.getLiteralValue(operand1),
             "timeUnitRange");
         switch (timeUnitRange) {
         case YEAR:
+        case ISOYEAR:
         case QUARTER:
         case MONTH:
         case WEEK:
         case DAY:
-          final Expression operand1 =
-              preFloor ? call(operand, type, TimeUnit.DAY) : operand;
+          final Expression dayOperand0 =
+              preFloor ? call(operand0, type, TimeUnit.DAY) : operand0;
           return Expressions.call(floorMethod,
-              translator.getLiteral(argValueList.get(1)), operand1);
-        case NANOSECOND:
+              translator.getLiteral(operand1), dayOperand0);
         default:
-          return call(operand, type, timeUnitRange.startUnit);
+          return call(operand0, type, timeUnitRange.startUnit);
         }
 
       default:
@@ -2083,6 +2302,13 @@ private static class FloorImplementor extends MethodNameImplementor {
 
     private Expression call(Expression operand, Type type,
         TimeUnit timeUnit) {
+      if (timeUnit.multiplier.compareTo(BigDecimal.ONE) < 0) {
+        // MICROSECOND has a multiplier of 0.001,
+        // NANOSECOND has a multiplier of 0.000001.
+        // In integer arithmetic, these underflow to zero, so we get a
+        // divide-by-zero exception. FLOOR and CEIL on these units should no-op.
+        return EnumUtils.convert(operand, type);
+      }
       return Expressions.call(SqlFunctions.class, methodName,
           EnumUtils.convert(operand, type),
           EnumUtils.convert(
@@ -2090,19 +2316,102 @@ private Expression call(Expression operand, Type type,
     }
   }
 
+  /** Implementor for the {@code TIMESTAMPADD} function. */
+  private static class TimestampAddImplementor extends MethodNameImplementor {
+    final Method customTimestampMethod;
+    final Method customDateMethod;
+
+    TimestampAddImplementor(String methodName, Method customTimestampMethod,
+        Method customDateMethod) {
+      super("timestampAdd", methodName, NullPolicy.STRICT, false);
+      this.customTimestampMethod = customTimestampMethod;
+      this.customDateMethod = customDateMethod;
+    }
+
+    @Override Expression implementSafe(final RexToLixTranslator translator,
+        final RexCall call, final List<Expression> argValueList) {
+      final Expression operand0 = argValueList.get(0);
+      final Expression operand1 = argValueList.get(1);
+      final Expression operand2 = argValueList.get(2);
+      switch (call.getType().getSqlTypeName()) {
+      case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
+      case TIMESTAMP:
+        return Expressions.call(customTimestampMethod, translator.getRoot(),
+            operand0, operand1, operand2);
+      default:
+        return Expressions.call(customDateMethod, translator.getRoot(),
+            operand0, operand1, operand2);
+      }
+    }
+  }
+
+  /** Implementor for the {@code TIMESTAMPDIFF} function. */
+  private static class TimestampDiffImplementor extends MethodNameImplementor {
+    final Method customTimestampMethod;
+    final Method customDateMethod;
+
+    TimestampDiffImplementor(String methodName, Method customTimestampMethod,
+        Method customDateMethod) {
+      super("timestampDiff", methodName, NullPolicy.STRICT, false);
+      this.customTimestampMethod = customTimestampMethod;
+      this.customDateMethod = customDateMethod;
+    }
+
+    @Override Expression implementSafe(final RexToLixTranslator translator,
+        final RexCall call, final List<Expression> argValueList) {
+      return Expressions.call(getMethod(call), translator.getRoot(),
+          argValueList.get(0), argValueList.get(1), argValueList.get(2));
+    }
+
+    private Method getMethod(RexCall call) {
+      switch (call.operands.get(1).getType().getSqlTypeName()) {
+      case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
+      case TIMESTAMP:
+        return customTimestampMethod;
+      default:
+        return customDateMethod;
+      }
+    }
+  }
+
+  /**
+   * Implementor for the {@code FORMAT_TIMESTAMP, FORMAT_DATE, FORMAT_TIME} and
+   * {@code FORMAT_DATETIME} functions.
+   */
+  private static class FormatDatetimeImplementor extends MethodNameImplementor {
+    FormatDatetimeImplementor() {
+      super("formatDatetime", NullPolicy.STRICT, false);
+    }
+
+    @Override Expression implementSafe(final RexToLixTranslator translator,
+        final RexCall call, final List<Expression> argValueList) {
+      final Expression operand0 = argValueList.get(0);
+      final Expression operand1 = argValueList.get(1);
+      Method method;
+      switch (call.operands.get(1).getType().getSqlTypeName()) {
+      case TIME:
+        method = BuiltInMethod.FORMAT_TIME.method;
+        break;
+      case DATE:
+        method = BuiltInMethod.FORMAT_DATE.method;
+        break;
+      default:
+        method = BuiltInMethod.FORMAT_TIMESTAMP.method;
+      }
+      return Expressions.call(method, translator.getRoot(), operand0, operand1);
+    }
+  }
+
   /** Implementor for a function that generates calls to a given method. */
   private static class MethodImplementor extends AbstractRexCallImplementor {
     protected final Method method;
 
-    MethodImplementor(Method method, @Nullable NullPolicy nullPolicy, boolean harmonize) {
-      super(nullPolicy, harmonize);
+    MethodImplementor(Method method, @Nullable NullPolicy nullPolicy,
+        boolean harmonize) {
+      super("method_call", nullPolicy, harmonize);
       this.method = method;
     }
 
-    @Override String getVariableName() {
-      return "method_call";
-    }
-
     @Override Expression implementSafe(RexToLixTranslator translator,
         RexCall call, List<Expression> argValueList) {
       if (Modifier.isStatic(method.getModifiers())) {
@@ -2207,7 +2516,8 @@ private static class JsonValueImplementor extends MethodImplementor {
       newOperands.add(defaultValueOnEmpty);
       newOperands.add(errorBehavior);
       newOperands.add(defaultValueOnError);
-      Class clazz = method.getDeclaringClass();
+      @SuppressWarnings("rawtypes")
+      final Class clazz = method.getDeclaringClass();
       expression = EnumUtils.call(null, clazz, method.getName(), newOperands);
 
       final Type returnType =
@@ -2223,14 +2533,15 @@ private static class JsonValueImplementor extends MethodImplementor {
   private static class MethodNameImplementor extends AbstractRexCallImplementor {
     protected final String methodName;
 
-    MethodNameImplementor(String methodName,
-        NullPolicy nullPolicy, boolean harmonize) {
-      super(nullPolicy, harmonize);
-      this.methodName = methodName;
+    MethodNameImplementor(String methodName, NullPolicy nullPolicy,
+        boolean harmonize) {
+      this("method_name_call", methodName, nullPolicy, harmonize);
     }
 
-    @Override String getVariableName() {
-      return "method_name_call";
+    MethodNameImplementor(String variableName, String methodName,
+        NullPolicy nullPolicy, boolean harmonize) {
+      super(variableName, nullPolicy, harmonize);
+      this.methodName = requireNonNull(methodName, "methodName");
     }
 
     @Override Expression implementSafe(RexToLixTranslator translator,
@@ -2272,13 +2583,10 @@ private static class BinaryImplementor extends AbstractRexCallImplementor {
 
     BinaryImplementor(NullPolicy nullPolicy, boolean harmonize,
         ExpressionType expressionType, String backupMethodName) {
-      super(nullPolicy, harmonize);
+      super("binary_call", nullPolicy, harmonize);
       this.expressionType = expressionType;
-      this.backupMethodName = backupMethodName;
-    }
-
-    @Override String getVariableName() {
-      return "binary_call";
+      this.backupMethodName =
+          requireNonNull(backupMethodName, "backupMethodName");
     }
 
     @Override Expression implementSafe(
@@ -2297,40 +2605,43 @@ private static class BinaryImplementor extends AbstractRexCallImplementor {
       //     return x == null || y == null ? null : x OP y
       //   ignore_null
       //     return x == null ? y : y == null ? x : x OP y
-      if (backupMethodName != null) {
-        // If one or both operands have ANY type, use the late-binding backup
-        // method.
-        if (anyAnyOperands(call)) {
-          return callBackupMethodAnyType(argValueList);
-        }
 
-        final Type type0 = argValueList.get(0).getType();
-        final Type type1 = argValueList.get(1).getType();
-        final SqlBinaryOperator op = (SqlBinaryOperator) call.getOperator();
-        final RelDataType relDataType0 = call.getOperands().get(0).getType();
-        final Expression fieldComparator = generateCollatorExpression(relDataType0.getCollation());
-        if (fieldComparator != null) {
-          argValueList.add(fieldComparator);
-        }
-        final Primitive primitive = Primitive.ofBoxOr(type0);
-        if (primitive == null
-            || type1 == BigDecimal.class
-            || COMPARISON_OPERATORS.contains(op)
-            && !COMP_OP_TYPES.contains(primitive)) {
-          return Expressions.call(SqlFunctions.class, backupMethodName,
-              argValueList);
-        }
-        // When checking equals or not equals on two primitive boxing classes
-        // (i.e. Long x, Long y), we should fall back to call `SqlFunctions.eq(x, y)`
-        // or `SqlFunctions.ne(x, y)`, rather than `x == y`
-        final Primitive boxPrimitive0 = Primitive.ofBox(type0);
-        final Primitive boxPrimitive1 = Primitive.ofBox(type1);
-        if (EQUALS_OPERATORS.contains(op)
-            && boxPrimitive0 != null && boxPrimitive1 != null) {
-          return Expressions.call(SqlFunctions.class, backupMethodName,
-              argValueList);
-        }
+      // If one or both operands have ANY type, use the late-binding backup
+      // method.
+      if (anyAnyOperands(call)) {
+        return callBackupMethodAnyType(argValueList);
+      }
+
+      final Type type0 = argValueList.get(0).getType();
+      final Type type1 = argValueList.get(1).getType();
+      final SqlBinaryOperator op = (SqlBinaryOperator) call.getOperator();
+      final RelDataType relDataType0 = call.getOperands().get(0).getType();
+      final Expression fieldComparator =
+          generateCollatorExpression(relDataType0.getCollation());
+      if (fieldComparator != null) {
+        argValueList.add(fieldComparator);
+      }
+
+      final Primitive primitive = Primitive.ofBoxOr(type0);
+      if (primitive == null
+          || type1 == BigDecimal.class
+          || COMPARISON_OPERATORS.contains(op)
+          && !COMP_OP_TYPES.contains(primitive)) {
+        return Expressions.call(SqlFunctions.class, backupMethodName,
+            argValueList);
+      }
+
+      // When checking equals or not equals on two primitive boxing classes
+      // (i.e. Long x, Long y), we should fall back to call `SqlFunctions.eq(x, y)`
+      // or `SqlFunctions.ne(x, y)`, rather than `x == y`
+      final Primitive boxPrimitive0 = Primitive.ofBox(type0);
+      final Primitive boxPrimitive1 = Primitive.ofBox(type1);
+      if (EQUALS_OPERATORS.contains(op)
+          && boxPrimitive0 != null && boxPrimitive1 != null) {
+        return Expressions.call(SqlFunctions.class, backupMethodName,
+            argValueList);
       }
+
       return Expressions.makeBinary(expressionType,
           argValueList.get(0), argValueList.get(1));
     }
@@ -2367,20 +2678,16 @@ private static Expression maybeBox(Expression expression) {
 
   /** Implementor for unary operators. */
   private static class UnaryImplementor extends AbstractRexCallImplementor {
-    private final ExpressionType expressionType;
-    private final @Nullable String backupMethodName;
+    final ExpressionType expressionType;
+    final @Nullable String backupMethodName;
 
     UnaryImplementor(ExpressionType expressionType, NullPolicy nullPolicy,
         @Nullable String backupMethodName) {
-      super(nullPolicy, false);
+      super("unary_call", nullPolicy, false);
       this.expressionType = expressionType;
       this.backupMethodName = backupMethodName;
     }
 
-    @Override String getVariableName() {
-      return "unary_call";
-    }
-
     @Override Expression implementSafe(RexToLixTranslator translator,
         RexCall call, List<Expression> argValueList) {
       final Expression argValue = argValueList.get(0);
@@ -2408,11 +2715,7 @@ private static class UnaryImplementor extends AbstractRexCallImplementor {
   /** Implementor for the {@code EXTRACT(unit FROM datetime)} function. */
   private static class ExtractImplementor extends AbstractRexCallImplementor {
     ExtractImplementor() {
-      super(NullPolicy.STRICT, false);
-    }
-
-    @Override String getVariableName() {
-      return "extract";
+      super("extract", NullPolicy.STRICT, false);
     }
 
     @Override Expression implementSafe(final RexToLixTranslator translator,
@@ -2452,14 +2755,16 @@ private static class ExtractImplementor extends AbstractRexCallImplementor {
         case INTERVAL_SECOND:
           break;
         case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
-          operand = Expressions.call(
-              BuiltInMethod.TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_TIMESTAMP.method,
-              operand,
-              Expressions.call(BuiltInMethod.TIME_ZONE.method, translator.getRoot()));
+          operand =
+              Expressions.call(BuiltInMethod.TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_TIMESTAMP.method,
+                  operand,
+                  Expressions.call(BuiltInMethod.TIME_ZONE.method,
+                      translator.getRoot()));
           // fall through
         case TIMESTAMP:
-          operand = Expressions.call(BuiltInMethod.FLOOR_DIV.method,
-              operand, Expressions.constant(TimeUnit.DAY.multiplier.longValue()));
+          operand =
+              Expressions.call(BuiltInMethod.FLOOR_DIV.method, operand,
+                  Expressions.constant(TimeUnit.DAY.multiplier.longValue()));
           // fall through
         case DATE:
           return Expressions.call(BuiltInMethod.UNIX_DATE_EXTRACT.method,
@@ -2481,18 +2786,20 @@ private static class ExtractImplementor extends AbstractRexCallImplementor {
         switch (sqlTypeName) {
         case DATE:
           // convert to milliseconds
-          operand = Expressions.multiply(operand,
-              Expressions.constant(TimeUnit.DAY.multiplier.longValue()));
+          operand =
+              Expressions.multiply(operand,
+                  Expressions.constant(TimeUnit.DAY.multiplier.longValue()));
           // fall through
         case TIMESTAMP:
           // convert to seconds
           return Expressions.divide(operand,
               Expressions.constant(TimeUnit.SECOND.multiplier.longValue()));
         case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
-          operand = Expressions.call(
-              BuiltInMethod.TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_TIMESTAMP.method,
-              operand,
-              Expressions.call(BuiltInMethod.TIME_ZONE.method, translator.getRoot()));
+          operand =
+              Expressions.call(BuiltInMethod.TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_TIMESTAMP.method,
+                  operand,
+                  Expressions.call(BuiltInMethod.TIME_ZONE.method,
+                      translator.getRoot()));
           return Expressions.divide(operand,
               Expressions.constant(TimeUnit.SECOND.multiplier.longValue()));
         case INTERVAL_YEAR:
@@ -2530,8 +2837,9 @@ private static class ExtractImplementor extends AbstractRexCallImplementor {
       if (unit == TimeUnit.QUARTER) {
         operand = Expressions.subtract(operand, Expressions.constant(1L));
       }
-      operand = Expressions.divide(operand,
-          Expressions.constant(unit.multiplier.longValue()));
+      operand =
+          Expressions.divide(operand,
+              Expressions.constant(unit.multiplier.longValue()));
       if (unit == TimeUnit.QUARTER) {
         operand = Expressions.add(operand, Expressions.constant(1L));
       }
@@ -2577,11 +2885,7 @@ private static long getFactor(TimeUnit unit) {
   /** Implementor for the SQL {@code COALESCE} operator. */
   private static class CoalesceImplementor extends AbstractRexCallImplementor {
     CoalesceImplementor() {
-      super(NullPolicy.NONE, false);
-    }
-
-    @Override String getVariableName() {
-      return "coalesce";
+      super("coalesce", NullPolicy.NONE, false);
     }
 
     @Override Expression implementSafe(final RexToLixTranslator translator,
@@ -2605,11 +2909,7 @@ private static Expression implementRecurse(RexToLixTranslator translator,
   /** Implementor for the SQL {@code CAST} operator. */
   private static class CastImplementor extends AbstractRexCallImplementor {
     CastImplementor() {
-      super(NullPolicy.STRICT, false);
-    }
-
-    @Override String getVariableName() {
-      return "cast";
+      super("cast", NullPolicy.STRICT, false);
     }
 
     @Override Expression implementSafe(final RexToLixTranslator translator,
@@ -2632,8 +2932,9 @@ private static class CastImplementor extends AbstractRexCallImplementor {
       }
       final RelDataType targetType =
           nullifyType(translator.typeFactory, call.getType(), false);
+      boolean safe = call.getKind() == SqlKind.SAFE_CAST;
       return translator.translateCast(sourceType,
-              targetType, argValueList.get(0));
+              targetType, argValueList.get(0), safe);
     }
 
     private static RelDataType nullifyType(JavaTypeFactory typeFactory,
@@ -2652,11 +2953,7 @@ private static RelDataType nullifyType(JavaTypeFactory typeFactory,
   /** Implementor for the {@code REINTERPRET} internal SQL operator. */
   private static class ReinterpretImplementor extends AbstractRexCallImplementor {
     ReinterpretImplementor() {
-      super(NullPolicy.STRICT, false);
-    }
-
-    @Override String getVariableName() {
-      return "reInterpret";
+      super("reinterpret", NullPolicy.STRICT, false);
     }
 
     @Override Expression implementSafe(final RexToLixTranslator translator,
@@ -2668,17 +2965,12 @@ private static class ReinterpretImplementor extends AbstractRexCallImplementor {
 
   /** Implementor for a array concat. */
   private static class ArrayConcatImplementor extends AbstractRexCallImplementor {
-
     ArrayConcatImplementor() {
-      super(NullPolicy.STRICT, false);
-    }
-
-    @Override String getVariableName() {
-      return "array_concat";
+      super("array_concat", NullPolicy.STRICT, false);
     }
 
-    @Override Expression implementSafe(RexToLixTranslator translator, RexCall call,
-        List<Expression> argValueList) {
+    @Override Expression implementSafe(RexToLixTranslator translator,
+        RexCall call, List<Expression> argValueList) {
       final BlockBuilder blockBuilder = translator.getBlockBuilder();
       final Expression list =
           blockBuilder.append("list", Expressions.new_(ArrayList.class), false);
@@ -2691,8 +2983,8 @@ private static class ArrayConcatImplementor extends AbstractRexCallImplementor {
                     Expressions.equal(nullValue, expression)),
                 Expressions.assign(list, nullValue),
                 Expressions.statement(
-                    Expressions.call(list, BuiltInMethod.COLLECTION_ADDALL.method, expression)))
-        );
+                    Expressions.call(list,
+                        BuiltInMethod.COLLECTION_ADDALL.method, expression))));
       }
       return list;
     }
@@ -2700,16 +2992,14 @@ private static class ArrayConcatImplementor extends AbstractRexCallImplementor {
 
   /** Implementor for a array or string concat. */
   private static class ConcatImplementor extends AbstractRexCallImplementor {
-    private ArrayConcatImplementor arrayConcatImplementor =
+    final ArrayConcatImplementor arrayConcatImplementor =
         new ArrayConcatImplementor();
-    private MethodImplementor stringConcatImplementor
-        = new MethodImplementor(BuiltInMethod.STRING_CONCAT.method, NullPolicy.STRICT, false);
-    ConcatImplementor() {
-      super(NullPolicy.STRICT, false);
-    }
+    final MethodImplementor stringConcatImplementor =
+        new MethodImplementor(BuiltInMethod.STRING_CONCAT.method,
+            NullPolicy.STRICT, false);
 
-    @Override String getVariableName() {
-      return "concat";
+    ConcatImplementor() {
+      super("concat", NullPolicy.STRICT, false);
     }
 
     @Override Expression implementSafe(RexToLixTranslator translator, RexCall call,
@@ -2726,11 +3016,7 @@ private static class ValueConstructorImplementor
       extends AbstractRexCallImplementor {
 
     ValueConstructorImplementor() {
-      super(NullPolicy.NONE, false);
-    }
-
-    @Override String getVariableName() {
-      return "value_constructor";
+      super("value_constructor", NullPolicy.NONE, false);
     }
 
     @Override Expression implementSafe(RexToLixTranslator translator,
@@ -2771,11 +3057,7 @@ private static class ValueConstructorImplementor
   /** Implementor for the {@code ITEM} SQL operator. */
   private static class ItemImplementor extends AbstractRexCallImplementor {
     ItemImplementor() {
-      super(NullPolicy.STRICT, false);
-    }
-
-    @Override String getVariableName() {
-      return "item";
+      super("item", NullPolicy.STRICT, false);
     }
 
     // Since we follow PostgreSQL's semantics that an out-of-bound reference
@@ -2808,11 +3090,7 @@ private MethodImplementor getImplementor(SqlTypeName sqlTypeName) {
   private static class SystemFunctionImplementor
       extends AbstractRexCallImplementor {
     SystemFunctionImplementor() {
-      super(NullPolicy.NONE, false);
-    }
-
-    @Override String getVariableName() {
-      return "system_func";
+      super("system_func", NullPolicy.NONE, false);
     }
 
     @Override Expression implementSafe(final RexToLixTranslator translator,
@@ -2849,10 +3127,10 @@ private static class SystemFunctionImplementor
 
   /** Implementor for the {@code NOT} operator. */
   private static class NotImplementor extends AbstractRexCallImplementor {
-    private AbstractRexCallImplementor implementor;
+    private final AbstractRexCallImplementor implementor;
 
     private NotImplementor(AbstractRexCallImplementor implementor) {
-      super(null, false);
+      super("not", null, false);
       this.implementor = implementor;
     }
 
@@ -2860,10 +3138,6 @@ static AbstractRexCallImplementor of(AbstractRexCallImplementor implementor) {
       return new NotImplementor(implementor);
     }
 
-    @Override String getVariableName() {
-      return "not";
-    }
-
     @Override Expression implementSafe(final RexToLixTranslator translator,
         final RexCall call, final List<Expression> argValueList) {
       final Expression expression =
@@ -2876,10 +3150,7 @@ static AbstractRexCallImplementor of(AbstractRexCallImplementor implementor) {
   private static class DatetimeArithmeticImplementor
       extends AbstractRexCallImplementor {
     DatetimeArithmeticImplementor() {
-      super(NullPolicy.STRICT, false);
-    }
-    @Override String getVariableName() {
-      return "dateTime_arithmetic";
+      super("dateTime_arithmetic", NullPolicy.STRICT, false);
     }
 
     @Override Expression implementSafe(final RexToLixTranslator translator,
@@ -2894,10 +3165,11 @@ private static class DatetimeArithmeticImplementor
       case DATE:
         switch (typeName) {
         case TIMESTAMP:
-          trop0 = Expressions.convert_(
-              Expressions.multiply(trop0,
-                  Expressions.constant(DateTimeUtils.MILLIS_PER_DAY)),
-              long.class);
+          trop0 =
+              Expressions.convert_(
+                  Expressions.multiply(trop0,
+                      Expressions.constant(DateTimeUtils.MILLIS_PER_DAY)),
+                  long.class);
           break;
         default:
           switch (typeName1) {
@@ -2911,10 +3183,11 @@ private static class DatetimeArithmeticImplementor
           case INTERVAL_MINUTE:
           case INTERVAL_MINUTE_SECOND:
           case INTERVAL_SECOND:
-            trop1 = Expressions.convert_(
-                Expressions.divide(trop1,
-                    Expressions.constant(DateTimeUtils.MILLIS_PER_DAY)),
-                int.class);
+            trop1 =
+                Expressions.convert_(
+                    Expressions.divide(trop1,
+                        Expressions.constant(DateTimeUtils.MILLIS_PER_DAY)),
+                    int.class);
             break;
           default:
             break;
@@ -2983,7 +3256,7 @@ private static class DatetimeArithmeticImplementor
           TimeUnit toUnit = TimeUnit.MILLISECOND;
           return multiplyDivide(
               Expressions.convert_(Expressions.subtract(trop0, trop1),
-                  (Class) long.class),
+                  long.class),
               fromUnit.multiplier, toUnit.multiplier);
         default:
           throw new AssertionError(call);
@@ -3025,9 +3298,10 @@ private static class LastImplementor implements MatchImplementor {
 
       // TODO: verify if the variable is needed
       @SuppressWarnings("unused")
-      final BinaryExpression lastIndex = Expressions.subtract(
-          Expressions.call(rows, BuiltInMethod.COLLECTION_SIZE.method),
-          Expressions.constant(1));
+      final BinaryExpression lastIndex =
+          Expressions.subtract(
+              Expressions.call(rows, BuiltInMethod.COLLECTION_SIZE.method),
+              Expressions.constant(1));
 
       // Just take the last one, if exists
       if ("*".equals(alpha)) {
@@ -3093,10 +3367,15 @@ RexToLixTranslator.Result implement(
    */
   private abstract static class AbstractRexCallImplementor
       implements RexCallImplementor {
+    /** Variable name should be meaningful. It helps us debug issues. */
+    final String variableName;
+
     final @Nullable NullPolicy nullPolicy;
     private final boolean harmonize;
 
-    AbstractRexCallImplementor(@Nullable NullPolicy nullPolicy, boolean harmonize) {
+    AbstractRexCallImplementor(String variableName,
+        @Nullable NullPolicy nullPolicy, boolean harmonize) {
+      this.variableName = requireNonNull(variableName, "variableName");
       this.nullPolicy = nullPolicy;
       this.harmonize = harmonize;
     }
@@ -3120,7 +3399,9 @@ private abstract static class AbstractRexCallImplementor
     }
 
     // Variable name facilitates reasoning about issues when necessary
-    abstract String getVariableName();
+    String getVariableName() {
+      return variableName;
+    }
 
     /** Figures out conditional expression according to NullPolicy. */
     Expression getCondition(final List<Expression> argIsNullList) {
@@ -3163,12 +3444,13 @@ private ParameterExpression genValueStatement(
       // the implementation's type is correct, we can't convert it.
       final SqlOperator op = call.getOperator();
       final Type returnType = translator.typeFactory.getJavaClass(call.getType());
-      final boolean noConvert = (returnType == null)
-              || (returnType == callValue.getType())
-              || (op instanceof SqlUserDefinedTableMacro)
-              || (op instanceof SqlUserDefinedTableFunction);
+      requireNonNull(returnType, "returnType");
+      final boolean noConvert =
+          returnType == callValue.getType()
+              || op instanceof SqlUserDefinedTableMacro
+              || op instanceof SqlUserDefinedTableFunction;
       final Expression convertedCallValue =
-              noConvert
+          noConvert
               ? callValue
               : EnumUtils.convert(callValue, returnType);
 
@@ -3189,7 +3471,7 @@ Expression getIfTrue(Type type, final List<Expression> argValueList) {
     }
 
     // E.g., "final boolean xxx_isNull = xxx_value == null"
-    private ParameterExpression genIsNullStatement(
+    protected final ParameterExpression genIsNullStatement(
         final RexToLixTranslator translator, final ParameterExpression value) {
       final ParameterExpression isNullVariable =
           Expressions.parameter(Boolean.TYPE,
@@ -3289,11 +3571,7 @@ abstract Expression implementSafe(RexToLixTranslator translator,
    */
   private static class LogicalAndImplementor extends AbstractRexCallImplementor {
     LogicalAndImplementor() {
-      super(NullPolicy.NONE, true);
-    }
-
-    @Override String getVariableName() {
-      return "logical_and";
+      super("logical_and", NullPolicy.NONE, true);
     }
 
     @Override public RexToLixTranslator.Result implement(final RexToLixTranslator translator,
@@ -3347,11 +3625,7 @@ private static class LogicalAndImplementor extends AbstractRexCallImplementor {
    */
   private static class LogicalOrImplementor extends AbstractRexCallImplementor {
     LogicalOrImplementor() {
-      super(NullPolicy.NONE, true);
-    }
-
-    @Override String getVariableName() {
-      return "logical_or";
+      super("logical_or", NullPolicy.NONE, true);
     }
 
     @Override public RexToLixTranslator.Result implement(final RexToLixTranslator translator,
@@ -3404,16 +3678,47 @@ private static class LogicalOrImplementor extends AbstractRexCallImplementor {
    */
   private static class LogicalNotImplementor extends AbstractRexCallImplementor {
     LogicalNotImplementor() {
-      super(NullPolicy.NONE, true);
+      super("logical_not", NullPolicy.NONE, true);
     }
 
-    @Override String getVariableName() {
-      return "logical_not";
+    @Override Expression implementSafe(final RexToLixTranslator translator,
+        final RexCall call, final List<Expression> argValueList) {
+      return Expressions.call(BuiltInMethod.NOT.method, argValueList);
+    }
+  }
+
+  /** Implementor for the {@code LN}, {@code LOG}, and {@code LOG10} operators.
+   *
+   * <p>Handles all logarithm functions using log rules to determine the
+   * appropriate base (i.e. base e for LN).
+   */
+  private static class LogImplementor extends AbstractRexCallImplementor {
+    LogImplementor() {
+      super("log", NullPolicy.STRICT, true);
     }
 
     @Override Expression implementSafe(final RexToLixTranslator translator,
         final RexCall call, final List<Expression> argValueList) {
-      return Expressions.call(BuiltInMethod.NOT.method, argValueList);
+      return Expressions.call(BuiltInMethod.LOG.method, args(call, argValueList));
+    }
+
+    private static List<Expression> args(RexCall call,
+        List<Expression> argValueList) {
+      Expression operand0 = argValueList.get(0);
+      final Expressions.FluentList<Expression> list = Expressions.list(operand0);
+      switch (call.getOperator().getName()) {
+      case "LOG":
+        if (argValueList.size() == 2) {
+          return list.append(argValueList.get(1));
+        }
+        // fall through
+      case "LN":
+        return list.append(Expressions.constant(Math.exp(1)));
+      case "LOG10":
+        return list.append(Expressions.constant(BigDecimal.TEN));
+      default:
+        throw new AssertionError("Operator not found: " + call.getOperator());
+      }
     }
   }
 
@@ -3427,12 +3732,8 @@ private static class ReflectiveImplementor extends AbstractRexCallImplementor {
     protected final Method method;
 
     ReflectiveImplementor(Method method, @Nullable NullPolicy nullPolicy) {
-      super(nullPolicy, false);
-      this.method = method;
-    }
-
-    @Override String getVariableName() {
-      return "reflective_" + method.getName();
+      super("reflective_" + method.getName(), nullPolicy, false);
+      this.method = requireNonNull(method, "method");
     }
 
     @Override Expression implementSafe(RexToLixTranslator translator,
@@ -3458,11 +3759,7 @@ private static class RandImplementor extends AbstractRexCallImplementor {
     };
 
     RandImplementor() {
-      super(NullPolicy.STRICT, false);
-    }
-
-    @Override String getVariableName() {
-      return "rand";
+      super("rand", NullPolicy.STRICT, false);
     }
 
     @Override Expression implementSafe(final RexToLixTranslator translator,
@@ -3480,11 +3777,7 @@ private static class RandIntegerImplementor extends AbstractRexCallImplementor {
     };
 
     RandIntegerImplementor() {
-      super(NullPolicy.STRICT, false);
-    }
-
-    @Override String getVariableName() {
-      return "rand_integer";
+      super("rand_integer", NullPolicy.STRICT, false);
     }
 
     @Override Expression implementSafe(final RexToLixTranslator translator,
@@ -3497,11 +3790,7 @@ private static class RandIntegerImplementor extends AbstractRexCallImplementor {
   /** Implementor for the {@code PI} operator. */
   private static class PiImplementor extends AbstractRexCallImplementor {
     PiImplementor() {
-      super(NullPolicy.NONE, false);
-    }
-
-    @Override String getVariableName() {
-      return "pi";
+      super("pi", NullPolicy.NONE, false);
     }
 
     @Override Expression implementSafe(final RexToLixTranslator translator,
@@ -3513,11 +3802,7 @@ private static class PiImplementor extends AbstractRexCallImplementor {
   /** Implementor for the {@code IS FALSE} SQL operator. */
   private static class IsFalseImplementor extends AbstractRexCallImplementor {
     IsFalseImplementor() {
-      super(NullPolicy.STRICT, false);
-    }
-
-    @Override String getVariableName() {
-      return "is_false";
+      super("is_false", NullPolicy.STRICT, false);
     }
 
     @Override Expression getIfTrue(Type type, final List<Expression> argValueList) {
@@ -3533,11 +3818,7 @@ private static class IsFalseImplementor extends AbstractRexCallImplementor {
   /** Implementor for the {@code IS NOT FALSE} SQL operator. */
   private static class IsNotFalseImplementor extends AbstractRexCallImplementor {
     IsNotFalseImplementor() {
-      super(NullPolicy.STRICT, false);
-    }
-
-    @Override String getVariableName() {
-      return "is_not_false";
+      super("is_not_false", NullPolicy.STRICT, false);
     }
 
     @Override Expression getIfTrue(Type type, final List<Expression> argValueList) {
@@ -3553,11 +3834,7 @@ private static class IsNotFalseImplementor extends AbstractRexCallImplementor {
   /** Implementor for the {@code IS NOT NULL} SQL operator. */
   private static class IsNotNullImplementor extends AbstractRexCallImplementor {
     IsNotNullImplementor() {
-      super(NullPolicy.STRICT, false);
-    }
-
-    @Override String getVariableName() {
-      return "is_not_null";
+      super("is_not_null", NullPolicy.STRICT, false);
     }
 
     @Override Expression getIfTrue(Type type, final List<Expression> argValueList) {
@@ -3573,11 +3850,7 @@ private static class IsNotNullImplementor extends AbstractRexCallImplementor {
   /** Implementor for the {@code IS NOT TRUE} SQL operator. */
   private static class IsNotTrueImplementor extends AbstractRexCallImplementor {
     IsNotTrueImplementor() {
-      super(NullPolicy.STRICT, false);
-    }
-
-    @Override String getVariableName() {
-      return "is_not_true";
+      super("is_not_true", NullPolicy.STRICT, false);
     }
 
     @Override Expression getIfTrue(Type type, final List<Expression> argValueList) {
@@ -3593,11 +3866,7 @@ private static class IsNotTrueImplementor extends AbstractRexCallImplementor {
   /** Implementor for the {@code IS NULL} SQL operator. */
   private static class IsNullImplementor extends AbstractRexCallImplementor {
     IsNullImplementor() {
-      super(NullPolicy.STRICT, false);
-    }
-
-    @Override String getVariableName() {
-      return "is_null";
+      super("is_null", NullPolicy.STRICT, false);
     }
 
     @Override Expression getIfTrue(Type type, final List<Expression> argValueList) {
@@ -3613,11 +3882,7 @@ private static class IsNullImplementor extends AbstractRexCallImplementor {
   /** Implementor for the {@code IS TRUE} SQL operator. */
   private static class IsTrueImplementor extends AbstractRexCallImplementor {
     IsTrueImplementor() {
-      super(NullPolicy.STRICT, false);
-    }
-
-    @Override String getVariableName() {
-      return "is_true";
+      super("is_true", NullPolicy.STRICT, false);
     }
 
     @Override Expression getIfTrue(Type type, final List<Expression> argValueList) {
@@ -3640,11 +3905,7 @@ private static class RegexpReplaceImplementor extends AbstractRexCallImplementor
     };
 
     RegexpReplaceImplementor() {
-      super(NullPolicy.STRICT, false);
-    }
-
-    @Override String getVariableName() {
-      return "regexp_replace";
+      super("regexp_replace", NullPolicy.STRICT, false);
     }
 
     @Override Expression implementSafe(RexToLixTranslator translator,
@@ -3657,11 +3918,7 @@ private static class RegexpReplaceImplementor extends AbstractRexCallImplementor
   /** Implementor for the {@code DEFAULT} function. */
   private static class DefaultImplementor extends AbstractRexCallImplementor {
     DefaultImplementor() {
-      super(NullPolicy.NONE, false);
-    }
-
-    @Override String getVariableName() {
-      return "default";
+      super("default", NullPolicy.NONE, false);
     }
 
     @Override Expression implementSafe(final RexToLixTranslator translator,
@@ -3734,6 +3991,96 @@ private static class HopImplementor implements TableFunctionCallImplementor {
     }
   }
 
+  /**
+   * Implements
+   * <a href="https://www.postgresql.org/docs/current/functions-comparisons.html#id-1.5.8.30.16">
+   * ANY/SOME</a> and
+   * <a href="https://www.postgresql.org/docs/current/functions-comparisons.html#id-1.5.8.30.17">ALL</a>
+   * operators when the argument is an array or multiset expression.
+   */
+  private static class QuantifyCollectionImplementor extends AbstractRexCallImplementor {
+    private final SqlBinaryOperator binaryOperator;
+    private final RexCallImplementor binaryImplementor;
+
+    QuantifyCollectionImplementor(SqlBinaryOperator binaryOperator,
+        RexCallImplementor binaryImplementor) {
+      super("quantify", NullPolicy.ANY, false);
+      this.binaryOperator = binaryOperator;
+      this.binaryImplementor = binaryImplementor;
+    }
+
+    @Override Expression implementSafe(RexToLixTranslator translator, RexCall call,
+        List<Expression> argValueList) {
+      Expression left = argValueList.get(0);
+      Expression right = argValueList.get(1);
+      final RelDataType rightComponentType =
+          requireNonNull(call.getOperands().get(1).getType().getComponentType());
+      // If the array expression yields a null array, the result of SOME|ALL will be null
+      if (rightComponentType.getSqlTypeName() == SqlTypeName.NULL) {
+        return NULL_EXPR;
+      }
+
+      // The expression generated by this method will look as follows:
+      // final T _quantify_left_value = <left_value>
+      // <Function1|Predicate1> lambda =
+      //    new org.apache.calcite.linq4j.function.<Function1|Predicate1>() {
+      //        public Boolean apply(T el) {
+      //          return <binaryImplementor code>(_quantify_left_value, el);
+      //        }
+      //    }
+      // If the lambda returns java.lang.Boolean then the lambda can return null.
+      // In this case nullableExists or nullableSome should be used:
+      // return org.apache.calcite.runtime.SqlFunctions.<nullableExists|nullableSome>(_list, lambda)
+      // otherwise:
+      // return org.apache.calcite.linq4j.function.Functions.<exists|all>(_list, lambda)
+      BlockBuilder lambdaBuilder = new BlockBuilder();
+      final ParameterExpression leftExpr =
+          Expressions.parameter(left.getType(),
+              translator.getBlockBuilder().newName("_" + getVariableName() + "_left_value"));
+      // left should have final modifier otherwise it can not be passed to lambda
+      translator.getBlockBuilder().add(Expressions.declare(Modifier.FINAL, leftExpr, left));
+      RexNode leftRex = call.getOperands().get(0);
+      final ParameterExpression lambdaArg =
+          Expressions.parameter(translator.typeFactory.getJavaClass(rightComponentType), "el");
+      final RexCall binaryImplementorRexCall =
+          (RexCall) translator.builder.makeCall(binaryOperator, leftRex,
+              translator.builder.makeDynamicParam(rightComponentType, 0));
+      final List<RexToLixTranslator.Result> binaryImplementorArgs =
+          ImmutableList.of(
+              new RexToLixTranslator.Result(
+                  genIsNullStatement(translator, leftExpr), leftExpr),
+              new RexToLixTranslator.Result(
+                  genIsNullStatement(translator, lambdaArg), lambdaArg));
+      final RexToLixTranslator.Result condition =
+          binaryImplementor.implement(translator, binaryImplementorRexCall, binaryImplementorArgs);
+      lambdaBuilder.add(Expressions.return_(null, condition.valueVariable));
+      final FunctionExpression<?> predicate =
+          Expressions.lambda(lambdaBuilder.toBlock(), lambdaArg);
+      return Expressions.call(getMethod(condition.valueVariable.getType(), call.getKind()), right,
+          predicate);
+    }
+
+    private static Method getMethod(Type comparisonReturnType, SqlKind kind) {
+      switch (kind) {
+      case SOME:
+        return Primitive.is(comparisonReturnType)
+            ? BuiltInMethod.COLLECTION_EXISTS.method
+            // if the array contains any null elements and no true comparison result is obtained,
+            // the result of SOME will be null, not false.
+            : BuiltInMethod.COLLECTION_NULLABLE_EXISTS.method;
+      case ALL:
+        return Primitive.is(comparisonReturnType)
+            ? BuiltInMethod.COLLECTION_ALL.method
+            // if the array contains any null elements and no false comparison result is obtained,
+            // the result of ALL will be null, not true.
+            : BuiltInMethod.COLLECTION_NULLABLE_ALL.method;
+      default:
+        throw new IllegalArgumentException("Unknown quantify operator " + kind
+            + ". Only support SOME, ALL.");
+      }
+    }
+  }
+
   /** Implements the {@code SESSION} table function. */
   private static class SessionImplementor implements TableFunctionCallImplementor {
     @Override public Expression implement(RexToLixTranslator translator,
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/RexToLixTranslator.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/RexToLixTranslator.java
index 0e3b4675e0d..2eba9bf112a 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/RexToLixTranslator.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/RexToLixTranslator.java
@@ -50,13 +50,13 @@
 import org.apache.calcite.rex.RexTableInputRef;
 import org.apache.calcite.rex.RexUtil;
 import org.apache.calcite.rex.RexVisitor;
-import org.apache.calcite.runtime.GeoFunctions;
-import org.apache.calcite.runtime.Geometries;
+import org.apache.calcite.runtime.SpatialTypeFunctions;
 import org.apache.calcite.schema.FunctionContext;
 import org.apache.calcite.sql.SqlIntervalQualifier;
 import org.apache.calcite.sql.SqlOperator;
 import org.apache.calcite.sql.SqlWindowTableFunction;
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
+import org.apache.calcite.sql.type.SqlTypeFamily;
 import org.apache.calcite.sql.type.SqlTypeUtil;
 import org.apache.calcite.sql.validate.SqlConformance;
 import org.apache.calcite.util.BuiltInMethod;
@@ -69,6 +69,7 @@
 import com.google.common.collect.ImmutableMap;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
+import org.locationtech.jts.geom.Geometry;
 
 import java.lang.reflect.Constructor;
 import java.lang.reflect.Method;
@@ -79,7 +80,9 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.function.Supplier;
 
+import static org.apache.calcite.linq4j.tree.Expressions.constant;
 import static org.apache.calcite.sql.fun.SqlLibraryOperators.TRANSLATE3;
 import static org.apache.calcite.sql.fun.SqlStdOperatorTable.CASE;
 import static org.apache.calcite.sql.fun.SqlStdOperatorTable.CHAR_LENGTH;
@@ -98,7 +101,7 @@
 public class RexToLixTranslator implements RexVisitor<RexToLixTranslator.Result> {
   public static final Map<Method, SqlOperator> JAVA_TO_SQL_METHOD_MAP =
       ImmutableMap.<Method, SqlOperator>builder()
-          .put(findMethod(String.class, "toUpperCase"), UPPER)
+          .put(BuiltInMethod.STRING_TO_UPPER.method, UPPER)
           .put(BuiltInMethod.SUBSTRING.method, SUBSTRING)
           .put(BuiltInMethod.OCTET_LENGTH.method, OCTET_LENGTH)
           .put(BuiltInMethod.CHAR_LENGTH.method, CHAR_LENGTH)
@@ -143,15 +146,6 @@ public class RexToLixTranslator implements RexVisitor<RexToLixTranslator.Result>
 
   private @Nullable Type currentStorageType;
 
-  private static Method findMethod(
-      Class<?> clazz, String name, Class... parameterTypes) {
-    try {
-      return clazz.getMethod(name, parameterTypes);
-    } catch (NoSuchMethodException e) {
-      throw new RuntimeException(e);
-    }
-  }
-
   private RexToLixTranslator(@Nullable RexProgram program,
       JavaTypeFactory typeFactory,
       Expression root,
@@ -220,14 +214,18 @@ public static Expression translateTableFunction(JavaTypeFactory typeFactory,
       SqlConformance conformance, BlockBuilder list,
       Expression root, RexCall rexCall, Expression inputEnumerable,
       PhysType inputPhysType, PhysType outputPhysType) {
-    return new RexToLixTranslator(null, typeFactory, root, null, list,
-        null, new RexBuilder(typeFactory), conformance, null)
-        .translateTableFunction(rexCall, inputEnumerable, inputPhysType, outputPhysType);
+    final RexToLixTranslator translator =
+        new RexToLixTranslator(null, typeFactory, root, null, list,
+            null, new RexBuilder(typeFactory), conformance, null);
+    return translator
+        .translateTableFunction(rexCall, inputEnumerable, inputPhysType,
+            outputPhysType);
   }
 
   /** Creates a translator for translating aggregate functions. */
   public static RexToLixTranslator forAggregation(JavaTypeFactory typeFactory,
-      BlockBuilder list, @Nullable InputGetter inputGetter, SqlConformance conformance) {
+      BlockBuilder list, @Nullable InputGetter inputGetter,
+      SqlConformance conformance) {
     final ParameterExpression root = DataContext.ROOT;
     return new RexToLixTranslator(null, typeFactory, root, inputGetter, list,
         null, new RexBuilder(typeFactory), conformance, null);
@@ -263,132 +261,164 @@ Expression translate(RexNode expr, RexImpTable.NullAs nullAs,
     return nullAs.handle(translated);
   }
 
+  /**
+   * Used for safe operators that return null if an exception is thrown.
+   */
+  private static Expression expressionHandlingSafe(Expression body, boolean safe) {
+    return safe ? safeExpression(body) : body;
+  }
+
+  private static Expression safeExpression(Expression body) {
+    final ParameterExpression e_ =
+        Expressions.parameter(Exception.class, new BlockBuilder().newName("e"));
+
+    return Expressions.call(
+        Expressions.lambda(
+            Expressions.block(
+                Expressions.tryCatch(
+                    Expressions.return_(null, body),
+                Expressions.catch_(e_,
+                    Expressions.return_(null, constant(null)))))),
+        BuiltInMethod.FUNCTION0_APPLY.method);
+  }
+
   Expression translateCast(
+      RelDataType sourceType,
+      RelDataType targetType,
+      Expression operand,
+      boolean safe) {
+    Expression convert = getConvertExpression(sourceType, targetType, operand);
+    Expression convert2 = checkExpressionPadTruncate(convert, sourceType, targetType);
+    Expression convert3 = expressionHandlingSafe(convert2, safe);
+    return scaleIntervalToNumber(sourceType, targetType, convert3);
+  }
+
+  private Expression getConvertExpression(
       RelDataType sourceType,
       RelDataType targetType,
       Expression operand) {
-    Expression convert = null;
+    final Supplier<Expression> defaultExpression = () ->
+        EnumUtils.convert(operand, typeFactory.getJavaClass(targetType));
+
     switch (targetType.getSqlTypeName()) {
     case ANY:
-      convert = operand;
-      break;
+      return operand;
+
+    case GEOMETRY:
+      switch (sourceType.getSqlTypeName()) {
+      case CHAR:
+      case VARCHAR:
+        return Expressions.call(BuiltInMethod.ST_GEOM_FROM_EWKT.method, operand);
+
+      default:
+        return defaultExpression.get();
+      }
+
     case DATE:
-      convert = translateCastToDate(sourceType, operand);
-      break;
+      return translateCastToDate(sourceType, operand, defaultExpression);
+
     case TIME:
-      convert = translateCastToTime(sourceType, operand);
-      break;
+      return translateCastToTime(sourceType, operand, defaultExpression);
+
     case TIME_WITH_LOCAL_TIME_ZONE:
       switch (sourceType.getSqlTypeName()) {
       case CHAR:
       case VARCHAR:
-        convert =
-            Expressions.call(BuiltInMethod.STRING_TO_TIME_WITH_LOCAL_TIME_ZONE.method, operand);
-        break;
+        return Expressions.call(BuiltInMethod.STRING_TO_TIME_WITH_LOCAL_TIME_ZONE.method,
+            operand);
+
       case TIME:
-        convert = Expressions.call(
+        return Expressions.call(
             BuiltInMethod.TIME_STRING_TO_TIME_WITH_LOCAL_TIME_ZONE.method,
-            RexImpTable.optimize2(
-                operand,
-                Expressions.call(
-                    BuiltInMethod.UNIX_TIME_TO_STRING.method,
+            RexImpTable.optimize2(operand,
+                Expressions.call(BuiltInMethod.UNIX_TIME_TO_STRING.method,
                     operand)),
             Expressions.call(BuiltInMethod.TIME_ZONE.method, root));
-        break;
+
       case TIMESTAMP:
-        convert = Expressions.call(
+        return Expressions.call(
             BuiltInMethod.TIMESTAMP_STRING_TO_TIMESTAMP_WITH_LOCAL_TIME_ZONE.method,
-            RexImpTable.optimize2(
-                operand,
-                Expressions.call(
-                    BuiltInMethod.UNIX_TIMESTAMP_TO_STRING.method,
+            RexImpTable.optimize2(operand,
+                Expressions.call(BuiltInMethod.UNIX_TIMESTAMP_TO_STRING.method,
                     operand)),
             Expressions.call(BuiltInMethod.TIME_ZONE.method, root));
-        break;
+
       case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
-        convert = RexImpTable.optimize2(
-            operand,
+        return RexImpTable.optimize2(operand,
             Expressions.call(
-                BuiltInMethod.TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_TIME_WITH_LOCAL_TIME_ZONE.method,
+                BuiltInMethod
+                    .TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_TIME_WITH_LOCAL_TIME_ZONE
+                    .method,
                 operand));
-        break;
+
       default:
-        break;
+        return defaultExpression.get();
       }
-      break;
+
     case TIMESTAMP:
       switch (sourceType.getSqlTypeName()) {
       case CHAR:
       case VARCHAR:
-        convert =
-            Expressions.call(BuiltInMethod.STRING_TO_TIMESTAMP.method, operand);
-        break;
+        return Expressions.call(BuiltInMethod.STRING_TO_TIMESTAMP.method,
+            operand);
+
       case DATE:
-        convert = Expressions.multiply(
-            Expressions.convert_(operand, long.class),
+        return Expressions.multiply(Expressions.convert_(operand, long.class),
             Expressions.constant(DateTimeUtils.MILLIS_PER_DAY));
-        break;
+
       case TIME:
-        convert =
-            Expressions.add(
-                Expressions.multiply(
-                    Expressions.convert_(
-                        Expressions.call(BuiltInMethod.CURRENT_DATE.method, root),
-                        long.class),
-                    Expressions.constant(DateTimeUtils.MILLIS_PER_DAY)),
-                Expressions.convert_(operand, long.class));
-        break;
+        return Expressions.add(
+            Expressions.multiply(
+                Expressions.convert_(
+                    Expressions.call(BuiltInMethod.CURRENT_DATE.method, root),
+                    long.class),
+                Expressions.constant(DateTimeUtils.MILLIS_PER_DAY)),
+            Expressions.convert_(operand, long.class));
+
       case TIME_WITH_LOCAL_TIME_ZONE:
-        convert = RexImpTable.optimize2(
-            operand,
+        return RexImpTable.optimize2(operand,
             Expressions.call(
                 BuiltInMethod.TIME_WITH_LOCAL_TIME_ZONE_TO_TIMESTAMP.method,
-                Expressions.call(
-                    BuiltInMethod.UNIX_DATE_TO_STRING.method,
+                Expressions.call(BuiltInMethod.UNIX_DATE_TO_STRING.method,
                     Expressions.call(BuiltInMethod.CURRENT_DATE.method, root)),
                 operand,
                 Expressions.call(BuiltInMethod.TIME_ZONE.method, root)));
-        break;
+
       case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
-        convert = RexImpTable.optimize2(
-            operand,
+        return RexImpTable.optimize2(operand,
             Expressions.call(
                 BuiltInMethod.TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_TIMESTAMP.method,
                 operand,
                 Expressions.call(BuiltInMethod.TIME_ZONE.method, root)));
-        break;
+
       default:
-        break;
+        return defaultExpression.get();
       }
-      break;
+
     case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
       switch (sourceType.getSqlTypeName()) {
       case CHAR:
       case VARCHAR:
-        convert =
-            Expressions.call(
-                BuiltInMethod.STRING_TO_TIMESTAMP_WITH_LOCAL_TIME_ZONE.method,
-                operand);
-        break;
+        return Expressions.call(
+            BuiltInMethod.STRING_TO_TIMESTAMP_WITH_LOCAL_TIME_ZONE.method,
+            operand);
+
       case DATE:
-        convert = Expressions.call(
+        return Expressions.call(
             BuiltInMethod.TIMESTAMP_STRING_TO_TIMESTAMP_WITH_LOCAL_TIME_ZONE.method,
-            RexImpTable.optimize2(
-                operand,
+            RexImpTable.optimize2(operand,
                 Expressions.call(
                     BuiltInMethod.UNIX_TIMESTAMP_TO_STRING.method,
                     Expressions.multiply(
                         Expressions.convert_(operand, long.class),
                         Expressions.constant(DateTimeUtils.MILLIS_PER_DAY)))),
             Expressions.call(BuiltInMethod.TIME_ZONE.method, root));
-        break;
+
       case TIME:
-        convert = Expressions.call(
+        return Expressions.call(
             BuiltInMethod.TIMESTAMP_STRING_TO_TIMESTAMP_WITH_LOCAL_TIME_ZONE.method,
-            RexImpTable.optimize2(
-                operand,
-                Expressions.call(
-                    BuiltInMethod.UNIX_TIMESTAMP_TO_STRING.method,
+            RexImpTable.optimize2(operand,
+                Expressions.call(BuiltInMethod.UNIX_TIMESTAMP_TO_STRING.method,
                     Expressions.add(
                         Expressions.multiply(
                             Expressions.convert_(
@@ -397,95 +427,83 @@ Expression translateCast(
                             Expressions.constant(DateTimeUtils.MILLIS_PER_DAY)),
                         Expressions.convert_(operand, long.class)))),
             Expressions.call(BuiltInMethod.TIME_ZONE.method, root));
-        break;
+
       case TIME_WITH_LOCAL_TIME_ZONE:
-        convert = RexImpTable.optimize2(
-            operand,
+        return RexImpTable.optimize2(operand,
             Expressions.call(
-                BuiltInMethod.TIME_WITH_LOCAL_TIME_ZONE_TO_TIMESTAMP_WITH_LOCAL_TIME_ZONE.method,
-                Expressions.call(
-                    BuiltInMethod.UNIX_DATE_TO_STRING.method,
+                BuiltInMethod
+                    .TIME_WITH_LOCAL_TIME_ZONE_TO_TIMESTAMP_WITH_LOCAL_TIME_ZONE
+                    .method,
+                Expressions.call(BuiltInMethod.UNIX_DATE_TO_STRING.method,
                     Expressions.call(BuiltInMethod.CURRENT_DATE.method, root)),
                 operand));
-        break;
+
       case TIMESTAMP:
-        convert = Expressions.call(
+        return Expressions.call(
             BuiltInMethod.TIMESTAMP_STRING_TO_TIMESTAMP_WITH_LOCAL_TIME_ZONE.method,
-            RexImpTable.optimize2(
-                operand,
+            RexImpTable.optimize2(operand,
                 Expressions.call(
                     BuiltInMethod.UNIX_TIMESTAMP_TO_STRING.method,
                     operand)),
             Expressions.call(BuiltInMethod.TIME_ZONE.method, root));
-        break;
+
       default:
-        break;
+        return defaultExpression.get();
       }
-      break;
+
     case BOOLEAN:
       switch (sourceType.getSqlTypeName()) {
       case CHAR:
       case VARCHAR:
-        convert = Expressions.call(
-            BuiltInMethod.STRING_TO_BOOLEAN.method,
-            operand);
-        break;
+        return Expressions.call(BuiltInMethod.STRING_TO_BOOLEAN.method, operand);
+
       default:
-        break;
+        return defaultExpression.get();
       }
-      break;
+
     case CHAR:
     case VARCHAR:
       final SqlIntervalQualifier interval =
           sourceType.getIntervalQualifier();
       switch (sourceType.getSqlTypeName()) {
       case DATE:
-        convert = RexImpTable.optimize2(
-            operand,
-            Expressions.call(
-                BuiltInMethod.UNIX_DATE_TO_STRING.method,
+        return RexImpTable.optimize2(operand,
+            Expressions.call(BuiltInMethod.UNIX_DATE_TO_STRING.method,
                 operand));
-        break;
+
       case TIME:
-        convert = RexImpTable.optimize2(
-            operand,
-            Expressions.call(
-                BuiltInMethod.UNIX_TIME_TO_STRING.method,
+        return RexImpTable.optimize2(operand,
+            Expressions.call(BuiltInMethod.UNIX_TIME_TO_STRING.method,
                 operand));
-        break;
+
       case TIME_WITH_LOCAL_TIME_ZONE:
-        convert = RexImpTable.optimize2(
-            operand,
+        return RexImpTable.optimize2(operand,
             Expressions.call(
                 BuiltInMethod.TIME_WITH_LOCAL_TIME_ZONE_TO_STRING.method,
                 operand,
                 Expressions.call(BuiltInMethod.TIME_ZONE.method, root)));
-        break;
+
       case TIMESTAMP:
-        convert = RexImpTable.optimize2(
-            operand,
-            Expressions.call(
-                BuiltInMethod.UNIX_TIMESTAMP_TO_STRING.method,
+        return RexImpTable.optimize2(operand,
+            Expressions.call(BuiltInMethod.UNIX_TIMESTAMP_TO_STRING.method,
                 operand));
-        break;
+
       case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
-        convert = RexImpTable.optimize2(
-            operand,
+        return RexImpTable.optimize2(operand,
             Expressions.call(
                 BuiltInMethod.TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_STRING.method,
                 operand,
                 Expressions.call(BuiltInMethod.TIME_ZONE.method, root)));
-        break;
+
       case INTERVAL_YEAR:
       case INTERVAL_YEAR_MONTH:
       case INTERVAL_MONTH:
-        convert = RexImpTable.optimize2(
-            operand,
-            Expressions.call(
-                BuiltInMethod.INTERVAL_YEAR_MONTH_TO_STRING.method,
+        return RexImpTable.optimize2(operand,
+            Expressions.call(BuiltInMethod.INTERVAL_YEAR_MONTH_TO_STRING.method,
                 operand,
-                Expressions.constant(requireNonNull(interval, "interval").timeUnitRange)));
-        break;
+                Expressions.constant(
+                    requireNonNull(interval, "interval").timeUnitRange)));
+
       case INTERVAL_DAY:
       case INTERVAL_DAY_HOUR:
       case INTERVAL_DAY_MINUTE:
@@ -496,33 +514,33 @@ Expression translateCast(
       case INTERVAL_MINUTE:
       case INTERVAL_MINUTE_SECOND:
       case INTERVAL_SECOND:
-        convert = RexImpTable.optimize2(
-            operand,
-            Expressions.call(
-                BuiltInMethod.INTERVAL_DAY_TIME_TO_STRING.method,
+        return RexImpTable.optimize2(operand,
+            Expressions.call(BuiltInMethod.INTERVAL_DAY_TIME_TO_STRING.method,
                 operand,
-                Expressions.constant(requireNonNull(interval, "interval").timeUnitRange),
+                Expressions.constant(
+                    requireNonNull(interval, "interval").timeUnitRange),
                 Expressions.constant(
                     interval.getFractionalSecondPrecision(
                         typeFactory.getTypeSystem()))));
-        break;
+
       case BOOLEAN:
-        convert = RexImpTable.optimize2(
-            operand,
-            Expressions.call(
-                BuiltInMethod.BOOLEAN_TO_STRING.method,
+        return RexImpTable.optimize2(operand,
+            Expressions.call(BuiltInMethod.BOOLEAN_TO_STRING.method,
                 operand));
-        break;
+
       default:
-        break;
+        return defaultExpression.get();
       }
-      break;
+
     default:
-      break;
-    }
-    if (convert == null) {
-      convert = EnumUtils.convert(operand, typeFactory.getJavaClass(targetType));
+      return defaultExpression.get();
     }
+  }
+
+  private static Expression checkExpressionPadTruncate(
+      Expression operand,
+      RelDataType sourceType,
+      RelDataType targetType) {
     // Going from anything to CHAR(n) or VARCHAR(n), make sure value is no
     // longer than n.
     boolean pad = false;
@@ -535,51 +553,51 @@ Expression translateCast(
     case VARCHAR:
     case VARBINARY:
       final int targetPrecision = targetType.getPrecision();
-      if (targetPrecision >= 0) {
-        switch (sourceType.getSqlTypeName()) {
-        case CHAR:
-        case VARCHAR:
-        case BINARY:
-        case VARBINARY:
-          // If this is a widening cast, no need to truncate.
-          final int sourcePrecision = sourceType.getPrecision();
-          if (SqlTypeUtil.comparePrecision(sourcePrecision, targetPrecision)
-              <= 0) {
-            truncate = false;
-          }
-          // If this is a widening cast, no need to pad.
-          if (SqlTypeUtil.comparePrecision(sourcePrecision, targetPrecision)
-              >= 0) {
-            pad = false;
-          }
-          // fall through
-        default:
-          if (truncate || pad) {
-            convert =
-                Expressions.call(
-                    pad
-                        ? BuiltInMethod.TRUNCATE_OR_PAD.method
-                        : BuiltInMethod.TRUNCATE.method,
-                    convert,
-                    Expressions.constant(targetPrecision));
-          }
+      if (targetPrecision < 0) {
+        return operand;
+      }
+      switch (sourceType.getSqlTypeName()) {
+      case CHAR:
+      case VARCHAR:
+      case BINARY:
+      case VARBINARY:
+        // If this is a widening cast, no need to truncate.
+        final int sourcePrecision = sourceType.getPrecision();
+        if (SqlTypeUtil.comparePrecision(sourcePrecision, targetPrecision)
+            <= 0) {
+          truncate = false;
+        }
+        // If this is a widening cast, no need to pad.
+        if (SqlTypeUtil.comparePrecision(sourcePrecision, targetPrecision)
+            >= 0) {
+          pad = false;
+        }
+        // fall through
+      default:
+        if (truncate || pad) {
+          final Method method =
+              pad ? BuiltInMethod.TRUNCATE_OR_PAD.method
+                  : BuiltInMethod.TRUNCATE.method;
+          return Expressions.call(method, operand,
+              Expressions.constant(targetPrecision));
         }
+        return operand;
       }
-      break;
+
+      // Checkstyle thinks that the previous branch should have a break, but it
+      // is mistaken.
+      // CHECKSTYLE: IGNORE 1
     case TIMESTAMP:
       int targetScale = targetType.getScale();
       if (targetScale == RelDataType.SCALE_NOT_SPECIFIED) {
         targetScale = 0;
       }
       if (targetScale < sourceType.getScale()) {
-        convert =
-            Expressions.call(
-                BuiltInMethod.ROUND_LONG.method,
-                convert,
-                Expressions.constant(
-                    (long) Math.pow(10, 3 - targetScale)));
+        return Expressions.call(BuiltInMethod.ROUND_LONG.method, operand,
+            Expressions.constant((long) Math.pow(10, 3 - targetScale)));
       }
-      break;
+      return operand;
+
     case INTERVAL_YEAR:
     case INTERVAL_YEAR_MONTH:
     case INTERVAL_MONTH:
@@ -593,88 +611,82 @@ Expression translateCast(
     case INTERVAL_MINUTE:
     case INTERVAL_MINUTE_SECOND:
     case INTERVAL_SECOND:
-      switch (requireNonNull(sourceType.getSqlTypeName().getFamily(),
-          () -> "null SqlTypeFamily for " + sourceType + ", SqlTypeName "
-              + sourceType.getSqlTypeName())) {
+      final SqlTypeFamily family =
+          requireNonNull(sourceType.getSqlTypeName().getFamily(),
+              () -> "null SqlTypeFamily for " + sourceType + ", SqlTypeName "
+                  + sourceType.getSqlTypeName());
+      switch (family) {
       case NUMERIC:
-        final BigDecimal multiplier = targetType.getSqlTypeName().getEndUnit().multiplier;
+        final BigDecimal multiplier =
+            targetType.getSqlTypeName().getEndUnit().multiplier;
         final BigDecimal divider = BigDecimal.ONE;
-        convert = RexImpTable.multiplyDivide(convert, multiplier, divider);
-        break;
+        return RexImpTable.multiplyDivide(operand, multiplier, divider);
+
       default:
-        break;
+        return operand;
       }
-      break;
+
     default:
-      break;
+      return operand;
     }
-    return scaleIntervalToNumber(sourceType, targetType, convert);
   }
 
-  private @Nullable Expression translateCastToTime(RelDataType sourceType, Expression operand) {
-    Expression convert = null;
+  private Expression translateCastToTime(RelDataType sourceType,
+      Expression operand, Supplier<Expression> defaultExpression) {
     switch (sourceType.getSqlTypeName()) {
     case CHAR:
     case VARCHAR:
-      convert =
-          Expressions.call(BuiltInMethod.STRING_TO_TIME.method, operand);
-      break;
+      return Expressions.call(BuiltInMethod.STRING_TO_TIME.method, operand);
+
     case TIME_WITH_LOCAL_TIME_ZONE:
-      convert = RexImpTable.optimize2(
-          operand,
+      return RexImpTable.optimize2(operand,
           Expressions.call(
               BuiltInMethod.TIME_WITH_LOCAL_TIME_ZONE_TO_TIME.method,
               operand,
               Expressions.call(BuiltInMethod.TIME_ZONE.method, root)));
-      break;
+
     case TIMESTAMP:
-      convert = Expressions.convert_(
-          Expressions.call(
-              BuiltInMethod.FLOOR_MOD.method,
+      return Expressions.convert_(
+          Expressions.call(BuiltInMethod.FLOOR_MOD.method,
               operand,
               Expressions.constant(DateTimeUtils.MILLIS_PER_DAY)),
           int.class);
-      break;
+
     case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
-      convert = RexImpTable.optimize2(
-          operand,
+      return RexImpTable.optimize2(operand,
           Expressions.call(
               BuiltInMethod.TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_TIME.method,
               operand,
               Expressions.call(BuiltInMethod.TIME_ZONE.method, root)));
-      break;
+
     default:
-      break;
+      return defaultExpression.get();
     }
-    return convert;
   }
 
-  private @Nullable Expression translateCastToDate(RelDataType sourceType, Expression operand) {
-    Expression convert = null;
+  private Expression translateCastToDate(RelDataType sourceType,
+      Expression operand, Supplier<Expression> defaultExpression) {
     switch (sourceType.getSqlTypeName()) {
     case CHAR:
     case VARCHAR:
-      convert =
-          Expressions.call(BuiltInMethod.STRING_TO_DATE.method, operand);
-      break;
+      return Expressions.call(BuiltInMethod.STRING_TO_DATE.method, operand);
+
     case TIMESTAMP:
-      convert = Expressions.convert_(
+      return Expressions.convert_(
           Expressions.call(BuiltInMethod.FLOOR_DIV.method,
               operand, Expressions.constant(DateTimeUtils.MILLIS_PER_DAY)),
           int.class);
-      break;
+
     case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
-      convert = RexImpTable.optimize2(
-          operand,
+      return RexImpTable.optimize2(operand,
           Expressions.call(
               BuiltInMethod.TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_DATE.method,
               operand,
               Expressions.call(BuiltInMethod.TIME_ZONE.method, root)));
-      break;
+
     default:
-      break;
+      return defaultExpression.get();
     }
-    return convert;
   }
 
   /**
@@ -691,8 +703,8 @@ Expression translateCast(
    */
   Expression handleMethodCheckedExceptions(Expression callExpr) {
     // Try statement
-    ParameterExpression methodCall = Expressions.parameter(
-        callExpr.getType(), list.newName("method_call"));
+    ParameterExpression methodCall =
+        Expressions.parameter(callExpr.getType(), list.newName("method_call"));
     list.add(Expressions.declare(Modifier.FINAL, methodCall, null));
     Statement st = Expressions.statement(Expressions.assign(methodCall, callExpr));
     // Catch Block, wrap checked exception in unchecked exception
@@ -802,14 +814,16 @@ public static Expression translateLiteral(
               literal.getValueAs(byte[].class),
               byte[].class));
     case GEOMETRY:
-      final Geometries.Geom geom = requireNonNull(literal.getValueAs(Geometries.Geom.class),
-          () -> "getValueAs(Geometries.Geom) for " + literal);
-      final String wkt = GeoFunctions.ST_AsWKT(geom);
-      return Expressions.call(null, BuiltInMethod.ST_GEOM_FROM_TEXT.method,
+      final Geometry geom =
+          requireNonNull(literal.getValueAs(Geometry.class),
+              () -> "getValueAs(Geometries.Geom) for " + literal);
+      final String wkt = SpatialTypeFunctions.ST_AsWKT(geom);
+      return Expressions.call(null, BuiltInMethod.ST_GEOM_FROM_EWKT.method,
           Expressions.constant(wkt));
     case SYMBOL:
-      value2 = requireNonNull(literal.getValueAs(Enum.class),
-          () -> "getValueAs(Enum.class) for " + literal);
+      value2 =
+          requireNonNull(literal.getValueAs(Enum.class),
+              () -> "getValueAs(Enum.class) for " + literal);
       javaClass = value2.getClass();
       break;
     default:
@@ -1011,8 +1025,9 @@ private static Expression scaleIntervalToNumber(
     }
     // Generate one line of code to get the input, e.g.,
     // "final Employee current =(Employee) inputEnumerator.current();"
-    final Expression valueExpression = requireNonNull(inputGetter, "inputGetter").field(
-        list, inputRef.getIndex(), currentStorageType);
+    final Expression valueExpression =
+        requireNonNull(inputGetter, "inputGetter")
+            .field(list, inputRef.getIndex(), currentStorageType);
 
     // Generate one line of code for the value of RexInputRef, e.g.,
     // "final Integer input_value = current.commission;"
@@ -1082,8 +1097,8 @@ private static Expression scaleIntervalToNumber(
     // "final boolean literal_isNull = false;"
     final Expression isNullExpression =
         literal.isNull() ? RexImpTable.TRUE_EXPR : RexImpTable.FALSE_EXPR;
-    final ParameterExpression isNullVariable = Expressions.parameter(
-        Boolean.TYPE, list.newName("literal_isNull"));
+    final ParameterExpression isNullVariable =
+        Expressions.parameter(Boolean.TYPE, list.newName("literal_isNull"));
     list.add(Expressions.declare(Modifier.FINAL, isNullVariable, isNullExpression));
 
     // Maintain the map from valueVariable (ParameterExpression) to real Expression
@@ -1198,8 +1213,8 @@ private static Expression implementCallOperand2(final RexNode operand,
   private Result implementPrev(RexCall call) {
     final RexNode node = call.getOperands().get(0);
     final RexNode offset = call.getOperands().get(1);
-    final Expression offs = Expressions.multiply(translate(offset),
-            Expressions.constant(-1));
+    final Expression offs =
+        Expressions.multiply(translate(offset), Expressions.constant(-1));
     requireNonNull((EnumerableMatch.PrevInputGetter) inputGetter, "inputGetter")
         .setOffset(offs);
     return node.accept(this);
@@ -1260,14 +1275,17 @@ private Result implementCaseWhen(RexCall call) {
    *      }
    * }</pre></blockquote>
    */
-  private static void implementRecursively(final RexToLixTranslator currentTranslator,
-      final List<RexNode> operandList, final ParameterExpression valueVariable, int pos) {
-    final BlockBuilder currentBlockBuilder = currentTranslator.getBlockBuilder();
-    final List<@Nullable Type> storageTypes = EnumUtils.internalTypes(operandList);
+  private static void implementRecursively(RexToLixTranslator currentTranslator,
+      List<RexNode> operandList, ParameterExpression valueVariable, int pos) {
+    final BlockBuilder currentBlockBuilder =
+        currentTranslator.getBlockBuilder();
+    final List<@Nullable Type> storageTypes =
+        EnumUtils.internalTypes(operandList);
     // [ELSE] clause
     if (pos == operandList.size() - 1) {
-      Expression res = implementCallOperand2(operandList.get(pos),
-          storageTypes.get(pos), currentTranslator);
+      Expression res =
+          implementCallOperand2(operandList.get(pos), storageTypes.get(pos),
+              currentTranslator);
       currentBlockBuilder.add(
           Expressions.statement(
               Expressions.assign(valueVariable,
@@ -1276,19 +1294,21 @@ private static void implementRecursively(final RexToLixTranslator currentTransla
     }
     // Condition code: !a_isNull && a_value
     final RexNode testerNode = operandList.get(pos);
-    final Result testerResult = implementCallOperand(testerNode,
-        storageTypes.get(pos), currentTranslator);
-    final Expression tester = Expressions.andAlso(
-        Expressions.not(testerResult.isNullVariable),
-        testerResult.valueVariable);
+    final Result testerResult =
+        implementCallOperand(testerNode, storageTypes.get(pos),
+            currentTranslator);
+    final Expression tester =
+        Expressions.andAlso(Expressions.not(testerResult.isNullVariable),
+            testerResult.valueVariable);
     // Code for {if} branch
     final RexNode ifTrueNode = operandList.get(pos + 1);
     final BlockBuilder ifTrueBlockBuilder =
         new BlockBuilder(true, currentBlockBuilder);
     final RexToLixTranslator ifTrueTranslator =
         currentTranslator.setBlock(ifTrueBlockBuilder);
-    final Expression ifTrueRes = implementCallOperand2(ifTrueNode,
-        storageTypes.get(pos + 1), ifTrueTranslator);
+    final Expression ifTrueRes =
+        implementCallOperand2(ifTrueNode, storageTypes.get(pos + 1),
+            ifTrueTranslator);
     // Assign the value: case_when_value = ifTrueRes
     ifTrueBlockBuilder.add(
         Expressions.statement(
@@ -1312,7 +1332,7 @@ private static void implementRecursively(final RexToLixTranslator currentTransla
         Expressions.ifThenElse(tester, ifTrue, ifFalse));
   }
 
-  private Result toInnerStorageType(final Result result, final Type storageType) {
+  private Result toInnerStorageType(Result result, Type storageType) {
     final Expression valueExpression =
         EnumUtils.toInternal(result.valueVariable, storageType);
     if (valueExpression.equals(result.valueVariable)) {
@@ -1328,29 +1348,35 @@ private Result toInnerStorageType(final Result result, final Type storageType) {
   }
 
   @Override public Result visitDynamicParam(RexDynamicParam dynamicParam) {
-    final Pair<RexNode, @Nullable Type> key = Pair.of(dynamicParam, currentStorageType);
+    final Pair<RexNode, @Nullable Type> key =
+        Pair.of(dynamicParam, currentStorageType);
     if (rexWithStorageTypeResultMap.containsKey(key)) {
       return rexWithStorageTypeResultMap.get(key);
     }
     final Type storageType = currentStorageType != null
         ? currentStorageType : typeFactory.getJavaClass(dynamicParam.getType());
-    final Expression valueExpression = EnumUtils.convert(
-        Expressions.call(root, BuiltInMethod.DATA_CONTEXT_GET.method,
-            Expressions.constant("?" + dynamicParam.getIndex())),
-        storageType);
+    final Expression valueExpression =
+        EnumUtils.convert(
+            Expressions.call(root, BuiltInMethod.DATA_CONTEXT_GET.method,
+                Expressions.constant("?" + dynamicParam.getIndex())),
+            storageType);
     final ParameterExpression valueVariable =
-        Expressions.parameter(valueExpression.getType(), list.newName("value_dynamic_param"));
+        Expressions.parameter(valueExpression.getType(),
+            list.newName("value_dynamic_param"));
     list.add(Expressions.declare(Modifier.FINAL, valueVariable, valueExpression));
     final ParameterExpression isNullVariable =
         Expressions.parameter(Boolean.TYPE, list.newName("isNull_dynamic_param"));
-    list.add(Expressions.declare(Modifier.FINAL, isNullVariable, checkNull(valueVariable)));
+    list.add(
+        Expressions.declare(Modifier.FINAL, isNullVariable,
+            checkNull(valueVariable)));
     final Result result = new Result(isNullVariable, valueVariable);
     rexWithStorageTypeResultMap.put(key, result);
     return result;
   }
 
   @Override public Result visitFieldAccess(RexFieldAccess fieldAccess) {
-    final Pair<RexNode, @Nullable Type> key = Pair.of(fieldAccess, currentStorageType);
+    final Pair<RexNode, @Nullable Type> key =
+        Pair.of(fieldAccess, currentStorageType);
     if (rexWithStorageTypeResultMap.containsKey(key)) {
       return rexWithStorageTypeResultMap.get(key);
     }
@@ -1365,19 +1391,20 @@ private Result toInnerStorageType(final Result result, final Type storageType) {
       }
       final RexToLixTranslator.InputGetter getter =
           correlates.apply(((RexCorrelVariable) target).getName());
-      final Expression input = getter.field(
-          list, fieldIndex, currentStorageType);
+      final Expression input =
+          getter.field(list, fieldIndex, currentStorageType);
       final Expression condition = checkNull(input);
       final ParameterExpression valueVariable =
           Expressions.parameter(input.getType(), list.newName("corInp_value"));
       list.add(Expressions.declare(Modifier.FINAL, valueVariable, input));
       final ParameterExpression isNullVariable =
           Expressions.parameter(Boolean.TYPE, list.newName("corInp_isNull"));
-      final Expression isNullExpression = Expressions.condition(
-          condition,
-          RexImpTable.TRUE_EXPR,
-          checkNull(valueVariable));
-      list.add(Expressions.declare(Modifier.FINAL, isNullVariable, isNullExpression));
+      final Expression isNullExpression =
+          Expressions.condition(condition,
+              RexImpTable.TRUE_EXPR,
+              checkNull(valueVariable));
+      list.add(
+          Expressions.declare(Modifier.FINAL, isNullVariable, isNullExpression));
       final Result result1 = new Result(isNullVariable, valueVariable);
       rexWithStorageTypeResultMap.put(key, result1);
       return result1;
@@ -1386,9 +1413,10 @@ private Result toInnerStorageType(final Result result, final Type storageType) {
           builder.makeLiteral(fieldIndex, typeFactory.createType(int.class), true);
       RexNode rxName =
           builder.makeLiteral(fieldName, typeFactory.createType(String.class), true);
-      RexCall accessCall = (RexCall) builder.makeCall(
-          fieldAccess.getType(), SqlStdOperatorTable.STRUCT_ACCESS,
-          ImmutableList.of(target, rxIndex, rxName));
+      RexCall accessCall =
+          (RexCall) builder.makeCall(fieldAccess.getType(),
+              SqlStdOperatorTable.STRUCT_ACCESS,
+              ImmutableList.of(target, rxIndex, rxName));
       final Result result2 = accessCall.accept(this);
       rexWithStorageTypeResultMap.put(key, result2);
       return result2;
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/StrictAggImplementor.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/StrictAggImplementor.java
index cc07a30a2b5..105c8ac9c60 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/StrictAggImplementor.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/StrictAggImplementor.java
@@ -165,13 +165,14 @@ protected abstract void implementNotNullAdd(AggContext info,
     String tmpName = result.accumulator().isEmpty()
         ? "ar"
         : (result.accumulator().get(0) + "$Res");
-    ParameterExpression res = Expressions.parameter(0, info.returnType(),
-        result.currentBlock().newName(tmpName));
+    ParameterExpression res =
+        Expressions.parameter(0, info.returnType(),
+            result.currentBlock().newName(tmpName));
 
     List<Expression> acc = result.accumulator();
     final BlockBuilder thenBlock = result.nestBlock();
-    Expression nonNull = EnumUtils.convert(
-        implementNotNullResult(info, result), info.returnType());
+    Expression nonNull =
+        EnumUtils.convert(implementNotNullResult(info, result), info.returnType());
     result.exitBlock();
     thenBlock.add(Expressions.statement(Expressions.assign(res, nonNull)));
     BlockStatement thenBranch = thenBlock.toBlock();
diff --git a/core/src/main/java/org/apache/calcite/adapter/java/ReflectiveSchema.java b/core/src/main/java/org/apache/calcite/adapter/java/ReflectiveSchema.java
index cec684e03c9..ba1f9f70fa8 100644
--- a/core/src/main/java/org/apache/calcite/adapter/java/ReflectiveSchema.java
+++ b/core/src/main/java/org/apache/calcite/adapter/java/ReflectiveSchema.java
@@ -141,11 +141,11 @@ private Map<String, Table> createTableMap() {
           // This enables to keep the same Statistics.of below
           referentialConstraints = ImmutableList.of();
         }
-        table.statistic = Statistics.of(
-            ImmutableList.copyOf(
-                Iterables.concat(
-                    referentialConstraints,
-                    Collections.singleton(rc))));
+        table.statistic =
+            Statistics.of(
+                ImmutableList.copyOf(
+                    Iterables.concat(referentialConstraints,
+                        Collections.singleton(rc))));
       }
     }
     return tableMap;
@@ -362,8 +362,8 @@ private static class MethodTableMacro extends ReflectiveFunctionBase
 
     @Override public TranslatableTable apply(final List<? extends @Nullable Object> arguments) {
       try {
-        final Object o = requireNonNull(
-            method.invoke(schema.getTarget(), arguments.toArray()),
+        final Object o = method.invoke(schema.getTarget(), arguments.toArray());
+        requireNonNull(o,
             () -> "method " + method + " returned null for arguments " + arguments);
         return (TranslatableTable) o;
       } catch (IllegalAccessException | InvocationTargetException e) {
@@ -400,9 +400,9 @@ private static class FieldTable<T> extends ReflectiveTable {
 
     @Override public Expression getExpression(SchemaPlus schema,
         String tableName, Class clazz) {
-      ReflectiveSchema reflectiveSchema = requireNonNull(
-          schema.unwrap(ReflectiveSchema.class),
-          () -> "schema.unwrap(ReflectiveSchema.class) for " + schema);
+      ReflectiveSchema reflectiveSchema =
+          requireNonNull(schema.unwrap(ReflectiveSchema.class),
+              () -> "schema.unwrap(ReflectiveSchema.class) for " + schema);
       return Expressions.field(
           reflectiveSchema.getTargetExpression(
               schema.getParentSchema(), schema.getName()), field);
diff --git a/core/src/main/java/org/apache/calcite/adapter/jdbc/JdbcCatalogSchema.java b/core/src/main/java/org/apache/calcite/adapter/jdbc/JdbcCatalogSchema.java
index eeb347d963f..cd1e8cf51ba 100644
--- a/core/src/main/java/org/apache/calcite/adapter/jdbc/JdbcCatalogSchema.java
+++ b/core/src/main/java/org/apache/calcite/adapter/jdbc/JdbcCatalogSchema.java
@@ -111,9 +111,9 @@ private SubSchemaMap computeSubSchemaMap() {
              connection.getMetaData().getSchemas(catalog, null)) {
       defaultSchemaName = connection.getSchema();
       while (resultSet.next()) {
-        final String schemaName = requireNonNull(
-            resultSet.getString(1),
-            () -> "got null schemaName from the database");
+        final String schemaName =
+            requireNonNull(resultSet.getString(1),
+                "got null schemaName from the database");
         builder.put(schemaName,
             new JdbcSchema(dataSource, dialect, convention, catalog, schemaName));
       }
diff --git a/core/src/main/java/org/apache/calcite/adapter/jdbc/JdbcRules.java b/core/src/main/java/org/apache/calcite/adapter/jdbc/JdbcRules.java
index 37fb747a87d..9c60fd15b4b 100644
--- a/core/src/main/java/org/apache/calcite/adapter/jdbc/JdbcRules.java
+++ b/core/src/main/java/org/apache/calcite/adapter/jdbc/JdbcRules.java
@@ -73,6 +73,7 @@
 
 import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.slf4j.Logger;
@@ -96,7 +97,9 @@ private JdbcRules() {
   protected static final Logger LOGGER = CalciteTrace.getPlannerTracer();
 
   static final RelFactories.ProjectFactory PROJECT_FACTORY =
-      (input, hints, projects, fieldNames) -> {
+      (input, hints, projects, fieldNames, variablesSet) -> {
+        Preconditions.checkArgument(variablesSet.isEmpty(),
+            "JdbcProject does not allow variables");
         final RelOptCluster cluster = input.getCluster();
         final RelDataType rowType =
             RexUtil.createStructType(cluster.getTypeFactory(), projects,
@@ -116,8 +119,9 @@ private JdbcRules() {
   static final RelFactories.JoinFactory JOIN_FACTORY =
       (left, right, hints, condition, variablesSet, joinType, semiJoinDone) -> {
         final RelOptCluster cluster = left.getCluster();
-        final RelTraitSet traitSet = cluster.traitSetOf(
-            requireNonNull(left.getConvention(), "left.getConvention()"));
+        final RelTraitSet traitSet =
+            cluster.traitSetOf(
+                requireNonNull(left.getConvention(), "left.getConvention()"));
         try {
           return new JdbcJoin(cluster, traitSet, left, right, condition,
               variablesSet, joinType);
@@ -149,8 +153,9 @@ private JdbcRules() {
   public static final RelFactories.AggregateFactory AGGREGATE_FACTORY =
       (input, hints, groupSet, groupSets, aggCalls) -> {
         final RelOptCluster cluster = input.getCluster();
-        final RelTraitSet traitSet = cluster.traitSetOf(
-            requireNonNull(input.getConvention(), "input.getConvention()"));
+        final RelTraitSet traitSet =
+            cluster.traitSetOf(
+                requireNonNull(input.getConvention(), "input.getConvention()"));
         try {
           return new JdbcAggregate(cluster, traitSet, input, groupSet,
               groupSets, aggCalls);
@@ -170,8 +175,9 @@ private JdbcRules() {
       (kind, inputs, all) -> {
         RelNode input = inputs.get(0);
         RelOptCluster cluster = input.getCluster();
-        final RelTraitSet traitSet = cluster.traitSetOf(
-            requireNonNull(input.getConvention(), "input.getConvention()"));
+        final RelTraitSet traitSet =
+            cluster.traitSetOf(
+                requireNonNull(input.getConvention(), "input.getConvention()"));
         switch (kind) {
         case UNION:
           return new JdbcUnion(cluster, traitSet, inputs, all);
@@ -331,6 +337,9 @@ protected JdbcJoinRule(Config config) {
     private static boolean canJoinOnCondition(RexNode node) {
       final List<RexNode> operands;
       switch (node.getKind()) {
+      case LITERAL:
+        // literal on a join condition would be TRUE or FALSE
+        return true;
       case AND:
       case OR:
         operands = ((RexCall) node).getOperands();
@@ -507,6 +516,11 @@ private static boolean userDefinedFunctionInProject(Project project) {
       return false;
     }
 
+    @Override public boolean matches(RelOptRuleCall call) {
+      Project project = call.rel(0);
+      return project.getVariablesSet().isEmpty();
+    }
+
     @Override public @Nullable RelNode convert(RelNode rel) {
       final Project project = (Project) rel;
 
@@ -532,7 +546,7 @@ public JdbcProject(
         RelNode input,
         List<? extends RexNode> projects,
         RelDataType rowType) {
-      super(cluster, traitSet, ImmutableList.of(), input, projects, rowType);
+      super(cluster, traitSet, ImmutableList.of(), input, projects, rowType, ImmutableSet.of());
       assert getConvention() instanceof JdbcConvention;
     }
 
diff --git a/core/src/main/java/org/apache/calcite/adapter/jdbc/JdbcSchema.java b/core/src/main/java/org/apache/calcite/adapter/jdbc/JdbcSchema.java
index e09de96e82e..2f3e4e302ad 100644
--- a/core/src/main/java/org/apache/calcite/adapter/jdbc/JdbcSchema.java
+++ b/core/src/main/java/org/apache/calcite/adapter/jdbc/JdbcSchema.java
@@ -49,6 +49,8 @@
 import com.google.common.collect.Ordering;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import java.sql.Connection;
 import java.sql.DatabaseMetaData;
@@ -74,6 +76,8 @@
  * as much as possible of the query logic to SQL.</p>
  */
 public class JdbcSchema implements Schema {
+  private static final Logger LOGGER = LoggerFactory.getLogger(JdbcSchema.class);
+
   final DataSource dataSource;
   final @Nullable String catalog;
   final @Nullable String schema;
@@ -175,10 +179,11 @@ public static JdbcSchema create(
       return JdbcSchema.create(
           parentSchema, name, dataSource, jdbcCatalog, jdbcSchema);
     } else {
-      SqlDialectFactory factory = AvaticaUtils.instantiatePlugin(
-          SqlDialectFactory.class, sqlDialectFactory);
-      return JdbcSchema.create(
-          parentSchema, name, dataSource, factory, jdbcCatalog, jdbcSchema);
+      SqlDialectFactory factory =
+          AvaticaUtils.instantiatePlugin(SqlDialectFactory.class,
+              sqlDialectFactory);
+      return JdbcSchema.create(parentSchema, name, dataSource, factory,
+          jdbcCatalog, jdbcSchema);
     }
   }
 
@@ -290,7 +295,7 @@ private ImmutableMap<String, JdbcTable> computeTables() {
         final TableType tableType =
             Util.enumVal(TableType.OTHER, tableTypeName2);
         if (tableType == TableType.OTHER  && tableTypeName2 != null) {
-          System.out.println("Unknown table type: " + tableTypeName2);
+          LOGGER.info("Unknown table type: {}", tableTypeName2);
         }
         final JdbcTable table =
             new JdbcTable(this, tableDef.tableCat, tableDef.tableSchem,
@@ -418,13 +423,14 @@ private static RelDataType sqlType(RelDataTypeFactory typeFactory, int dataType,
       if (typeString != null && typeString.endsWith(" ARRAY")) {
         // E.g. hsqldb gives "INTEGER ARRAY", so we deduce the component type
         // "INTEGER".
-        final String remaining = typeString.substring(0,
-            typeString.length() - " ARRAY".length());
+        final String remaining =
+            typeString.substring(0, typeString.length() - " ARRAY".length());
         component = parseTypeString(typeFactory, remaining);
       }
       if (component == null) {
-        component = typeFactory.createTypeWithNullability(
-            typeFactory.createSqlType(SqlTypeName.ANY), true);
+        component =
+            typeFactory.createTypeWithNullability(
+                typeFactory.createSqlType(SqlTypeName.ANY), true);
       }
       return typeFactory.createArrayType(component, -1);
     default:
diff --git a/core/src/main/java/org/apache/calcite/adapter/jdbc/JdbcTable.java b/core/src/main/java/org/apache/calcite/adapter/jdbc/JdbcTable.java
index 2139b120e09..f021df5badd 100644
--- a/core/src/main/java/org/apache/calcite/adapter/jdbc/JdbcTable.java
+++ b/core/src/main/java/org/apache/calcite/adapter/jdbc/JdbcTable.java
@@ -150,7 +150,7 @@ SqlString generateSql() {
     final SqlNodeList selectList = SqlNodeList.SINGLETON_STAR;
     SqlSelect node =
         new SqlSelect(SqlParserPos.ZERO, SqlNodeList.EMPTY, selectList,
-            tableName(), null, null, null, null, null, null, null, null);
+            tableName(), null, null, null, null, null, null, null, null, null);
     final SqlWriterConfig config = SqlPrettyWriter.config()
         .withAlwaysUseParentheses(true)
         .withDialect(jdbcSchema.dialect);
diff --git a/core/src/main/java/org/apache/calcite/adapter/jdbc/JdbcToEnumerableConverter.java b/core/src/main/java/org/apache/calcite/adapter/jdbc/JdbcToEnumerableConverter.java
index 313a896ec1f..80cf32d992b 100644
--- a/core/src/main/java/org/apache/calcite/adapter/jdbc/JdbcToEnumerableConverter.java
+++ b/core/src/main/java/org/apache/calcite/adapter/jdbc/JdbcToEnumerableConverter.java
@@ -22,6 +22,7 @@
 import org.apache.calcite.adapter.enumerable.JavaRowFormat;
 import org.apache.calcite.adapter.enumerable.PhysType;
 import org.apache.calcite.adapter.enumerable.PhysTypeImpl;
+import org.apache.calcite.adapter.enumerable.RexImpTable;
 import org.apache.calcite.adapter.java.JavaTypeFactory;
 import org.apache.calcite.config.CalciteSystemProperty;
 import org.apache.calcite.linq4j.tree.BlockBuilder;
@@ -180,20 +181,22 @@ protected JdbcToEnumerableConverter(
                       toIndexesTableExpression(sqlString)),
                   DataContext.ROOT));
 
-      enumerable = builder0.append("enumerable",
-          Expressions.call(
-              BuiltInMethod.RESULT_SET_ENUMERABLE_OF_PREPARED.method,
-              Schemas.unwrap(jdbcConvention.expression, DataSource.class),
-              sql_,
-              rowBuilderFactory_,
-              preparedStatementConsumer_));
+      enumerable =
+          builder0.append("enumerable",
+              Expressions.call(
+                  BuiltInMethod.RESULT_SET_ENUMERABLE_OF_PREPARED.method,
+                  Schemas.unwrap(jdbcConvention.expression, DataSource.class),
+                  sql_,
+                  rowBuilderFactory_,
+                  preparedStatementConsumer_));
     } else {
-      enumerable = builder0.append("enumerable",
-          Expressions.call(
-              BuiltInMethod.RESULT_SET_ENUMERABLE_OF.method,
-              Schemas.unwrap(jdbcConvention.expression, DataSource.class),
-              sql_,
-              rowBuilderFactory_));
+      enumerable =
+          builder0.append("enumerable",
+              Expressions.call(
+                  BuiltInMethod.RESULT_SET_ENUMERABLE_OF.method,
+                  Schemas.unwrap(jdbcConvention.expression, DataSource.class),
+                  sql_,
+                  rowBuilderFactory_));
     }
     builder0.add(
         Expressions.statement(
@@ -263,24 +266,30 @@ private static void generateGet(EnumerableRelImplementor implementor,
     case DATE:
     case TIME:
     case TIMESTAMP:
-      source = Expressions.call(
-          getMethod(sqlTypeName, fieldType.isNullable(), offset),
-          Expressions.<Expression>list()
-              .append(
-                  Expressions.call(resultSet_,
-                      getMethod2(sqlTypeName), dateTimeArgs))
-          .appendIf(offset, getTimeZoneExpression(implementor)));
+      source =
+          Expressions.call(
+              getMethod(sqlTypeName, fieldType.isNullable(), offset),
+              Expressions.<Expression>list()
+                  .append(
+                      Expressions.call(resultSet_,
+                          getMethod2(sqlTypeName), dateTimeArgs))
+                  .appendIf(offset, getTimeZoneExpression(implementor)));
       break;
     case ARRAY:
-      final Expression x = Expressions.convert_(
-          Expressions.call(resultSet_, jdbcGetMethod(primitive),
-              Expressions.constant(i + 1)),
-          java.sql.Array.class);
+      final Expression x =
+          Expressions.convert_(
+              Expressions.call(resultSet_, jdbcGetMethod(primitive),
+                  Expressions.constant(i + 1)),
+              java.sql.Array.class);
       source = Expressions.call(BuiltInMethod.JDBC_ARRAY_TO_LIST.method, x);
       break;
+    case NULL:
+      source = RexImpTable.NULL_EXPR;
+      break;
     default:
-      source = Expressions.call(
-          resultSet_, jdbcGetMethod(primitive), Expressions.constant(i + 1));
+      source =
+          Expressions.call(resultSet_, jdbcGetMethod(primitive),
+              Expressions.constant(i + 1));
     }
     builder.add(
         Expressions.statement(
@@ -304,8 +313,12 @@ private static Method getMethod(SqlTypeName sqlTypeName, boolean nullable,
     switch (sqlTypeName) {
     case DATE:
       return (nullable
-          ? BuiltInMethod.DATE_TO_INT_OPTIONAL
-          : BuiltInMethod.DATE_TO_INT).method;
+          ? (offset
+          ? BuiltInMethod.DATE_TO_INT_OPTIONAL_OFFSET
+          : BuiltInMethod.DATE_TO_INT_OPTIONAL)
+          : (offset
+              ? BuiltInMethod.DATE_TO_INT_OFFSET
+              : BuiltInMethod.DATE_TO_INT)).method;
     case TIME:
       return (nullable
           ? BuiltInMethod.TIME_TO_INT_OPTIONAL
diff --git a/core/src/main/java/org/apache/calcite/config/CalciteSystemProperty.java b/core/src/main/java/org/apache/calcite/config/CalciteSystemProperty.java
index 0b92204247f..29140dab4bc 100644
--- a/core/src/main/java/org/apache/calcite/config/CalciteSystemProperty.java
+++ b/core/src/main/java/org/apache/calcite/config/CalciteSystemProperty.java
@@ -16,7 +16,6 @@
  */
 package org.apache.calcite.config;
 
-import com.google.common.base.MoreObjects;
 import com.google.common.collect.ImmutableSet;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
@@ -30,6 +29,7 @@
 import java.util.function.Function;
 import java.util.function.IntPredicate;
 import java.util.stream.Stream;
+import javax.annotation.CheckForNull;
 
 import static java.util.Objects.requireNonNull;
 
@@ -196,8 +196,13 @@ public final class CalciteSystemProperty<T> {
             "../../calcite-test-dataset"
         };
         for (String s : dirs) {
-          if (new File(s).exists() && new File(s, "vm").exists()) {
-            return s;
+          try {
+            if (new File(s).exists() && new File(s, "vm").exists()) {
+              return s;
+            }
+          } catch (SecurityException ignore) {
+            // Ignore SecurityException on purpose because if
+            // we can't get to the file we fall through.
           }
         }
         return ".";
@@ -425,11 +430,22 @@ private static CalciteSystemProperty<String> stringProperty(
     });
   }
 
+  private static <T> T firstNonEmpty(@CheckForNull T t0, T t1) {
+    //Bug.upgrade("remove when 18.0 is the minimum Guava version");
+    if (t0 != null) {
+      return t0;
+    }
+    if (t1 != null) {
+      return t1;
+    }
+    throw new NullPointerException();
+  }
+
   private static Properties loadProperties() {
     Properties saffronProperties = new Properties();
-    ClassLoader classLoader = MoreObjects.firstNonNull(
-        Thread.currentThread().getContextClassLoader(),
-        CalciteSystemProperty.class.getClassLoader());
+    ClassLoader classLoader =
+        firstNonEmpty(Thread.currentThread().getContextClassLoader(),
+            CalciteSystemProperty.class.getClassLoader());
     // Read properties from the file "saffron.properties", if it exists in classpath
     try (InputStream stream = requireNonNull(classLoader, "classLoader")
         .getResourceAsStream("saffron.properties")) {
@@ -438,10 +454,9 @@ private static Properties loadProperties() {
       }
     } catch (IOException e) {
       throw new RuntimeException("while reading from saffron.properties file", e);
-    } catch (RuntimeException e) {
-      if (!"java.security.AccessControlException".equals(e.getClass().getName())) {
-        throw e;
-      }
+    } catch (SecurityException ignore) {
+      // Ignore SecurityException on purpose because if
+      // we can't get to the file we fall through.
     }
 
     // Merge system and saffron properties, mapping deprecated saffron
diff --git a/core/src/main/java/org/apache/calcite/config/Lex.java b/core/src/main/java/org/apache/calcite/config/Lex.java
index 172b6b8c5cd..e486c1a94e0 100644
--- a/core/src/main/java/org/apache/calcite/config/Lex.java
+++ b/core/src/main/java/org/apache/calcite/config/Lex.java
@@ -36,7 +36,7 @@ public enum Lex {
    * a back-tick is escaped using a backslash.
    * Character literals may be enclosed in single or double quotes. */
   BIG_QUERY(Quoting.BACK_TICK_BACKSLASH, Casing.UNCHANGED, Casing.UNCHANGED,
-      true, CharLiteralStyle.BQ_SINGLE, CharLiteralStyle.BQ_DOUBLE),
+      false, CharLiteralStyle.BQ_SINGLE, CharLiteralStyle.BQ_DOUBLE),
 
   /** Lexical policy similar to Oracle. The case of identifiers enclosed in
    * double-quotes is preserved; unquoted identifiers are converted to
diff --git a/core/src/main/java/org/apache/calcite/interpreter/AggregateNode.java b/core/src/main/java/org/apache/calcite/interpreter/AggregateNode.java
index f5b2cf96935..f1aea708235 100644
--- a/core/src/main/java/org/apache/calcite/interpreter/AggregateNode.java
+++ b/core/src/main/java/org/apache/calcite/interpreter/AggregateNode.java
@@ -347,8 +347,8 @@ private ScalarAccumulator(ScalarAccumulatorDef def, Object[] values) {
     }
 
     @Override public void send(Row row) {
-      @Nullable Object[] sendValues = requireNonNull(def.sendContext.values,
-          "def.sendContext.values");
+      @Nullable Object[] sendValues =
+          requireNonNull(def.sendContext.values, "def.sendContext.values");
       System.arraycopy(row.getValues(), 0, sendValues, 0,
           def.rowLength);
       System.arraycopy(this.values, 0, sendValues, def.rowLength,
@@ -763,8 +763,8 @@ private static class UdaAccumulator implements Accumulator {
       }
       final @Nullable Object[] args = {value};
       try {
-        AggregateFunctionImpl aggFunction = requireNonNull(factory.aggFunction,
-            "factory.aggFunction");
+        AggregateFunctionImpl aggFunction =
+            requireNonNull(factory.aggFunction, "factory.aggFunction");
         return requireNonNull(aggFunction.resultMethod, "aggFunction.resultMethod")
             .invoke(factory.instance, args);
       } catch (IllegalAccessException | InvocationTargetException e) {
diff --git a/core/src/main/java/org/apache/calcite/interpreter/Bindables.java b/core/src/main/java/org/apache/calcite/interpreter/Bindables.java
index 77b5287fc24..9f879da917c 100644
--- a/core/src/main/java/org/apache/calcite/interpreter/Bindables.java
+++ b/core/src/main/java/org/apache/calcite/interpreter/Bindables.java
@@ -78,6 +78,7 @@
 
 import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.immutables.value.Value;
@@ -386,6 +387,11 @@ protected BindableProjectRule(Config config) {
       super(config);
     }
 
+    @Override public boolean matches(RelOptRuleCall call) {
+      final LogicalProject project = call.rel(0);
+      return project.getVariablesSet().isEmpty();
+    }
+
     @Override public RelNode convert(RelNode rel) {
       final LogicalProject project = (LogicalProject) rel;
       return new BindableProject(rel.getCluster(),
@@ -403,7 +409,7 @@ protected BindableProjectRule(Config config) {
   public static class BindableProject extends Project implements BindableRel {
     public BindableProject(RelOptCluster cluster, RelTraitSet traitSet,
         RelNode input, List<? extends RexNode> projects, RelDataType rowType) {
-      super(cluster, traitSet, ImmutableList.of(), input, projects, rowType);
+      super(cluster, traitSet, ImmutableList.of(), input, projects, rowType, ImmutableSet.of());
       assert getConvention() instanceof BindableConvention;
     }
 
diff --git a/core/src/main/java/org/apache/calcite/interpreter/Interpreter.java b/core/src/main/java/org/apache/calcite/interpreter/Interpreter.java
index 6dd41c282a0..85569d65b64 100644
--- a/core/src/main/java/org/apache/calcite/interpreter/Interpreter.java
+++ b/core/src/main/java/org/apache/calcite/interpreter/Interpreter.java
@@ -107,8 +107,8 @@ private static RelNode optimize(RelNode rootRel) {
 
   @Override public Enumerator<@Nullable Object[]> enumerator() {
     start();
-    final NodeInfo nodeInfo = requireNonNull(nodes.get(rootRel),
-        () -> "nodeInfo for " + rootRel);
+    final NodeInfo nodeInfo =
+        requireNonNull(nodes.get(rootRel), () -> "nodeInfo for " + rootRel);
     final Enumerator<Row> rows;
     if (nodeInfo.rowEnumerable != null) {
       rows = nodeInfo.rowEnumerable.enumerator();
@@ -359,9 +359,10 @@ Pair<RelNode, Map<RelNode, NodeInfo>> visitRoot(RelNode p) {
       if (!found) {
         if (p instanceof InterpretableRel) {
           InterpretableRel interpretableRel = (InterpretableRel) p;
-          node = interpretableRel.implement(
-              new InterpretableRel.InterpreterImplementor(this, null,
-                  DataContexts.EMPTY));
+          node =
+              interpretableRel.implement(
+                  new InterpretableRel.InterpreterImplementor(this, null,
+                      DataContexts.EMPTY));
         } else {
           // Probably need to add a visit(XxxRel) method to CoreCompiler.
           throw new AssertionError("interpreter: no implementation for "
diff --git a/core/src/main/java/org/apache/calcite/interpreter/JaninoRexCompiler.java b/core/src/main/java/org/apache/calcite/interpreter/JaninoRexCompiler.java
index cc7274209d9..bc0bf816494 100644
--- a/core/src/main/java/org/apache/calcite/interpreter/JaninoRexCompiler.java
+++ b/core/src/main/java/org/apache/calcite/interpreter/JaninoRexCompiler.java
@@ -149,8 +149,7 @@ static Scalar.Producer baz(ParameterExpression context_,
     declarations.add(
         Expressions.methodDecl(Modifier.PUBLIC, Object.class,
             BuiltInMethod.FUNCTION_APPLY.method.getName(),
-            ImmutableList.of(
-                objectRoot),
+            ImmutableList.of(objectRoot),
             Expressions.block(
                 Expressions.return_(null,
                     Expressions.call(
@@ -167,13 +166,13 @@ static Scalar.Producer baz(ParameterExpression context_,
 
     // public Object execute(Context)
     final BlockBuilder builder = new BlockBuilder();
-    final Expression values_ = builder.append("values",
-        Expressions.newArrayBounds(Object.class, 1,
-            Expressions.constant(1)));
+    final Expression values_ =
+        builder.append("values",
+            Expressions.newArrayBounds(Object.class, 1,
+                Expressions.constant(1)));
     builder.add(
         Expressions.statement(
-            Expressions.call(
-                Expressions.parameter(Scalar.class, "this"),
+            Expressions.call(Expressions.parameter(Scalar.class, "this"),
                 BuiltInMethod.SCALAR_EXECUTE2.method, context_, values_)));
     builder.add(
         Expressions.return_(null,
diff --git a/core/src/main/java/org/apache/calcite/interpreter/JoinNode.java b/core/src/main/java/org/apache/calcite/interpreter/JoinNode.java
index 9fc63f7cfae..d7057c7db04 100644
--- a/core/src/main/java/org/apache/calcite/interpreter/JoinNode.java
+++ b/core/src/main/java/org/apache/calcite/interpreter/JoinNode.java
@@ -46,8 +46,9 @@ public JoinNode(Compiler compiler, Join rel) {
     this.leftSource = compiler.source(rel, 0);
     this.rightSource = compiler.source(rel, 1);
     this.sink = compiler.sink(rel);
-    this.condition = compiler.compile(ImmutableList.of(rel.getCondition()),
-        compiler.combinedRowType(rel.getInputs()));
+    this.condition =
+        compiler.compile(ImmutableList.of(rel.getCondition()),
+            compiler.combinedRowType(rel.getInputs()));
     this.rel = rel;
     this.context = compiler.createContext();
 
diff --git a/core/src/main/java/org/apache/calcite/interpreter/ProjectNode.java b/core/src/main/java/org/apache/calcite/interpreter/ProjectNode.java
index dda0d9fe270..8db41bd38ad 100644
--- a/core/src/main/java/org/apache/calcite/interpreter/ProjectNode.java
+++ b/core/src/main/java/org/apache/calcite/interpreter/ProjectNode.java
@@ -30,8 +30,8 @@ public class ProjectNode extends AbstractSingleNode<Project> {
   public ProjectNode(Compiler compiler, Project rel) {
     super(compiler, rel);
     this.projectCount = rel.getProjects().size();
-    this.scalar = compiler.compile(rel.getProjects(),
-        rel.getInput().getRowType());
+    this.scalar =
+        compiler.compile(rel.getProjects(), rel.getInput().getRowType());
     this.context = compiler.createContext();
   }
 
diff --git a/core/src/main/java/org/apache/calcite/interpreter/TableScanNode.java b/core/src/main/java/org/apache/calcite/interpreter/TableScanNode.java
index ece2008dd07..343d10174e2 100644
--- a/core/src/main/java/org/apache/calcite/interpreter/TableScanNode.java
+++ b/core/src/main/java/org/apache/calcite/interpreter/TableScanNode.java
@@ -19,7 +19,6 @@
 import org.apache.calcite.DataContext;
 import org.apache.calcite.linq4j.Enumerable;
 import org.apache.calcite.linq4j.Queryable;
-import org.apache.calcite.linq4j.function.Function1;
 import org.apache.calcite.plan.RelOptTable;
 import org.apache.calcite.plan.RelOptUtil;
 import org.apache.calcite.rel.core.TableScan;
@@ -137,9 +136,9 @@ private static TableScanNode createQueryable(Compiler compiler,
     final Enumerable<Row> rowEnumerable;
     if (elementType instanceof Class) {
       //noinspection unchecked
-      final Queryable<Object> queryable = Schemas.queryable(root,
-          (Class) elementType,
-          relOptTable.getQualifiedName());
+      final Queryable<Object> queryable =
+          Schemas.queryable(root, (Class) elementType,
+              relOptTable.getQualifiedName());
       ImmutableList.Builder<Field> fieldBuilder = ImmutableList.builder();
       Class type = (Class) elementType;
       for (Field field : type.getFields()) {
@@ -256,8 +255,9 @@ private static TableScanNode createEnumerable(Compiler compiler,
         filter2 = filter;
         inputRowType = rel.getRowType();
       } else {
-        final Mapping mapping = Mappings.target(acceptedProjects,
-            rel.getTable().getRowType().getFieldCount());
+        final Mapping mapping =
+            Mappings.target(acceptedProjects,
+                rel.getTable().getRowType().getFieldCount());
         filter2 = RexUtil.apply(mapping, filter);
         final RelDataTypeFactory.Builder builder =
             rel.getCluster().getTypeFactory().builder();
@@ -278,16 +278,14 @@ private static TableScanNode createEnumerable(Compiler compiler,
       });
     }
     if (rejectedProjects != null) {
-      enumerable = enumerable.select(
-          new Function1<Row, Row>() {
-            final @Nullable Object[] values = new Object[rejectedProjects.size()];
-            @Override public Row apply(Row row) {
-              final @Nullable Object[] inValues = row.getValues();
-              for (int i = 0; i < rejectedProjects.size(); i++) {
-                values[i] = inValues[rejectedProjects.get(i)];
-              }
-              return Row.asCopy(values);
+      final @Nullable Object[] values = new Object[rejectedProjects.size()];
+      enumerable =
+          enumerable.select(row -> {
+            final @Nullable Object[] inValues = row.getValues();
+            for (int i = 0; i < rejectedProjects.size(); i++) {
+              values[i] = inValues[rejectedProjects.get(i)];
             }
+            return Row.asCopy(values);
           });
     }
     return new TableScanNode(compiler, rel, enumerable);
diff --git a/core/src/main/java/org/apache/calcite/jdbc/CachingCalciteSchema.java b/core/src/main/java/org/apache/calcite/jdbc/CachingCalciteSchema.java
index 1c62d913ab7..19b204aafa0 100644
--- a/core/src/main/java/org/apache/calcite/jdbc/CachingCalciteSchema.java
+++ b/core/src/main/java/org/apache/calcite/jdbc/CachingCalciteSchema.java
@@ -54,7 +54,8 @@ class CachingCalciteSchema extends CalciteSchema {
   private boolean cache = true;
 
   /** Creates a CachingCalciteSchema. */
-  CachingCalciteSchema(@Nullable CalciteSchema parent, Schema schema, String name) {
+  CachingCalciteSchema(@Nullable CalciteSchema parent, Schema schema,
+      String name) {
     this(parent, schema, name, null, null, null, null, null, null, null, null);
   }
 
@@ -119,9 +120,7 @@ private CachingCalciteSchema(@Nullable CalciteSchema parent, Schema schema,
   @Override protected @Nullable CalciteSchema getImplicitSubSchema(String schemaName,
       boolean caseSensitive) {
     final long now = System.currentTimeMillis();
-    final SubSchemaCache subSchemaCache =
-        implicitSubSchemaCache.get(now);
-    //noinspection LoopStatementThatDoesntLoop
+    final SubSchemaCache subSchemaCache = implicitSubSchemaCache.get(now);
     for (String schemaName2
         : subSchemaCache.names.range(schemaName, caseSensitive)) {
       return subSchemaCache.cache.getUnchecked(schemaName2);
@@ -151,7 +150,8 @@ private CachingCalciteSchema(@Nullable CalciteSchema parent, Schema schema,
     return null;
   }
 
-  @Override protected @Nullable TypeEntry getImplicitType(String name, boolean caseSensitive) {
+  @Override protected @Nullable TypeEntry getImplicitType(String name,
+      boolean caseSensitive) {
     final long now = System.currentTimeMillis();
     final NameSet implicitTypeNames = implicitTypeCache.get(now);
     for (String typeName
@@ -166,7 +166,8 @@ private CachingCalciteSchema(@Nullable CalciteSchema parent, Schema schema,
 
   @Override protected void addImplicitSubSchemaToBuilder(
       ImmutableSortedMap.Builder<String, CalciteSchema> builder) {
-    ImmutableSortedMap<String, CalciteSchema> explicitSubSchemas = builder.build();
+    ImmutableSortedMap<String, CalciteSchema> explicitSubSchemas =
+        builder.build();
     final long now = System.currentTimeMillis();
     final SubSchemaCache subSchemaCache = implicitSubSchemaCache.get(now);
     for (String name : subSchemaCache.names.iterable()) {
@@ -237,8 +238,8 @@ private CachingCalciteSchema(@Nullable CalciteSchema parent, Schema schema,
     }
   }
 
-  @Override protected @Nullable TableEntry getImplicitTableBasedOnNullaryFunction(String tableName,
-      boolean caseSensitive) {
+  @Override protected @Nullable TableEntry getImplicitTableBasedOnNullaryFunction(
+      String tableName, boolean caseSensitive) {
     final long now = System.currentTimeMillis();
     final NameSet set = implicitFunctionCache.get(now);
     for (String s : set.range(tableName, caseSensitive)) {
@@ -256,9 +257,10 @@ private CachingCalciteSchema(@Nullable CalciteSchema parent, Schema schema,
 
   @Override protected CalciteSchema snapshot(@Nullable CalciteSchema parent,
       SchemaVersion version) {
-    CalciteSchema snapshot = new CachingCalciteSchema(parent,
-        schema.snapshot(version), name, null, tableMap, latticeMap, typeMap,
-        functionMap, functionNames, nullaryFunctionMap, getPath());
+    CalciteSchema snapshot =
+        new CachingCalciteSchema(parent, schema.snapshot(version), name, null,
+            tableMap, latticeMap, typeMap,
+            functionMap, functionNames, nullaryFunctionMap, getPath());
     for (CalciteSchema subSchema : subSchemaMap.map().values()) {
       CalciteSchema subSchemaSnapshot = subSchema.snapshot(snapshot, version);
       snapshot.subSchemaMap.put(subSchema.name, subSchemaSnapshot);
@@ -338,19 +340,20 @@ private static class SubSchemaCache {
     private SubSchemaCache(final CalciteSchema calciteSchema,
         Set<String> names) {
       this.names = NameSet.immutableCopyOf(names);
-      this.cache = CacheBuilder.newBuilder().build(
-          new CacheLoader<String, CalciteSchema>() {
-            @SuppressWarnings("NullableProblems")
-            @Override public CalciteSchema load(String schemaName) {
-              final Schema subSchema =
-                  calciteSchema.schema.getSubSchema(schemaName);
-              if (subSchema == null) {
-                throw new RuntimeException("sub-schema " + schemaName
-                    + " not found");
-              }
-              return new CachingCalciteSchema(calciteSchema, subSchema, schemaName);
-            }
-          });
+      this.cache =
+          CacheBuilder.newBuilder()
+              .build(new CacheLoader<String, CalciteSchema>() {
+                @Override public CalciteSchema load(String schemaName) {
+                  final Schema subSchema =
+                      calciteSchema.schema.getSubSchema(schemaName);
+                  if (subSchema == null) {
+                    throw new RuntimeException("sub-schema " + schemaName
+                        + " not found");
+                  }
+                  return new CachingCalciteSchema(calciteSchema, subSchema,
+                      schemaName);
+                }
+              });
     }
   }
 }
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 03deda30f4c..12fae545720 100644
--- a/core/src/main/java/org/apache/calcite/jdbc/CalciteConnectionImpl.java
+++ b/core/src/main/java/org/apache/calcite/jdbc/CalciteConnectionImpl.java
@@ -39,7 +39,6 @@
 import org.apache.calcite.linq4j.Ord;
 import org.apache.calcite.linq4j.QueryProvider;
 import org.apache.calcite.linq4j.Queryable;
-import org.apache.calcite.linq4j.function.Function0;
 import org.apache.calcite.linq4j.tree.Expression;
 import org.apache.calcite.linq4j.tree.Expressions;
 import org.apache.calcite.materialize.Lattice;
@@ -48,6 +47,8 @@
 import org.apache.calcite.prepare.CalciteCatalogReader;
 import org.apache.calcite.rel.type.DelegatingTypeSystem;
 import org.apache.calcite.rel.type.RelDataTypeSystem;
+import org.apache.calcite.rel.type.TimeFrameSet;
+import org.apache.calcite.rel.type.TimeFrames;
 import org.apache.calcite.runtime.Hook;
 import org.apache.calcite.schema.SchemaPlus;
 import org.apache.calcite.schema.SchemaVersion;
@@ -85,6 +86,7 @@
 import java.util.Properties;
 import java.util.TimeZone;
 import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.function.Supplier;
 
 import static org.apache.calcite.linq4j.Nullness.castNonNull;
 
@@ -102,7 +104,7 @@ abstract class CalciteConnectionImpl
   public final JavaTypeFactory typeFactory;
 
   final CalciteSchema rootSchema;
-  final Function0<CalcitePrepare> prepareFactory;
+  final Supplier<CalcitePrepare> prepareFactory;
   final CalciteServer server = new CalciteServerImpl();
 
   // must be package-protected
@@ -125,7 +127,7 @@ protected CalciteConnectionImpl(Driver driver, AvaticaFactory factory,
       @Nullable JavaTypeFactory typeFactory) {
     super(driver, factory, url, info);
     CalciteConnectionConfig cfg = new CalciteConnectionConfigImpl(info);
-    this.prepareFactory = driver.prepareFactory;
+    this.prepareFactory = driver::createPrepare;
     if (typeFactory != null) {
       this.typeFactory = typeFactory;
     } else {
@@ -230,7 +232,7 @@ <T> CalcitePrepare.CalciteSignature<T> parseQuery(
       CalcitePrepare.Context prepareContext, long maxRowCount) {
     CalcitePrepare.Dummy.push(prepareContext);
     try {
-      final CalcitePrepare prepare = prepareFactory.apply();
+      final CalcitePrepare prepare = prepareFactory.get();
       return prepare.prepareSql(prepareContext, query, Object[].class,
           maxRowCount);
     } finally {
@@ -419,6 +421,9 @@ static class DataContextImpl implements DataContext {
       Hook.CURRENT_TIME.run(timeHolder);
       final long time = timeHolder.get();
       final TimeZone timeZone = connection.getTimeZone();
+      final TimeFrameSet timeFrameSet =
+          connection.typeFactory.getTypeSystem()
+              .deriveTimeFrameSet(TimeFrames.CORE);
       final long localOffset = timeZone.getOffset(time);
       final long currentOffset = localOffset;
       final String user = "sa";
@@ -437,6 +442,7 @@ static class DataContextImpl implements DataContext {
           .put(Variable.CURRENT_TIMESTAMP.camelName, time + currentOffset)
           .put(Variable.LOCAL_TIMESTAMP.camelName, time + localOffset)
           .put(Variable.TIME_ZONE.camelName, timeZone)
+          .put(Variable.TIME_FRAME_SET.camelName, timeFrameSet)
           .put(Variable.USER.camelName, user)
           .put(Variable.SYSTEM_USER.camelName, systemUser)
           .put(Variable.LOCALE.camelName, locale)
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 32289b795c5..460b9e2029f 100644
--- a/core/src/main/java/org/apache/calcite/jdbc/CalciteMetaImpl.java
+++ b/core/src/main/java/org/apache/calcite/jdbc/CalciteMetaImpl.java
@@ -381,9 +381,10 @@ Enumerable<MetaTable> tables(final MetaSchema schema_) {
     final CalciteMetaSchema schema = (CalciteMetaSchema) schema_;
     return Linq4j.asEnumerable(schema.calciteSchema.getTableNames())
         .select((Function1<String, MetaTable>) name -> {
-          final Table table = requireNonNull(
-              schema.calciteSchema.getTable(name, true),
-              () -> "table " + name + " is not found (case sensitive)").getTable();
+          final Table table =
+              requireNonNull(schema.calciteSchema.getTable(name, true),
+                  () -> "table " + name + " is not found (case sensitive)")
+                  .getTable();
           return new CalciteMetaTable(table,
               schema.tableCatalog,
               schema.tableSchem,
@@ -509,8 +510,7 @@ public Enumerable<MetaColumn> columns(final MetaTable table_) {
             .selectMany(schema -> functions(schema, catalog, matcher(functionNamePattern)))
             .orderBy(x ->
                 (Comparable) FlatLists.of(
-                    x.functionCat, x.functionSchem, x.functionName, x.specificName
-                )),
+                    x.functionCat, x.functionSchem, x.functionName, x.specificName)),
         MetaFunction.class,
         "FUNCTION_CAT",
         "FUNCTION_SCHEM",
@@ -535,9 +535,7 @@ Enumerable<MetaFunction> functions(final MetaSchema schema_, final String catalo
                   schema.getName(),
                   op.getName(),
                   (short) DatabaseMetaData.functionResultUnknown,
-                  op.getName()
-              )
-          );
+                  op.getName()));
     }
     return Linq4j.asEnumerable(schema.calciteSchema.getFunctionNames())
         .selectMany(name ->
@@ -664,8 +662,9 @@ private static CalcitePrepare.Query<Object> toQuery(
       int fetchMaxRowCount) throws NoSuchStatementException {
     final CalciteConnectionImpl calciteConnection = getConnection();
     CalciteServerStatement stmt = calciteConnection.server.getStatement(h);
-    final Signature signature = requireNonNull(stmt.getSignature(),
-        () -> "stmt.getSignature() is null for " + stmt);
+    final Signature signature =
+        requireNonNull(stmt.getSignature(),
+            () -> "stmt.getSignature() is null for " + stmt);
     final Iterator<Object> iterator;
     Iterator<Object> stmtResultSet = stmt.getResultSet();
     if (stmtResultSet == null) {
@@ -697,8 +696,9 @@ private static CalcitePrepare.Query<Object> toQuery(
       throws NoSuchStatementException {
     final CalciteConnectionImpl calciteConnection = getConnection();
     CalciteServerStatement stmt = calciteConnection.server.getStatement(h);
-    final Signature signature = requireNonNull(stmt.getSignature(),
-        () -> "stmt.getSignature() is null for " + stmt);
+    final Signature signature =
+        requireNonNull(stmt.getSignature(),
+            () -> "stmt.getSignature() is null for " + stmt);
 
     MetaResultSet metaResultSet;
     if (signature.statementType.canUpdate()) {
@@ -706,8 +706,9 @@ private static CalcitePrepare.Query<Object> toQuery(
           _createIterable(h, signature, parameterValues, null);
       final Iterator<Object> iterator = iterable.iterator();
       stmt.setResultSet(iterator);
-      metaResultSet = MetaResultSet.count(h.connectionId, h.id,
-          ((Number) iterator.next()).intValue());
+      metaResultSet =
+          MetaResultSet.count(h.connectionId, h.id,
+              ((Number) iterator.next()).intValue());
     } else {
       // Don't populate the first frame.
       // It's not worth saving a round-trip, since we're local.
diff --git a/core/src/main/java/org/apache/calcite/jdbc/CalciteStatement.java b/core/src/main/java/org/apache/calcite/jdbc/CalciteStatement.java
index 3c7c2be7c42..9b06b7fc2a6 100644
--- a/core/src/main/java/org/apache/calcite/jdbc/CalciteStatement.java
+++ b/core/src/main/java/org/apache/calcite/jdbc/CalciteStatement.java
@@ -68,7 +68,7 @@ public abstract class CalciteStatement extends AvaticaStatement {
   protected <T> CalcitePrepare.CalciteSignature<T> prepare(
       Queryable<T> queryable) {
     final CalciteConnectionImpl calciteConnection = getConnection();
-    final CalcitePrepare prepare = calciteConnection.prepareFactory.apply();
+    final CalcitePrepare prepare = calciteConnection.prepareFactory.get();
     final CalciteServerStatement serverStatement;
     try {
       serverStatement = calciteConnection.server.getStatement(handle);
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 06aa637b68e..20753ebd821 100644
--- a/core/src/main/java/org/apache/calcite/jdbc/Driver.java
+++ b/core/src/main/java/org/apache/calcite/jdbc/Driver.java
@@ -45,6 +45,9 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Properties;
+import java.util.function.Supplier;
+
+import static java.util.Objects.requireNonNull;
 
 /**
  * Calcite JDBC driver.
@@ -52,18 +55,61 @@
 public class Driver extends UnregisteredDriver {
   public static final String CONNECT_STRING_PREFIX = "jdbc:calcite:";
 
-  final Function0<CalcitePrepare> prepareFactory;
+  protected final @Nullable Supplier<CalcitePrepare> prepareFactory;
 
   static {
     new Driver().register();
   }
 
-  @SuppressWarnings("method.invocation.invalid")
+  /** Creates a Driver. */
   public Driver() {
-    super();
-    this.prepareFactory = createPrepareFactory();
+    this(null);
+  }
+
+  /** Creates a Driver with a factory for {@code CalcitePrepare} objects;
+   * if the factory is null, the driver will call
+   * {@link #createPrepareFactory()}. */
+  protected Driver(@Nullable Supplier<CalcitePrepare> prepareFactory) {
+    this.prepareFactory = prepareFactory;
+  }
+
+  /** Creates a copy of this Driver with a new factory for creating
+   * {@link CalcitePrepare}.
+   *
+   * <p>Allows users of the Driver to change the factory without subclassing
+   * the Driver. But subclasses of the driver should override this method to
+   * create an instance of their subclass.
+   *
+   * @param prepareFactory Supplier of a {@code CalcitePrepare}
+   * @return Driver with the provided prepareFactory
+   */
+  public Driver withPrepareFactory(Supplier<CalcitePrepare> prepareFactory) {
+    requireNonNull(prepareFactory, "prepareFactory");
+    if (this.prepareFactory == prepareFactory) {
+      return this;
+    }
+    return new Driver(prepareFactory);
+  }
+
+  /** Creates a {@link CalcitePrepare} to be used to prepare a statement for
+   * execution.
+   *
+   * <p>If you wish to use a custom prepare, either override this method or
+   * call {@link #withPrepareFactory(Supplier)}. */
+  public CalcitePrepare createPrepare() {
+    if (prepareFactory != null) {
+      return prepareFactory.get();
+    }
+    return createPrepareFactory().apply();
   }
 
+  /** Returns a factory with which to create a {@link CalcitePrepare}.
+   *
+   * <p>Now deprecated; if you wish to use a custom prepare, overrides of this
+   * method will still work, but we prefer that you call
+   * {@link #withPrepareFactory(Supplier)}
+   * or override {@link #createPrepare()}. */
+  @Deprecated // to be removed before 2.0
   protected Function0<CalcitePrepare> createPrepareFactory() {
     return CalcitePrepare.DEFAULT_FACTORY;
   }
diff --git a/core/src/main/java/org/apache/calcite/jdbc/JavaTypeFactoryImpl.java b/core/src/main/java/org/apache/calcite/jdbc/JavaTypeFactoryImpl.java
index ae9acb86935..d689759c75e 100644
--- a/core/src/main/java/org/apache/calcite/jdbc/JavaTypeFactoryImpl.java
+++ b/core/src/main/java/org/apache/calcite/jdbc/JavaTypeFactoryImpl.java
@@ -27,7 +27,6 @@
 import org.apache.calcite.rel.type.RelDataTypeFieldImpl;
 import org.apache.calcite.rel.type.RelDataTypeSystem;
 import org.apache.calcite.rel.type.RelRecordType;
-import org.apache.calcite.runtime.Geometries;
 import org.apache.calcite.runtime.Unit;
 import org.apache.calcite.sql.type.BasicSqlType;
 import org.apache.calcite.sql.type.IntervalSqlType;
@@ -39,6 +38,7 @@
 import org.apache.calcite.util.Util;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
+import org.locationtech.jts.geom.Geometry;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
@@ -216,7 +216,7 @@ private static Type fieldType(Field field) {
       case VARBINARY:
         return ByteString.class;
       case GEOMETRY:
-        return Geometries.Geom.class;
+        return Geometry.class;
       case SYMBOL:
         return Enum.class;
       case ANY:
@@ -270,14 +270,14 @@ public static RelDataType toSql(final RelDataTypeFactory typeFactory,
         // 1. type.getJavaClass() is collection with erased generic type
         // 2. ElementType returned by JavaType is also of JavaType,
         // and needs conversion using typeFactory
-        final RelDataType elementType = toSqlTypeWithNullToAny(
-            typeFactory, type.getComponentType());
+        final RelDataType elementType =
+            toSqlTypeWithNullToAny(typeFactory, type.getComponentType());
         relDataType = typeFactory.createArrayType(elementType, -1);
       } else if (SqlTypeUtil.isMap(type)) {
-        final RelDataType keyType = toSqlTypeWithNullToAny(
-            typeFactory, type.getKeyType());
-        final RelDataType valueType = toSqlTypeWithNullToAny(
-            typeFactory, type.getValueType());
+        final RelDataType keyType =
+            toSqlTypeWithNullToAny(typeFactory, type.getKeyType());
+        final RelDataType valueType =
+            toSqlTypeWithNullToAny(typeFactory, type.getValueType());
         relDataType = typeFactory.createMapType(keyType, valueType);
       } else {
         relDataType = typeFactory.createSqlType(sqlTypeName);
diff --git a/core/src/main/java/org/apache/calcite/jdbc/SimpleCalciteSchema.java b/core/src/main/java/org/apache/calcite/jdbc/SimpleCalciteSchema.java
index 9630bc4b512..032b6d88ea1 100644
--- a/core/src/main/java/org/apache/calcite/jdbc/SimpleCalciteSchema.java
+++ b/core/src/main/java/org/apache/calcite/jdbc/SimpleCalciteSchema.java
@@ -103,8 +103,9 @@ private SimpleCalciteSchema(@Nullable CalciteSchema parent,
   @Override protected @Nullable CalciteSchema getImplicitSubSchema(String schemaName,
       boolean caseSensitive) {
     // Check implicit schemas.
-    final String schemaName2 = caseSensitive ? schemaName : caseInsensitiveLookup(
-        schema.getSubSchemaNames(), schemaName);
+    final String schemaName2 =
+        caseSensitive ? schemaName
+            : caseInsensitiveLookup(schema.getSubSchemaNames(), schemaName);
     if (schemaName2 == null) {
       return null;
     }
@@ -118,8 +119,9 @@ private SimpleCalciteSchema(@Nullable CalciteSchema parent,
   @Override protected @Nullable TableEntry getImplicitTable(String tableName,
       boolean caseSensitive) {
     // Check implicit tables.
-    final String tableName2 = caseSensitive ? tableName : caseInsensitiveLookup(
-        schema.getTableNames(), tableName);
+    final String tableName2 =
+        caseSensitive ? tableName
+            : caseInsensitiveLookup(schema.getTableNames(), tableName);
     if (tableName2 == null) {
       return null;
     }
@@ -132,8 +134,9 @@ private SimpleCalciteSchema(@Nullable CalciteSchema parent,
 
   @Override protected @Nullable TypeEntry getImplicitType(String name, boolean caseSensitive) {
     // Check implicit types.
-    final String name2 = caseSensitive ? name : caseInsensitiveLookup(
-        schema.getTypeNames(), name);
+    final String name2 =
+        caseSensitive ? name
+            : caseInsensitiveLookup(schema.getTypeNames(), name);
     if (name2 == null) {
       return null;
     }
@@ -219,9 +222,10 @@ private SimpleCalciteSchema(@Nullable CalciteSchema parent,
 
   @Override protected CalciteSchema snapshot(@Nullable CalciteSchema parent,
       SchemaVersion version) {
-    CalciteSchema snapshot = new SimpleCalciteSchema(parent,
-        schema.snapshot(version), name, null, tableMap, latticeMap, typeMap,
-        functionMap, functionNames, nullaryFunctionMap, getPath());
+    CalciteSchema snapshot =
+        new SimpleCalciteSchema(parent, schema.snapshot(version), name, null,
+            tableMap, latticeMap, typeMap,
+            functionMap, functionNames, nullaryFunctionMap, getPath());
     for (CalciteSchema subSchema : subSchemaMap.map().values()) {
       CalciteSchema subSchemaSnapshot = subSchema.snapshot(snapshot, version);
       snapshot.subSchemaMap.put(subSchema.name, subSchemaSnapshot);
diff --git a/core/src/main/java/org/apache/calcite/materialize/CachingLatticeStatisticProvider.java b/core/src/main/java/org/apache/calcite/materialize/CachingLatticeStatisticProvider.java
index 2a3d59cc2c0..1f13e471721 100644
--- a/core/src/main/java/org/apache/calcite/materialize/CachingLatticeStatisticProvider.java
+++ b/core/src/main/java/org/apache/calcite/materialize/CachingLatticeStatisticProvider.java
@@ -40,8 +40,10 @@ class CachingLatticeStatisticProvider implements LatticeStatisticProvider {
   CachingLatticeStatisticProvider(final Lattice lattice,
       final LatticeStatisticProvider provider) {
     this.lattice = lattice;
-    cache = CacheBuilder.newBuilder().build(
-        CacheLoader.from(key -> provider.cardinality(ImmutableList.of(key))));
+    cache =
+        CacheBuilder.newBuilder().build(
+            CacheLoader.from(key ->
+                provider.cardinality(ImmutableList.of(key))));
   }
 
   @Override public double cardinality(List<Lattice.Column> columns) {
diff --git a/core/src/main/java/org/apache/calcite/materialize/Lattice.java b/core/src/main/java/org/apache/calcite/materialize/Lattice.java
index 35a7ddda532..596b17769e3 100644
--- a/core/src/main/java/org/apache/calcite/materialize/Lattice.java
+++ b/core/src/main/java/org/apache/calcite/materialize/Lattice.java
@@ -169,10 +169,10 @@ private static void populateAliases(SqlNode from, List<@Nullable String> aliases
       populateAliases(join.getRight(), aliases, null);
     } else if (from.getKind() == SqlKind.AS) {
       populateAliases(SqlUtil.stripAs(from), aliases,
-          SqlValidatorUtil.getAlias(from, -1));
+          SqlValidatorUtil.alias(from));
     } else {
       if (current == null) {
-        current = SqlValidatorUtil.getAlias(from, -1);
+        current = SqlValidatorUtil.alias(from);
       }
       aliases.add(current);
     }
@@ -1117,12 +1117,14 @@ void fixUp(MutableNode node) {
         if (node.alias == null) {
           node.alias = Util.last(node.table.t.getQualifiedName());
         }
-        node.alias = SqlValidatorUtil.uniquify(node.alias, aliases,
-            SqlValidatorUtil.ATTEMPT_SUGGESTER);
+        node.alias =
+            SqlValidatorUtil.uniquify(node.alias, aliases,
+                SqlValidatorUtil.ATTEMPT_SUGGESTER);
         node.startCol = c;
         for (String name : node.table.t.getRowType().getFieldNames()) {
-          final String alias = SqlValidatorUtil.uniquify(name,
-              columnAliases, SqlValidatorUtil.ATTEMPT_SUGGESTER);
+          final String alias =
+              SqlValidatorUtil.uniquify(name, columnAliases,
+                  SqlValidatorUtil.ATTEMPT_SUGGESTER);
           final BaseColumn column =
               new BaseColumn(c++, castNonNull(node.alias), name, alias);
           columnList.add(column);
diff --git a/core/src/main/java/org/apache/calcite/materialize/LatticeSuggester.java b/core/src/main/java/org/apache/calcite/materialize/LatticeSuggester.java
index 093980b0195..67045320fa6 100644
--- a/core/src/main/java/org/apache/calcite/materialize/LatticeSuggester.java
+++ b/core/src/main/java/org/apache/calcite/materialize/LatticeSuggester.java
@@ -248,8 +248,9 @@ private void addFrame(Query q, Frame frame, List<Lattice> lattices) {
                     final DerivedColRef derivedColRef =
                         (DerivedColRef) colRef;
                     final String alias = deriveAlias(measure, derivedColRef);
-                    column = latticeBuilder.expression(derivedColRef.e, alias,
-                        derivedColRef.tableAliases());
+                    column =
+                        latticeBuilder.expression(derivedColRef.e, alias,
+                            derivedColRef.tableAliases());
                   } else {
                     throw new AssertionError("expression in measure");
                   }
diff --git a/core/src/main/java/org/apache/calcite/materialize/MaterializationService.java b/core/src/main/java/org/apache/calcite/materialize/MaterializationService.java
index 2997d9d1dc3..91cdeca0c05 100644
--- a/core/src/main/java/org/apache/calcite/materialize/MaterializationService.java
+++ b/core/src/main/java/org/apache/calcite/materialize/MaterializationService.java
@@ -142,8 +142,8 @@ private MaterializationService() {
     RelDataType rowType = null;
     if (tableEntry == null) {
       Table table = tableFactory.createTable(schema, viewSql, viewSchemaPath);
-      final String tableName = Schemas.uniqueTableName(schema,
-          Util.first(suggestedTableName, "m"));
+      final String tableName =
+          Schemas.uniqueTableName(schema, Util.first(suggestedTableName, "m"));
       tableEntry = schema.add(tableName, table, ImmutableList.of(viewSql));
       Hook.CREATE_MATERIALIZATION.run(tableName);
       rowType = table.getRowType(connection.getTypeFactory());
diff --git a/core/src/main/java/org/apache/calcite/materialize/MutableNode.java b/core/src/main/java/org/apache/calcite/materialize/MutableNode.java
index 081a6ea9919..1d9faa9b323 100644
--- a/core/src/main/java/org/apache/calcite/materialize/MutableNode.java
+++ b/core/src/main/java/org/apache/calcite/materialize/MutableNode.java
@@ -46,13 +46,17 @@ class MutableNode {
       Ordering.from(
           new Comparator<MutableNode>() {
             @Override public int compare(MutableNode o1, MutableNode o2) {
-              int c = Ordering.<String>natural().lexicographical().compare(
-                  o1.table.t.getQualifiedName(), o2.table.t.getQualifiedName());
+              int c =
+                  Ordering.<String>natural().lexicographical()
+                      .compare(o1.table.t.getQualifiedName(),
+                          o2.table.t.getQualifiedName());
               if (c == 0 && o1.step != null && o2.step != null) {
                 // The nodes have the same table. Now compare them based on the
                 // columns they use as foreign key.
-                c = Ordering.<Integer>natural().lexicographical().compare(
-                    IntPair.left(o1.step.keys), IntPair.left(o2.step.keys));
+                c =
+                    Ordering.<Integer>natural().lexicographical()
+                        .compare(IntPair.left(o1.step.keys),
+                            IntPair.left(o2.step.keys));
               }
               return c;
             }
diff --git a/core/src/main/java/org/apache/calcite/model/ModelHandler.java b/core/src/main/java/org/apache/calcite/model/ModelHandler.java
index acab4b8608b..e464ab1dae0 100644
--- a/core/src/main/java/org/apache/calcite/model/ModelHandler.java
+++ b/core/src/main/java/org/apache/calcite/model/ModelHandler.java
@@ -330,8 +330,9 @@ public void visit(JsonJdbcSchema jsonSchema) {
           JdbcSchema.create(parentSchema, jsonSchema.name, dataSource,
               jsonSchema.jdbcCatalog, jsonSchema.jdbcSchema);
     } else {
-      SqlDialectFactory factory = AvaticaUtils.instantiatePlugin(
-          SqlDialectFactory.class, jsonSchema.sqlDialectFactory);
+      SqlDialectFactory factory =
+          AvaticaUtils.instantiatePlugin(SqlDialectFactory.class,
+              jsonSchema.sqlDialectFactory);
       schema =
           JdbcSchema.create(parentSchema, jsonSchema.name, dataSource,
               factory, jsonSchema.jdbcCatalog, jsonSchema.jdbcSchema);
@@ -478,15 +479,16 @@ public void visit(final JsonType jsonType) {
         } else {
           final RelDataTypeFactory.Builder builder = typeFactory.builder();
           for (JsonTypeAttribute jsonTypeAttribute : jsonType.attributes) {
-            final SqlTypeName typeName = requireNonNull(
-                SqlTypeName.get(jsonTypeAttribute.type),
-                () -> "SqlTypeName.get for " + jsonTypeAttribute.type);
+            final SqlTypeName typeName =
+                requireNonNull(SqlTypeName.get(jsonTypeAttribute.type),
+                    () -> "SqlTypeName.get for " + jsonTypeAttribute.type);
             RelDataType type = typeFactory.createSqlType(typeName);
             if (type == null) {
-              type = requireNonNull(currentSchema().getType(jsonTypeAttribute.type),
-                  () -> "type " + jsonTypeAttribute.type + " is not found in schema "
-                      + currentSchemaName())
-                  .apply(typeFactory);
+              type =
+                  requireNonNull(currentSchema().getType(jsonTypeAttribute.type),
+                      () -> "type " + jsonTypeAttribute.type
+                          + " is not found in schema " + currentSchemaName())
+                      .apply(typeFactory);
             }
             builder.add(jsonTypeAttribute.name, type);
           }
diff --git a/core/src/main/java/org/apache/calcite/plan/ConventionTraitDef.java b/core/src/main/java/org/apache/calcite/plan/ConventionTraitDef.java
index ddb844b97da..a68f5a22bc1 100644
--- a/core/src/main/java/org/apache/calcite/plan/ConventionTraitDef.java
+++ b/core/src/main/java/org/apache/calcite/plan/ConventionTraitDef.java
@@ -135,8 +135,9 @@ private ConventionTraitDef() {
     final RelMetadataQuery mq = rel.getCluster().getMetadataQuery();
     final ConversionData conversionData = getConversionData(planner);
 
-    final Convention fromConvention = requireNonNull(rel.getConvention(),
-        () -> "convention is null for rel " + rel);
+    final Convention fromConvention =
+        requireNonNull(rel.getConvention(),
+            () -> "convention is null for rel " + rel);
 
     List<List<Convention>> conversionPaths =
         conversionData.getPaths(fromConvention, toConvention);
diff --git a/core/src/main/java/org/apache/calcite/plan/RelOptMaterialization.java b/core/src/main/java/org/apache/calcite/plan/RelOptMaterialization.java
index 59d47676a40..62e4df76495 100644
--- a/core/src/main/java/org/apache/calcite/plan/RelOptMaterialization.java
+++ b/core/src/main/java/org/apache/calcite/plan/RelOptMaterialization.java
@@ -89,8 +89,8 @@ public RelOptMaterialization(RelNode tableRel, RelNode queryRel,
   public static @Nullable RelNode tryUseStar(RelNode rel,
       final RelOptTable starRelOptTable) {
     final StarTable starTable = starRelOptTable.unwrapOrThrow(StarTable.class);
-    RelNode rel2 = rel.accept(
-        new RelShuttleImpl() {
+    RelNode rel2 =
+        rel.accept(new RelShuttleImpl() {
           @Override public RelNode visit(TableScan scan) {
             RelOptTable relOptTable = scan.getTable();
             final Table table = relOptTable.unwrap(Table.class);
@@ -154,9 +154,10 @@ private void match(ProjectFilterTable left, ProjectFilterTable right,
                       Mappings.offsetTarget(
                           Mappings.offsetSource(rightMapping, offset),
                           leftMapping.getTargetCount()));
-              final RelNode project = RelOptUtil.createProject(
-                  leftRelOptTable.toRel(ViewExpanders.simpleContext(cluster)),
-                  Mappings.asListNonNull(mapping.inverse()));
+              final RelNode project =
+                  RelOptUtil.createProject(
+                      leftRelOptTable.toRel(ViewExpanders.simpleContext(cluster)),
+                      Mappings.asListNonNull(mapping.inverse()));
               final List<RexNode> conditions = new ArrayList<>();
               if (left.condition != null) {
                 conditions.add(left.condition);
@@ -179,9 +180,10 @@ private void match(ProjectFilterTable left, ProjectFilterTable right,
                   Mappings.merge(
                       Mappings.offsetSource(leftMapping, offset),
                       Mappings.offsetTarget(rightMapping, leftCount));
-              final RelNode project = RelOptUtil.createProject(
-                  rightRelOptTable.toRel(ViewExpanders.simpleContext(cluster)),
-                  Mappings.asListNonNull(mapping.inverse()));
+              final RelNode project =
+                  RelOptUtil.createProject(
+                      rightRelOptTable.toRel(ViewExpanders.simpleContext(cluster)),
+                      Mappings.asListNonNull(mapping.inverse()));
               final List<RexNode> conditions = new ArrayList<>();
               if (left.condition != null) {
                 conditions.add(
@@ -201,10 +203,11 @@ private void match(ProjectFilterTable left, ProjectFilterTable right,
       // No rewrite happened.
       return null;
     }
-    final Program program = Programs.hep(
-        ImmutableList.of(
-            CoreRules.PROJECT_FILTER_TRANSPOSE, CoreRules.AGGREGATE_PROJECT_MERGE,
-            CoreRules.AGGREGATE_FILTER_TRANSPOSE),
+    final Program program =
+        Programs.hep(
+            ImmutableList.of(CoreRules.PROJECT_FILTER_TRANSPOSE,
+                CoreRules.AGGREGATE_PROJECT_MERGE,
+                CoreRules.AGGREGATE_FILTER_TRANSPOSE),
         false,
         DefaultRelMetadataProvider.INSTANCE);
     return program.run(castNonNull(null), rel2, castNonNull(null),
@@ -270,12 +273,13 @@ public RelOptTable getTable() {
    * as close to leaves as possible.
    */
   public static RelNode toLeafJoinForm(RelNode rel) {
-    final Program program = Programs.hep(
-        ImmutableList.of(CoreRules.JOIN_PROJECT_RIGHT_TRANSPOSE,
-            CoreRules.JOIN_PROJECT_LEFT_TRANSPOSE,
-            CoreRules.FILTER_INTO_JOIN,
-            CoreRules.PROJECT_REMOVE,
-            CoreRules.PROJECT_MERGE),
+    final Program program =
+        Programs.hep(
+            ImmutableList.of(CoreRules.JOIN_PROJECT_RIGHT_TRANSPOSE,
+                CoreRules.JOIN_PROJECT_LEFT_TRANSPOSE,
+                CoreRules.FILTER_INTO_JOIN,
+                CoreRules.PROJECT_REMOVE,
+                CoreRules.PROJECT_MERGE),
         false,
         DefaultRelMetadataProvider.INSTANCE);
     if (CalciteSystemProperty.DEBUG.value()) {
@@ -283,9 +287,9 @@ public static RelNode toLeafJoinForm(RelNode rel) {
           RelOptUtil.dumpPlan("before", rel, SqlExplainFormat.TEXT,
               SqlExplainLevel.DIGEST_ATTRIBUTES));
     }
-    final RelNode rel2 = program.run(castNonNull(null), rel, castNonNull(null),
-        ImmutableList.of(),
-        ImmutableList.of());
+    final RelNode rel2 =
+        program.run(castNonNull(null), rel, castNonNull(null),
+            ImmutableList.of(), ImmutableList.of());
     if (CalciteSystemProperty.DEBUG.value()) {
       System.out.println(
           RelOptUtil.dumpPlan("after", rel2, SqlExplainFormat.TEXT,
diff --git a/core/src/main/java/org/apache/calcite/plan/RelOptMaterializations.java b/core/src/main/java/org/apache/calcite/plan/RelOptMaterializations.java
index a75909c8777..71246f860d2 100644
--- a/core/src/main/java/org/apache/calcite/plan/RelOptMaterializations.java
+++ b/core/src/main/java/org/apache/calcite/plan/RelOptMaterializations.java
@@ -192,8 +192,8 @@ private static List<RelNode> substitute(
     // First, if the materialization is in terms of a star table, rewrite
     // the query in terms of the star table.
     if (materialization.starRelOptTable != null) {
-      RelNode newRoot = RelOptMaterialization.tryUseStar(root,
-          materialization.starRelOptTable);
+      RelNode newRoot =
+          RelOptMaterialization.tryUseStar(root, materialization.starRelOptTable);
       if (newRoot != null) {
         root = newRoot;
       }
@@ -248,11 +248,10 @@ private static RelNode trimUnusedfields(RelNode relNode) {
     if (relOptTables.size() != 0) {
       relOptSchema = relOptTables.get(0).getRelOptSchema();
     }
-    final RelBuilder relBuilder = RelFactories.LOGICAL_BUILDER.create(
-        relNode.getCluster(), relOptSchema);
+    final RelBuilder relBuilder =
+        RelFactories.LOGICAL_BUILDER.create(relNode.getCluster(), relOptSchema);
     final RelFieldTrimmer relFieldTrimmer = new RelFieldTrimmer(null, relBuilder);
-    final RelNode rel = relFieldTrimmer.trim(relNode);
-    return rel;
+    return relFieldTrimmer.trim(relNode);
   }
 
   /**
diff --git a/core/src/main/java/org/apache/calcite/plan/RelOptRuleCall.java b/core/src/main/java/org/apache/calcite/plan/RelOptRuleCall.java
index fa4c4773028..b39aad73e23 100644
--- a/core/src/main/java/org/apache/calcite/plan/RelOptRuleCall.java
+++ b/core/src/main/java/org/apache/calcite/plan/RelOptRuleCall.java
@@ -201,13 +201,17 @@ public RelOptPlanner getPlanner() {
    * @return true iff rule should be excluded
    */
   public boolean isRuleExcluded() {
-    if (!(rels[0] instanceof Hintable)) {
-      return false;
+    for (RelNode rel : rels) {
+      if (!(rel instanceof Hintable)) {
+        continue;
+      }
+      if (rel.getCluster()
+              .getHintStrategies()
+              .isRuleExcluded((Hintable) rel, rule)) {
+        return true;
+      }
     }
-
-    return rels[0].getCluster()
-        .getHintStrategies()
-        .isRuleExcluded((Hintable) rels[0], rule);
+    return false;
   }
 
   /**
diff --git a/core/src/main/java/org/apache/calcite/plan/RelOptRules.java b/core/src/main/java/org/apache/calcite/plan/RelOptRules.java
index aa56f7857aa..3829c3c4343 100644
--- a/core/src/main/java/org/apache/calcite/plan/RelOptRules.java
+++ b/core/src/main/java/org/apache/calcite/plan/RelOptRules.java
@@ -47,8 +47,7 @@ private RelOptRules() {
   /** Calc rule set; public so that {@link org.apache.calcite.tools.Programs} can
    * use it. */
   public static final ImmutableList<RelOptRule> CALC_RULES =
-      ImmutableList.of(
-          Bindables.FROM_NONE_RULE,
+      ImmutableList.of(Bindables.FROM_NONE_RULE,
           EnumerableRules.ENUMERABLE_CALC_RULE,
           EnumerableRules.ENUMERABLE_FILTER_TO_CALC_RULE,
           EnumerableRules.ENUMERABLE_PROJECT_TO_CALC_RULE,
@@ -62,89 +61,91 @@ private RelOptRules() {
           CoreRules.FILTER_CALC_MERGE,
           CoreRules.PROJECT_CALC_MERGE);
 
-  static final List<RelOptRule> BASE_RULES = ImmutableList.of(
-      CoreRules.AGGREGATE_STAR_TABLE,
-      CoreRules.AGGREGATE_PROJECT_STAR_TABLE,
-      CalciteSystemProperty.COMMUTE.value()
-          ? CoreRules.JOIN_ASSOCIATE
-          : CoreRules.PROJECT_MERGE,
-      CoreRules.FILTER_SCAN,
-      CoreRules.PROJECT_FILTER_TRANSPOSE,
-      CoreRules.FILTER_PROJECT_TRANSPOSE,
-      CoreRules.FILTER_INTO_JOIN,
-      CoreRules.JOIN_PUSH_EXPRESSIONS,
-      CoreRules.AGGREGATE_EXPAND_DISTINCT_AGGREGATES,
-      CoreRules.AGGREGATE_EXPAND_WITHIN_DISTINCT,
-      CoreRules.AGGREGATE_CASE_TO_FILTER,
-      CoreRules.AGGREGATE_REDUCE_FUNCTIONS,
-      CoreRules.FILTER_AGGREGATE_TRANSPOSE,
-      CoreRules.PROJECT_WINDOW_TRANSPOSE,
-      CoreRules.MATCH,
-      CoreRules.JOIN_COMMUTE,
-      JoinPushThroughJoinRule.RIGHT,
-      JoinPushThroughJoinRule.LEFT,
-      CoreRules.SORT_PROJECT_TRANSPOSE,
-      CoreRules.SORT_JOIN_TRANSPOSE,
-      CoreRules.SORT_REMOVE_CONSTANT_KEYS,
-      CoreRules.SORT_UNION_TRANSPOSE,
-      CoreRules.EXCHANGE_REMOVE_CONSTANT_KEYS,
-      CoreRules.SORT_EXCHANGE_REMOVE_CONSTANT_KEYS);
+  static final List<RelOptRule> BASE_RULES =
+      ImmutableList.of(CoreRules.AGGREGATE_STAR_TABLE,
+          CoreRules.AGGREGATE_PROJECT_STAR_TABLE,
+          CalciteSystemProperty.COMMUTE.value()
+              ? CoreRules.JOIN_ASSOCIATE
+              : CoreRules.PROJECT_MERGE,
+          CoreRules.FILTER_SCAN,
+          CoreRules.PROJECT_FILTER_TRANSPOSE,
+          CoreRules.FILTER_PROJECT_TRANSPOSE,
+          CoreRules.FILTER_INTO_JOIN,
+          CoreRules.JOIN_PUSH_EXPRESSIONS,
+          CoreRules.AGGREGATE_EXPAND_DISTINCT_AGGREGATES,
+          CoreRules.AGGREGATE_EXPAND_WITHIN_DISTINCT,
+          CoreRules.AGGREGATE_CASE_TO_FILTER,
+          CoreRules.AGGREGATE_REDUCE_FUNCTIONS,
+          CoreRules.FILTER_AGGREGATE_TRANSPOSE,
+          CoreRules.PROJECT_WINDOW_TRANSPOSE,
+          CoreRules.MATCH,
+          CoreRules.JOIN_COMMUTE,
+          JoinPushThroughJoinRule.RIGHT,
+          JoinPushThroughJoinRule.LEFT,
+          CoreRules.SORT_PROJECT_TRANSPOSE,
+          CoreRules.SORT_JOIN_TRANSPOSE,
+          CoreRules.SORT_REMOVE_CONSTANT_KEYS,
+          CoreRules.SORT_UNION_TRANSPOSE,
+          CoreRules.EXCHANGE_REMOVE_CONSTANT_KEYS,
+          CoreRules.SORT_EXCHANGE_REMOVE_CONSTANT_KEYS);
 
-  static final List<RelOptRule> ABSTRACT_RULES = ImmutableList.of(
-      CoreRules.AGGREGATE_ANY_PULL_UP_CONSTANTS,
-      CoreRules.UNION_PULL_UP_CONSTANTS,
-      PruneEmptyRules.UNION_INSTANCE,
-      PruneEmptyRules.INTERSECT_INSTANCE,
-      PruneEmptyRules.MINUS_INSTANCE,
-      PruneEmptyRules.PROJECT_INSTANCE,
-      PruneEmptyRules.FILTER_INSTANCE,
-      PruneEmptyRules.SORT_INSTANCE,
-      PruneEmptyRules.AGGREGATE_INSTANCE,
-      PruneEmptyRules.JOIN_LEFT_INSTANCE,
-      PruneEmptyRules.JOIN_RIGHT_INSTANCE,
-      PruneEmptyRules.SORT_FETCH_ZERO_INSTANCE,
-      CoreRules.UNION_MERGE,
-      CoreRules.INTERSECT_MERGE,
-      CoreRules.MINUS_MERGE,
-      CoreRules.PROJECT_TO_LOGICAL_PROJECT_AND_WINDOW,
-      CoreRules.FILTER_MERGE,
-      DateRangeRules.FILTER_INSTANCE,
-      CoreRules.INTERSECT_TO_DISTINCT);
+  static final List<RelOptRule> ABSTRACT_RULES =
+      ImmutableList.of(CoreRules.AGGREGATE_ANY_PULL_UP_CONSTANTS,
+          CoreRules.UNION_PULL_UP_CONSTANTS,
+          PruneEmptyRules.UNION_INSTANCE,
+          PruneEmptyRules.INTERSECT_INSTANCE,
+          PruneEmptyRules.MINUS_INSTANCE,
+          PruneEmptyRules.PROJECT_INSTANCE,
+          PruneEmptyRules.FILTER_INSTANCE,
+          PruneEmptyRules.SORT_INSTANCE,
+          PruneEmptyRules.AGGREGATE_INSTANCE,
+          PruneEmptyRules.JOIN_LEFT_INSTANCE,
+          PruneEmptyRules.JOIN_RIGHT_INSTANCE,
+          PruneEmptyRules.SORT_FETCH_ZERO_INSTANCE,
+          PruneEmptyRules.EMPTY_TABLE_INSTANCE,
+          CoreRules.UNION_MERGE,
+          CoreRules.INTERSECT_MERGE,
+          CoreRules.MINUS_MERGE,
+          CoreRules.PROJECT_TO_LOGICAL_PROJECT_AND_WINDOW,
+          CoreRules.FILTER_MERGE,
+          DateRangeRules.FILTER_INSTANCE,
+          CoreRules.INTERSECT_TO_DISTINCT);
 
-  static final List<RelOptRule> ABSTRACT_RELATIONAL_RULES = ImmutableList.of(
-      CoreRules.FILTER_INTO_JOIN,
-      CoreRules.JOIN_CONDITION_PUSH,
-      AbstractConverter.ExpandConversionRule.INSTANCE,
-      CoreRules.JOIN_COMMUTE,
-      CoreRules.PROJECT_TO_SEMI_JOIN,
-      CoreRules.JOIN_TO_SEMI_JOIN,
-      CoreRules.AGGREGATE_REMOVE,
-      CoreRules.UNION_TO_DISTINCT,
-      CoreRules.PROJECT_REMOVE,
-      CoreRules.PROJECT_AGGREGATE_MERGE,
-      CoreRules.AGGREGATE_JOIN_TRANSPOSE,
-      CoreRules.AGGREGATE_MERGE,
-      CoreRules.AGGREGATE_PROJECT_MERGE,
-      CoreRules.CALC_REMOVE,
-      CoreRules.SORT_REMOVE);
+  static final List<RelOptRule> ABSTRACT_RELATIONAL_RULES =
+      ImmutableList.of(CoreRules.FILTER_INTO_JOIN,
+          CoreRules.JOIN_CONDITION_PUSH,
+          AbstractConverter.ExpandConversionRule.INSTANCE,
+          CoreRules.JOIN_COMMUTE,
+          CoreRules.PROJECT_TO_SEMI_JOIN,
+          CoreRules.JOIN_ON_UNIQUE_TO_SEMI_JOIN,
+          CoreRules.JOIN_TO_SEMI_JOIN,
+          CoreRules.AGGREGATE_REMOVE,
+          CoreRules.UNION_TO_DISTINCT,
+          CoreRules.PROJECT_REMOVE,
+          CoreRules.PROJECT_AGGREGATE_MERGE,
+          CoreRules.AGGREGATE_JOIN_TRANSPOSE,
+          CoreRules.AGGREGATE_MERGE,
+          CoreRules.AGGREGATE_PROJECT_MERGE,
+          CoreRules.CALC_REMOVE,
+          CoreRules.SORT_REMOVE);
 
-  static final List<RelOptRule> CONSTANT_REDUCTION_RULES = ImmutableList.of(
-      CoreRules.PROJECT_REDUCE_EXPRESSIONS,
-      CoreRules.FILTER_REDUCE_EXPRESSIONS,
-      CoreRules.CALC_REDUCE_EXPRESSIONS,
-      CoreRules.WINDOW_REDUCE_EXPRESSIONS,
-      CoreRules.JOIN_REDUCE_EXPRESSIONS,
-      CoreRules.FILTER_VALUES_MERGE,
-      CoreRules.PROJECT_FILTER_VALUES_MERGE,
-      CoreRules.PROJECT_VALUES_MERGE,
-      CoreRules.AGGREGATE_VALUES);
+  static final List<RelOptRule> CONSTANT_REDUCTION_RULES =
+      ImmutableList.of(CoreRules.PROJECT_REDUCE_EXPRESSIONS,
+          CoreRules.FILTER_REDUCE_EXPRESSIONS,
+          CoreRules.CALC_REDUCE_EXPRESSIONS,
+          CoreRules.WINDOW_REDUCE_EXPRESSIONS,
+          CoreRules.JOIN_REDUCE_EXPRESSIONS,
+          CoreRules.FILTER_VALUES_MERGE,
+          CoreRules.PROJECT_FILTER_VALUES_MERGE,
+          CoreRules.PROJECT_VALUES_MERGE,
+          CoreRules.AGGREGATE_VALUES);
 
-  public static final List<RelOptRule> MATERIALIZATION_RULES = ImmutableList.of(
-      MaterializedViewRules.FILTER_SCAN,
-      MaterializedViewRules.PROJECT_FILTER,
-      MaterializedViewRules.FILTER,
-      MaterializedViewRules.PROJECT_JOIN,
-      MaterializedViewRules.JOIN,
-      MaterializedViewRules.PROJECT_AGGREGATE,
-      MaterializedViewRules.AGGREGATE);
+  public static final List<RelOptRule> MATERIALIZATION_RULES =
+      ImmutableList.of(MaterializedViewRules.FILTER_SCAN,
+          MaterializedViewRules.PROJECT_FILTER,
+          MaterializedViewRules.FILTER,
+          MaterializedViewRules.PROJECT_JOIN,
+          MaterializedViewRules.JOIN,
+          MaterializedViewRules.PROJECT_AGGREGATE,
+          MaterializedViewRules.AGGREGATE);
 }
diff --git a/core/src/main/java/org/apache/calcite/plan/RelOptSamplingParameters.java b/core/src/main/java/org/apache/calcite/plan/RelOptSamplingParameters.java
index 2e9ddb7b8dc..99eb3da9077 100644
--- a/core/src/main/java/org/apache/calcite/plan/RelOptSamplingParameters.java
+++ b/core/src/main/java/org/apache/calcite/plan/RelOptSamplingParameters.java
@@ -48,7 +48,7 @@ public RelOptSamplingParameters(
   /**
    * Indicates whether Bernoulli or system sampling should be performed.
    * Bernoulli sampling requires the decision whether to include each row in
-   * the the sample to be independent across rows. System sampling allows
+   * the sample to be independent across rows. System sampling allows
    * implementation-dependent behavior.
    *
    * @return true if Bernoulli sampling is configured, false for system
diff --git a/core/src/main/java/org/apache/calcite/plan/RelOptUtil.java b/core/src/main/java/org/apache/calcite/plan/RelOptUtil.java
index c7b5c7cbcc7..b3e9552dac8 100644
--- a/core/src/main/java/org/apache/calcite/plan/RelOptUtil.java
+++ b/core/src/main/java/org/apache/calcite/plan/RelOptUtil.java
@@ -387,7 +387,9 @@ public static void verifyTypeEquivalence(
         + "set type is " + expectedRowType.getFullTypeString()
         + "\nexpression type is " + actualRowType.getFullTypeString()
         + "\nset is " + equivalenceClass.toString()
-        + "\nexpression is " + RelOptUtil.toString(newRel);
+        + "\nexpression is " + RelOptUtil.toString(newRel)
+        + getFullTypeDifferenceString("rowtype of original rel", expectedRowType,
+        "rowtype of new rel", actualRowType);
     throw new AssertionError(s);
   }
 
@@ -425,9 +427,10 @@ public static RelNode propagateRelHints(RelNode originalRel, RelNode equiv) {
         || ((Hintable) originalRel).getHints().size() == 0) {
       return equiv;
     }
-    final RelShuttle shuttle = new SubTreeHintPropagateShuttle(
-        originalRel.getCluster().getHintStrategies(),
-        ((Hintable) originalRel).getHints());
+    final RelShuttle shuttle =
+        new SubTreeHintPropagateShuttle(
+            originalRel.getCluster().getHintStrategies(),
+            ((Hintable) originalRel).getHints());
     return equiv.accept(shuttle);
   }
 
@@ -475,6 +478,10 @@ public static RelNode copyRelHints(RelNode originalRel, RelNode newRel) {
    * or {@code newRel} directly if one of them are not {@link Hintable}
    */
   public static RelNode copyRelHints(RelNode originalRel, RelNode newRel, boolean filterHints) {
+    if (originalRel == newRel && !filterHints) {
+      return originalRel;
+    }
+
     if (originalRel instanceof Hintable
         && newRel instanceof Hintable
         && ((Hintable) originalRel).getHints().size() > 0) {
@@ -885,31 +892,31 @@ public static RelNode createCastRel(
     List<RexNode> castExps;
     RelNode input;
     List<RelHint> hints = ImmutableList.of();
+    Set<CorrelationId> correlationVariables;
     if (rel instanceof Project) {
       // No need to create another project node if the rel
       // is already a project.
       final Project project = (Project) rel;
-      castExps = RexUtil.generateCastExpressions(
-          rexBuilder,
-          castRowType,
-          ((Project) rel).getProjects());
+      castExps =
+          RexUtil.generateCastExpressions(rexBuilder, castRowType,
+              ((Project) rel).getProjects());
       input = rel.getInput(0);
       hints = project.getHints();
+      correlationVariables = project.getVariablesSet();
     } else {
-      castExps = RexUtil.generateCastExpressions(
-          rexBuilder,
-          castRowType,
-          rowType);
+      castExps =
+          RexUtil.generateCastExpressions(rexBuilder, castRowType, rowType);
       input = rel;
+      correlationVariables = ImmutableSet.of();
     }
     if (rename) {
       // Use names and types from castRowType.
       return projectFactory.createProject(input, hints, castExps,
-          castRowType.getFieldNames());
+          castRowType.getFieldNames(), correlationVariables);
     } else {
       // Use names from rowType, types from castRowType.
       return projectFactory.createProject(input, hints, castExps,
-          rowType.getFieldNames());
+          rowType.getFieldNames(), correlationVariables);
     }
   }
 
@@ -3189,8 +3196,9 @@ public static RexNode pushPastCalc(RexNode node, Calc calc) {
   }
 
   private static RexShuttle pushShuttle(final Calc calc) {
-    final List<RexNode> projects = Util.transform(calc.getProgram().getProjectList(),
-        calc.getProgram()::expandLocalRef);
+    final List<RexNode> projects =
+        Util.transform(calc.getProgram().getProjectList(),
+            calc.getProgram()::expandLocalRef);
     return new RexShuttle() {
       @Override public RexNode visitInputRef(RexInputRef ref) {
         return projects.get(ref.getIndex());
@@ -3619,7 +3627,8 @@ public static RelNode projectMapping(
               : fieldNames.get(i));
       exprList.add(rexBuilder.makeInputRef(rel, source));
     }
-    return projectFactory.createProject(rel, ImmutableList.of(), exprList, outputNameList);
+    return projectFactory.createProject(rel, ImmutableList.of(), exprList, outputNameList,
+        ImmutableSet.of());
   }
 
   /** Predicate for if a {@link Calc} does not contain windowed aggregates. */
@@ -3731,8 +3740,9 @@ public static RelNode pushDownJoinConditions(Join originalJoin,
     // yet.
     if (!containsGet(joinCond)
         && RexUtil.SubQueryFinder.find(joinCond) == null) {
-      joinCond = pushDownEqualJoinConditions(joinCond, leftCount, rightCount, extraLeftExprs,
-          extraRightExprs, relBuilder.getRexBuilder());
+      joinCond =
+          pushDownEqualJoinConditions(joinCond, leftCount, rightCount,
+              extraLeftExprs, extraRightExprs, relBuilder.getRexBuilder());
     }
 
     relBuilder.push(originalJoin.getLeft());
@@ -3886,8 +3896,8 @@ private static RexNode pushDownEqualJoinConditions(
       for (int i = 0; i < operands.size(); i++) {
         RexNode operand = operands.get(i);
         if (operand instanceof RexCall) {
-          operand = collapseExpandedIsNotDistinctFromExpr(
-              (RexCall) operand, builder);
+          operand =
+              collapseExpandedIsNotDistinctFromExpr((RexCall) operand, builder);
         }
         if (node.getKind() == SqlKind.AND
             && operand.getKind() != SqlKind.EQUALS
diff --git a/core/src/main/java/org/apache/calcite/plan/RelTraitSet.java b/core/src/main/java/org/apache/calcite/plan/RelTraitSet.java
index 955d0e945f2..9e7e3d5a9f4 100644
--- a/core/src/main/java/org/apache/calcite/plan/RelTraitSet.java
+++ b/core/src/main/java/org/apache/calcite/plan/RelTraitSet.java
@@ -693,8 +693,8 @@ public RelTraitSet simplify() {
     for (int i = 0; i < traits.length; i++) {
       final RelTrait trait = traits[i];
       if (trait instanceof RelCompositeTrait) {
-        x = x.replace(i,
-            ((RelCompositeTrait) trait).size() == 1
+        x =
+            x.replace(i, ((RelCompositeTrait) trait).size() == 1
                 ? ((RelCompositeTrait) trait).trait(0)
                 : trait.getTraitDef().getDefault());
       }
diff --git a/core/src/main/java/org/apache/calcite/plan/Strong.java b/core/src/main/java/org/apache/calcite/plan/Strong.java
index 52b7f2686e1..5e6612d520d 100644
--- a/core/src/main/java/org/apache/calcite/plan/Strong.java
+++ b/core/src/main/java/org/apache/calcite/plan/Strong.java
@@ -152,13 +152,38 @@ public static boolean allStrong(List<RexNode> operands) {
   /** Returns whether an expression is definitely not true. */
   public boolean isNotTrue(RexNode node) {
     switch (node.getKind()) {
+    //TODO Enrich with more possible cases?
     case IS_NOT_NULL:
-      return anyNull(((RexCall) node).getOperands());
+      return isNull(((RexCall) node).getOperands().get(0));
+    case OR:
+      return allNotTrue(((RexCall) node).getOperands());
+    case AND:
+      return anyNotTrue(((RexCall) node).getOperands());
     default:
       return isNull(node);
     }
   }
 
+  /** Returns whether all expressions in a list are definitely not true. */
+  private boolean allNotTrue(List<RexNode> operands) {
+    for (RexNode operand : operands) {
+      if (!isNotTrue(operand)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /** Returns whether any expressions in a list are definitely not true. */
+  private boolean anyNotTrue(List<RexNode> operands) {
+    for (RexNode operand : operands) {
+      if (isNotTrue(operand)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
   /** Returns whether an expression is definitely null.
    *
    * <p>The answer is based on calls to {@link #isNull} for its constituent
diff --git a/core/src/main/java/org/apache/calcite/plan/SubstitutionVisitor.java b/core/src/main/java/org/apache/calcite/plan/SubstitutionVisitor.java
index 8044fca6895..9e7cddbd717 100644
--- a/core/src/main/java/org/apache/calcite/plan/SubstitutionVisitor.java
+++ b/core/src/main/java/org/apache/calcite/plan/SubstitutionVisitor.java
@@ -307,10 +307,11 @@ void register(MutableRel result, MutableRel query) {
 
     RexNode x = andNot(rexBuilder, target2, condition2);
     if (mayBeSatisfiable(x)) {
-      RexNode x2 = RexUtil.composeConjunction(rexBuilder,
-          ImmutableList.of(condition2, target2));
-      RexNode r = canonizeNode(rexBuilder,
-          simplify.simplifyUnknownAsFalse(x2));
+      RexNode x2 =
+          RexUtil.composeConjunction(rexBuilder,
+              ImmutableList.of(condition2, target2));
+      RexNode r =
+          canonizeNode(rexBuilder, simplify.simplifyUnknownAsFalse(x2));
       if (!r.isAlwaysFalse() && isEquivalent(condition2, r)) {
         List<RexNode> conjs = RelOptUtil.conjunctions(r);
         for (RexNode e : RelOptUtil.conjunctions(target2)) {
@@ -410,10 +411,10 @@ private static boolean isEquivalent(RexNode condition, RexNode target) {
     //  e: x = 1 AND y = 2 AND z = 3 AND NOT (x = 1 AND y = 2)
     //  disjunctions: {x = 1, y = 2, z = 3}
     //  notDisjunctions: {x = 1 AND y = 2}
-    final Set<String> conditionDisjunctions = new HashSet<>(
-        RexUtil.strings(RelOptUtil.conjunctions(condition)));
-    final Set<String> targetDisjunctions = new HashSet<>(
-        RexUtil.strings(RelOptUtil.conjunctions(target)));
+    final Set<String> conditionDisjunctions =
+        new HashSet<>(RexUtil.strings(RelOptUtil.conjunctions(condition)));
+    final Set<String> targetDisjunctions =
+        new HashSet<>(RexUtil.strings(RelOptUtil.conjunctions(target)));
     if (conditionDisjunctions.equals(targetDisjunctions)) {
       return true;
     }
@@ -605,8 +606,8 @@ assert rowTypesAreEquivalent(
                   // Meanwhile we stop matching the descendants and jump
                   // to the next subtree in pre-order traversal.
                   if (!target.equals(replacement)) {
-                    Replacement r = replace(
-                        query.getInput(), target, replacement.clone());
+                    Replacement r =
+                        replace(query.getInput(), target, replacement.clone());
                     assert r != null
                         : rule + "should have returned a result containing the target.";
                     attempted.add(r);
@@ -1098,16 +1099,16 @@ private ScanToCalcUnifyRule() {
       final RexShuttle shuttle = getRexShuttle(targetProjs);
       final List<RexNode> compenProjs;
       try {
-        compenProjs = shuttle.apply(
-            rexBuilder.identityProjects(query.rowType));
+        compenProjs = shuttle.apply(rexBuilder.identityProjects(query.rowType));
       } catch (MatchFailed e) {
         return null;
       }
       if (RexUtil.isIdentity(compenProjs, target.rowType)) {
         return call.result(target);
       } else {
-        RexProgram compenRexProgram = RexProgram.create(
-            target.rowType, compenProjs, null, query.rowType, rexBuilder);
+        RexProgram compenRexProgram =
+            RexProgram.create(target.rowType, compenProjs, null, query.rowType,
+                rexBuilder);
         MutableCalc compenCalc = MutableCalc.of(target, compenRexProgram);
         return tryMergeParentCalcAndGenResult(call, compenCalc);
       }
@@ -1172,9 +1173,9 @@ private CalcToCalcUnifyRule() {
             && RexUtil.isIdentity(compenProjs, target.rowType)) {
           return call.result(target);
         } else {
-          final RexProgram compenRexProgram = RexProgram.create(
-              target.rowType, compenProjs, compenCond,
-              query.rowType, rexBuilder);
+          final RexProgram compenRexProgram =
+              RexProgram.create(target.rowType, compenProjs, compenCond,
+                  query.rowType, rexBuilder);
           final MutableCalc compenCalc = MutableCalc.of(target, compenRexProgram);
           return tryMergeParentCalcAndGenResult(call, compenCalc);
         }
@@ -1257,9 +1258,9 @@ private JoinOnLeftCalcToJoinUnifyRule() {
                 new RexInputRef(newIdx, query.rowType.getFieldList().get(i).getType()));
           }
         }
-        final RexProgram compenRexProgram = RexProgram.create(
-            target.rowType, compenProjs, compenCond,
-            query.rowType, rexBuilder);
+        final RexProgram compenRexProgram =
+            RexProgram.create(target.rowType, compenProjs, compenCond,
+                query.rowType, rexBuilder);
         final MutableCalc compenCalc = MutableCalc.of(target, compenRexProgram);
         return tryMergeParentCalcAndGenResult(call, compenCalc);
       }
@@ -1338,14 +1339,15 @@ private JoinOnRightCalcToJoinUnifyRule() {
             compenProjs.add(
                 new RexInputRef(i, query.rowType.getFieldList().get(i).getType()));
           } else {
-            final RexNode shifted = RexUtil.shift(qInput1Projs.get(i - fieldCnt(qInput0)),
-                qInput0.rowType.getFieldCount());
+            final RexNode shifted =
+                RexUtil.shift(qInput1Projs.get(i - fieldCnt(qInput0)),
+                    qInput0.rowType.getFieldCount());
             compenProjs.add(shifted);
           }
         }
-        final RexProgram compensatingRexProgram = RexProgram.create(
-            target.rowType, compenProjs, compenCond,
-            query.rowType, rexBuilder);
+        final RexProgram compensatingRexProgram =
+            RexProgram.create(target.rowType, compenProjs, compenCond,
+                query.rowType, rexBuilder);
         final MutableCalc compenCalc = MutableCalc.of(target, compensatingRexProgram);
         return tryMergeParentCalcAndGenResult(call, compenCalc);
       }
@@ -1418,22 +1420,24 @@ private JoinOnCalcsToJoinUnifyRule() {
       if (splitted != null && splitted.isAlwaysTrue()) {
         final RexNode qInput1CondShifted =
             RexUtil.shift(qInput1Cond, fieldCnt(qInput0.getInput()));
-        final RexNode compenCond = RexUtil.composeConjunction(rexBuilder,
-            ImmutableList.of(qInput0Cond, qInput1CondShifted));
+        final RexNode compenCond =
+            RexUtil.composeConjunction(rexBuilder,
+                ImmutableList.of(qInput0Cond, qInput1CondShifted));
 
         final List<RexNode> compenProjs = new ArrayList<>();
         for (int i = 0; i < query.rowType.getFieldCount(); i++) {
           if (i < fieldCnt(qInput0)) {
             compenProjs.add(qInput0Projs.get(i));
           } else {
-            RexNode shifted = RexUtil.shift(qInput1Projs.get(i - fieldCnt(qInput0)),
-                fieldCnt(qInput0.getInput()));
+            RexNode shifted =
+                RexUtil.shift(qInput1Projs.get(i - fieldCnt(qInput0)),
+                    fieldCnt(qInput0.getInput()));
             compenProjs.add(shifted);
           }
         }
-        final RexProgram compensatingRexProgram = RexProgram.create(
-            target.rowType, compenProjs, compenCond,
-            query.rowType, rexBuilder);
+        final RexProgram compensatingRexProgram =
+            RexProgram.create(target.rowType, compenProjs, compenCond,
+                query.rowType, rexBuilder);
         final MutableCalc compensatingCalc =
             MutableCalc.of(target, compensatingRexProgram);
         return tryMergeParentCalcAndGenResult(call, compensatingCalc);
@@ -1497,10 +1501,10 @@ private AggregateOnCalcToAggregateUnifyRule() {
       final MutableAggregate aggregate2 =
           permute(query, qInput.getInput(), inverseMapping);
 
-      final Mappings.TargetMapping mappingForQueryCond = Mappings.target(
-          target.groupSet::indexOf,
-          target.getInput().rowType.getFieldCount(),
-          target.groupSet.cardinality());
+      final Mappings.TargetMapping mappingForQueryCond =
+          Mappings.target(target.groupSet::indexOf,
+              target.getInput().rowType.getFieldCount(),
+              target.groupSet.cardinality());
       final RexNode targetCond = RexUtil.apply(mappingForQueryCond, qInputCond);
 
       final MutableRel unifiedAggregate =
@@ -1524,9 +1528,9 @@ private AggregateOnCalcToAggregateUnifyRule() {
         }
         final List<RexNode> compenProjs =
             MutableRels.createProjectExprs(unifiedAggregate, posList);
-        final RexProgram compensatingRexProgram = RexProgram.create(
-            unifiedAggregate.rowType, compenProjs, null,
-            query.rowType, rexBuilder);
+        final RexProgram compensatingRexProgram =
+            RexProgram.create(unifiedAggregate.rowType, compenProjs, null,
+                query.rowType, rexBuilder);
         final MutableCalc compenCalc =
             MutableCalc.of(unifiedAggregate, compensatingRexProgram);
         if (unifiedAggregate instanceof MutableCalc) {
@@ -1708,8 +1712,9 @@ && sameRelCollectionNoOrderConsidered(queryGrandInputs, targetInputs)) {
         final Pair<RexNode, List<RexNode>> queryInputExplained =
             explainCalc(queryInputs.get(i));
         // Matching fails when filtering conditions are not equal or projects are not equal.
-        RexNode residue = splitFilter(call.getSimplify(), queryInputExplained0.left,
-            queryInputExplained.left);
+        RexNode residue =
+            splitFilter(call.getSimplify(), queryInputExplained0.left,
+                queryInputExplained.left);
         if (residue == null || !residue.isAlwaysTrue()) {
           return null;
         }
@@ -1721,11 +1726,11 @@ && sameRelCollectionNoOrderConsidered(queryGrandInputs, targetInputs)) {
         }
       }
 
-      List<RexNode> projectExprs = MutableRels.createProjects(target,
-          queryInputExplained0.right);
-      final RexProgram compenRexProgram = RexProgram.create(
-          target.rowType, projectExprs, queryInputExplained0.left,
-          query.rowType, rexBuilder);
+      List<RexNode> projectExprs =
+          MutableRels.createProjects(target, queryInputExplained0.right);
+      final RexProgram compenRexProgram =
+          RexProgram.create(target.rowType, projectExprs,
+              queryInputExplained0.left, query.rowType, rexBuilder);
       final MutableCalc compenCalc = MutableCalc.of(target, compenRexProgram);
       return tryMergeParentCalcAndGenResult(call, compenCalc);
     }
@@ -1777,8 +1782,9 @@ private static UnifyResult tryMergeParentCalcAndGenResult(
       UnifyRuleCall call, MutableRel child) {
     final MutableRel parent = call.query.getParent();
     if (child instanceof MutableCalc && parent instanceof MutableCalc) {
-      final MutableCalc mergedCalc = mergeCalc(call.getCluster().getRexBuilder(),
-          (MutableCalc) parent, (MutableCalc) child);
+      final MutableCalc mergedCalc =
+          mergeCalc(call.getCluster().getRexBuilder(), (MutableCalc) parent,
+              (MutableCalc) child);
       if (mergedCalc != null) {
         // Note that property of stopTrying in the result is false
         // and this query node deserves further matching iterations.
@@ -1911,8 +1917,8 @@ public static MutableAggregate permute(MutableAggregate aggregate,
       for (AggregateCall aggregateCall : query.aggCalls) {
         int i = target.aggCalls.indexOf(aggregateCall);
         if (i < 0) {
-          final AggregateCall newAggCall = genAggCallWithTargetGrouping(
-              aggregateCall, targetGroupByIndexList);
+          final AggregateCall newAggCall =
+              genAggCallWithTargetGrouping(aggregateCall, targetGroupByIndexList);
           if (newAggCall == null) {
             return null;
           } else {
@@ -1933,12 +1939,14 @@ public static MutableAggregate permute(MutableAggregate aggregate,
 
       if (targetGroupGenAggCalls.isEmpty()) {
         List<RexNode> compenProjs = MutableRels.createProjectExprs(target, projects);
-        RexProgram compenRexProgram = RexProgram.create(
-            target.rowType, compenProjs, targetCond, query.rowType, rexBuilder);
+        RexProgram compenRexProgram =
+            RexProgram.create(target.rowType, compenProjs, targetCond,
+                query.rowType, rexBuilder);
         result = MutableCalc.of(target, compenRexProgram);
       } else {
-        result = MutableAggregate.of(target,
-            target.groupSet, target.groupSets, targetGroupGenAggCalls);
+        result =
+            MutableAggregate.of(target, target.groupSet, target.groupSets,
+                targetGroupGenAggCalls);
       }
     } else if (target.getGroupType() == Aggregate.Group.SIMPLE) {
       // Query is coarser level of aggregation. Generate an aggregate.
@@ -1952,8 +1960,9 @@ public static MutableAggregate permute(MutableAggregate aggregate,
       final ImmutableBitSet groupSet = query.groupSet.permute(map);
       ImmutableList<ImmutableBitSet> groupSets = null;
       if (query.getGroupType() != Aggregate.Group.SIMPLE) {
-        groupSets = ImmutableBitSet.ORDERING.immutableSortedCopy(
-            ImmutableBitSet.permute(query.groupSets, map));
+        groupSets =
+            ImmutableBitSet.ORDERING.immutableSortedCopy(
+                ImmutableBitSet.permute(query.groupSets, map));
       }
       final List<AggregateCall> aggregateCalls = new ArrayList<>();
       for (AggregateCall aggregateCall : query.aggCalls) {
@@ -1967,12 +1976,12 @@ public static MutableAggregate permute(MutableAggregate aggregate,
             // and the materialization recognition will fail.
             final SqlAggFunction aggFunction = aggregateCall.getAggregation().getRollup();
             if (aggFunction != null) {
-              newAggCall = AggregateCall.create(aggFunction,
-                  aggregateCall.isDistinct(), aggregateCall.isApproximate(),
-                  aggregateCall.ignoreNulls(),
-                  ImmutableList.of(target.groupSet.cardinality() + i), -1,
-                  aggregateCall.distinctKeys, aggregateCall.collation,
-                  aggregateCall.type, aggregateCall.name);
+              newAggCall =
+                  AggregateCall.create(aggFunction, aggregateCall.isDistinct(),
+                      aggregateCall.isApproximate(), aggregateCall.ignoreNulls(),
+                      ImmutableList.of(target.groupSet.cardinality() + i), -1,
+                      aggregateCall.distinctKeys, aggregateCall.collation,
+                      aggregateCall.type, aggregateCall.name);
             }
           }
         }
@@ -1987,16 +1996,17 @@ public static MutableAggregate permute(MutableAggregate aggregate,
         aggregateCalls.add(newAggCall);
       }
       if (targetCond != null && !targetCond.isAlwaysTrue()) {
-        RexProgram compenRexProgram = RexProgram.create(
-            target.rowType, rexBuilder.identityProjects(target.rowType),
-            targetCond, target.rowType, rexBuilder);
-
-        result = MutableAggregate.of(
-            MutableCalc.of(target, compenRexProgram),
-            groupSet, groupSets, aggregateCalls);
+        RexProgram compenRexProgram =
+            RexProgram.create(target.rowType,
+                rexBuilder.identityProjects(target.rowType),
+                targetCond, target.rowType, rexBuilder);
+
+        result =
+            MutableAggregate.of(MutableCalc.of(target, compenRexProgram),
+                groupSet, groupSets, aggregateCalls);
       } else {
-        result = MutableAggregate.of(
-            target, groupSet, groupSets, aggregateCalls);
+        result =
+            MutableAggregate.of(target, groupSet, groupSets, aggregateCalls);
       }
     } else {
       return null;
diff --git a/core/src/main/java/org/apache/calcite/plan/visualizer/RuleMatchVisualizer.java b/core/src/main/java/org/apache/calcite/plan/visualizer/RuleMatchVisualizer.java
index 66a20e8f2af..7851ec15641 100644
--- a/core/src/main/java/org/apache/calcite/plan/visualizer/RuleMatchVisualizer.java
+++ b/core/src/main/java/org/apache/calcite/plan/visualizer/RuleMatchVisualizer.java
@@ -24,6 +24,7 @@
 import org.apache.calcite.plan.volcano.RelSubset;
 import org.apache.calcite.rel.RelNode;
 import org.apache.calcite.rel.metadata.RelMetadataQuery;
+import org.apache.calcite.util.Util;
 
 import org.apache.commons.io.IOUtils;
 
@@ -46,7 +47,6 @@
 import java.text.MessageFormat;
 import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.Collections;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -96,10 +96,11 @@ public class RuleMatchVisualizer implements RelOptListener {
   private final Map<String, NodeUpdateHelper> allNodes = new LinkedHashMap<>();
 
   /**
-   * Use this constructor to save the result on disk at the end of the planning phase.
-   * <p>
-   * Note: when using HepPlanner, {@link #writeToFile()} needs to be called manually.
-   * </p>
+   * Use this constructor to save the result on disk at the end of the planning
+   * phase.
+   *
+   * <p>Note: when using HepPlanner, {@link #writeToFile()} needs to be called
+   * manually.
    */
   public RuleMatchVisualizer(
       String outputDirectory,
@@ -354,9 +355,10 @@ private void addStep(String stepID, @Nullable RelOptRuleCall ruleCall) {
       }
     }
 
-    List<String> matchedRels = ruleCall == null
-        ? Collections.emptyList()
-        : Arrays.stream(ruleCall.rels).map(this::key).collect(Collectors.toList());
+    List<String> matchedRels =
+        Arrays.stream(ruleCall == null ? new RelNode[0] : ruleCall.rels)
+            .map(RuleMatchVisualizer::key)
+            .collect(Util.toImmutableList());
     this.steps.add(new StepInfo(stepID, nextNodeUpdates, matchedRels));
   }
 
@@ -423,11 +425,11 @@ public void writeToFile() {
   // methods related to string representation
   //--------------------------------------------------------------------------------
 
-  private String key(final RelNode rel) {
+  private static String key(final RelNode rel) {
     return "" + rel.getId();
   }
 
-  private String getNodeLabel(final RelNode relNode) {
+  private static String getNodeLabel(final RelNode relNode) {
     if (relNode instanceof RelSubset) {
       final RelSubset relSubset = (RelSubset) relNode;
       String setId = getSetId(relSubset);
@@ -438,7 +440,7 @@ private String getNodeLabel(final RelNode relNode) {
     return "#" + relNode.getId() + "-" + relNode.getRelTypeName();
   }
 
-  private String getSetId(final RelSubset relSubset) {
+  private static String getSetId(final RelSubset relSubset) {
     String explanation = getNodeExplanation(relSubset);
     int start = explanation.indexOf("RelSubset") + "RelSubset".length();
     if (start < 0) {
@@ -451,7 +453,7 @@ private String getSetId(final RelSubset relSubset) {
     return explanation.substring(start, end);
   }
 
-  private String getNodeExplanation(final RelNode relNode) {
+  private static String getNodeExplanation(final RelNode relNode) {
     InputExcludedRelWriter relWriter = new InputExcludedRelWriter();
     relNode.explain(relWriter);
     return relWriter.toString();
@@ -472,8 +474,7 @@ private static String formatCost(Double rowCount, @Nullable RelOptCost cost) {
             formatCostScientific(cost.getRows()),
             formatCostScientific(cost.getCpu()),
             formatCostScientific(cost.getIo())
-        }
-    );
+        });
   }
 
   private static String formatCostScientific(double costNumber) {
diff --git a/core/src/main/java/org/apache/calcite/plan/visualizer/StepInfo.java b/core/src/main/java/org/apache/calcite/plan/visualizer/StepInfo.java
index ce91058efc3..01340c6b7a4 100644
--- a/core/src/main/java/org/apache/calcite/plan/visualizer/StepInfo.java
+++ b/core/src/main/java/org/apache/calcite/plan/visualizer/StepInfo.java
@@ -16,7 +16,9 @@
  */
 package org.apache.calcite.plan.visualizer;
 
-import java.util.Collections;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+
 import java.util.List;
 import java.util.Map;
 
@@ -32,8 +34,8 @@ class StepInfo {
       final Map<String, Object> updates,
       final List<String> matchedRels) {
     this.id = id;
-    this.updates = Collections.unmodifiableMap(updates);
-    this.matchedRels = Collections.unmodifiableList(matchedRels);
+    this.updates = ImmutableMap.copyOf(updates);
+    this.matchedRels = ImmutableList.copyOf(matchedRels);
   }
 
   public String getId() {
diff --git a/core/src/main/java/org/apache/calcite/plan/volcano/Dumpers.java b/core/src/main/java/org/apache/calcite/plan/volcano/Dumpers.java
index 0e25bce5b8e..4664a194346 100644
--- a/core/src/main/java/org/apache/calcite/plan/volcano/Dumpers.java
+++ b/core/src/main/java/org/apache/calcite/plan/volcano/Dumpers.java
@@ -178,8 +178,9 @@ static void dumpGraphviz(VolcanoPlanner planner, PrintWriter pw) {
     }
     pw.println("digraph G {");
     pw.println("\troot [style=filled,label=\"Root\"];");
-    PartiallyOrderedSet<RelSubset> subsetPoset = new PartiallyOrderedSet<>(
-        (e1, e2) -> e1.getTraitSet().satisfies(e2.getTraitSet()));
+    PartiallyOrderedSet<RelSubset> subsetPoset =
+        new PartiallyOrderedSet<>(
+            (e1, e2) -> e1.getTraitSet().satisfies(e2.getTraitSet()));
     Set<RelSubset> nonEmptySubsets = new HashSet<>();
     for (RelSet set : ordering.immutableSortedCopy(planner.allSets)) {
       pw.print("\tsubgraph cluster");
diff --git a/core/src/main/java/org/apache/calcite/plan/volcano/RelSet.java b/core/src/main/java/org/apache/calcite/plan/volcano/RelSet.java
index 7142a68d5cd..1fd6ed9229a 100644
--- a/core/src/main/java/org/apache/calcite/plan/volcano/RelSet.java
+++ b/core/src/main/java/org/apache/calcite/plan/volcano/RelSet.java
@@ -178,8 +178,8 @@ void obliterateRelNode(RelNode rel) {
   public RelSubset add(RelNode rel) {
     assert equivalentSet == null : "adding to a dead set";
     final RelTraitSet traitSet = rel.getTraitSet().simplify();
-    final RelSubset subset = getOrCreateSubset(
-        rel.getCluster(), traitSet, rel.isEnforcer());
+    final RelSubset subset =
+        getOrCreateSubset(rel.getCluster(), traitSet, rel.isEnforcer());
     subset.add(rel);
     return subset;
   }
@@ -192,9 +192,10 @@ public RelSubset add(RelNode rel) {
   void addConverters(RelSubset subset, boolean required,
       boolean useAbstractConverter) {
     RelOptCluster cluster = subset.getCluster();
-    List<RelSubset> others = subsets.stream().filter(
-        n -> required ? n.isDelivered() : n.isRequired())
-        .collect(Collectors.toList());
+    List<RelSubset> others =
+        subsets.stream()
+            .filter(n -> required ? n.isDelivered() : n.isRequired())
+            .collect(Collectors.toList());
 
     for (RelSubset other : others) {
       assert other.getTraitSet().size() == subset.getTraitSet().size();
@@ -242,12 +243,11 @@ void addConverters(RelSubset subset, boolean required,
       if (needsConverter) {
         final RelNode enforcer;
         if (useAbstractConverter) {
-          enforcer = new AbstractConverter(
-              cluster, from, null, to.getTraitSet());
+          enforcer = new AbstractConverter(cluster, from, null, to.getTraitSet());
         } else {
-          Convention convention = requireNonNull(
-              subset.getConvention(),
-              () -> "convention is null for " + subset);
+          Convention convention =
+              requireNonNull(subset.getConvention(),
+                  () -> "convention is null for " + subset);
           enforcer = convention.enforce(from, to.getTraitSet());
         }
 
diff --git a/core/src/main/java/org/apache/calcite/plan/volcano/RelSubset.java b/core/src/main/java/org/apache/calcite/plan/volcano/RelSubset.java
index 8e4a75e8e12..c482e6875ac 100644
--- a/core/src/main/java/org/apache/calcite/plan/volcano/RelSubset.java
+++ b/core/src/main/java/org/apache/calcite/plan/volcano/RelSubset.java
@@ -33,7 +33,6 @@
 import org.apache.calcite.rel.metadata.RelMetadataQuery;
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.sql.SqlExplainLevel;
-import org.apache.calcite.util.Litmus;
 import org.apache.calcite.util.Pair;
 import org.apache.calcite.util.Util;
 import org.apache.calcite.util.trace.CalciteTrace;
@@ -51,6 +50,7 @@
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Comparator;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedHashSet;
 import java.util.List;
@@ -172,8 +172,7 @@ public class RelSubset extends AbstractRelNode {
   private void computeBestCost(
       @UnderInitialization RelSubset this,
       RelOptCluster cluster,
-      RelOptPlanner planner
-  ) {
+      RelOptPlanner planner) {
     bestCost = planner.getCostFactory().makeInfiniteCost();
     final RelMetadataQuery mq = cluster.getMetadataQuery();
     @SuppressWarnings("method.invocation.invalid")
@@ -364,12 +363,6 @@ void add(RelNode rel) {
       planner.getListener().relEquivalenceFound(event);
     }
 
-    // If this isn't the first rel in the set, it must have compatible
-    // row type.
-    if (set.rel != null) {
-      RelOptUtil.equal("rowtype of new rel", rel.getRowType(),
-          "rowtype of set", getRowType(), Litmus.THROW);
-    }
     set.addInternal(rel);
     if (false) {
       Set<CorrelationId> variablesSet = RelOptUtil.getVariablesSet(rel);
@@ -605,6 +598,7 @@ private boolean visitRel(RelNode p) {
    */
   static class CheapestPlanReplacer {
     VolcanoPlanner planner;
+    final Map<Integer, RelNode> visited = new HashMap<>();
 
     CheapestPlanReplacer(VolcanoPlanner planner) {
       super();
@@ -623,6 +617,13 @@ public RelNode visit(
         RelNode p,
         int ordinal,
         @Nullable RelNode parent) {
+      final int pId = p.getId();
+      RelNode prevVisit = visited.get(pId);
+      if (prevVisit != null) {
+        // return memoized result of previous visit if available
+        return prevVisit;
+      }
+
       if (p instanceof RelSubset) {
         RelSubset subset = (RelSubset) p;
         RelNode cheapest = subset.best;
@@ -737,6 +738,7 @@ public RelNode visit(
         planner.provenanceMap.put(
             p, new VolcanoPlanner.DirectProvenance(pOld));
       }
+      visited.put(pId, p); // memoize result for pId
       return p;
     }
   }
diff --git a/core/src/main/java/org/apache/calcite/plan/volcano/TopDownRuleDriver.java b/core/src/main/java/org/apache/calcite/plan/volcano/TopDownRuleDriver.java
index 35a1ca2f725..02a3a8d9fc0 100644
--- a/core/src/main/java/org/apache/calcite/plan/volcano/TopDownRuleDriver.java
+++ b/core/src/main/java/org/apache/calcite/plan/volcano/TopDownRuleDriver.java
@@ -596,10 +596,11 @@ private class ApplyRule implements GeneratorTask {
             rel, group.upperBound);
       }
     }
-    VolcanoRuleMatch match = ruleQueue.popMatch(
-        Pair.of(rel,
-            m -> m.getRule() instanceof ConverterRule
-                && ((ConverterRule) m.getRule()).getOutTrait().satisfies(
+    VolcanoRuleMatch match =
+        ruleQueue.popMatch(
+            Pair.of(rel,
+                m -> m.getRule() instanceof ConverterRule
+                    && ((ConverterRule) m.getRule()).getOutTrait().satisfies(
                     requireNonNull(group.getTraitSet().getConvention(),
                         () -> "convention for " + group))));
     if (match != null) {
diff --git a/core/src/main/java/org/apache/calcite/plan/volcano/VolcanoPlanner.java b/core/src/main/java/org/apache/calcite/plan/volcano/VolcanoPlanner.java
index c40a980ab76..ad57236c476 100644
--- a/core/src/main/java/org/apache/calcite/plan/volcano/VolcanoPlanner.java
+++ b/core/src/main/java/org/apache/calcite/plan/volcano/VolcanoPlanner.java
@@ -1173,8 +1173,9 @@ private RelSet merge(RelSet set1, RelSet set2) {
     // Was the set we merged with the root? If so, the result is the new
     // root.
     if (set2 == getSet(root)) {
-      root = set1.getOrCreateSubset(
-          root.getCluster(), root.getTraitSet(), root.isRequired());
+      root =
+          set1.getOrCreateSubset(root.getCluster(), root.getTraitSet(),
+              root.isRequired());
       ensureRootConverters();
     }
 
@@ -1346,12 +1347,11 @@ private RelSubset registerImpl(
 
     // Place the expression in the appropriate equivalence set.
     if (set == null) {
-      set = new RelSet(
-          nextSetId++,
-          Util.minus(
-              RelOptUtil.getVariablesSet(rel),
-              rel.getVariablesSet()),
-          RelOptUtil.getVariablesUsed(rel));
+      set =
+          new RelSet(nextSetId++,
+              Util.minus(RelOptUtil.getVariablesSet(rel),
+                  rel.getVariablesSet()),
+              RelOptUtil.getVariablesUsed(rel));
       this.allSets.add(set);
     }
 
diff --git a/core/src/main/java/org/apache/calcite/plan/volcano/VolcanoRelMetadataProvider.java b/core/src/main/java/org/apache/calcite/plan/volcano/VolcanoRelMetadataProvider.java
index 499b4fc407b..266aec0a144 100644
--- a/core/src/main/java/org/apache/calcite/plan/volcano/VolcanoRelMetadataProvider.java
+++ b/core/src/main/java/org/apache/calcite/plan/volcano/VolcanoRelMetadataProvider.java
@@ -31,7 +31,8 @@
 
 import java.lang.reflect.Method;
 import java.util.List;
-import java.util.Objects;
+
+import static java.util.Objects.requireNonNull;
 
 /**
  * VolcanoRelMetadataProvider implements the {@link RelMetadataProvider}
@@ -60,9 +61,9 @@ public class VolcanoRelMetadataProvider implements RelMetadataProvider {
 
     return (rel, mq) -> {
       final RelSubset subset = (RelSubset) rel;
-      final RelMetadataProvider provider = Objects.requireNonNull(
-          rel.getCluster().getMetadataProvider(),
-          "metadataProvider");
+      final RelMetadataProvider provider =
+          requireNonNull(rel.getCluster().getMetadataProvider(),
+              "metadataProvider");
 
       // REVIEW jvs 29-Mar-2006: I'm not sure what the correct precedence
       // should be here.  Letting the current best plan take the first shot is
diff --git a/core/src/main/java/org/apache/calcite/plan/volcano/VolcanoRuleCall.java b/core/src/main/java/org/apache/calcite/plan/volcano/VolcanoRuleCall.java
index 8582a0c1a6e..a4b84907126 100644
--- a/core/src/main/java/org/apache/calcite/plan/volcano/VolcanoRuleCall.java
+++ b/core/src/main/java/org/apache/calcite/plan/volcano/VolcanoRuleCall.java
@@ -302,9 +302,9 @@ private void matchRecurse(int solve) {
         final RelSubset subset = volcanoPlanner.getSubsetNonNull(previous);
         successors = subset.getParentRels();
       } else {
-        parentOperand = requireNonNull(
-            operand.getParent(),
-            () -> "operand.getParent() for " + operand);
+        parentOperand =
+            requireNonNull(operand.getParent(),
+                () -> "operand.getParent() for " + operand);
         final RelNode parentRel = rels[parentOperand.ordinalInRule];
         final List<RelNode> inputs = parentRel.getInputs();
         // if the child is unordered, then add all rels in all input subsets to the successors list
diff --git a/core/src/main/java/org/apache/calcite/prepare/CalciteCatalogReader.java b/core/src/main/java/org/apache/calcite/prepare/CalciteCatalogReader.java
index 56a0c90e0fb..9c60635184f 100644
--- a/core/src/main/java/org/apache/calcite/prepare/CalciteCatalogReader.java
+++ b/core/src/main/java/org/apache/calcite/prepare/CalciteCatalogReader.java
@@ -48,7 +48,7 @@
 import org.apache.calcite.sql.type.SqlReturnTypeInference;
 import org.apache.calcite.sql.type.SqlTypeFamily;
 import org.apache.calcite.sql.type.SqlTypeName;
-import org.apache.calcite.sql.util.ListSqlOperatorTable;
+import org.apache.calcite.sql.util.SqlOperatorTables;
 import org.apache.calcite.sql.validate.SqlMoniker;
 import org.apache.calcite.sql.validate.SqlMonikerImpl;
 import org.apache.calcite.sql.validate.SqlMonikerType;
@@ -288,14 +288,14 @@ public static SqlOperatorTable operatorTable(String... classNames) {
           className, "*", true);
     }
 
-    final ListSqlOperatorTable table = new ListSqlOperatorTable();
+    final List<SqlOperator> list = new ArrayList<>();
     for (String name : schema.getFunctionNames()) {
       schema.getFunctions(name, true).forEach(function -> {
         final SqlIdentifier id = new SqlIdentifier(name, SqlParserPos.ZERO);
-        table.add(toOp(id, function));
+        list.add(toOp(id, function));
       });
     }
-    return table;
+    return SqlOperatorTables.of(list);
   }
 
   /** Converts a function to a {@link org.apache.calcite.sql.SqlOperator}. */
@@ -382,8 +382,8 @@ private static SqlReturnTypeInference infer(final ScalarFunction function) {
       final RelDataTypeFactory typeFactory = opBinding.getTypeFactory();
       final RelDataType type;
       if (function instanceof ScalarFunctionImpl) {
-        type = ((ScalarFunctionImpl) function).getReturnType(typeFactory,
-            opBinding);
+        type =
+            ((ScalarFunctionImpl) function).getReturnType(typeFactory, opBinding);
       } else {
         type = function.getReturnType(typeFactory);
       }
diff --git a/core/src/main/java/org/apache/calcite/prepare/CalciteMaterializer.java b/core/src/main/java/org/apache/calcite/prepare/CalciteMaterializer.java
index 03dff8a4f2a..4bbae5c59f9 100644
--- a/core/src/main/java/org/apache/calcite/prepare/CalciteMaterializer.java
+++ b/core/src/main/java/org/apache/calcite/prepare/CalciteMaterializer.java
@@ -85,10 +85,11 @@ void populate(Materialization materialization) {
     useStar(schema, materialization);
 
     List<String> tableName = materialization.materializedTable.path();
-    RelOptTable table = requireNonNull(
-        this.catalogReader.getTable(tableName),
-        () -> "table " + tableName + " is not found");
-    materialization.tableRel = sqlToRelConverter2.toRel(table, ImmutableList.of());
+    RelOptTable table =
+        requireNonNull(this.catalogReader.getTable(tableName),
+            () -> "table " + tableName + " is not found");
+    materialization.tableRel =
+        sqlToRelConverter2.toRel(table, ImmutableList.of());
   }
 
   /** Converts a relational expression to use a
diff --git a/core/src/main/java/org/apache/calcite/prepare/CalcitePrepareImpl.java b/core/src/main/java/org/apache/calcite/prepare/CalcitePrepareImpl.java
index 6d06705677c..d9655a7f7a6 100644
--- a/core/src/main/java/org/apache/calcite/prepare/CalcitePrepareImpl.java
+++ b/core/src/main/java/org/apache/calcite/prepare/CalcitePrepareImpl.java
@@ -16,6 +16,7 @@
  */
 package org.apache.calcite.prepare;
 
+import org.apache.calcite.DataContexts;
 import org.apache.calcite.adapter.enumerable.EnumerableCalc;
 import org.apache.calcite.adapter.enumerable.EnumerableConvention;
 import org.apache.calcite.adapter.enumerable.EnumerableInterpretable;
@@ -72,6 +73,7 @@
 import org.apache.calcite.rel.type.RelDataTypeFactory;
 import org.apache.calcite.rel.type.RelDataTypeField;
 import org.apache.calcite.rex.RexBuilder;
+import org.apache.calcite.rex.RexExecutorImpl;
 import org.apache.calcite.rex.RexInputRef;
 import org.apache.calcite.rex.RexNode;
 import org.apache.calcite.rex.RexProgram;
@@ -110,7 +112,6 @@
 import org.apache.calcite.util.Pair;
 import org.apache.calcite.util.Util;
 
-import com.google.common.base.Supplier;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
@@ -128,6 +129,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.function.Supplier;
 
 import static org.apache.calcite.linq4j.Nullness.castNonNull;
 import static org.apache.calcite.util.Static.RESOURCE;
@@ -442,6 +444,7 @@ protected RelOptPlanner createPlanner(
     }
     final VolcanoPlanner planner =
         new VolcanoPlanner(costFactory, externalContext);
+    planner.setExecutor(new RexExecutorImpl(DataContexts.EMPTY));
     planner.addRelTraitDef(ConventionTraitDef.INSTANCE);
     if (CalciteSystemProperty.ENABLE_COLLATION_TRAIT.value()) {
       planner.addRelTraitDef(RelCollationTraitDef.INSTANCE);
@@ -511,8 +514,10 @@ <T> CalciteSignature<T> prepare_(
         throw new AssertionError("factory returned null planner");
       }
       try {
+        CalcitePreparingStmt preparingStmt =
+            getPreparingStmt(context, elementType, catalogReader, planner);
         return prepare2_(context, query, elementType, maxRowCount,
-            catalogReader, planner);
+            catalogReader, preparingStmt);
       } catch (RelOptPlanner.CannotPlanException e) {
         exception = e;
       }
@@ -520,6 +525,31 @@ <T> CalciteSignature<T> prepare_(
     throw exception;
   }
 
+  /** Returns CalcitePreparingStmt
+   *
+   * <p>Override this function to return a custom {@link CalcitePreparingStmt} and
+   * {@link #createSqlValidator} to enable custom validation logic.
+   */
+  protected CalcitePreparingStmt getPreparingStmt(
+      Context context,
+      Type elementType,
+      CalciteCatalogReader catalogReader,
+      RelOptPlanner planner) {
+    final JavaTypeFactory typeFactory = context.getTypeFactory();
+    final EnumerableRel.Prefer prefer;
+    if (elementType == Object[].class) {
+      prefer = EnumerableRel.Prefer.ARRAY;
+    } else {
+      prefer = EnumerableRel.Prefer.CUSTOM;
+    }
+    final Convention resultConvention =
+        enableBindable ? BindableConvention.INSTANCE
+            : EnumerableConvention.INSTANCE;
+    return new CalcitePreparingStmt(this, context, catalogReader, typeFactory,
+            context.getRootSchema(), prefer, createCluster(planner, new RexBuilder(typeFactory)),
+            resultConvention, createConvertletTable());
+  }
+
   /** Quickly prepares a simple SQL statement, circumventing the usual
    * preparation process. */
   private static <T> CalciteSignature<T> simplePrepare(Context context, String sql) {
@@ -587,21 +617,8 @@ <T> CalciteSignature<T> prepare2_(
       Type elementType,
       long maxRowCount,
       CalciteCatalogReader catalogReader,
-      RelOptPlanner planner) {
+      CalcitePreparingStmt preparingStmt) {
     final JavaTypeFactory typeFactory = context.getTypeFactory();
-    final EnumerableRel.Prefer prefer;
-    if (elementType == Object[].class) {
-      prefer = EnumerableRel.Prefer.ARRAY;
-    } else {
-      prefer = EnumerableRel.Prefer.CUSTOM;
-    }
-    final Convention resultConvention =
-        enableBindable ? BindableConvention.INSTANCE
-            : EnumerableConvention.INSTANCE;
-    final CalcitePreparingStmt preparingStmt =
-        new CalcitePreparingStmt(this, context, catalogReader, typeFactory,
-            context.getRootSchema(), prefer, createCluster(planner, new RexBuilder(typeFactory)),
-            resultConvention, createConvertletTable());
 
     final RelDataType x;
     final Prepare.PreparedResult preparedResult;
@@ -642,11 +659,10 @@ <T> CalciteSignature<T> prepare2_(
             Meta.StatementType.OTHER_DDL);
       }
 
-      final SqlValidator validator =
-          createSqlValidator(context, catalogReader);
+      final SqlValidator validator = preparingStmt.createSqlValidator(catalogReader);
 
-      preparedResult = preparingStmt.prepareSql(
-          sqlNode, Object.class, validator, true);
+      preparedResult =
+          preparingStmt.prepareSql(sqlNode, Object.class, validator, true);
       switch (sqlNode.getKind()) {
       case INSERT:
       case DELETE:
@@ -934,8 +950,12 @@ public <R> R perform(CalciteServerStatement statement,
         prepareContext.getRootSchema().plus(), statement);
   }
 
-  /** Holds state for the process of preparing a SQL statement. */
-  static class CalcitePreparingStmt extends Prepare
+  /** Holds state for the process of preparing a SQL statement.
+   *
+   * <p>Overload this class and {@link #createSqlValidator} to provide desired SqlValidator
+   * and custom validation logic.</p>
+   */
+  public static class CalcitePreparingStmt extends Prepare
       implements RelOptTable.ViewExpander {
     protected final RelOptPlanner planner;
     protected final RexBuilder rexBuilder;
@@ -951,7 +971,12 @@ static class CalcitePreparingStmt extends Prepare
     private int expansionDepth;
     private @Nullable SqlValidator sqlValidator;
 
-    CalcitePreparingStmt(CalcitePrepareImpl prepare,
+    /** Constructor.
+     *
+     * <p>Overload this constructor and {@link #createSqlValidator} to provide desired
+     *  SqlValidaor and custom validation logic.</p>
+     */
+    public CalcitePreparingStmt(CalcitePrepareImpl prepare,
         Context context,
         CatalogReader catalogReader,
         RelDataTypeFactory typeFactory,
@@ -1003,8 +1028,9 @@ private PreparedResult prepare_(Supplier<RelNode> fn,
           rel instanceof Sort
               ? ((Sort) rel).collation
               : RelCollations.EMPTY;
-      RelRoot root = new RelRoot(rel, resultType, SqlKind.SELECT, fields,
-          collation, new ArrayList<>());
+      RelRoot root =
+          new RelRoot(rel, resultType, SqlKind.SELECT, fields, collation,
+              new ArrayList<>());
 
       if (timingTracer != null) {
         timingTracer.traceTime("end sql2rel");
@@ -1119,8 +1145,9 @@ protected SqlValidator createSqlValidator(CatalogReader catalogReader) {
           for (int field : Pair.left(root.fields)) {
             projects.add(rexBuilder.makeInputRef(enumerable, field));
           }
-          RexProgram program = RexProgram.create(enumerable.getRowType(),
-              projects, null, root.validatedRowType, rexBuilder);
+          RexProgram program =
+              RexProgram.create(enumerable.getRowType(), projects, null,
+                  root.validatedRowType, rexBuilder);
           enumerable = EnumerableCalc.create(enumerable, program);
         }
 
@@ -1128,9 +1155,10 @@ protected SqlValidator createSqlValidator(CatalogReader catalogReader) {
           CatalogReader.THREAD_LOCAL.set(catalogReader);
           final SqlConformance conformance = context.config().conformance();
           internalParameters.put("_conformance", conformance);
-          bindable = EnumerableInterpretable.toBindable(internalParameters,
-              context.spark(), enumerable,
-              requireNonNull(prefer, "EnumerableRel.Prefer prefer"));
+          bindable =
+              EnumerableInterpretable.toBindable(internalParameters,
+                  context.spark(), enumerable,
+                  requireNonNull(prefer, "EnumerableRel.Prefer prefer"));
         } finally {
           CatalogReader.THREAD_LOCAL.remove();
         }
@@ -1259,10 +1287,11 @@ private static List<Expression> simpleList(BlockStatement statement) {
         // Case-sensitive name match because name was previously resolved.
         MemberExpression memberExpression = (MemberExpression) expression;
         PseudoField field = memberExpression.field;
-        Expression targetExpression = requireNonNull(memberExpression.expression,
-            () -> "static field access is not implemented yet."
-                + " field.name=" + field.getName()
-                + ", field.declaringClass=" + field.getDeclaringClass());
+        Expression targetExpression =
+            requireNonNull(memberExpression.expression,
+                () -> "static field access is not implemented yet."
+                    + " field.name=" + field.getName()
+                    + ", field.declaringClass=" + field.getDeclaringClass());
         return rexBuilder.makeFieldAccess(
             toRex(targetExpression),
             field.getName(),
diff --git a/core/src/main/java/org/apache/calcite/prepare/CalciteSqlValidator.java b/core/src/main/java/org/apache/calcite/prepare/CalciteSqlValidator.java
index b8a5623737b..8033173882a 100644
--- a/core/src/main/java/org/apache/calcite/prepare/CalciteSqlValidator.java
+++ b/core/src/main/java/org/apache/calcite/prepare/CalciteSqlValidator.java
@@ -22,10 +22,11 @@
 import org.apache.calcite.sql.SqlOperatorTable;
 import org.apache.calcite.sql.validate.SqlValidatorImpl;
 
-/** Validator. */
-class CalciteSqlValidator extends SqlValidatorImpl {
+/** Validator.
+ */
+public class CalciteSqlValidator extends SqlValidatorImpl {
 
-  CalciteSqlValidator(SqlOperatorTable opTab,
+  public CalciteSqlValidator(SqlOperatorTable opTab,
       CalciteCatalogReader catalogReader, JavaTypeFactory typeFactory,
       Config config) {
     super(opTab, catalogReader, typeFactory, config);
diff --git a/core/src/main/java/org/apache/calcite/prepare/LixToRelTranslator.java b/core/src/main/java/org/apache/calcite/prepare/LixToRelTranslator.java
index f7d02f3e2c7..2bd4eb0384f 100644
--- a/core/src/main/java/org/apache/calcite/prepare/LixToRelTranslator.java
+++ b/core/src/main/java/org/apache/calcite/prepare/LixToRelTranslator.java
@@ -39,6 +39,7 @@
 import org.apache.calcite.util.BuiltInMethod;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
 
 import java.lang.reflect.Type;
 import java.util.ArrayList;
@@ -108,7 +109,8 @@ public RelNode translate(Expression expression) {
         return LogicalProject.create(input,
             ImmutableList.of(),
             toRex(input, (FunctionExpression) call.expressions.get(0)),
-            (List<String>) null);
+            (List<String>) null,
+            ImmutableSet.of());
 
       case WHERE:
         input = translate(getTargetExpression(call));
diff --git a/core/src/main/java/org/apache/calcite/prepare/PlannerImpl.java b/core/src/main/java/org/apache/calcite/prepare/PlannerImpl.java
index a16c5a8a270..6792a87de8e 100644
--- a/core/src/main/java/org/apache/calcite/prepare/PlannerImpl.java
+++ b/core/src/main/java/org/apache/calcite/prepare/PlannerImpl.java
@@ -129,12 +129,14 @@ private static CalciteConnectionConfig connConfig(Context context,
         context.maybeUnwrap(CalciteConnectionConfigImpl.class)
             .orElse(CalciteConnectionConfig.DEFAULT);
     if (!config.isSet(CalciteConnectionProperty.CASE_SENSITIVE)) {
-      config = config.set(CalciteConnectionProperty.CASE_SENSITIVE,
-          String.valueOf(parserConfig.caseSensitive()));
+      config =
+          config.set(CalciteConnectionProperty.CASE_SENSITIVE,
+              String.valueOf(parserConfig.caseSensitive()));
     }
     if (!config.isSet(CalciteConnectionProperty.CONFORMANCE)) {
-      config = config.set(CalciteConnectionProperty.CONFORMANCE,
-          String.valueOf(parserConfig.conformance()));
+      config =
+          config.set(CalciteConnectionProperty.CONFORMANCE,
+              String.valueOf(parserConfig.conformance()));
     }
     return config;
   }
@@ -237,6 +239,15 @@ private void ready() {
     return Pair.of(validatedNode, type);
   }
 
+  @Override public RelDataType getParameterRowType() {
+    if (state.ordinal() < State.STATE_4_VALIDATED.ordinal()) {
+      throw new RuntimeException("Need to call #validate() first");
+    }
+
+    return requireNonNull(validator, "validator")
+        .getParameterRowType(requireNonNull(validatedSqlNode, "validatedSqlNode"));
+  }
+
   @SuppressWarnings("deprecation")
   @Override public final RelNode convert(SqlNode sql) {
     return rel(sql).rel;
@@ -244,12 +255,13 @@ private void ready() {
 
   @Override public RelRoot rel(SqlNode sql) {
     ensure(State.STATE_4_VALIDATED);
-    SqlNode validatedSqlNode = requireNonNull(this.validatedSqlNode,
-        "validatedSqlNode is null. Need to call #validate() first");
+    SqlNode validatedSqlNode =
+        requireNonNull(this.validatedSqlNode,
+            "validatedSqlNode is null. Need to call #validate() first");
     final RexBuilder rexBuilder = createRexBuilder();
-    final RelOptCluster cluster = RelOptCluster.create(
-        requireNonNull(planner, "planner"),
-        rexBuilder);
+    final RelOptCluster cluster =
+        RelOptCluster.create(requireNonNull(planner, "planner"),
+            rexBuilder);
     final SqlToRelConverter.Config config =
         sqlToRelConverterConfig.withTrimUnusedFields(false);
     final SqlToRelConverter sqlToRelConverter =
@@ -260,8 +272,8 @@ private void ready() {
     root = root.withRel(sqlToRelConverter.flattenTypes(root.rel, true));
     final RelBuilder relBuilder =
         config.getRelBuilderFactory().create(cluster, null);
-    root = root.withRel(
-        RelDecorrelator.decorrelateQuery(root.rel, relBuilder));
+    root =
+        root.withRel(RelDecorrelator.decorrelateQuery(root.rel, relBuilder));
     state = State.STATE_5_CONVERTED;
     return root;
   }
diff --git a/core/src/main/java/org/apache/calcite/prepare/Prepare.java b/core/src/main/java/org/apache/calcite/prepare/Prepare.java
index 03c2dd07b62..695181bfc62 100644
--- a/core/src/main/java/org/apache/calcite/prepare/Prepare.java
+++ b/core/src/main/java/org/apache/calcite/prepare/Prepare.java
@@ -100,7 +100,7 @@ public abstract class Prepare {
   protected @MonotonicNonNull RelDataType parameterRowType;
 
   // temporary. for testing.
-  public static final TryThreadLocal<@Nullable Boolean> THREAD_TRIM =
+  public static final TryThreadLocal<Boolean> THREAD_TRIM =
       TryThreadLocal.of(false);
 
   /** Temporary, until
@@ -110,7 +110,7 @@ public abstract class Prepare {
    * <p>The default is false, meaning do not expand queries during sql-to-rel,
    * but a few tests override and set it to true. After CALCITE-1045
    * is fixed, remove those overrides and use false everywhere. */
-  public static final TryThreadLocal<@Nullable Boolean> THREAD_EXPAND =
+  public static final TryThreadLocal<Boolean> THREAD_EXPAND =
       TryThreadLocal.of(false);
 
   // temporary. for testing.
@@ -119,8 +119,7 @@ public abstract class Prepare {
 
   protected Prepare(CalcitePrepare.Context context, CatalogReader catalogReader,
       Convention resultConvention) {
-    assert context != null;
-    this.context = context;
+    this.context = requireNonNull(context, "context");
     this.catalogReader = catalogReader;
     this.resultConvention = resultConvention;
   }
@@ -174,8 +173,9 @@ protected RelRoot optimize(RelRoot root,
     final RelTraitSet desiredTraits = getDesiredRootTraitSet(root);
 
     final Program program = getProgram();
-    final RelNode rootRel4 = program.run(
-        planner, root.rel, desiredTraits, materializationList, latticeList);
+    final RelNode rootRel4 =
+        program.run(planner, root.rel, desiredTraits, materializationList,
+            latticeList);
     if (LOGGER.isDebugEnabled()) {
       LOGGER.debug("Plan after physical tweaks:\n{}",
           RelOptUtil.toString(rootRel4, SqlExplainLevel.ALL_ATTRIBUTES));
@@ -236,7 +236,7 @@ public PreparedResult prepareSql(
     final SqlToRelConverter.Config config =
         SqlToRelConverter.config()
             .withTrimUnusedFields(true)
-            .withExpand(castNonNull(THREAD_EXPAND.get()))
+            .withExpand(THREAD_EXPAND.get())
             .withInSubQueryThreshold(castNonNull(THREAD_INSUBQUERY_THRESHOLD.get()))
             .withExplain(sqlQuery.getKind() == SqlKind.EXPLAIN);
     final Holder<SqlToRelConverter.Config> configHolder = Holder.of(config);
@@ -375,7 +375,7 @@ protected abstract RelNode decorrelate(SqlToRelConverter sqlToRelConverter,
   protected RelRoot trimUnusedFields(RelRoot root) {
     final SqlToRelConverter.Config config = SqlToRelConverter.config()
         .withTrimUnusedFields(shouldTrim(root.rel))
-        .withExpand(castNonNull(THREAD_EXPAND.get()))
+        .withExpand(THREAD_EXPAND.get())
         .withInSubQueryThreshold(castNonNull(THREAD_INSUBQUERY_THRESHOLD.get()));
     final SqlToRelConverter converter =
         getSqlToRelConverter(getSqlValidator(), catalogReader, config);
diff --git a/core/src/main/java/org/apache/calcite/prepare/QueryableRelBuilder.java b/core/src/main/java/org/apache/calcite/prepare/QueryableRelBuilder.java
index 5385c6d9e74..4731e029ddc 100644
--- a/core/src/main/java/org/apache/calcite/prepare/QueryableRelBuilder.java
+++ b/core/src/main/java/org/apache/calcite/prepare/QueryableRelBuilder.java
@@ -49,6 +49,7 @@
 import org.apache.calcite.schema.impl.AbstractTableQueryable;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.checkerframework.checker.nullness.qual.PolyNull;
@@ -549,7 +550,8 @@ private void setRel(RelNode rel) {
     RelNode child = toRel(source);
     List<RexNode> nodes = translator.toRexList(selector, child);
     setRel(
-        LogicalProject.create(child, ImmutableList.of(), nodes, (List<String>)  null));
+        LogicalProject.create(child, ImmutableList.of(), nodes, (List<String>)  null,
+            ImmutableSet.of()));
     return castNonNull(null);
   }
 
diff --git a/core/src/main/java/org/apache/calcite/prepare/RelOptTableImpl.java b/core/src/main/java/org/apache/calcite/prepare/RelOptTableImpl.java
index 08782924958..29a6f07c014 100644
--- a/core/src/main/java/org/apache/calcite/prepare/RelOptTableImpl.java
+++ b/core/src/main/java/org/apache/calcite/prepare/RelOptTableImpl.java
@@ -18,6 +18,7 @@
 
 import org.apache.calcite.jdbc.CalciteSchema;
 import org.apache.calcite.linq4j.tree.Expression;
+import org.apache.calcite.linq4j.tree.TableExpressionFactory;
 import org.apache.calcite.materialize.Lattice;
 import org.apache.calcite.plan.RelOptSchema;
 import org.apache.calcite.plan.RelOptTable;
@@ -34,11 +35,8 @@
 import org.apache.calcite.rel.type.RelProtoDataType;
 import org.apache.calcite.rel.type.RelRecordType;
 import org.apache.calcite.schema.ColumnStrategy;
-import org.apache.calcite.schema.FilterableTable;
 import org.apache.calcite.schema.ModifiableTable;
 import org.apache.calcite.schema.Path;
-import org.apache.calcite.schema.ProjectableFilterableTable;
-import org.apache.calcite.schema.QueryableTable;
 import org.apache.calcite.schema.ScannableTable;
 import org.apache.calcite.schema.Schema;
 import org.apache.calcite.schema.SchemaPlus;
@@ -66,7 +64,6 @@
 import java.util.Collection;
 import java.util.List;
 import java.util.Set;
-import java.util.function.Function;
 
 import static java.util.Objects.requireNonNull;
 
@@ -77,7 +74,7 @@ public class RelOptTableImpl extends Prepare.AbstractPreparingTable {
   private final @Nullable RelOptSchema schema;
   private final RelDataType rowType;
   private final @Nullable Table table;
-  private final @Nullable Function<Class, Expression> expressionFunction;
+  private final @Nullable TableExpressionFactory tableExpressionFactory;
   private final ImmutableList<String> names;
 
   /** Estimate for the row count, or null.
@@ -94,13 +91,13 @@ private RelOptTableImpl(
       RelDataType rowType,
       List<String> names,
       @Nullable Table table,
-      @Nullable Function<Class, Expression> expressionFunction,
+      @Nullable TableExpressionFactory tableExpressionFactory,
       @Nullable Double rowCount) {
     this.schema = schema;
     this.rowType = requireNonNull(rowType, "rowType");
     this.names = ImmutableList.copyOf(names);
     this.table = table; // may be null
-    this.expressionFunction = expressionFunction; // may be null
+    this.tableExpressionFactory = tableExpressionFactory; // may be null
     this.rowCount = rowCount; // may be null
   }
 
@@ -113,29 +110,53 @@ public static RelOptTableImpl create(
         c -> expression, null);
   }
 
+  @Deprecated // to be removed before 2.0
   public static RelOptTableImpl create(
       @Nullable RelOptSchema schema,
       RelDataType rowType,
       List<String> names,
       Table table,
       Expression expression) {
+    return create(schema, rowType, names, table, c -> expression);
+  }
+
+  /**
+   * Creates {@link RelOptTableImpl} instance with specified arguments
+   * and row count obtained from table statistic.
+   *
+   * @param schema table schema
+   * @param rowType table row type
+   * @param names full table path
+   * @param table table
+   * @param expressionFactory expression function for accessing table data
+   *                          in the generated code
+   *
+   * @return {@link RelOptTableImpl} instance
+   */
+  public static RelOptTableImpl create(
+      @Nullable RelOptSchema schema,
+      RelDataType rowType,
+      List<String> names,
+      Table table,
+      TableExpressionFactory expressionFactory) {
     return new RelOptTableImpl(schema, rowType, names, table,
-        c -> expression, table.getStatistic().getRowCount());
+        expressionFactory, table.getStatistic().getRowCount());
   }
 
   public static RelOptTableImpl create(@Nullable RelOptSchema schema, RelDataType rowType,
       Table table, Path path) {
     final SchemaPlus schemaPlus = MySchemaPlus.create(path);
     return new RelOptTableImpl(schema, rowType, Pair.left(path), table,
-        getClassExpressionFunction(schemaPlus, Util.last(path).left, table),
+        c -> Schemas.getTableExpression(schemaPlus, Util.last(path).left, table, c),
         table.getStatistic().getRowCount());
   }
 
   public static RelOptTableImpl create(@Nullable RelOptSchema schema, RelDataType rowType,
       final CalciteSchema.TableEntry tableEntry, @Nullable Double rowCount) {
     final Table table = tableEntry.getTable();
-    return new RelOptTableImpl(schema, rowType, tableEntry.path(),
-        table, getClassExpressionFunction(tableEntry, table), rowCount);
+    return new RelOptTableImpl(schema, rowType, tableEntry.path(), table,
+        c -> Schemas.getTableExpression(tableEntry.schema.plus(), tableEntry.name, table, c),
+        rowCount);
   }
 
   /**
@@ -143,7 +164,7 @@ public static RelOptTableImpl create(@Nullable RelOptSchema schema, RelDataType
    */
   public RelOptTableImpl copy(RelDataType newRowType) {
     return new RelOptTableImpl(this.schema, newRowType, this.names, this.table,
-        this.expressionFunction, this.rowCount);
+        this.tableExpressionFactory, this.rowCount);
   }
 
   @Override public String toString() {
@@ -155,32 +176,6 @@ public RelOptTableImpl copy(RelDataType newRowType) {
         + '}';
   }
 
-  private static Function<Class, Expression> getClassExpressionFunction(
-      CalciteSchema.TableEntry tableEntry, Table table) {
-    return getClassExpressionFunction(tableEntry.schema.plus(), tableEntry.name,
-        table);
-  }
-
-  private static Function<Class, Expression> getClassExpressionFunction(
-      final SchemaPlus schema, final String tableName, final Table table) {
-    if (table instanceof QueryableTable) {
-      final QueryableTable queryableTable = (QueryableTable) table;
-      return clazz -> queryableTable.getExpression(schema, tableName, clazz);
-    } else if (table instanceof ScannableTable
-        || table instanceof FilterableTable
-        || table instanceof ProjectableFilterableTable) {
-      return clazz -> Schemas.tableExpression(schema, Object[].class, tableName,
-          table.getClass());
-    } else if (table instanceof StreamableTable) {
-      return getClassExpressionFunction(schema, tableName,
-          ((StreamableTable) table).stream());
-    } else {
-      return input -> {
-        throw new UnsupportedOperationException();
-      };
-    }
-  }
-
   public static RelOptTableImpl create(@Nullable RelOptSchema schema,
       RelDataType rowType, Table table, ImmutableList<String> names) {
     assert table instanceof TranslatableTable
@@ -211,10 +206,10 @@ public static RelOptTableImpl create(@Nullable RelOptSchema schema,
   }
 
   @Override public @Nullable Expression getExpression(Class clazz) {
-    if (expressionFunction == null) {
+    if (tableExpressionFactory == null) {
       return null;
     }
-    return expressionFunction.apply(clazz);
+    return tableExpressionFactory.create(clazz);
   }
 
   @Override protected RelOptTable extend(Table extendedTable) {
@@ -222,7 +217,7 @@ public static RelOptTableImpl create(@Nullable RelOptSchema schema,
     final RelDataType extendedRowType =
         extendedTable.getRowType(schema.getTypeFactory());
     return new RelOptTableImpl(schema, extendedRowType, getQualifiedName(),
-        extendedTable, expressionFunction, getRowCount());
+        extendedTable, tableExpressionFactory, getRowCount());
   }
 
   @Override public boolean equals(@Nullable Object obj) {
@@ -274,7 +269,7 @@ public static RelOptTableImpl create(@Nullable RelOptSchema schema,
       }
       final RelOptTable relOptTable =
           new RelOptTableImpl(this.schema, b.build(), this.names, this.table,
-              this.expressionFunction, this.rowCount) {
+              this.tableExpressionFactory, this.rowCount) {
             @Override public <T extends Object> @Nullable T unwrap(Class<T> clazz) {
               if (clazz.isAssignableFrom(InitializerExpressionFactory.class)) {
                 return clazz.cast(NullInitializerExpressionFactory.INSTANCE);
diff --git a/core/src/main/java/org/apache/calcite/profile/ProfilerImpl.java b/core/src/main/java/org/apache/calcite/profile/ProfilerImpl.java
index 237f18e4635..0c60f278f11 100644
--- a/core/src/main/java/org/apache/calcite/profile/ProfilerImpl.java
+++ b/core/src/main/java/org/apache/calcite/profile/ProfilerImpl.java
@@ -189,8 +189,9 @@ class Run {
       }
       // The surprise queue must have enough room for all singleton groups
       // plus all initial groups.
-      surprises = new SurpriseQueue(1 + columns.size() + initialGroups.size(),
-          interestingCount);
+      surprises =
+          new SurpriseQueue(1 + columns.size() + initialGroups.size(),
+              interestingCount);
     }
 
     Profile profile(Iterable<List<Comparable>> rows) {
@@ -421,8 +422,10 @@ private double expectedCardinality(double rowCount,
         return rowCount;
       default:
         double c = rowCount;
-        List<ImmutableBitSet> parents = requireNonNull(keyPoset.getParents(columns, true),
-            () -> "keyPoset.getParents(columns, true) is null for " + columns);
+        List<ImmutableBitSet> parents =
+            requireNonNull(keyPoset.getParents(columns, true),
+                () -> "keyPoset.getParents(columns, true) is null for "
+                    + columns);
         for (ImmutableBitSet bitSet : parents) {
           if (bitSet.isEmpty()) {
             // If the parent is the empty group (i.e. "GROUP BY ()", the grand
@@ -431,11 +434,15 @@ private double expectedCardinality(double rowCount,
           }
           final Distribution d1 = distributions.get(bitSet);
           final double c2 = cardinality(rowCount, columns.except(bitSet));
-          final double d = Lattice.getRowCount(rowCount, requireNonNull(d1, "d1").cardinality, c2);
+          final double d =
+              Lattice.getRowCount(rowCount,
+                  requireNonNull(d1, "d1").cardinality, c2);
           c = Math.min(c, d);
         }
-        List<ImmutableBitSet> children = requireNonNull(keyPoset.getChildren(columns, true),
-            () -> "keyPoset.getChildren(columns, true) is null for " + columns);
+        List<ImmutableBitSet> children =
+            requireNonNull(keyPoset.getChildren(columns, true),
+                () -> "keyPoset.getChildren(columns, true) is null for "
+                    + columns);
         for (ImmutableBitSet bitSet : children) {
           final Distribution d1 = distributions.get(bitSet);
           c = Math.min(c, requireNonNull(d1, "d1").cardinality);
diff --git a/core/src/main/java/org/apache/calcite/profile/SimpleProfiler.java b/core/src/main/java/org/apache/calcite/profile/SimpleProfiler.java
index ffe92171c62..2b4c413c5e3 100644
--- a/core/src/main/java/org/apache/calcite/profile/SimpleProfiler.java
+++ b/core/src/main/java/org/apache/calcite/profile/SimpleProfiler.java
@@ -196,8 +196,9 @@ Profile profile(Iterable<List<Comparable>> rows) {
             }
             space.dependencies.or(dependents.toBitSet());
             for (int d : dependents) {
-              Space spaceD = requireNonNull(singletonSpaces.get(d),
-                  () -> "singletonSpaces.get(d) is null for " + d);
+              Space spaceD =
+                  requireNonNull(singletonSpaces.get(d),
+                      () -> "singletonSpaces.get(d) is null for " + d);
               spaceD.dependents.add(s.columnOrdinals);
             }
           }
@@ -207,8 +208,9 @@ Profile profile(Iterable<List<Comparable>> rows) {
         final SortedSet<Comparable> valueSet;
         if (space.columns.size() == 1) {
           nullCount = space.nullCount;
-          valueSet = ImmutableSortedSet.copyOf(
-              Util.transform(space.values, Iterables::getOnlyElement));
+          valueSet =
+              ImmutableSortedSet.copyOf(
+                  Util.transform(space.values, Iterables::getOnlyElement));
         } else {
           nullCount = -1;
           valueSet = null;
@@ -280,8 +282,10 @@ private boolean containsKey(ImmutableBitSet ordinals, boolean strict) {
 
     private boolean hasNull(ImmutableBitSet columnOrdinals) {
       for (Integer columnOrdinal : columnOrdinals) {
-        Space space = requireNonNull(singletonSpaces.get(columnOrdinal),
-            () -> "singletonSpaces.get(columnOrdinal) is null for " + columnOrdinal);
+        Space space =
+            requireNonNull(singletonSpaces.get(columnOrdinal),
+                () -> "singletonSpaces.get(columnOrdinal) is null for "
+                    + columnOrdinal);
         if (space.nullCount > 0) {
           return true;
         }
diff --git a/core/src/main/java/org/apache/calcite/rel/AbstractRelNode.java b/core/src/main/java/org/apache/calcite/rel/AbstractRelNode.java
index f7902cffd95..53e6d95911b 100644
--- a/core/src/main/java/org/apache/calcite/rel/AbstractRelNode.java
+++ b/core/src/main/java/org/apache/calcite/rel/AbstractRelNode.java
@@ -126,8 +126,7 @@ protected static <T> T sole(List<T> collection) {
 
   @Pure
   @Override public final @Nullable Convention getConvention(
-      @UnknownInitialization AbstractRelNode this
-  ) {
+      @UnknownInitialization AbstractRelNode this) {
     return traitSet == null ? null : traitSet.getTrait(ConventionTraitDef.INSTANCE);
   }
 
diff --git a/core/src/main/java/org/apache/calcite/rel/RelCollations.java b/core/src/main/java/org/apache/calcite/rel/RelCollations.java
index 189b776e665..feea59687ec 100644
--- a/core/src/main/java/org/apache/calcite/rel/RelCollations.java
+++ b/core/src/main/java/org/apache/calcite/rel/RelCollations.java
@@ -209,8 +209,8 @@ public static boolean containsOrderless(RelCollation collation,
     if (colKeys.size() < distinctKeys.size()) {
       return false;
     } else {
-      ImmutableBitSet bitset = ImmutableBitSet.of(
-          colKeys.subList(0, distinctKeys.size()));
+      ImmutableBitSet bitset =
+          ImmutableBitSet.of(colKeys.subList(0, distinctKeys.size()));
       return bitset.equals(keysBitSet);
     }
   }
diff --git a/core/src/main/java/org/apache/calcite/rel/RelDistributions.java b/core/src/main/java/org/apache/calcite/rel/RelDistributions.java
index c3aa8f69406..769592d39f7 100644
--- a/core/src/main/java/org/apache/calcite/rel/RelDistributions.java
+++ b/core/src/main/java/org/apache/calcite/rel/RelDistributions.java
@@ -103,7 +103,7 @@ private RelDistributionImpl(Type type, ImmutableIntList keys) {
           || Ordering.natural().isOrdered(keys)
           : "key columns of hash distribution must be in order";
       assert type == Type.HASH_DISTRIBUTED
-          || type == Type.RANDOM_DISTRIBUTED
+          || type == Type.RANGE_DISTRIBUTED
           || keys.isEmpty();
     }
 
diff --git a/core/src/main/java/org/apache/calcite/rel/RelHomogeneousShuttle.java b/core/src/main/java/org/apache/calcite/rel/RelHomogeneousShuttle.java
index 25c33ceba09..0c725dd1e0e 100644
--- a/core/src/main/java/org/apache/calcite/rel/RelHomogeneousShuttle.java
+++ b/core/src/main/java/org/apache/calcite/rel/RelHomogeneousShuttle.java
@@ -19,6 +19,7 @@
 import org.apache.calcite.rel.core.TableFunctionScan;
 import org.apache.calcite.rel.core.TableScan;
 import org.apache.calcite.rel.logical.LogicalAggregate;
+import org.apache.calcite.rel.logical.LogicalCalc;
 import org.apache.calcite.rel.logical.LogicalCorrelate;
 import org.apache.calcite.rel.logical.LogicalExchange;
 import org.apache.calcite.rel.logical.LogicalFilter;
@@ -28,6 +29,7 @@
 import org.apache.calcite.rel.logical.LogicalMinus;
 import org.apache.calcite.rel.logical.LogicalProject;
 import org.apache.calcite.rel.logical.LogicalSort;
+import org.apache.calcite.rel.logical.LogicalTableModify;
 import org.apache.calcite.rel.logical.LogicalUnion;
 import org.apache.calcite.rel.logical.LogicalValues;
 
@@ -91,4 +93,12 @@ public class RelHomogeneousShuttle extends RelShuttleImpl {
   @Override public RelNode visit(LogicalExchange exchange) {
     return visit((RelNode) exchange);
   }
+
+  @Override public RelNode visit(LogicalCalc calc) {
+    return visit((RelNode) calc);
+  }
+
+  @Override public RelNode visit(LogicalTableModify modify) {
+    return visit((RelNode) modify);
+  }
 }
diff --git a/core/src/main/java/org/apache/calcite/rel/RelNode.java b/core/src/main/java/org/apache/calcite/rel/RelNode.java
index 21f6586cc2f..ef3b878ce70 100644
--- a/core/src/main/java/org/apache/calcite/rel/RelNode.java
+++ b/core/src/main/java/org/apache/calcite/rel/RelNode.java
@@ -152,9 +152,6 @@ public interface RelNode extends RelOptNode, Cloneable {
    * expression but also used and therefore not available to parents of this
    * relational expression.
    *
-   * <p>Note: only {@link org.apache.calcite.rel.core.Correlate} should set
-   * variables.
-   *
    * @return Names of variables which are set in this relational
    *   expression
    */
diff --git a/core/src/main/java/org/apache/calcite/rel/RelNodes.java b/core/src/main/java/org/apache/calcite/rel/RelNodes.java
index dab3b5e5f63..8f5397cf0ea 100644
--- a/core/src/main/java/org/apache/calcite/rel/RelNodes.java
+++ b/core/src/main/java/org/apache/calcite/rel/RelNodes.java
@@ -16,8 +16,6 @@
  */
 package org.apache.calcite.rel;
 
-import org.apache.calcite.runtime.Utilities;
-
 import com.google.common.collect.Ordering;
 
 import java.util.Comparator;
@@ -38,7 +36,7 @@ private RelNodes() {}
 
   /** Compares arrays of {@link RelNode}. */
   public static int compareRels(RelNode[] rels0, RelNode[] rels1) {
-    int c = Utilities.compare(rels0.length, rels1.length);
+    int c = Integer.compare(rels0.length, rels1.length);
     if (c != 0) {
       return c;
     }
@@ -56,12 +54,13 @@ private static class RelNodeComparator implements Comparator<RelNode> {
     @Override public int compare(RelNode o1, RelNode o2) {
       // Compare on field count first. It is more stable than id (when rules
       // are added to the set of active rules).
-      final int c = Utilities.compare(o1.getRowType().getFieldCount(),
-          o2.getRowType().getFieldCount());
+      final int c =
+          Integer.compare(o1.getRowType().getFieldCount(),
+              o2.getRowType().getFieldCount());
       if (c != 0) {
         return -c;
       }
-      return Utilities.compare(o1.getId(), o2.getId());
+      return Integer.compare(o1.getId(), o2.getId());
     }
   }
 }
diff --git a/core/src/main/java/org/apache/calcite/rel/RelRoot.java b/core/src/main/java/org/apache/calcite/rel/RelRoot.java
index d72c0ae3108..7e6ba78e56b 100644
--- a/core/src/main/java/org/apache/calcite/rel/RelRoot.java
+++ b/core/src/main/java/org/apache/calcite/rel/RelRoot.java
@@ -27,6 +27,7 @@
 import org.apache.calcite.util.mapping.Mappings;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -166,7 +167,7 @@ public RelNode project(boolean force) {
     for (Pair<Integer, String> field : fields) {
       projects.add(rexBuilder.makeInputRef(rel, field.left));
     }
-    return LogicalProject.create(rel, hints, projects, Pair.right(fields));
+    return LogicalProject.create(rel, hints, projects, Pair.right(fields), ImmutableSet.of());
   }
 
   public boolean isNameTrivial() {
diff --git a/core/src/main/java/org/apache/calcite/rel/core/Aggregate.java b/core/src/main/java/org/apache/calcite/rel/core/Aggregate.java
index abb56ba0b41..568a1b45d4c 100644
--- a/core/src/main/java/org/apache/calcite/rel/core/Aggregate.java
+++ b/core/src/main/java/org/apache/calcite/rel/core/Aggregate.java
@@ -622,4 +622,21 @@ public AggCallBinding(RelDataTypeFactory typeFactory,
       return SqlUtil.newContextException(SqlParserPos.ZERO, e);
     }
   }
+
+  /** Used for PERCENTILE_DISC return type inference. */
+  public static class PercentileDiscAggCallBinding extends AggCallBinding {
+    private final RelDataType collationType;
+
+    PercentileDiscAggCallBinding(RelDataTypeFactory typeFactory, SqlAggFunction aggFunction,
+        List<RelDataType> operands, RelDataType collationType, int groupCount,
+        boolean filter) {
+      super(typeFactory, aggFunction, operands, groupCount, filter);
+      assert aggFunction.isPercentile();
+      this.collationType = collationType;
+    }
+
+    @Override public RelDataType getCollationType() {
+      return collationType;
+    }
+  }
 }
diff --git a/core/src/main/java/org/apache/calcite/rel/core/AggregateCall.java b/core/src/main/java/org/apache/calcite/rel/core/AggregateCall.java
index b3bff0ffb55..b1cdcbc57f2 100644
--- a/core/src/main/java/org/apache/calcite/rel/core/AggregateCall.java
+++ b/core/src/main/java/org/apache/calcite/rel/core/AggregateCall.java
@@ -23,6 +23,7 @@
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeFactory;
 import org.apache.calcite.sql.SqlAggFunction;
+import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.type.SqlTypeUtil;
 import org.apache.calcite.util.ImmutableBitSet;
 import org.apache.calcite.util.Optionality;
@@ -428,6 +429,15 @@ public Aggregate.AggCallBinding createBinding(
       Aggregate aggregateRelBase) {
     final RelDataType rowType = aggregateRelBase.getInput().getRowType();
 
+    if (aggFunction.getKind() == SqlKind.PERCENTILE_DISC
+        || aggFunction.getKind() == SqlKind.PERCENTILE_CONT) {
+      assert collation.getKeys().size() == 1;
+      return new Aggregate.PercentileDiscAggCallBinding(
+          aggregateRelBase.getCluster().getTypeFactory(), aggFunction,
+          SqlTypeUtil.projectTypes(rowType, argList),
+          SqlTypeUtil.projectTypes(rowType, collation.getKeys()).get(0),
+          aggregateRelBase.getGroupCount(), hasFilter());
+    }
     return new Aggregate.AggCallBinding(
         aggregateRelBase.getCluster().getTypeFactory(), aggFunction,
         SqlTypeUtil.projectTypes(rowType, argList),
diff --git a/core/src/main/java/org/apache/calcite/rel/core/Collect.java b/core/src/main/java/org/apache/calcite/rel/core/Collect.java
index 28b83c5ff51..d5b1e4588db 100644
--- a/core/src/main/java/org/apache/calcite/rel/core/Collect.java
+++ b/core/src/main/java/org/apache/calcite/rel/core/Collect.java
@@ -25,6 +25,7 @@
 import org.apache.calcite.rel.SingleRel;
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeFactory;
+import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.sql.type.SqlTypeUtil;
 
@@ -124,6 +125,7 @@ public static Collect create(RelNode input, RelDataType rowType) {
    * @param collectionType ARRAY, MAP or MULTISET
    * @param fieldName      Name of the sole output field
    */
+  @Deprecated // to be removed before 2.0
   public static Collect create(RelNode input,
       SqlTypeName collectionType,
       String fieldName) {
@@ -132,6 +134,35 @@ public static Collect create(RelNode input,
             fieldName, input.getRowType()));
   }
 
+  /**
+   * Creates a Collect.
+   *
+   * @param input          Input relational expression
+   * @param sqlKind        SqlKind
+   * @param fieldName      Name of the sole output field
+   */
+  public static Collect create(RelNode input,
+      SqlKind sqlKind,
+      String fieldName) {
+    SqlTypeName collectionType = getCollectionType(sqlKind);
+    RelDataType rowType;
+    switch (sqlKind) {
+    case ARRAY_QUERY_CONSTRUCTOR:
+    case MULTISET_QUERY_CONSTRUCTOR:
+      rowType =
+          deriveRowType(input.getCluster().getTypeFactory(), collectionType,
+              fieldName,
+              SqlTypeUtil.deriveCollectionQueryComponentType(collectionType,
+                  input.getRowType()));
+      break;
+    default:
+      rowType =
+          deriveRowType(input.getCluster().getTypeFactory(), collectionType,
+              fieldName, input.getRowType());
+    }
+    return create(input, rowType);
+  }
+
   /** Returns the row type, guaranteed not null.
    * (The row type is never null after initialization, but
    * CheckerFramework can't deduce that references are safe.) */
@@ -173,6 +204,23 @@ private static SqlTypeName getCollectionType(RelDataType rowType) {
         .getType().getSqlTypeName();
   }
 
+  private static SqlTypeName getCollectionType(SqlKind sqlKind) {
+    switch (sqlKind) {
+    case ARRAY_QUERY_CONSTRUCTOR:
+    case ARRAY_VALUE_CONSTRUCTOR:
+      return SqlTypeName.ARRAY;
+    case MULTISET_QUERY_CONSTRUCTOR:
+    case MULTISET_VALUE_CONSTRUCTOR:
+      return SqlTypeName.MULTISET;
+    case MAP_QUERY_CONSTRUCTOR:
+    case MAP_VALUE_CONSTRUCTOR:
+      return SqlTypeName.MAP;
+    default:
+      throw new IllegalArgumentException("not a collection kind "
+          + sqlKind);
+    }
+  }
+
   @Override protected RelDataType deriveRowType() {
     // this method should never be called; rowType is always set
     throw new UnsupportedOperationException();
diff --git a/core/src/main/java/org/apache/calcite/rel/core/Match.java b/core/src/main/java/org/apache/calcite/rel/core/Match.java
index 40bcd54eed3..abdea8e9783 100644
--- a/core/src/main/java/org/apache/calcite/rel/core/Match.java
+++ b/core/src/main/java/org/apache/calcite/rel/core/Match.java
@@ -249,8 +249,9 @@ private static class AggregateFinder extends RexVisitorImpl<Void> {
         visitEach(call.operands);
       }
       if (aggFunction != null) {
-        RexMRAggCall aggCall = new RexMRAggCall(aggFunction,
-            call.getType(), call.getOperands(), aggregateCalls.size());
+        RexMRAggCall aggCall =
+            new RexMRAggCall(aggFunction, call.getType(), call.getOperands(),
+                aggregateCalls.size());
         aggregateCalls.add(aggCall);
         Set<String> pv = new PatternVarFinder().go(call.getOperands());
         if (pv.size() == 0) {
diff --git a/core/src/main/java/org/apache/calcite/rel/core/Project.java b/core/src/main/java/org/apache/calcite/rel/core/Project.java
index f4a2e3ac3dd..ddcb037db92 100644
--- a/core/src/main/java/org/apache/calcite/rel/core/Project.java
+++ b/core/src/main/java/org/apache/calcite/rel/core/Project.java
@@ -45,6 +45,7 @@
 import org.apache.calcite.util.mapping.Mappings;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
 
 import org.apiguardian.api.API;
 import org.checkerframework.checker.nullness.qual.EnsuresNonNullIf;
@@ -53,6 +54,7 @@
 import java.util.HashSet;
 import java.util.List;
 import java.util.Objects;
+import java.util.Optional;
 import java.util.Set;
 
 import static java.util.Objects.requireNonNull;
@@ -70,6 +72,8 @@ public abstract class Project extends SingleRel implements Hintable {
 
   protected final ImmutableList<RelHint> hints;
 
+  protected final ImmutableSet<CorrelationId> variablesSet;
+
   //~ Constructors -----------------------------------------------------------
 
   /**
@@ -81,6 +85,8 @@ public abstract class Project extends SingleRel implements Hintable {
    * @param input    Input relational expression
    * @param projects List of expressions for the input columns
    * @param rowType  Output row type
+   * @param variableSet Correlation variables set by this relational expression
+   *                    to be used by nested expressions
    */
   @SuppressWarnings("method.invocation.invalid")
   protected Project(
@@ -89,25 +95,38 @@ protected Project(
       List<RelHint> hints,
       RelNode input,
       List<? extends RexNode> projects,
-      RelDataType rowType) {
+      RelDataType rowType,
+      Set<CorrelationId> variableSet) {
     super(cluster, traits, input);
     assert rowType != null;
     this.exps = ImmutableList.copyOf(projects);
     this.hints = ImmutableList.copyOf(hints);
     this.rowType = rowType;
+    this.variablesSet = ImmutableSet.copyOf(variableSet);
     assert isValid(Litmus.THROW, null);
   }
 
+  @Deprecated // to be removed before 2.0
+  protected Project(
+      RelOptCluster cluster,
+      RelTraitSet traits,
+      List<RelHint> hints,
+      RelNode input,
+      List<? extends RexNode> projects,
+      RelDataType rowType) {
+    this(cluster, traits, hints, input, projects, rowType, ImmutableSet.of());
+  }
+
   @Deprecated // to be removed before 2.0
   protected Project(RelOptCluster cluster, RelTraitSet traits,
       RelNode input, List<? extends RexNode> projects, RelDataType rowType) {
-    this(cluster, traits, ImmutableList.of(), input, projects, rowType);
+    this(cluster, traits, ImmutableList.of(), input, projects, rowType, ImmutableSet.of());
   }
 
   @Deprecated // to be removed before 2.0
   protected Project(RelOptCluster cluster, RelTraitSet traitSet, RelNode input,
       List<? extends RexNode> projects, RelDataType rowType, int flags) {
-    this(cluster, traitSet, ImmutableList.of(), input, projects, rowType);
+    this(cluster, traitSet, ImmutableList.of(), input, projects, rowType, ImmutableSet.of());
     Util.discard(flags);
   }
 
@@ -120,7 +139,12 @@ protected Project(RelInput input) {
         ImmutableList.of(),
         input.getInput(),
         requireNonNull(input.getExpressionList("exprs"), "exprs"),
-        input.getRowType("exprs", "fields"));
+        input.getRowType("exprs", "fields"),
+        ImmutableSet.copyOf(
+            Util.transform(
+                Optional.ofNullable(input.getIntegerList("variablesSet"))
+                    .orElse(ImmutableList.of()),
+                id -> new CorrelationId(id))));
   }
 
   //~ Methods ----------------------------------------------------------------
@@ -264,8 +288,13 @@ private static int countTrivial(List<RexNode> refs) {
     return refs.size();
   }
 
+  @Override public Set<CorrelationId> getVariablesSet() {
+    return variablesSet;
+  }
+
   @Override public RelWriter explainTerms(RelWriter pw) {
     super.explainTerms(pw);
+    pw.itemIf("variablesSet", variablesSet, !variablesSet.isEmpty());
     // Skip writing field names so the optimizer can reuse the projects that differ in
     // field names only
     if (pw.getDetailLevel() == SqlExplainLevel.DIGEST_ATTRIBUTES) {
diff --git a/core/src/main/java/org/apache/calcite/rel/core/RelFactories.java b/core/src/main/java/org/apache/calcite/rel/core/RelFactories.java
index 6d5e2c0d65c..3a0d5433511 100644
--- a/core/src/main/java/org/apache/calcite/rel/core/RelFactories.java
+++ b/core/src/main/java/org/apache/calcite/rel/core/RelFactories.java
@@ -163,9 +163,29 @@ public interface ProjectFactory {
      * @param childExprs The projection expressions
      * @param fieldNames The projection field names
      * @return a project
+     * @deprecated Use {@link #createProject(RelNode, List, List, List, Set)} instead
+     */
+    @Deprecated // to be removed before 2.0
+    default RelNode createProject(RelNode input, List<RelHint> hints,
+        List<? extends RexNode> childExprs, @Nullable List<? extends @Nullable String> fieldNames) {
+      return createProject(input, hints, childExprs, fieldNames, ImmutableSet.of());
+    }
+
+    /**
+     * Creates a project.
+     *
+     * @param input The input
+     * @param hints The hints
+     * @param childExprs The projection expressions
+     * @param fieldNames The projection field names
+     * @param variablesSet Correlating variables that are set when reading a row
+     *                     from the input, and which may be referenced from the
+     *                     projection expressions
+     * @return a project
      */
     RelNode createProject(RelNode input, List<RelHint> hints,
-        List<? extends RexNode> childExprs, @Nullable List<? extends @Nullable String> fieldNames);
+        List<? extends RexNode> childExprs, @Nullable List<? extends @Nullable String> fieldNames,
+        Set<CorrelationId> variablesSet);
   }
 
   /**
@@ -174,8 +194,9 @@ RelNode createProject(RelNode input, List<RelHint> hints,
    */
   private static class ProjectFactoryImpl implements ProjectFactory {
     @Override public RelNode createProject(RelNode input, List<RelHint> hints,
-        List<? extends RexNode> childExprs, @Nullable List<? extends @Nullable String> fieldNames) {
-      return LogicalProject.create(input, hints, childExprs, fieldNames);
+        List<? extends RexNode> childExprs, @Nullable List<? extends @Nullable String> fieldNames,
+        Set<CorrelationId> variablesSet) {
+      return LogicalProject.create(input, hints, childExprs, fieldNames, variablesSet);
     }
   }
 
diff --git a/core/src/main/java/org/apache/calcite/rel/core/Snapshot.java b/core/src/main/java/org/apache/calcite/rel/core/Snapshot.java
index 66a30296323..317314d0adc 100644
--- a/core/src/main/java/org/apache/calcite/rel/core/Snapshot.java
+++ b/core/src/main/java/org/apache/calcite/rel/core/Snapshot.java
@@ -18,20 +18,27 @@
 
 import org.apache.calcite.plan.RelOptCluster;
 import org.apache.calcite.plan.RelTraitSet;
+import org.apache.calcite.rel.RelInput;
 import org.apache.calcite.rel.RelNode;
 import org.apache.calcite.rel.RelWriter;
 import org.apache.calcite.rel.SingleRel;
+import org.apache.calcite.rel.hint.Hintable;
+import org.apache.calcite.rel.hint.RelHint;
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rex.RexNode;
 import org.apache.calcite.rex.RexShuttle;
 import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.util.Litmus;
 
+import com.google.common.collect.ImmutableList;
+
 import org.checkerframework.checker.nullness.qual.Nullable;
 
 import java.util.List;
 import java.util.Objects;
 
+import static java.util.Objects.requireNonNull;
+
 /**
  * Relational expression that returns the contents of a relation expression as
  * it was at a given time in the past.
@@ -43,30 +50,60 @@
  * returns the contents whose versions that overlap with the given specific
  * period (i.e. those that started before given period and ended after it).
  */
-public abstract class Snapshot extends SingleRel  {
+public abstract class Snapshot extends SingleRel implements Hintable {
   //~ Instance fields --------------------------------------------------------
 
   private final RexNode period;
 
+  protected final ImmutableList<RelHint> hints;
+
   //~ Constructors -----------------------------------------------------------
 
+  /**
+   * Creates a Snapshot by parsing serialized output.
+   */
+  public Snapshot(RelInput input) {
+    this(input.getCluster(),
+        input.getTraitSet(),
+        ImmutableList.of(),
+        input.getInput(),
+        requireNonNull(input.getExpression("period"), "period"));
+  }
+
   /**
    * Creates a Snapshot.
    *
    * @param cluster   Cluster that this relational expression belongs to
    * @param traitSet  The traits of this relational expression
+   * @param hints     Hints for this node
    * @param input     Input relational expression
    * @param period    Timestamp expression which as the table was at the given
    *                  time in the past
    */
   @SuppressWarnings("method.invocation.invalid")
-  protected Snapshot(RelOptCluster cluster, RelTraitSet traitSet, RelNode input,
-      RexNode period) {
+  protected Snapshot(RelOptCluster cluster, RelTraitSet traitSet, List<RelHint> hints,
+      RelNode input, RexNode period) {
     super(cluster, traitSet, input);
     this.period = Objects.requireNonNull(period, "period");
+    this.hints = ImmutableList.copyOf(hints);
     assert isValid(Litmus.THROW, null);
   }
 
+  /**
+   * Creates a Snapshot.
+   *
+   * @param cluster   Cluster that this relational expression belongs to
+   * @param traitSet  The traits of this relational expression
+   * @param input     Input relational expression
+   * @param period    Timestamp expression which as the table was at the given
+   *                  time in the past
+   */
+  @SuppressWarnings("method.invocation.invalid")
+  protected Snapshot(
+      RelOptCluster cluster, RelTraitSet traitSet, RelNode input, RexNode period) {
+    this(cluster, traitSet, ImmutableList.of(), input, period);
+  }
+
   //~ Methods ----------------------------------------------------------------
 
   @Override public final RelNode copy(RelTraitSet traitSet, List<RelNode> inputs) {
@@ -100,4 +137,8 @@ public RexNode getPeriod() {
     }
     return litmus.succeed();
   }
+
+  @Override public ImmutableList<RelHint> getHints() {
+    return hints;
+  }
 }
diff --git a/core/src/main/java/org/apache/calcite/rel/core/Window.java b/core/src/main/java/org/apache/calcite/rel/core/Window.java
index e744f940ff8..8b52f999e8d 100644
--- a/core/src/main/java/org/apache/calcite/rel/core/Window.java
+++ b/core/src/main/java/org/apache/calcite/rel/core/Window.java
@@ -269,9 +269,7 @@ public Group(
     }
 
     @RequiresNonNull({"keys", "orderKeys", "lowerBound", "upperBound", "aggCalls"})
-    private String computeString(
-        @UnderInitialization Group this
-    ) {
+    private String computeString(@UnderInitialization Group this) {
       final StringBuilder buf = new StringBuilder("window(");
       final int i = buf.length();
       if (!keys.isEmpty()) {
@@ -279,7 +277,10 @@ private String computeString(
         buf.append(keys);
       }
       if (!orderKeys.getFieldCollations().isEmpty()) {
-        buf.append(buf.length() == i ? "order by " : " order by ");
+        if (buf.length() > i) {
+          buf.append(' ');
+        }
+        buf.append("order by ");
         buf.append(orderKeys);
       }
       if (orderKeys.getFieldCollations().isEmpty()
@@ -301,14 +302,20 @@ private String computeString(
         // which is NOT equivalent to
         // "ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW"
       } else {
-        buf.append(isRows ? " rows " : " range ");
+        if (buf.length() > i) {
+          buf.append(' ');
+        }
+        buf.append(isRows ? "rows " : "range ");
         buf.append("between ");
         buf.append(lowerBound);
         buf.append(" and ");
         buf.append(upperBound);
       }
       if (!aggCalls.isEmpty()) {
-        buf.append(buf.length() == i ? "aggs " : " aggs ");
+        if (buf.length() > i) {
+          buf.append(' ');
+        }
+        buf.append("aggs ");
         buf.append(aggCalls);
       }
       buf.append(")");
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 d39947dfdfe..c3f8a7c2caa 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
@@ -54,7 +54,10 @@
 import org.apache.calcite.sql.SqlIntervalQualifier;
 import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.SqlOperator;
+import org.apache.calcite.sql.SqlOperatorTable;
 import org.apache.calcite.sql.SqlSyntax;
+import org.apache.calcite.sql.fun.SqlLibrary;
+import org.apache.calcite.sql.fun.SqlLibraryOperatorTableFactory;
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
 import org.apache.calcite.sql.parser.SqlParserPos;
 import org.apache.calcite.sql.type.SqlTypeName;
@@ -73,6 +76,7 @@
 import java.lang.reflect.InvocationTargetException;
 import java.math.BigDecimal;
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
@@ -92,6 +96,7 @@ public class RelJson {
   private final Map<String, Constructor> constructorMap = new HashMap<>();
   private final @Nullable JsonBuilder jsonBuilder;
   private final InputTranslator inputTranslator;
+  private final SqlOperatorTable operatorTable;
 
   public static final List<String> PACKAGES =
       ImmutableList.of(
@@ -103,14 +108,34 @@ public class RelJson {
 
   /** Private constructor. */
   private RelJson(@Nullable JsonBuilder jsonBuilder,
-      InputTranslator inputTranslator) {
+      InputTranslator inputTranslator, SqlOperatorTable operatorTable) {
     this.jsonBuilder = jsonBuilder;
     this.inputTranslator = requireNonNull(inputTranslator, "inputTranslator");
+    this.operatorTable = requireNonNull(operatorTable, "operatorTable");
   }
 
   /** Creates a RelJson. */
+  public static RelJson create() {
+    return new RelJson(null, RelJson::translateInput,
+        SqlStdOperatorTable.instance());
+  }
+
+  /** Creates a RelJson.
+   *
+   * @deprecated Use {@link RelJson#create}, followed by
+   * {@link #withJsonBuilder} if {@code jsonBuilder} is not null. */
+  @Deprecated // to be removed before 2.0
   public RelJson(@Nullable JsonBuilder jsonBuilder) {
-    this(jsonBuilder, RelJson::translateInput);
+    this(jsonBuilder, RelJson::translateInput, SqlStdOperatorTable.instance());
+  }
+
+  /** Returns a RelJson with a given JsonBuilder. */
+  public RelJson withJsonBuilder(JsonBuilder jsonBuilder) {
+    requireNonNull(jsonBuilder, "jsonBuilder");
+    if (jsonBuilder == this.jsonBuilder) {
+      return this;
+    }
+    return new RelJson(jsonBuilder, inputTranslator, operatorTable);
   }
 
   /** Returns a RelJson with a given InputTranslator. */
@@ -118,7 +143,23 @@ public RelJson withInputTranslator(InputTranslator inputTranslator) {
     if (inputTranslator == this.inputTranslator) {
       return this;
     }
-    return new RelJson(jsonBuilder, inputTranslator);
+    return new RelJson(jsonBuilder, inputTranslator, operatorTable);
+  }
+
+  /** Returns a RelJson with a given operator table. */
+  public RelJson withOperatorTable(SqlOperatorTable operatorTable) {
+    if (operatorTable == this.operatorTable) {
+      return this;
+    }
+    return new RelJson(jsonBuilder, inputTranslator, operatorTable);
+  }
+
+  /** Returns a RelJson with an operator table that consists of the standard
+   * operators plus operators in all libraries. */
+  public RelJson withLibraryOperatorTable() {
+    return withOperatorTable(
+        SqlLibraryOperatorTableFactory.INSTANCE.getOperatorTable(
+            SqlLibrary.values()));
   }
 
   private JsonBuilder jsonBuilder() {
@@ -300,9 +341,10 @@ public RelDataType toType(RelDataTypeFactory typeFactory, Object o) {
       final boolean nullable = get(map, "nullable");
       return typeFactory.createTypeWithNullability(type, nullable);
     } else {
-      final SqlTypeName sqlTypeName = requireNonNull(
-          Util.enumVal(SqlTypeName.class, (String) o),
-          () -> "unable to find enum value " + o + " in class " + SqlTypeName.class);
+      final SqlTypeName sqlTypeName =
+          requireNonNull(Util.enumVal(SqlTypeName.class, (String) o),
+              () -> "unable to find enum value " + o
+                  + " in class " + SqlTypeName.class);
       return typeFactory.createSqlType(sqlTypeName);
     }
   }
@@ -396,9 +438,9 @@ public Object toJson(AggregateCall node) {
       return toJson((RexWindowBound) value);
     } else if (value instanceof CorrelationId) {
       return toJson((CorrelationId) value);
-    } else if (value instanceof List) {
+    } else if (value instanceof List || value instanceof Set) {
       final List<@Nullable Object> list = jsonBuilder().list();
-      for (Object o : (List<?>) value) {
+      for (Object o : (Collection<?>) value) {
         list.add(toJson(o));
       }
       return list;
@@ -589,13 +631,26 @@ private Object toJson(RexWindowBound windowBound) {
       map.put("type", windowBound.isPreceding() ? "UNBOUNDED_PRECEDING" : "UNBOUNDED_FOLLOWING");
     } else {
       map.put("type", windowBound.isPreceding() ? "PRECEDING" : "FOLLOWING");
-      RexNode offset = requireNonNull(windowBound.getOffset(),
-          () -> "getOffset for window bound " + windowBound);
+      RexNode offset =
+          requireNonNull(windowBound.getOffset(),
+              () -> "getOffset for window bound " + windowBound);
       map.put("offset", toJson(offset));
     }
     return map;
   }
 
+  /**
+   * Translates a JSON expression into a RexNode.
+   *
+   * @param cluster The optimization environment
+   * @param o JSON object
+   * @return the transformed RexNode
+   */
+  public RexNode toRex(RelOptCluster cluster, Object o) {
+    RelInput input = new RelInputForCluster(cluster);
+    return toRex(input, o);
+  }
+
   @SuppressWarnings({"rawtypes", "unchecked"})
   @PolyNull RexNode toRex(RelInput relInput, @PolyNull Object o) {
     final RelOptCluster cluster = relInput.getCluster();
@@ -774,15 +829,15 @@ private List<RexNode> toRexList(RelInput relInput, List operands) {
     String kind = get(map, "kind");
     String syntax = get(map, "syntax");
     SqlKind sqlKind = SqlKind.valueOf(kind);
-    SqlSyntax  sqlSyntax = SqlSyntax.valueOf(syntax);
+    SqlSyntax sqlSyntax = SqlSyntax.valueOf(syntax);
     List<SqlOperator> operators = new ArrayList<>();
-    SqlStdOperatorTable.instance().lookupOperatorOverloads(
+    operatorTable.lookupOperatorOverloads(
         new SqlIdentifier(name, new SqlParserPos(0, 0)),
         null,
         sqlSyntax,
         operators,
         SqlNameMatchers.liberal());
-    for (SqlOperator operator: operators) {
+    for (SqlOperator operator : operators) {
       if (operator.kind == sqlKind) {
         return operator;
       }
@@ -816,11 +871,14 @@ private List<RexNode> toRexList(RelInput relInput, List operands) {
    * @param translator Input translator
    * @param o JSON object
    * @return the transformed RexNode
+   *
+   * @deprecated Use {@link #toRex(RelOptCluster, Object)}
    */
+  @Deprecated // to be removed before 2.0
   public static RexNode readExpression(RelOptCluster cluster,
       InputTranslator translator, Map<String, Object> o) {
     RelInput relInput = new RelInputForCluster(cluster);
-    return new RelJson(null, translator).toRex(relInput, o);
+    return new RelJson(null, translator, SqlStdOperatorTable.instance()).toRex(relInput, o);
   }
 
   /**
diff --git a/core/src/main/java/org/apache/calcite/rel/externalize/RelJsonReader.java b/core/src/main/java/org/apache/calcite/rel/externalize/RelJsonReader.java
index 165a29fe92d..a98d0e8848a 100644
--- a/core/src/main/java/org/apache/calcite/rel/externalize/RelJsonReader.java
+++ b/core/src/main/java/org/apache/calcite/rel/externalize/RelJsonReader.java
@@ -53,6 +53,7 @@
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
+import java.util.function.UnaryOperator;
 
 import static java.util.Objects.requireNonNull;
 
@@ -68,15 +69,21 @@ public class RelJsonReader {
 
   private final RelOptCluster cluster;
   private final RelOptSchema relOptSchema;
-  private final RelJson relJson = new RelJson(null);
+  private final RelJson relJson;
   private final Map<String, RelNode> relMap = new LinkedHashMap<>();
   private @Nullable RelNode lastRel;
 
   public RelJsonReader(RelOptCluster cluster, RelOptSchema relOptSchema,
       Schema schema) {
+    this(cluster, relOptSchema, schema, UnaryOperator.identity());
+  }
+
+  public RelJsonReader(RelOptCluster cluster, RelOptSchema relOptSchema,
+      Schema schema, UnaryOperator<RelJson> relJsonTransform) {
     this.cluster = cluster;
     this.relOptSchema = relOptSchema;
     Util.discard(schema);
+    relJson = relJsonTransform.apply(RelJson.create());
   }
 
   public RelNode read(String s) throws IOException {
@@ -99,7 +106,7 @@ public static RelDataType readType(RelDataTypeFactory typeFactory, String s)
     Map<String, Object> o = mapper
         .configure(DeserializationFeature.USE_BIG_DECIMAL_FOR_FLOATS, true)
         .readValue(s, TYPE_REF);
-    return new RelJson(null).toType(typeFactory, o);
+    return RelJson.create().toType(typeFactory, o);
   }
 
   private void readRels(List<Map<String, Object>> jsonRels) {
@@ -122,12 +129,11 @@ private void readRel(final Map<String, Object> jsonRel) {
       }
 
       @Override public RelOptTable getTable(String table) {
-        final List<String> list = requireNonNull(
-            getStringList(table),
-            () -> "getStringList for " + table);
-        return requireNonNull(
-            relOptSchema.getTableForMember(list),
-            () -> "table " + table + " is not found in schema " + relOptSchema.toString());
+        final List<String> list =
+            requireNonNull(getStringList(table),
+                () -> "getStringList for " + table);
+        return requireNonNull(relOptSchema.getTableForMember(list),
+            () -> "table " + table + " is not found in schema " + relOptSchema);
       }
 
       @Override public RelNode getInput() {
@@ -302,20 +308,22 @@ public ImmutableList<RexLiteral> getTuple(List jsonTuple) {
 
   private AggregateCall toAggCall(Map<String, Object> jsonAggCall) {
     @SuppressWarnings("unchecked")
-    final Map<String, Object> aggMap = (Map) requireNonNull(
-        jsonAggCall.get("agg"),
-        "agg key is not found");
-    final SqlAggFunction aggregation = requireNonNull(
-        relJson.toAggregation(aggMap),
-        () -> "relJson.toAggregation output for " + aggMap);
-    final Boolean distinct = (Boolean) requireNonNull(jsonAggCall.get("distinct"),
-        "jsonAggCall.distinct");
+    final Map<String, Object> aggMap =
+        (Map) requireNonNull(jsonAggCall.get("agg"),
+            "agg key is not found");
+    final SqlAggFunction aggregation =
+        requireNonNull(relJson.toAggregation(aggMap),
+            () -> "relJson.toAggregation output for " + aggMap);
+    final boolean distinct =
+        requireNonNull((Boolean) jsonAggCall.get("distinct"),
+            "jsonAggCall.distinct");
     @SuppressWarnings("unchecked")
-    final List<Integer> operands = (List<Integer>) requireNonNull(
-        jsonAggCall.get("operands"),
-        "jsonAggCall.operands");
+    final List<Integer> operands =
+        requireNonNull((List<Integer>) jsonAggCall.get("operands"),
+            "jsonAggCall.operands");
     final Integer filterOperand = (Integer) jsonAggCall.get("filter");
-    final Object jsonAggType = requireNonNull(jsonAggCall.get("type"), "jsonAggCall.type");
+    final Object jsonAggType =
+        requireNonNull(jsonAggCall.get("type"), "jsonAggCall.type");
     final RelDataType type =
         relJson.toType(cluster.getTypeFactory(), jsonAggType);
     final String name = (String) jsonAggCall.get("name");
diff --git a/core/src/main/java/org/apache/calcite/rel/externalize/RelJsonWriter.java b/core/src/main/java/org/apache/calcite/rel/externalize/RelJsonWriter.java
index 964a9455271..85d275f79d6 100644
--- a/core/src/main/java/org/apache/calcite/rel/externalize/RelJsonWriter.java
+++ b/core/src/main/java/org/apache/calcite/rel/externalize/RelJsonWriter.java
@@ -31,6 +31,9 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
+import java.util.function.UnaryOperator;
+
+import static java.util.Objects.requireNonNull;
 
 /**
  * Callback for a relational expression to dump itself as JSON.
@@ -49,14 +52,23 @@ public class RelJsonWriter implements RelWriter {
 
   //~ Constructors -------------------------------------------------------------
 
+  /** Creates a RelJsonWriter with a private JsonBuilder. */
   public RelJsonWriter() {
     this(new JsonBuilder());
   }
 
+  /** Creates a RelJsonWriter with a given JsonBuilder. */
   public RelJsonWriter(JsonBuilder jsonBuilder) {
-    this.jsonBuilder = jsonBuilder;
+    this(jsonBuilder, UnaryOperator.identity());
+  }
+
+  /** Creates a RelJsonWriter. */
+  public RelJsonWriter(JsonBuilder jsonBuilder,
+      UnaryOperator<RelJson> relJsonTransform) {
+    this.jsonBuilder = requireNonNull(jsonBuilder, "jsonBuilder");
     relList = this.jsonBuilder.list();
-    relJson = new RelJson(this.jsonBuilder);
+    relJson =
+        relJsonTransform.apply(RelJson.create().withJsonBuilder(jsonBuilder));
   }
 
   //~ Methods ------------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/rel/hint/HintPredicates.java b/core/src/main/java/org/apache/calcite/rel/hint/HintPredicates.java
index f8479829680..b2d8756d8d0 100644
--- a/core/src/main/java/org/apache/calcite/rel/hint/HintPredicates.java
+++ b/core/src/main/java/org/apache/calcite/rel/hint/HintPredicates.java
@@ -80,6 +80,11 @@ public abstract class HintPredicates {
   public static final HintPredicate WINDOW =
       new NodeTypeHintPredicate(NodeTypeHintPredicate.NodeType.WINDOW);
 
+  /** A hint predicate that indicates a hint can only be used to
+   * {@link org.apache.calcite.rel.core.Snapshot} nodes. */
+  public static final HintPredicate SNAPSHOT =
+      new NodeTypeHintPredicate(NodeTypeHintPredicate.NodeType.SNAPSHOT);
+
   /**
    * Returns a composed hint predicate that represents a short-circuiting logical
    * AND of an array of hint predicates {@code hintPredicates}.  When evaluating the composed
diff --git a/core/src/main/java/org/apache/calcite/rel/hint/HintStrategyTable.java b/core/src/main/java/org/apache/calcite/rel/hint/HintStrategyTable.java
index 3c91690386d..a2e0a3233e6 100644
--- a/core/src/main/java/org/apache/calcite/rel/hint/HintStrategyTable.java
+++ b/core/src/main/java/org/apache/calcite/rel/hint/HintStrategyTable.java
@@ -100,11 +100,11 @@ private boolean canApply(RelHint hint, RelNode rel) {
    */
   public boolean validateHint(RelHint hint) {
     final Key key = Key.of(hint.hintName);
-    boolean hintExists = this.errorHandler.check(
-        this.strategies.containsKey(key),
-        "Hint: {} should be registered in the {}",
-        hint.hintName,
-        this.getClass().getSimpleName());
+    boolean hintExists =
+        this.errorHandler.check(this.strategies.containsKey(key),
+            "Hint: {} should be registered in the {}",
+            hint.hintName,
+            this.getClass().getSimpleName());
     if (!hintExists) {
       return false;
     }
@@ -233,18 +233,5 @@ public static class HintErrorLogger implements Litmus {
       LOGGER.warn(requireNonNull(message, "message"), args);
       return false;
     }
-
-    @Override public boolean succeed() {
-      return true;
-    }
-
-    @Override public boolean check(boolean condition, @Nullable String message,
-        @Nullable Object... args) {
-      if (condition) {
-        return succeed();
-      } else {
-        return fail(message, args);
-      }
-    }
   }
 }
diff --git a/core/src/main/java/org/apache/calcite/rel/hint/NodeTypeHintPredicate.java b/core/src/main/java/org/apache/calcite/rel/hint/NodeTypeHintPredicate.java
index 225453d543e..7fd3b784110 100644
--- a/core/src/main/java/org/apache/calcite/rel/hint/NodeTypeHintPredicate.java
+++ b/core/src/main/java/org/apache/calcite/rel/hint/NodeTypeHintPredicate.java
@@ -24,6 +24,7 @@
 import org.apache.calcite.rel.core.Join;
 import org.apache.calcite.rel.core.Project;
 import org.apache.calcite.rel.core.SetOp;
+import org.apache.calcite.rel.core.Snapshot;
 import org.apache.calcite.rel.core.Sort;
 import org.apache.calcite.rel.core.TableScan;
 import org.apache.calcite.rel.core.Values;
@@ -99,7 +100,12 @@ enum NodeType {
     /**
      * The hint would be propagated to the Window nodes.
      */
-    WINDOW(Window.class);
+    WINDOW(Window.class),
+
+    /**
+     * The hint would be propagated to the Snapshot nodes.
+     */
+    SNAPSHOT(Snapshot.class);
 
     /** Relational expression clazz that the hint can apply to. */
     @SuppressWarnings("ImmutableEnumChecker")
diff --git a/core/src/main/java/org/apache/calcite/rel/logical/LogicalCalc.java b/core/src/main/java/org/apache/calcite/rel/logical/LogicalCalc.java
index 8e5d2acd76f..2ab47e5c2fc 100644
--- a/core/src/main/java/org/apache/calcite/rel/logical/LogicalCalc.java
+++ b/core/src/main/java/org/apache/calcite/rel/logical/LogicalCalc.java
@@ -25,6 +25,7 @@
 import org.apache.calcite.rel.RelDistributionTraitDef;
 import org.apache.calcite.rel.RelInput;
 import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.RelShuttle;
 import org.apache.calcite.rel.core.Calc;
 import org.apache.calcite.rel.core.CorrelationId;
 import org.apache.calcite.rel.hint.RelHint;
@@ -140,4 +141,8 @@ public static LogicalCalc create(final RelNode input,
     return new LogicalCalc(getCluster(), traitSet,
         ImmutableList.copyOf(hintList), input, program);
   }
+
+  @Override public RelNode accept(RelShuttle shuttle) {
+    return shuttle.visit(this);
+  }
 }
diff --git a/core/src/main/java/org/apache/calcite/rel/logical/LogicalProject.java b/core/src/main/java/org/apache/calcite/rel/logical/LogicalProject.java
index cb64b372700..2cfe9e0b9c8 100644
--- a/core/src/main/java/org/apache/calcite/rel/logical/LogicalProject.java
+++ b/core/src/main/java/org/apache/calcite/rel/logical/LogicalProject.java
@@ -24,6 +24,7 @@
 import org.apache.calcite.rel.RelInput;
 import org.apache.calcite.rel.RelNode;
 import org.apache.calcite.rel.RelShuttle;
+import org.apache.calcite.rel.core.CorrelationId;
 import org.apache.calcite.rel.core.Project;
 import org.apache.calcite.rel.hint.RelHint;
 import org.apache.calcite.rel.metadata.RelMdCollation;
@@ -35,10 +36,12 @@
 import org.apache.calcite.util.Util;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 
 import java.util.List;
+import java.util.Set;
 
 /**
  * Sub-class of {@link org.apache.calcite.rel.core.Project} not
@@ -58,6 +61,8 @@ public final class LogicalProject extends Project {
    * @param input    Input relational expression
    * @param projects List of expressions for the input columns
    * @param rowType  Output row type
+   * @param variablesSet Correlation variables set by this relational expression
+   *                     to be used by nested expressions
    */
   public LogicalProject(
       RelOptCluster cluster,
@@ -65,22 +70,34 @@ public LogicalProject(
       List<RelHint> hints,
       RelNode input,
       List<? extends RexNode> projects,
-      RelDataType rowType) {
-    super(cluster, traitSet, hints, input, projects, rowType);
+      RelDataType rowType,
+      Set<CorrelationId> variablesSet) {
+    super(cluster, traitSet, hints, input, projects, rowType, variablesSet);
     assert traitSet.containsIfApplicable(Convention.NONE);
   }
 
+  @Deprecated // to be removed before 2.0
+  public LogicalProject(
+      RelOptCluster cluster,
+      RelTraitSet traitSet,
+      List<RelHint> hints,
+      RelNode input,
+      List<? extends RexNode> projects,
+      RelDataType rowType) {
+    this(cluster, traitSet, hints, input, projects, rowType, ImmutableSet.of());
+  }
+
   @Deprecated // to be removed before 2.0
   public LogicalProject(RelOptCluster cluster, RelTraitSet traitSet,
       RelNode input, List<? extends RexNode> projects, RelDataType rowType) {
-    this(cluster, traitSet, ImmutableList.of(), input, projects, rowType);
+    this(cluster, traitSet, ImmutableList.of(), input, projects, rowType, ImmutableSet.of());
   }
 
   @Deprecated // to be removed before 2.0
   public LogicalProject(RelOptCluster cluster, RelTraitSet traitSet,
       RelNode input, List<? extends RexNode> projects, RelDataType rowType,
       int flags) {
-    this(cluster, traitSet, ImmutableList.of(), input, projects, rowType);
+    this(cluster, traitSet, ImmutableList.of(), input, projects, rowType, ImmutableSet.of());
     Util.discard(flags);
   }
 
@@ -90,7 +107,7 @@ public LogicalProject(RelOptCluster cluster, RelNode input,
     this(cluster, cluster.traitSetOf(RelCollations.EMPTY),
         ImmutableList.of(), input, projects,
         RexUtil.createStructType(cluster.getTypeFactory(), projects,
-            fieldNames, null));
+            fieldNames, null), ImmutableSet.of());
     Util.discard(flags);
   }
 
@@ -103,32 +120,56 @@ public LogicalProject(RelInput input) {
 
   //~ Methods ----------------------------------------------------------------
 
-  /** Creates a LogicalProject. */
+  /**
+   * Creates a LogicalProject.
+   * @deprecated Use {@link #create(RelNode, List, List, List, Set)} instead
+   */
+  @Deprecated // to be removed before 2.0
   public static LogicalProject create(final RelNode input, List<RelHint> hints,
       final List<? extends RexNode> projects,
       @Nullable List<? extends @Nullable String> fieldNames) {
+    return create(input, hints, projects, fieldNames, ImmutableSet.of());
+  }
+
+  /** Creates a LogicalProject. */
+  public static LogicalProject create(final RelNode input, List<RelHint> hints,
+      final List<? extends RexNode> projects,
+      @Nullable List<? extends @Nullable String> fieldNames,
+      final Set<CorrelationId> variablesSet) {
     final RelOptCluster cluster = input.getCluster();
     final RelDataType rowType =
         RexUtil.createStructType(cluster.getTypeFactory(), projects,
             fieldNames, SqlValidatorUtil.F_SUGGESTER);
-    return create(input, hints, projects, rowType);
+    return create(input, hints, projects, rowType, variablesSet);
   }
 
-  /** Creates a LogicalProject, specifying row type rather than field names. */
+  /**
+   * Creates a LogicalProject, specifying row type rather than field names.
+   * @deprecated Use {@link #create(RelNode, List, List, RelDataType, Set)} instead
+   */
+  @Deprecated // to be removed before 2.0
   public static LogicalProject create(final RelNode input, List<RelHint> hints,
       final List<? extends RexNode> projects, RelDataType rowType) {
+    return create(input, hints, projects, rowType, ImmutableSet.of());
+  }
+
+  /** Creates a LogicalProject, specifying row type rather than field names. */
+  public static LogicalProject create(final RelNode input, List<RelHint> hints,
+      final List<? extends RexNode> projects, RelDataType rowType,
+      final Set<CorrelationId> variablesSet) {
     final RelOptCluster cluster = input.getCluster();
     final RelMetadataQuery mq = cluster.getMetadataQuery();
     final RelTraitSet traitSet =
         cluster.traitSet().replace(Convention.NONE)
             .replaceIfs(RelCollationTraitDef.INSTANCE,
                 () -> RelMdCollation.project(mq, input, projects));
-    return new LogicalProject(cluster, traitSet, hints, input, projects, rowType);
+    return new LogicalProject(cluster, traitSet, hints, input, projects, rowType, variablesSet);
   }
 
   @Override public LogicalProject copy(RelTraitSet traitSet, RelNode input,
       List<RexNode> projects, RelDataType rowType) {
-    return new LogicalProject(getCluster(), traitSet, hints, input, projects, rowType);
+    return new LogicalProject(getCluster(), traitSet, hints, input, projects, rowType,
+        variablesSet);
   }
 
   @Override public RelNode accept(RelShuttle shuttle) {
@@ -137,7 +178,7 @@ public static LogicalProject create(final RelNode input, List<RelHint> hints,
 
   @Override public RelNode withHints(List<RelHint> hintList) {
     return new LogicalProject(getCluster(), traitSet, hintList,
-        input, getProjects(), getRowType());
+        input, getProjects(), getRowType(), variablesSet);
   }
 
   @Override public boolean deepEquals(@Nullable Object obj) {
diff --git a/core/src/main/java/org/apache/calcite/rel/logical/LogicalSnapshot.java b/core/src/main/java/org/apache/calcite/rel/logical/LogicalSnapshot.java
index 47e9967f6db..d03293ee342 100644
--- a/core/src/main/java/org/apache/calcite/rel/logical/LogicalSnapshot.java
+++ b/core/src/main/java/org/apache/calcite/rel/logical/LogicalSnapshot.java
@@ -21,13 +21,19 @@
 import org.apache.calcite.plan.RelTraitSet;
 import org.apache.calcite.rel.RelCollationTraitDef;
 import org.apache.calcite.rel.RelDistributionTraitDef;
+import org.apache.calcite.rel.RelInput;
 import org.apache.calcite.rel.RelNode;
 import org.apache.calcite.rel.core.Snapshot;
+import org.apache.calcite.rel.hint.RelHint;
 import org.apache.calcite.rel.metadata.RelMdCollation;
 import org.apache.calcite.rel.metadata.RelMdDistribution;
 import org.apache.calcite.rel.metadata.RelMetadataQuery;
 import org.apache.calcite.rex.RexNode;
 
+import com.google.common.collect.ImmutableList;
+
+import java.util.List;
+
 /**
  * Sub-class of {@link org.apache.calcite.rel.core.Snapshot}
  * not targeted at any particular engine or calling convention.
@@ -36,6 +42,30 @@ public class LogicalSnapshot extends Snapshot {
 
   //~ Constructors -----------------------------------------------------------
 
+  /**
+   * Creates a LogicalSnapshot by parsing serialized output.
+   */
+  public LogicalSnapshot(RelInput input) {
+    super(input);
+  }
+
+  /**
+   * Creates a LogicalSnapshot.
+   *
+   * <p>Use {@link #create} unless you know what you're doing.
+   *
+   * @param cluster   Cluster that this relational expression belongs to
+   * @param traitSet  The traits of this relational expression
+   * @param hints     Hints for this node
+   * @param input     Input relational expression
+   * @param period    Timestamp expression which as the table was at the given
+   *                  time in the past
+   */
+  public LogicalSnapshot(RelOptCluster cluster, RelTraitSet traitSet, List<RelHint> hints,
+      RelNode input, RexNode period) {
+    super(cluster, traitSet, hints, input, period);
+  }
+
   /**
    * Creates a LogicalSnapshot.
    *
@@ -49,12 +79,12 @@ public class LogicalSnapshot extends Snapshot {
    */
   public LogicalSnapshot(RelOptCluster cluster, RelTraitSet traitSet,
       RelNode input, RexNode period) {
-    super(cluster, traitSet, input, period);
+    super(cluster, traitSet, ImmutableList.of(), input, period);
   }
 
   @Override public Snapshot copy(RelTraitSet traitSet, RelNode input,
       RexNode period) {
-    return new LogicalSnapshot(getCluster(), traitSet, input, period);
+    return new LogicalSnapshot(getCluster(), traitSet, hints, input, period);
   }
 
   /** Creates a LogicalSnapshot. */
@@ -69,4 +99,8 @@ public static LogicalSnapshot create(RelNode input, RexNode period) {
             () -> RelMdDistribution.snapshot(mq, input));
     return new LogicalSnapshot(cluster, traitSet, input, period);
   }
+
+  @Override public RelNode withHints(final List<RelHint> hintList) {
+    return new LogicalSnapshot(getCluster(), traitSet, hintList, input, getPeriod());
+  }
 }
diff --git a/core/src/main/java/org/apache/calcite/rel/logical/LogicalTableModify.java b/core/src/main/java/org/apache/calcite/rel/logical/LogicalTableModify.java
index 372bb0249d5..042547529dc 100644
--- a/core/src/main/java/org/apache/calcite/rel/logical/LogicalTableModify.java
+++ b/core/src/main/java/org/apache/calcite/rel/logical/LogicalTableModify.java
@@ -23,6 +23,7 @@
 import org.apache.calcite.prepare.Prepare;
 import org.apache.calcite.rel.RelInput;
 import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.RelShuttle;
 import org.apache.calcite.rel.core.TableModify;
 import org.apache.calcite.rex.RexNode;
 
@@ -92,4 +93,8 @@ public static LogicalTableModify create(RelOptTable table,
         sole(inputs), getOperation(), getUpdateColumnList(),
         getSourceExpressionList(), isFlattened());
   }
+
+  @Override public RelNode accept(RelShuttle shuttle) {
+    return shuttle.visit(this);
+  }
 }
diff --git a/core/src/main/java/org/apache/calcite/rel/logical/LogicalWindow.java b/core/src/main/java/org/apache/calcite/rel/logical/LogicalWindow.java
index 2ebc48b858d..7a1253b32e3 100644
--- a/core/src/main/java/org/apache/calcite/rel/logical/LogicalWindow.java
+++ b/core/src/main/java/org/apache/calcite/rel/logical/LogicalWindow.java
@@ -144,8 +144,9 @@ public static RelNode create(RelOptCluster cluster,
           return ref;
         }
         constants.add(literal);
-        ref = new RexInputRef(constantPool.size() + inputFieldCount,
-            literal.getType());
+        ref =
+            new RexInputRef(constantPool.size() + inputFieldCount,
+                literal.getType());
         constantPool.put(literal, ref);
         return ref;
       }
@@ -363,13 +364,14 @@ private static void addWindows(
     final RexWindow aggWindow = over.getWindow();
 
     // Look up or create a window.
-    RelCollation orderKeys = getCollation(
-        Lists.newArrayList(
-            Util.filter(aggWindow.orderKeys,
-                rexFieldCollation ->
-                    // If ORDER BY references constant (i.e. RexInputRef),
-                    // then we can ignore such ORDER BY key.
-                    rexFieldCollation.left instanceof RexLocalRef)));
+    RelCollation orderKeys =
+        getCollation(
+            Lists.newArrayList(
+                Util.filter(aggWindow.orderKeys,
+                    rexFieldCollation ->
+                        // If ORDER BY references constant (i.e. RexInputRef),
+                        // then we can ignore such ORDER BY key.
+                        rexFieldCollation.left instanceof RexLocalRef)));
     ImmutableBitSet groupSet =
         ImmutableBitSet.of(getProjectOrdinals(aggWindow.partitionKeys));
     final int groupLength = groupSet.length();
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/BuiltInMetadata.java b/core/src/main/java/org/apache/calcite/rel/metadata/BuiltInMetadata.java
index a2467a458b6..cbd7f38f210 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/BuiltInMetadata.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/BuiltInMetadata.java
@@ -45,8 +45,9 @@ public abstract class BuiltInMetadata {
 
   /** Metadata about the selectivity of a predicate. */
   public interface Selectivity extends Metadata {
-    MetadataDef<Selectivity> DEF = MetadataDef.of(Selectivity.class,
-        Selectivity.Handler.class, BuiltInMethod.SELECTIVITY.method);
+    MetadataDef<Selectivity> DEF =
+        MetadataDef.of(Selectivity.class, Selectivity.Handler.class,
+            BuiltInMethod.SELECTIVITY.method);
 
     /**
      * Estimates the percentage of an expression's output rows which satisfy a
@@ -73,8 +74,9 @@ interface Handler extends MetadataHandler<Selectivity> {
 
   /** Metadata about which combinations of columns are unique identifiers. */
   public interface UniqueKeys extends Metadata {
-    MetadataDef<UniqueKeys> DEF = MetadataDef.of(UniqueKeys.class,
-        UniqueKeys.Handler.class, BuiltInMethod.UNIQUE_KEYS.method);
+    MetadataDef<UniqueKeys> DEF =
+        MetadataDef.of(UniqueKeys.class, UniqueKeys.Handler.class,
+            BuiltInMethod.UNIQUE_KEYS.method);
 
     /**
      * Determines the set of unique minimal keys for this expression. A key is
@@ -105,8 +107,9 @@ interface Handler extends MetadataHandler<UniqueKeys> {
 
   /** Metadata about whether a set of columns uniquely identifies a row. */
   public interface ColumnUniqueness extends Metadata {
-    MetadataDef<ColumnUniqueness> DEF = MetadataDef.of(ColumnUniqueness.class,
-        ColumnUniqueness.Handler.class, BuiltInMethod.COLUMN_UNIQUENESS.method);
+    MetadataDef<ColumnUniqueness> DEF =
+        MetadataDef.of(ColumnUniqueness.class, ColumnUniqueness.Handler.class,
+            BuiltInMethod.COLUMN_UNIQUENESS.method);
 
     /**
      * Determines whether a specified set of columns from a specified relational
@@ -146,8 +149,9 @@ Boolean areColumnsUnique(RelNode r, RelMetadataQuery mq,
 
   /** Metadata about which columns are sorted. */
   public interface Collation extends Metadata {
-    MetadataDef<Collation> DEF = MetadataDef.of(Collation.class,
-        Collation.Handler.class, BuiltInMethod.COLLATIONS.method);
+    MetadataDef<Collation> DEF =
+        MetadataDef.of(Collation.class, Collation.Handler.class,
+            BuiltInMethod.COLLATIONS.method);
 
     /** Determines which columns are sorted. */
     ImmutableList<RelCollation> collations();
@@ -175,8 +179,9 @@ interface Handler extends MetadataHandler<Collation> {
    * among nodes, but it may be partitioned among threads running on the same
    * node. */
   public interface Distribution extends Metadata {
-    MetadataDef<Distribution> DEF = MetadataDef.of(Distribution.class,
-        Distribution.Handler.class, BuiltInMethod.DISTRIBUTION.method);
+    MetadataDef<Distribution> DEF =
+        MetadataDef.of(Distribution.class, Distribution.Handler.class,
+            BuiltInMethod.DISTRIBUTION.method);
 
     /** Determines how the rows are distributed. */
     RelDistribution distribution();
@@ -200,8 +205,9 @@ interface Handler extends MetadataHandler<Distribution> {
    * multimap only once.
    */
   public interface NodeTypes extends Metadata {
-    MetadataDef<NodeTypes> DEF = MetadataDef.of(NodeTypes.class,
-        NodeTypes.Handler.class, BuiltInMethod.NODE_TYPES.method);
+    MetadataDef<NodeTypes> DEF =
+        MetadataDef.of(NodeTypes.class, NodeTypes.Handler.class,
+            BuiltInMethod.NODE_TYPES.method);
 
     /**
      * Returns a multimap from the class to the nodes instantiating that
@@ -224,8 +230,9 @@ interface Handler extends MetadataHandler<NodeTypes> {
 
   /** Metadata about the number of rows returned by a relational expression. */
   public interface RowCount extends Metadata {
-    MetadataDef<RowCount> DEF = MetadataDef.of(RowCount.class,
-        RowCount.Handler.class, BuiltInMethod.ROW_COUNT.method);
+    MetadataDef<RowCount> DEF =
+        MetadataDef.of(RowCount.class, RowCount.Handler.class,
+            BuiltInMethod.ROW_COUNT.method);
 
     /**
      * Estimates the number of rows which will be returned by a relational
@@ -252,8 +259,9 @@ interface Handler extends MetadataHandler<RowCount> {
   /** Metadata about the maximum number of rows returned by a relational
    * expression. */
   public interface MaxRowCount extends Metadata {
-    MetadataDef<MaxRowCount> DEF = MetadataDef.of(MaxRowCount.class,
-        MaxRowCount.Handler.class, BuiltInMethod.MAX_ROW_COUNT.method);
+    MetadataDef<MaxRowCount> DEF =
+        MetadataDef.of(MaxRowCount.class, MaxRowCount.Handler.class,
+            BuiltInMethod.MAX_ROW_COUNT.method);
 
     /**
      * Estimates the max number of rows which will be returned by a relational
@@ -281,8 +289,9 @@ interface Handler extends MetadataHandler<MaxRowCount> {
   /** Metadata about the minimum number of rows returned by a relational
    * expression. */
   public interface MinRowCount extends Metadata {
-    MetadataDef<MinRowCount> DEF = MetadataDef.of(MinRowCount.class,
-        MinRowCount.Handler.class, BuiltInMethod.MIN_ROW_COUNT.method);
+    MetadataDef<MinRowCount> DEF =
+        MetadataDef.of(MinRowCount.class, MinRowCount.Handler.class,
+            BuiltInMethod.MIN_ROW_COUNT.method);
 
     /**
      * Estimates the minimum number of rows which will be returned by a
@@ -309,8 +318,9 @@ interface Handler extends MetadataHandler<MinRowCount> {
   /** Metadata about the number of distinct rows returned by a set of columns
    * in a relational expression. */
   public interface DistinctRowCount extends Metadata {
-    MetadataDef<DistinctRowCount> DEF = MetadataDef.of(DistinctRowCount.class,
-        DistinctRowCount.Handler.class, BuiltInMethod.DISTINCT_ROW_COUNT.method);
+    MetadataDef<DistinctRowCount> DEF =
+        MetadataDef.of(DistinctRowCount.class, DistinctRowCount.Handler.class,
+            BuiltInMethod.DISTINCT_ROW_COUNT.method);
 
     /**
      * Estimates the number of rows which would be produced by a GROUP BY on the
@@ -370,8 +380,9 @@ interface Handler extends MetadataHandler<PercentageOriginalRows> {
   /** Metadata about the number of distinct values in the original source of a
    * column or set of columns. */
   public interface PopulationSize extends Metadata {
-    MetadataDef<PopulationSize> DEF = MetadataDef.of(PopulationSize.class,
-        PopulationSize.Handler.class, BuiltInMethod.POPULATION_SIZE.method);
+    MetadataDef<PopulationSize> DEF =
+        MetadataDef.of(PopulationSize.class, PopulationSize.Handler.class,
+            BuiltInMethod.POPULATION_SIZE.method);
 
     /**
      * Estimates the distinct row count in the original source for the given
@@ -400,9 +411,10 @@ interface Handler extends MetadataHandler<PopulationSize> {
 
   /** Metadata about the size of rows and columns. */
   public interface Size extends Metadata {
-    MetadataDef<Size> DEF = MetadataDef.of(Size.class, Size.Handler.class,
-        BuiltInMethod.AVERAGE_ROW_SIZE.method,
-        BuiltInMethod.AVERAGE_COLUMN_SIZES.method);
+    MetadataDef<Size> DEF =
+        MetadataDef.of(Size.class, Size.Handler.class,
+            BuiltInMethod.AVERAGE_ROW_SIZE.method,
+            BuiltInMethod.AVERAGE_COLUMN_SIZES.method);
 
     /**
      * Determines the average size (in bytes) of a row from this relational
@@ -442,8 +454,9 @@ interface Handler extends MetadataHandler<Size> {
 
   /** Metadata about the origins of columns. */
   public interface ColumnOrigin extends Metadata {
-    MetadataDef<ColumnOrigin> DEF = MetadataDef.of(ColumnOrigin.class,
-        ColumnOrigin.Handler.class, BuiltInMethod.COLUMN_ORIGIN.method);
+    MetadataDef<ColumnOrigin> DEF =
+        MetadataDef.of(ColumnOrigin.class, ColumnOrigin.Handler.class,
+            BuiltInMethod.COLUMN_ORIGIN.method);
 
     /**
      * For a given output column of an expression, determines all columns of
@@ -473,8 +486,9 @@ interface Handler extends MetadataHandler<ColumnOrigin> {
 
   /** Metadata about the origins of expressions. */
   public interface ExpressionLineage extends Metadata {
-    MetadataDef<ExpressionLineage> DEF = MetadataDef.of(ExpressionLineage.class,
-        ExpressionLineage.Handler.class, BuiltInMethod.EXPRESSION_LINEAGE.method);
+    MetadataDef<ExpressionLineage> DEF =
+        MetadataDef.of(ExpressionLineage.class, ExpressionLineage.Handler.class,
+            BuiltInMethod.EXPRESSION_LINEAGE.method);
 
     /**
      * Given the input expression applied on the given {@link RelNode}, this
@@ -515,8 +529,9 @@ interface Handler extends MetadataHandler<ExpressionLineage> {
 
   /** Metadata to obtain references to tables used by a given expression. */
   public interface TableReferences extends Metadata {
-    MetadataDef<TableReferences> DEF = MetadataDef.of(TableReferences.class,
-        TableReferences.Handler.class, BuiltInMethod.TABLE_REFERENCES.method);
+    MetadataDef<TableReferences> DEF =
+        MetadataDef.of(TableReferences.class, TableReferences.Handler.class,
+            BuiltInMethod.TABLE_REFERENCES.method);
 
     /**
      * This provider returns the tables used by a given plan.
@@ -550,8 +565,9 @@ interface Handler extends MetadataHandler<TableReferences> {
   /** Metadata about the cost of evaluating a relational expression, including
    * all of its inputs. */
   public interface CumulativeCost extends Metadata {
-    MetadataDef<CumulativeCost> DEF = MetadataDef.of(CumulativeCost.class,
-        CumulativeCost.Handler.class, BuiltInMethod.CUMULATIVE_COST.method);
+    MetadataDef<CumulativeCost> DEF =
+        MetadataDef.of(CumulativeCost.class, CumulativeCost.Handler.class,
+            BuiltInMethod.CUMULATIVE_COST.method);
 
     /**
      * Estimates the cost of executing a relational expression, including the
@@ -580,9 +596,9 @@ interface Handler extends MetadataHandler<CumulativeCost> {
   /** Metadata about the cost of evaluating a relational expression, not
    * including its inputs. */
   public interface NonCumulativeCost extends Metadata {
-    MetadataDef<NonCumulativeCost> DEF = MetadataDef.of(NonCumulativeCost.class,
-        NonCumulativeCost.Handler.class,
-        BuiltInMethod.NON_CUMULATIVE_COST.method);
+    MetadataDef<NonCumulativeCost> DEF =
+        MetadataDef.of(NonCumulativeCost.class, NonCumulativeCost.Handler.class,
+            BuiltInMethod.NON_CUMULATIVE_COST.method);
 
     /**
      * Estimates the cost of executing a relational expression, not counting the
@@ -612,9 +628,9 @@ interface Handler extends MetadataHandler<NonCumulativeCost> {
 
   /** Metadata about whether a relational expression should appear in a plan. */
   public interface ExplainVisibility extends Metadata {
-    MetadataDef<ExplainVisibility> DEF = MetadataDef.of(ExplainVisibility.class,
-        ExplainVisibility.Handler.class,
-        BuiltInMethod.EXPLAIN_VISIBILITY.method);
+    MetadataDef<ExplainVisibility> DEF =
+        MetadataDef.of(ExplainVisibility.class, ExplainVisibility.Handler.class,
+            BuiltInMethod.EXPLAIN_VISIBILITY.method);
 
     /**
      * Determines whether a relational expression should be visible in EXPLAIN
@@ -641,8 +657,9 @@ Boolean isVisibleInExplain(RelNode r, RelMetadataQuery mq,
   /** Metadata about the predicates that hold in the rows emitted from a
    * relational expression. */
   public interface Predicates extends Metadata {
-    MetadataDef<Predicates> DEF = MetadataDef.of(Predicates.class,
-        Predicates.Handler.class, BuiltInMethod.PREDICATES.method);
+    MetadataDef<Predicates> DEF =
+        MetadataDef.of(Predicates.class, Predicates.Handler.class,
+            BuiltInMethod.PREDICATES.method);
 
     /**
      * Derives the predicates that hold on rows emitted from a relational
@@ -674,8 +691,9 @@ interface Handler extends MetadataHandler<Predicates> {
    * {@link org.apache.calcite.rel.core.TableScan} for the result predicates.
    */
   public interface AllPredicates extends Metadata {
-    MetadataDef<AllPredicates> DEF = MetadataDef.of(AllPredicates.class,
-            AllPredicates.Handler.class, BuiltInMethod.ALL_PREDICATES.method);
+    MetadataDef<AllPredicates> DEF =
+            MetadataDef.of(AllPredicates.class, AllPredicates.Handler.class,
+                BuiltInMethod.ALL_PREDICATES.method);
 
     /**
      * Derives the predicates that hold on rows emitted from a relational
@@ -702,9 +720,10 @@ interface Handler extends MetadataHandler<AllPredicates> {
    * how its operators are assigned to processes with independent resource
    * pools. */
   public interface Parallelism extends Metadata {
-    MetadataDef<Parallelism> DEF = MetadataDef.of(Parallelism.class,
-        Parallelism.Handler.class, BuiltInMethod.IS_PHASE_TRANSITION.method,
-        BuiltInMethod.SPLIT_COUNT.method);
+    MetadataDef<Parallelism> DEF =
+        MetadataDef.of(Parallelism.class, Parallelism.Handler.class,
+            BuiltInMethod.IS_PHASE_TRANSITION.method,
+            BuiltInMethod.SPLIT_COUNT.method);
 
     /** Returns whether each physical operator implementing this relational
      * expression belongs to a different process than its inputs.
@@ -741,8 +760,9 @@ interface Handler extends MetadataHandler<Parallelism> {
 
   /** Metadata to get the lower bound cost of a RelNode. */
   public interface LowerBoundCost extends Metadata {
-    MetadataDef<LowerBoundCost> DEF = MetadataDef.of(LowerBoundCost.class,
-        LowerBoundCost.Handler.class, BuiltInMethod.LOWER_BOUND_COST.method);
+    MetadataDef<LowerBoundCost> DEF =
+        MetadataDef.of(LowerBoundCost.class, LowerBoundCost.Handler.class,
+            BuiltInMethod.LOWER_BOUND_COST.method);
 
     /** Returns the lower bound cost of a RelNode. */
     RelOptCost getLowerBoundCost(VolcanoPlanner planner);
@@ -762,10 +782,11 @@ RelOptCost getLowerBoundCost(
 
   /** Metadata about the memory use of an operator. */
   public interface Memory extends Metadata {
-    MetadataDef<Memory> DEF = MetadataDef.of(Memory.class,
-        Memory.Handler.class, BuiltInMethod.MEMORY.method,
-        BuiltInMethod.CUMULATIVE_MEMORY_WITHIN_PHASE.method,
-        BuiltInMethod.CUMULATIVE_MEMORY_WITHIN_PHASE_SPLIT.method);
+    MetadataDef<Memory> DEF =
+        MetadataDef.of(Memory.class, Memory.Handler.class,
+            BuiltInMethod.MEMORY.method,
+            BuiltInMethod.CUMULATIVE_MEMORY_WITHIN_PHASE.method,
+            BuiltInMethod.CUMULATIVE_MEMORY_WITHIN_PHASE_SPLIT.method);
 
     /** Returns the expected amount of memory, in bytes, required by a physical
      * operator implementing this relational expression, across all splits.
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/CachingRelMetadataProvider.java b/core/src/main/java/org/apache/calcite/rel/metadata/CachingRelMetadataProvider.java
index 01e53a7362e..399c4b67aba 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/CachingRelMetadataProvider.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/CachingRelMetadataProvider.java
@@ -73,9 +73,10 @@ public CachingRelMetadataProvider(
     // TODO jvs 30-Mar-2006: Use meta-metadata to decide which metadata
     // query results can stay fresh until the next Ice Age.
     return (rel, mq) -> {
-      final Metadata metadata = requireNonNull(function.bind(rel, mq),
-          () -> "metadata must not be null, relClass=" + relClass
-              + ", metadataClass=" + metadataClass);
+      final Metadata metadata =
+          requireNonNull(function.bind(rel, mq),
+              () -> "metadata must not be null, relClass=" + relClass
+                  + ", metadataClass=" + metadataClass);
       return metadataClass.cast(
           Proxy.newProxyInstance(metadataClass.getClassLoader(),
               new Class[]{metadataClass},
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/ProxyingMetadataHandlerProvider.java b/core/src/main/java/org/apache/calcite/rel/metadata/ProxyingMetadataHandlerProvider.java
index fc426c3ad2d..9c84cbf3234 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/ProxyingMetadataHandlerProvider.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/ProxyingMetadataHandlerProvider.java
@@ -29,9 +29,10 @@
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
-import java.util.Objects;
 import java.util.stream.Collectors;
 
+import static java.util.Objects.requireNonNull;
+
 /**
  * A MetadataHandlerProvider built on a RelMetadataProvider.
  *
@@ -66,8 +67,9 @@ public ProxyingMetadataHandlerProvider(RelMetadataProvider provider) {
     final MetadataDef<?> def;
     try {
       field = metadataType.getField("DEF");
-      def = Objects.requireNonNull((MetadataDef<?>) field.get(null),
-          () -> "Unexpected failure. " + handlerClass);
+      def =
+          requireNonNull((MetadataDef<?>) field.get(null),
+              () -> "Unexpected failure. " + handlerClass);
     } catch (NoSuchFieldException | IllegalAccessException e) {
       throw new RuntimeException(e);
     }
@@ -76,30 +78,35 @@ public ProxyingMetadataHandlerProvider(RelMetadataProvider provider) {
     Map<String, Method> methodMap = methods.stream()
         .collect(Collectors.toMap(Method::getName, f -> f));
     InvocationHandler handler = (proxy, method, args) -> {
-      Method metadataMethod = Objects.requireNonNull(methodMap.get(method.getName()),
-          () -> "Not supported: " + method);
-      RelNode rel = Objects.requireNonNull((RelNode) args[0], "rel must be non null");
-      RelMetadataQuery mq = Objects.requireNonNull((RelMetadataQuery) args[1],
-          "mq must be non null");
+      Method metadataMethod =
+          requireNonNull(methodMap.get(method.getName()),
+              () -> "Not supported: " + method);
+      RelNode rel = requireNonNull((RelNode) args[0], "rel must be non null");
+      RelMetadataQuery mq =
+          requireNonNull((RelMetadataQuery) args[1], "mq must be non null");
 
       // using deprecated RelMetadataProvider method here as the non-deprecated methods completely
       // sidestep the purpose of RelMetadataProvider reflection-based functionality.
-      UnboundMetadata metadata = provider.apply(
-          (Class<? extends RelNode>) rel.getClass(),
-          (Class<? extends Metadata>) metadataType);
+      @SuppressWarnings({"unchecked", "rawtypes"})
+      UnboundMetadata metadata =
+          provider.apply(rel.getClass(),
+              (Class<? extends Metadata>) metadataType);
 
       if (metadata == null) {
-        Method handlerMethod = Arrays.stream(handlerClass.getMethods())
-            .filter(m -> m.getName().equals(metadataMethod.getName()))
-            .findFirst()
-            .orElseThrow(() -> new IllegalArgumentException("Unable to find method."));
+        Method handlerMethod =
+            Arrays.stream(handlerClass.getMethods())
+                .filter(m -> m.getName().equals(metadataMethod.getName()))
+                .findFirst()
+                .orElseThrow(()
+                    -> new IllegalArgumentException("Unable to find method."));
         throw new IllegalArgumentException(
-            String.format(Locale.ROOT, "No handler for "
-            + "method [%s] applied to argument of type [%s]; we recommend you create a "
-            + "catch-all (RelNode) handler", handlerMethod, rel.getClass()));
+            String.format(Locale.ROOT, "No handler for method [%s] applied to "
+                + "argument of type [%s]; we recommend you create a catch-all "
+                + "(RelNode) handler", handlerMethod, rel.getClass()));
       }
-      Metadata bound = Objects.requireNonNull(metadata, "expected defined metadata")
-          .bind(rel, mq);
+      Metadata bound =
+          requireNonNull(metadata, "expected defined metadata")
+              .bind(rel, mq);
 
       Object[] abbreviatedArgs = new Object[args.length - 2];
       System.arraycopy(args, 2, abbreviatedArgs, 0, abbreviatedArgs.length);
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/RelColumnOrigin.java b/core/src/main/java/org/apache/calcite/rel/metadata/RelColumnOrigin.java
index 28aa144d5a4..974501b50bd 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/RelColumnOrigin.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/RelColumnOrigin.java
@@ -62,7 +62,7 @@ public int getOriginColumnOrdinal() {
   /**
    * Consider the query <code>select a+b as c, d as e from t</code>. The
    * output column c has two origins (a and b), both of them derived. The
-   * output column d as one origin (c), which is not derived.
+   * output column e has one origin (d), which is not derived.
    *
    * @return false if value taken directly from column in origin table; true
    * otherwise
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdAllPredicates.java b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdAllPredicates.java
index 0ca61be9415..715a83dab3c 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdAllPredicates.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdAllPredicates.java
@@ -224,8 +224,8 @@ public class RelMdAllPredicates
         final Map<RelTableRef, RelTableRef> currentTablesMapping = new HashMap<>();
         for (RelTableRef rightRef : tableRefs) {
           int shift = 0;
-          Collection<RelTableRef> lRefs = qualifiedNamesToRefs.get(
-              rightRef.getQualifiedName());
+          Collection<RelTableRef> lRefs =
+              qualifiedNamesToRefs.get(rightRef.getQualifiedName());
           if (lRefs != null) {
             shift = lRefs.size();
           }
@@ -236,8 +236,9 @@ public class RelMdAllPredicates
             Util.transform(inputPreds.pulledUpPredicates,
                 e -> RexUtil.swapTableReferences(rexBuilder, e,
                     currentTablesMapping));
-        newPreds = newPreds.union(rexBuilder,
-            RelOptPredicateList.of(rexBuilder, updatedPreds));
+        newPreds =
+            newPreds.union(rexBuilder,
+                RelOptPredicateList.of(rexBuilder, updatedPreds));
       }
     }
 
@@ -249,12 +250,12 @@ public class RelMdAllPredicates
 
     // Infer column origin expressions for given references
     final Map<RexInputRef, Set<RexNode>> mapping = new LinkedHashMap<>();
-    final RelDataType fullRowType = SqlValidatorUtil.createJoinType(
-        rexBuilder.getTypeFactory(),
-        join.getLeft().getRowType(),
-        join.getRight().getRowType(),
-        null,
-        ImmutableList.of());
+    final RelDataType fullRowType =
+        SqlValidatorUtil.createJoinType(rexBuilder.getTypeFactory(),
+            join.getLeft().getRowType(),
+            join.getRight().getRowType(),
+            null,
+            ImmutableList.of());
     for (int idx : inputFieldsUsed) {
       final RexInputRef inputRef = RexInputRef.of(idx, fullRowType.getFieldList());
       final Set<RexNode> originalExprs = mq.getExpressionLineage(join, inputRef);
@@ -322,13 +323,14 @@ public class RelMdAllPredicates
         final Map<RelTableRef, RelTableRef> currentTablesMapping = new HashMap<>();
         for (RelTableRef rightRef : tableRefs) {
           int shift = 0;
-          Collection<RelTableRef> lRefs = qualifiedNamesToRefs.get(
-              rightRef.getQualifiedName());
+          Collection<RelTableRef> lRefs =
+              qualifiedNamesToRefs.get(rightRef.getQualifiedName());
           if (lRefs != null) {
             shift = lRefs.size();
           }
           currentTablesMapping.put(rightRef,
-              RelTableRef.of(rightRef.getTable(), shift + rightRef.getEntityNumber()));
+              RelTableRef.of(rightRef.getTable(),
+                  shift + rightRef.getEntityNumber()));
         }
         // Add to existing qualified names
         for (RelTableRef newRef : currentTablesMapping.values()) {
@@ -339,8 +341,9 @@ public class RelMdAllPredicates
             Util.transform(inputPreds.pulledUpPredicates,
                 e -> RexUtil.swapTableReferences(rexBuilder, e,
                     currentTablesMapping));
-        newPreds = newPreds.union(rexBuilder,
-            RelOptPredicateList.of(rexBuilder, updatedPreds));
+        newPreds =
+            newPreds.union(rexBuilder,
+                RelOptPredicateList.of(rexBuilder, updatedPreds));
       }
     }
     return newPreds;
@@ -349,7 +352,8 @@ public class RelMdAllPredicates
   /**
    * Extracts predicates for a Sort.
    */
-  public @Nullable RelOptPredicateList getAllPredicates(Sort sort, RelMetadataQuery mq) {
+  public @Nullable RelOptPredicateList getAllPredicates(Sort sort,
+      RelMetadataQuery mq) {
     return mq.getAllPredicates(sort.getInput());
   }
 
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdCollation.java b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdCollation.java
index e32ad62c514..537099d9c9f 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdCollation.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdCollation.java
@@ -149,6 +149,11 @@ private RelMdCollation() {}
 
   public @Nullable ImmutableList<RelCollation> collations(TableScan scan,
       RelMetadataQuery mq) {
+    final BuiltInMetadata.Collation.Handler handler =
+        scan.getTable().unwrap(BuiltInMetadata.Collation.Handler.class);
+    if (handler != null) {
+      return handler.collations(scan, mq);
+    }
     return copyOf(table(scan.getTable()));
   }
 
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdColumnOrigins.java b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdColumnOrigins.java
index 02bb8919fd8..dc30e6a20ac 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdColumnOrigins.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdColumnOrigins.java
@@ -30,6 +30,7 @@
 import org.apache.calcite.rel.core.Sort;
 import org.apache.calcite.rel.core.TableFunctionScan;
 import org.apache.calcite.rel.core.TableModify;
+import org.apache.calcite.rel.core.TableScan;
 import org.apache.calcite.rex.RexInputRef;
 import org.apache.calcite.rex.RexLocalRef;
 import org.apache.calcite.rex.RexNode;
@@ -164,6 +165,16 @@ private RelMdColumnOrigins() {}
     return createDerivedColumnOrigins(set);
   }
 
+  public @Nullable Set<RelColumnOrigin> getColumnOrigins(TableScan scan,
+      RelMetadataQuery mq, int iOutputColumn) {
+    final BuiltInMetadata.ColumnOrigin.Handler handler =
+        scan.getTable().unwrap(BuiltInMetadata.ColumnOrigin.Handler.class);
+    if (handler != null) {
+      return handler.getColumnOrigins(scan, mq, iOutputColumn);
+    }
+    return getColumnOrigins((RelNode) scan, mq, iOutputColumn);
+  }
+
   public @Nullable Set<RelColumnOrigin> getColumnOrigins(Filter rel,
       RelMetadataQuery mq, int iOutputColumn) {
     return mq.getColumnOrigins(rel.getInput(), iOutputColumn);
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdColumnUniqueness.java b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdColumnUniqueness.java
index 7e912f05c9c..91be3694349 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdColumnUniqueness.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdColumnUniqueness.java
@@ -78,9 +78,14 @@ private RelMdColumnUniqueness() {}
     return BuiltInMetadata.ColumnUniqueness.DEF;
   }
 
-  public Boolean areColumnsUnique(TableScan rel, RelMetadataQuery mq,
+  public Boolean areColumnsUnique(TableScan scan, RelMetadataQuery mq,
       ImmutableBitSet columns, boolean ignoreNulls) {
-    return rel.getTable().isKey(columns);
+    final BuiltInMetadata.ColumnUniqueness.Handler handler =
+        scan.getTable().unwrap(BuiltInMetadata.ColumnUniqueness.Handler.class);
+    if (handler != null) {
+      return handler.areColumnsUnique(scan, mq, columns, ignoreNulls);
+    }
+    return scan.getTable().isKey(columns);
   }
 
   public @Nullable Boolean areColumnsUnique(Filter rel, RelMetadataQuery mq,
@@ -248,9 +253,9 @@ public Boolean areColumnsUnique(Intersect rel, RelMetadataQuery mq,
         RelDataType castType =
             typeFactory.createTypeWithNullability(
                 projExpr.getType(), true);
-        RelDataType origType = typeFactory.createTypeWithNullability(
-            castOperand.getType(),
-            true);
+        RelDataType origType =
+            typeFactory.createTypeWithNullability(castOperand.getType(),
+                true);
         if (castType.equals(origType)) {
           childColumns.set(((RexInputRef) castOperand).getIndex());
         }
@@ -351,8 +356,24 @@ public Boolean areColumnsUnique(Intersect rel, RelMetadataQuery mq,
     if (Aggregate.isSimple(rel) || ignoreNulls) {
       columns = decorateWithConstantColumnsFromPredicates(columns, rel, mq);
       // group by keys form a unique key
-      ImmutableBitSet groupKey = ImmutableBitSet.range(rel.getGroupCount());
-      return columns.contains(groupKey);
+      final ImmutableBitSet groupKey = ImmutableBitSet.range(rel.getGroupCount());
+      final boolean contained = columns.contains(groupKey);
+      if (contained) {
+        return true;
+      } else if (!Aggregate.isSimple(rel)) {
+        return false;
+      }
+
+      final ImmutableBitSet commonKeys = columns.intersect(groupKey);
+      if (commonKeys.isEmpty()) {
+        return false;
+      }
+      final ImmutableBitSet.Builder targetColumns = ImmutableBitSet.builder();
+      for (int key: commonKeys) {
+        targetColumns.set(rel.getGroupSet().nth(key));
+      }
+
+      return mq.areColumnsUnique(rel.getInput(), targetColumns.build(), ignoreNulls);
     }
     return null;
   }
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdDistinctRowCount.java b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdDistinctRowCount.java
index d172f37f35c..b5609acf40a 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdDistinctRowCount.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdDistinctRowCount.java
@@ -26,6 +26,7 @@
 import org.apache.calcite.rel.core.Project;
 import org.apache.calcite.rel.core.Sort;
 import org.apache.calcite.rel.core.TableModify;
+import org.apache.calcite.rel.core.TableScan;
 import org.apache.calcite.rel.core.Union;
 import org.apache.calcite.rel.core.Values;
 import org.apache.calcite.rex.RexBuilder;
@@ -85,6 +86,16 @@ protected RelMdDistinctRowCount() {}
     return null;
   }
 
+  public @Nullable Double getDistinctRowCount(TableScan scan, RelMetadataQuery mq,
+      ImmutableBitSet groupKey, RexNode predicate) {
+    final BuiltInMetadata.DistinctRowCount.Handler handler =
+        scan.getTable().unwrap(BuiltInMetadata.DistinctRowCount.Handler.class);
+    if (handler != null) {
+      return handler.getDistinctRowCount(scan, mq, groupKey, predicate);
+    }
+    return getDistinctRowCount((RelNode) scan, mq, groupKey, predicate);
+  }
+
   public @Nullable Double getDistinctRowCount(Union rel, RelMetadataQuery mq,
       ImmutableBitSet groupKey, @Nullable RexNode predicate) {
     double rowCount = 0.0;
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdDistribution.java b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdDistribution.java
index 5133dbb939c..92aa73c243f 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdDistribution.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdDistribution.java
@@ -91,6 +91,11 @@ public RelDistribution distribution(TableModify rel, RelMetadataQuery mq) {
   }
 
   public @Nullable RelDistribution distribution(TableScan scan, RelMetadataQuery mq) {
+    final BuiltInMetadata.Distribution.Handler handler =
+        scan.getTable().unwrap(BuiltInMetadata.Distribution.Handler.class);
+    if (handler != null) {
+      return handler.distribution(scan, mq);
+    }
     return table(scan.getTable());
   }
 
@@ -145,8 +150,8 @@ public static RelDistribution calc(RelMetadataQuery mq, RelNode input,
     assert program.getCondition() != null || !program.getProjectList().isEmpty();
     final RelDistribution inputDistribution = mq.distribution(input);
     if (!program.getProjectList().isEmpty()) {
-      final Mappings.TargetMapping mapping = program.getPartialMapping(
-          input.getRowType().getFieldCount());
+      final Mappings.TargetMapping mapping =
+          program.getPartialMapping(input.getRowType().getFieldCount());
       return inputDistribution.apply(mapping);
     }
     return inputDistribution;
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdExplainVisibility.java b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdExplainVisibility.java
index 1f5d8f58873..a06b2842a13 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdExplainVisibility.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdExplainVisibility.java
@@ -17,6 +17,7 @@
 package org.apache.calcite.rel.metadata;
 
 import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.core.TableScan;
 import org.apache.calcite.sql.SqlExplainLevel;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
@@ -52,4 +53,15 @@ private RelMdExplainVisibility() {}
     // no information available
     return null;
   }
+
+  public @Nullable Boolean isVisibleInExplain(TableScan scan, RelMetadataQuery mq,
+      SqlExplainLevel explainLevel) {
+    final BuiltInMetadata.ExplainVisibility.Handler handler =
+        scan.getTable().unwrap(BuiltInMetadata.ExplainVisibility.Handler.class);
+    if (handler != null) {
+      return handler.isVisibleInExplain(scan, mq, explainLevel);
+    }
+    // Fall back to the catch-all.
+    return isVisibleInExplain((RelNode) scan, mq, explainLevel);
+  }
 }
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdExpressionLineage.java b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdExpressionLineage.java
index e21fcb5f316..16215e7c0b9 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdExpressionLineage.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdExpressionLineage.java
@@ -26,6 +26,7 @@
 import org.apache.calcite.rel.core.Join;
 import org.apache.calcite.rel.core.JoinRelType;
 import org.apache.calcite.rel.core.Project;
+import org.apache.calcite.rel.core.Snapshot;
 import org.apache.calcite.rel.core.Sort;
 import org.apache.calcite.rel.core.TableModify;
 import org.apache.calcite.rel.core.TableScan;
@@ -119,6 +120,12 @@ protected RelMdExpressionLineage() {}
    */
   public @Nullable Set<RexNode> getExpressionLineage(TableScan rel,
       RelMetadataQuery mq, RexNode outputExpression) {
+    final BuiltInMetadata.ExpressionLineage.Handler handler =
+        rel.getTable().unwrap(BuiltInMetadata.ExpressionLineage.Handler.class);
+    if (handler != null) {
+      return handler.getExpressionLineage(rel, mq, outputExpression);
+    }
+
     final RexBuilder rexBuilder = rel.getCluster().getRexBuilder();
 
     // Extract input fields referenced by expression
@@ -127,9 +134,9 @@ protected RelMdExpressionLineage() {}
     // Infer column origin expressions for given references
     final Map<RexInputRef, Set<RexNode>> mapping = new LinkedHashMap<>();
     for (int idx : inputFieldsUsed) {
-      final RexNode inputRef = RexTableInputRef.of(
-          RelTableRef.of(rel.getTable(), 0),
-          RexInputRef.of(idx, rel.getRowType().getFieldList()));
+      final RexNode inputRef =
+          RexTableInputRef.of(RelTableRef.of(rel.getTable(), 0),
+              RexInputRef.of(idx, rel.getRowType().getFieldList()));
       final RexInputRef ref = RexInputRef.of(idx, rel.getRowType().getFieldList());
       mapping.put(ref, ImmutableSet.of(inputRef));
     }
@@ -162,8 +169,9 @@ protected RelMdExpressionLineage() {}
     // Infer column origin expressions for given references
     final Map<RexInputRef, Set<RexNode>> mapping = new LinkedHashMap<>();
     for (int idx : inputFieldsUsed) {
-      final RexInputRef inputRef = RexInputRef.of(rel.getGroupSet().nth(idx),
-          input.getRowType().getFieldList());
+      final RexInputRef inputRef =
+          RexInputRef.of(rel.getGroupSet().nth(idx),
+              input.getRowType().getFieldList());
       final Set<RexNode> originalExprs = mq.getExpressionLineage(input, inputRef);
       if (originalExprs == null) {
         // Bail out
@@ -195,15 +203,14 @@ protected RelMdExpressionLineage() {}
     if (rel.getJoinType().isOuterJoin()) {
       // If we reference the inner side, we will bail out
       if (rel.getJoinType() == JoinRelType.LEFT) {
-        ImmutableBitSet rightFields = ImmutableBitSet.range(
-            nLeftColumns, rel.getRowType().getFieldCount());
+        ImmutableBitSet rightFields =
+            ImmutableBitSet.range(nLeftColumns, rel.getRowType().getFieldCount());
         if (inputFieldsUsed.intersects(rightFields)) {
           // We cannot map origin of this expression.
           return null;
         }
       } else if (rel.getJoinType() == JoinRelType.RIGHT) {
-        ImmutableBitSet leftFields = ImmutableBitSet.range(
-            0, nLeftColumns);
+        ImmutableBitSet leftFields = ImmutableBitSet.range(0, nLeftColumns);
         if (inputFieldsUsed.intersects(leftFields)) {
           // We cannot map origin of this expression.
           return null;
@@ -232,8 +239,8 @@ protected RelMdExpressionLineage() {}
     }
     for (RelTableRef rightRef : rightTableRefs) {
       int shift = 0;
-      Collection<RelTableRef> lRefs = qualifiedNamesToRefs.get(
-          rightRef.getQualifiedName());
+      Collection<RelTableRef> lRefs =
+          qualifiedNamesToRefs.get(rightRef.getQualifiedName());
       if (lRefs != null) {
         shift = lRefs.size();
       }
@@ -255,7 +262,8 @@ protected RelMdExpressionLineage() {}
         mapping.put(RexInputRef.of(idx, rel.getRowType().getFieldList()), originalExprs);
       } else {
         // Right input.
-        final RexInputRef inputRef = RexInputRef.of(idx - nLeftColumns,
+        final RexInputRef inputRef =
+            RexInputRef.of(idx - nLeftColumns,
                 rightInput.getRowType().getFieldList());
         final Set<RexNode> originalExprs = mq.getExpressionLineage(rightInput, inputRef);
         if (originalExprs == null) {
@@ -264,16 +272,17 @@ protected RelMdExpressionLineage() {}
         }
         // Right input references might need to be updated if there are
         // table names clashes with left input
-        final RelDataType fullRowType = SqlValidatorUtil.createJoinType(
-            rexBuilder.getTypeFactory(),
-            rel.getLeft().getRowType(),
-            rel.getRight().getRowType(),
-            null,
-            ImmutableList.of());
-        final Set<RexNode> updatedExprs = ImmutableSet.copyOf(
-            Util.transform(originalExprs, e ->
-                RexUtil.swapTableReferences(rexBuilder, e,
-                    currentTablesMapping)));
+        final RelDataType fullRowType =
+            SqlValidatorUtil.createJoinType(rexBuilder.getTypeFactory(),
+                rel.getLeft().getRowType(),
+                rel.getRight().getRowType(),
+                null,
+                ImmutableList.of());
+        final Set<RexNode> updatedExprs =
+            ImmutableSet.copyOf(
+                Util.transform(originalExprs, e ->
+                    RexUtil.swapTableReferences(rexBuilder, e,
+                        currentTablesMapping)));
         mapping.put(RexInputRef.of(idx, fullRowType), updatedExprs);
       }
     }
@@ -308,8 +317,8 @@ protected RelMdExpressionLineage() {}
       }
       for (RelTableRef tableRef : tableRefs) {
         int shift = 0;
-        Collection<RelTableRef> lRefs = qualifiedNamesToRefs.get(
-            tableRef.getQualifiedName());
+        Collection<RelTableRef> lRefs =
+            qualifiedNamesToRefs.get(tableRef.getQualifiedName());
         if (lRefs != null) {
           shift = lRefs.size();
         }
@@ -385,6 +394,18 @@ protected RelMdExpressionLineage() {}
     return mq.getExpressionLineage(rel.getInput(), outputExpression);
   }
 
+  /**
+   * Expression lineage from Snapshot.
+   * @param rel Snapshot relational expression
+   * @param mq metadata query
+   * @param outputExpression expression which needs to be inferred
+   * @return the inferred lineage, possibly null.
+   */
+  public @Nullable Set<RexNode> getExpressionLineage(Snapshot rel,
+      RelMetadataQuery mq, RexNode outputExpression) {
+    return mq.getExpressionLineage(rel.getInput(), outputExpression);
+  }
+
   /**
    * Expression lineage from Sort.
    */
@@ -471,8 +492,9 @@ private static Set<RexNode> createAllPossibleExpressions(RexBuilder rexBuilder,
       RexNode expr, ImmutableBitSet predFieldsUsed, Map<RexInputRef, Set<RexNode>> mapping,
       Map<RexInputRef, RexNode> singleMapping) {
     final @KeyFor("mapping") RexInputRef inputRef = mapping.keySet().iterator().next();
-    final Set<RexNode> replacements = requireNonNull(mapping.remove(inputRef),
-        () -> "mapping.remove(inputRef) is null for " + inputRef);
+    final Set<RexNode> replacements =
+        requireNonNull(mapping.remove(inputRef),
+            () -> "mapping.remove(inputRef) is null for " + inputRef);
     Set<RexNode> result = new HashSet<>();
     assert !replacements.isEmpty();
     if (predFieldsUsed.indexOf(inputRef.getIndex()) != -1) {
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdMaxRowCount.java b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdMaxRowCount.java
index a3c4b18afe7..3fe8f4311ae 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdMaxRowCount.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdMaxRowCount.java
@@ -181,7 +181,12 @@ private static boolean allGroupKeysAreConstant(Aggregate aggregate,
     return left * right;
   }
 
-  public Double getMaxRowCount(TableScan rel, RelMetadataQuery mq) {
+  public @Nullable Double getMaxRowCount(TableScan rel, RelMetadataQuery mq) {
+    final BuiltInMetadata.MaxRowCount.Handler handler =
+        rel.getTable().unwrap(BuiltInMetadata.MaxRowCount.Handler.class);
+    if (handler != null) {
+      return handler.getMaxRowCount(rel, mq);
+    }
     // For typical tables, there is no upper bound to the number of rows.
     return Double.POSITIVE_INFINITY;
   }
@@ -203,7 +208,7 @@ public Double getMaxRowCount(RelSubset rel, RelMetadataQuery mq) {
     for (RelNode node : rel.getRels()) {
       if (node instanceof Sort) {
         Sort sort = (Sort) node;
-        if (sort.fetch != null) {
+        if (sort.fetch instanceof RexLiteral) {
           return (double) RexLiteral.intValue(sort.fetch);
         }
       }
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdMinRowCount.java b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdMinRowCount.java
index 131fec5de21..9fff399917f 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdMinRowCount.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdMinRowCount.java
@@ -147,7 +147,12 @@ public Double getMinRowCount(Join rel, RelMetadataQuery mq) {
     return 0D;
   }
 
-  public Double getMinRowCount(TableScan rel, RelMetadataQuery mq) {
+  public @Nullable Double getMinRowCount(TableScan rel, RelMetadataQuery mq) {
+    final BuiltInMetadata.MinRowCount.Handler handler =
+        rel.getTable().unwrap(BuiltInMetadata.MinRowCount.Handler.class);
+    if (handler != null) {
+      return handler.getMinRowCount(rel, mq);
+    }
     return 0D;
   }
 
@@ -163,7 +168,7 @@ public Double getMinRowCount(RelSubset rel, RelMetadataQuery mq) {
     for (RelNode node : rel.getRels()) {
       if (node instanceof Sort) {
         Sort sort = (Sort) node;
-        if (sort.fetch != null) {
+        if (sort.fetch instanceof RexLiteral) {
           return (double) RexLiteral.intValue(sort.fetch);
         }
       }
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdNodeTypes.java b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdNodeTypes.java
index a7d160fcf82..60aa05f9f24 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdNodeTypes.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdNodeTypes.java
@@ -125,6 +125,11 @@ public class RelMdNodeTypes
 
   public @Nullable Multimap<Class<? extends RelNode>, RelNode> getNodeTypes(TableScan rel,
       RelMetadataQuery mq) {
+    final BuiltInMetadata.NodeTypes.Handler handler =
+        rel.getTable().unwrap(BuiltInMetadata.NodeTypes.Handler.class);
+    if (handler != null) {
+      return handler.getNodeTypes(rel, mq);
+    }
     return getNodeTypes(rel, TableScan.class, mq);
   }
 
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdParallelism.java b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdParallelism.java
index 2bd1747049d..ef08fff91bf 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdParallelism.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdParallelism.java
@@ -58,6 +58,11 @@ public Boolean isPhaseTransition(RelNode rel, RelMetadataQuery mq) {
   }
 
   public Boolean isPhaseTransition(TableScan rel, RelMetadataQuery mq) {
+    final BuiltInMetadata.Parallelism.Handler handler =
+        rel.getTable().unwrap(BuiltInMetadata.Parallelism.Handler.class);
+    if (handler != null) {
+      return handler.isPhaseTransition(rel, mq);
+    }
     return true;
   }
 
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdPercentageOriginalRows.java b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdPercentageOriginalRows.java
index a25d2eebf2e..e64514def17 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdPercentageOriginalRows.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdPercentageOriginalRows.java
@@ -21,6 +21,7 @@
 import org.apache.calcite.rel.RelNode;
 import org.apache.calcite.rel.core.Aggregate;
 import org.apache.calcite.rel.core.Join;
+import org.apache.calcite.rel.core.TableScan;
 import org.apache.calcite.rel.core.Union;
 
 import com.google.common.collect.ImmutableList;
@@ -47,14 +48,21 @@ public class RelMdPercentageOriginalRows {
                   BuiltInMetadata.CumulativeCost.Handler.class),
               ReflectiveRelMetadataProvider.reflectiveSource(
                   new RelMdNonCumulativeCost(),
-                  BuiltInMetadata.NonCumulativeCost.Handler.class
-              )
-          ));
+                  BuiltInMetadata.NonCumulativeCost.Handler.class)));
 
   //~ Methods ----------------------------------------------------------------
 
   private RelMdPercentageOriginalRows() {}
 
+  public @Nullable Double getPercentageOriginalRows(TableScan scan, RelMetadataQuery mq) {
+    final BuiltInMetadata.PercentageOriginalRows.Handler handler =
+        scan.getTable().unwrap(BuiltInMetadata.PercentageOriginalRows.Handler.class);
+    if (handler != null) {
+      return handler.getPercentageOriginalRows(scan, mq);
+    }
+    // Fall back to the catch-all.
+    return getPercentageOriginalRows((RelNode) scan, mq);
+  }
 
   public @Nullable Double getPercentageOriginalRows(Aggregate rel, RelMetadataQuery mq) {
     // REVIEW jvs 28-Mar-2006: The assumption here seems to be that
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdPopulationSize.java b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdPopulationSize.java
index 779457fb596..963c3bac5f0 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdPopulationSize.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdPopulationSize.java
@@ -24,6 +24,7 @@
 import org.apache.calcite.rel.core.Project;
 import org.apache.calcite.rel.core.Sort;
 import org.apache.calcite.rel.core.TableModify;
+import org.apache.calcite.rel.core.TableScan;
 import org.apache.calcite.rel.core.Union;
 import org.apache.calcite.rel.core.Values;
 import org.apache.calcite.rex.RexNode;
@@ -54,6 +55,16 @@ private RelMdPopulationSize() {}
     return BuiltInMetadata.PopulationSize.DEF;
   }
 
+  public @Nullable Double getPopulationSize(TableScan scan, RelMetadataQuery mq,
+      ImmutableBitSet groupKey) {
+    final BuiltInMetadata.PopulationSize.Handler handler =
+        scan.getTable().unwrap(BuiltInMetadata.PopulationSize.Handler.class);
+    if (handler != null) {
+      return handler.getPopulationSize(scan, mq, groupKey);
+    }
+    return getPopulationSize((RelNode) scan, mq, groupKey);
+  }
+
   public @Nullable Double getPopulationSize(Filter rel, RelMetadataQuery mq,
       ImmutableBitSet groupKey) {
     return mq.getPopulationSize(rel.getInput(), groupKey);
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdPredicates.java b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdPredicates.java
index e194c827033..c530b386531 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdPredicates.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdPredicates.java
@@ -25,6 +25,7 @@
 import org.apache.calcite.plan.volcano.RelSubset;
 import org.apache.calcite.rel.RelNode;
 import org.apache.calcite.rel.core.Aggregate;
+import org.apache.calcite.rel.core.Correlate;
 import org.apache.calcite.rel.core.Exchange;
 import org.apache.calcite.rel.core.Filter;
 import org.apache.calcite.rel.core.Intersect;
@@ -149,8 +150,13 @@ public RelOptPredicateList getPredicates(RelNode rel, RelMetadataQuery mq) {
   /**
    * Infers predicates for a table scan.
    */
-  public RelOptPredicateList getPredicates(TableScan table,
+  public RelOptPredicateList getPredicates(TableScan scan,
       RelMetadataQuery mq) {
+    final BuiltInMetadata.Predicates.Handler handler =
+        scan.getTable().unwrap(BuiltInMetadata.Predicates.Handler.class);
+    if (handler != null) {
+      return handler.getPredicates(scan, mq);
+    }
     return RelOptPredicateList.EMPTY;
   }
 
@@ -181,9 +187,10 @@ public RelOptPredicateList getPredicates(Project project,
     final List<RexNode> projectPullUpPredicates = new ArrayList<>();
 
     ImmutableBitSet.Builder columnsMappedBuilder = ImmutableBitSet.builder();
-    Mapping m = Mappings.create(MappingType.PARTIAL_FUNCTION,
-        input.getRowType().getFieldCount(),
-        project.getRowType().getFieldCount());
+    Mapping m =
+        Mappings.create(MappingType.PARTIAL_FUNCTION,
+            input.getRowType().getFieldCount(),
+            project.getRowType().getFieldCount());
 
     for (Ord<RexNode> expr : Ord.zip(project.getProjects())) {
       if (expr.e instanceof RexInputRef) {
@@ -270,6 +277,13 @@ private static RexNode projectPredicate(final RexBuilder rexBuilder, RelNode inp
     return rexBuilder.makeLiteral(true);
   }
 
+  /**
+   * Infers predicates for a correlate node.
+   */
+  public RelOptPredicateList getPredicates(Correlate correlate, RelMetadataQuery mq) {
+    return mq.getPulledUpPredicates(correlate.getLeft());
+  }
+
   /**
    * Add the Filter condition to the pulledPredicates list from the input.
    */
@@ -342,8 +356,10 @@ public RelOptPredicateList getPredicates(Aggregate agg, RelMetadataQuery mq) {
       // no rows!) but not on the output (there is one row).
       return RelOptPredicateList.EMPTY;
     }
-    Mapping m = Mappings.create(MappingType.PARTIAL_FUNCTION,
-        input.getRowType().getFieldCount(), agg.getRowType().getFieldCount());
+    Mapping m =
+        Mappings.create(MappingType.PARTIAL_FUNCTION,
+            input.getRowType().getFieldCount(),
+            agg.getRowType().getFieldCount());
 
     int i = 0;
     for (int j : groupKeys) {
@@ -558,12 +574,13 @@ static class JoinConditionBasedPredicateInference {
       nFieldsLeft = joinRel.getLeft().getRowType().getFieldList().size();
       nFieldsRight = joinRel.getRight().getRowType().getFieldList().size();
       nSysFields = joinRel.getSystemFieldList().size();
-      leftFieldsBitSet = ImmutableBitSet.range(nSysFields,
-          nSysFields + nFieldsLeft);
-      rightFieldsBitSet = ImmutableBitSet.range(nSysFields + nFieldsLeft,
-          nSysFields + nFieldsLeft + nFieldsRight);
-      allFieldsBitSet = ImmutableBitSet.range(0,
-          nSysFields + nFieldsLeft + nFieldsRight);
+      leftFieldsBitSet =
+          ImmutableBitSet.range(nSysFields, nSysFields + nFieldsLeft);
+      rightFieldsBitSet =
+          ImmutableBitSet.range(nSysFields + nFieldsLeft,
+              nSysFields + nFieldsLeft + nFieldsRight);
+      allFieldsBitSet =
+          ImmutableBitSet.range(0, nSysFields + nFieldsLeft + nFieldsRight);
 
       exprFields = new HashMap<>();
       allExprs = new HashSet<>();
@@ -571,10 +588,12 @@ static class JoinConditionBasedPredicateInference {
       if (leftPredicates == null) {
         leftChildPredicates = null;
       } else {
-        Mappings.TargetMapping leftMapping = Mappings.createShiftMapping(
-            nSysFields + nFieldsLeft, nSysFields, 0, nFieldsLeft);
-        leftChildPredicates = leftPredicates.accept(
-            new RexPermuteInputsShuttle(leftMapping, joinRel.getInput(0)));
+        Mappings.TargetMapping leftMapping =
+            Mappings.createShiftMapping(nSysFields + nFieldsLeft, nSysFields, 0,
+                nFieldsLeft);
+        leftChildPredicates =
+            leftPredicates.accept(
+                new RexPermuteInputsShuttle(leftMapping, joinRel.getInput(0)));
 
         allExprs.add(leftChildPredicates);
         for (RexNode r : RelOptUtil.conjunctions(leftChildPredicates)) {
@@ -585,11 +604,12 @@ static class JoinConditionBasedPredicateInference {
       if (rightPredicates == null) {
         rightChildPredicates = null;
       } else {
-        Mappings.TargetMapping rightMapping = Mappings.createShiftMapping(
-            nSysFields + nFieldsLeft + nFieldsRight,
-            nSysFields + nFieldsLeft, 0, nFieldsRight);
-        rightChildPredicates = rightPredicates.accept(
-            new RexPermuteInputsShuttle(rightMapping, joinRel.getInput(1)));
+        Mappings.TargetMapping rightMapping =
+            Mappings.createShiftMapping(nSysFields + nFieldsLeft + nFieldsRight,
+                nSysFields + nFieldsLeft, 0, nFieldsRight);
+        rightChildPredicates =
+            rightPredicates.accept(
+                new RexPermuteInputsShuttle(rightMapping, joinRel.getInput(1)));
 
         allExprs.add(rightChildPredicates);
         for (RexNode r : RelOptUtil.conjunctions(rightChildPredicates)) {
@@ -658,13 +678,14 @@ public RelOptPredicateList inferPredicates(
         break;
       }
 
-      Mappings.TargetMapping rightMapping = Mappings.createShiftMapping(
-          nSysFields + nFieldsLeft + nFieldsRight,
-          0, nSysFields + nFieldsLeft, nFieldsRight);
+      Mappings.TargetMapping rightMapping =
+          Mappings.createShiftMapping(nSysFields + nFieldsLeft + nFieldsRight,
+              0, nSysFields + nFieldsLeft, nFieldsRight);
       final RexPermuteInputsShuttle rightPermute =
           new RexPermuteInputsShuttle(rightMapping, joinRel);
-      Mappings.TargetMapping leftMapping = Mappings.createShiftMapping(
-          nSysFields + nFieldsLeft, 0, nSysFields, nFieldsLeft);
+      Mappings.TargetMapping leftMapping =
+          Mappings.createShiftMapping(nSysFields + nFieldsLeft, 0, nSysFields,
+              nFieldsLeft);
       final RexPermuteInputsShuttle leftPermute =
           new RexPermuteInputsShuttle(leftMapping, joinRel);
       final List<RexNode> leftInferredPredicates = new ArrayList<>();
@@ -683,18 +704,18 @@ public RelOptPredicateList inferPredicates(
       switch (joinType) {
       case SEMI:
         Iterable<RexNode> pulledUpPredicates;
-        pulledUpPredicates = Iterables.concat(
-            RelOptUtil.conjunctions(leftChildPredicates),
-            leftInferredPredicates);
+        pulledUpPredicates =
+            Iterables.concat(RelOptUtil.conjunctions(leftChildPredicates),
+                leftInferredPredicates);
         return RelOptPredicateList.of(rexBuilder, pulledUpPredicates,
             leftInferredPredicates, rightInferredPredicates);
       case INNER:
-        pulledUpPredicates = Iterables.concat(
-            RelOptUtil.conjunctions(leftChildPredicates),
-            RelOptUtil.conjunctions(rightChildPredicates),
-            RexUtil.retainDeterministic(
-                RelOptUtil.conjunctions(joinRel.getCondition())),
-            inferredPredicates);
+        pulledUpPredicates =
+            Iterables.concat(RelOptUtil.conjunctions(leftChildPredicates),
+                RelOptUtil.conjunctions(rightChildPredicates),
+                RexUtil.retainDeterministic(
+                    RelOptUtil.conjunctions(joinRel.getCondition())),
+                inferredPredicates);
         return RelOptPredicateList.of(rexBuilder, pulledUpPredicates,
           leftInferredPredicates, rightInferredPredicates);
       case LEFT:
@@ -728,8 +749,9 @@ private void infer(@Nullable RexNode predicates, Set<RexNode> allExprs,
           continue;
         }
         for (Mapping m : mappings(r)) {
-          RexNode tr = r.accept(
-              new RexPermuteInputsShuttle(m, joinRel.getInput(0),
+          RexNode tr =
+              r.accept(
+                  new RexPermuteInputsShuttle(m, joinRel.getInput(0),
                   joinRel.getInput(1)));
           // Filter predicates can be already simplified, so we should work with
           // simplified RexNode versions as well. It also allows prevent of having
@@ -749,8 +771,9 @@ && checkTarget(inferringFields, allExprs, simplifiedTarget)) {
     }
 
     Iterable<Mapping> mappings(final RexNode predicate) {
-      final ImmutableBitSet fields = requireNonNull(exprFields.get(predicate),
-          () -> "exprFields.get(predicate) is null for " + predicate);
+      final ImmutableBitSet fields =
+          requireNonNull(exprFields.get(predicate),
+              () -> "exprFields.get(predicate) is null for " + predicate);
       if (fields.cardinality() == 0) {
         return Collections.emptyList();
       }
@@ -766,12 +789,14 @@ private static boolean checkTarget(ImmutableBitSet inferringFields,
 
     @SuppressWarnings("JdkObsolete")
     private void markAsEquivalent(int p1, int p2) {
-      BitSet b = requireNonNull(equivalence.get(p1),
-          () -> "equivalence.get(p1) for " + p1);
+      BitSet b =
+          requireNonNull(equivalence.get(p1),
+              () -> "equivalence.get(p1) for " + p1);
       b.set(p2);
 
-      b = requireNonNull(equivalence.get(p2),
-          () -> "equivalence.get(p2) for " + p2);
+      b =
+          requireNonNull(equivalence.get(p2),
+              () -> "equivalence.get(p2) for " + p2);
       b.set(p1);
     }
 
@@ -847,8 +872,10 @@ class ExprsItr implements Iterator<Mapping> {
             .nextSetBit(i + 1), j++) {
           columns[j] = i;
           int fieldIndex = i;
-          columnSets[j] = requireNonNull(equivalence.get(i),
-              () -> "equivalence.get(i) is null for " + fieldIndex + ", " + equivalence);
+          columnSets[j] =
+              requireNonNull(equivalence.get(i),
+                  () -> "equivalence.get(i) is null for " + fieldIndex
+                      + ", " + equivalence);
           iterationIdx[j] = 0;
         }
         firstCall = true;
@@ -893,9 +920,10 @@ private void computeNextMapping(int level) {
       }
 
       private void initializeMapping() {
-        nextMapping = Mappings.create(MappingType.PARTIAL_FUNCTION,
-            nSysFields + nFieldsLeft + nFieldsRight,
-            nSysFields + nFieldsLeft + nFieldsRight);
+        nextMapping =
+            Mappings.create(MappingType.PARTIAL_FUNCTION,
+                nSysFields + nFieldsLeft + nFieldsRight,
+                nSysFields + nFieldsLeft + nFieldsRight);
         for (int i = 0; i < columnSets.length; i++) {
           BitSet c = columnSets[i];
           int t = c.nextSetBit(iterationIdx[i]);
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdRowCount.java b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdRowCount.java
index 5eb8178826b..2066c867fe9 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdRowCount.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdRowCount.java
@@ -197,7 +197,12 @@ public Double getRowCount(Aggregate rel, RelMetadataQuery mq) {
     return distinctRowCount;
   }
 
-  public Double getRowCount(TableScan rel, RelMetadataQuery mq) {
+  public @Nullable Double getRowCount(TableScan rel, RelMetadataQuery mq) {
+    final BuiltInMetadata.RowCount.Handler handler =
+        rel.getTable().unwrap(BuiltInMetadata.RowCount.Handler.class);
+    if (handler != null) {
+      return handler.getRowCount(rel, mq);
+    }
     return rel.estimateRowCount(mq);
   }
 
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdSelectivity.java b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdSelectivity.java
index f61b26cf88b..709b8d11c77 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdSelectivity.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdSelectivity.java
@@ -25,6 +25,7 @@
 import org.apache.calcite.rel.core.Project;
 import org.apache.calcite.rel.core.Sort;
 import org.apache.calcite.rel.core.TableModify;
+import org.apache.calcite.rel.core.TableScan;
 import org.apache.calcite.rel.core.Union;
 import org.apache.calcite.rex.RexBuilder;
 import org.apache.calcite.rex.RexLocalRef;
@@ -60,6 +61,16 @@ protected RelMdSelectivity() {
     return BuiltInMetadata.Selectivity.DEF;
   }
 
+  public @Nullable Double getSelectivity(TableScan scan, RelMetadataQuery mq,
+      RexNode predicate) {
+    final BuiltInMetadata.Selectivity.Handler handler =
+        scan.getTable().unwrap(BuiltInMetadata.Selectivity.Handler.class);
+    if (handler != null) {
+      return handler.getSelectivity(scan, mq, predicate);
+    }
+    return getSelectivity((RelNode) scan, mq, predicate);
+  }
+
   public @Nullable Double getSelectivity(Union rel, RelMetadataQuery mq,
       @Nullable RexNode predicate) {
     if ((rel.getInputs().size() == 0) || (predicate == null)) {
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdSize.java b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdSize.java
index 77b2ed6fd74..ca91d514783 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdSize.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdSize.java
@@ -171,7 +171,12 @@ protected RelMdSize() {}
     return list.build();
   }
 
-  public List<@Nullable Double> averageColumnSizes(TableScan rel, RelMetadataQuery mq) {
+  public @Nullable List<@Nullable Double> averageColumnSizes(TableScan rel, RelMetadataQuery mq) {
+    final BuiltInMetadata.Size.Handler handler =
+        rel.getTable().unwrap(BuiltInMetadata.Size.Handler.class);
+    if (handler != null) {
+      return handler.averageColumnSizes(rel, mq);
+    }
     final List<RelDataTypeField> fields = rel.getRowType().getFieldList();
     final ImmutableNullableList.Builder<@Nullable Double> list = ImmutableNullableList.builder();
     for (RelDataTypeField field : fields) {
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdTableReferences.java b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdTableReferences.java
index e9554a6946e..ebcbdc187dd 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdTableReferences.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdTableReferences.java
@@ -92,6 +92,11 @@ protected RelMdTableReferences() {}
    * TableScan table reference.
    */
   public Set<RelTableRef> getTableReferences(TableScan rel, RelMetadataQuery mq) {
+    final BuiltInMetadata.TableReferences.Handler handler =
+        rel.getTable().unwrap(BuiltInMetadata.TableReferences.Handler.class);
+    if (handler != null) {
+      return handler.getTableReferences(rel, mq);
+    }
     return ImmutableSet.of(RelTableRef.of(rel.getTable(), 0));
   }
 
@@ -132,12 +137,13 @@ public Set<RelTableRef> getTableReferences(TableScan rel, RelMetadataQuery mq) {
     }
     for (RelTableRef rightRef : rightTableRefs) {
       int shift = 0;
-      Collection<RelTableRef> lRefs = leftQualifiedNamesToRefs.get(rightRef.getQualifiedName());
+      Collection<RelTableRef> lRefs =
+          leftQualifiedNamesToRefs.get(rightRef.getQualifiedName());
       if (lRefs != null) {
         shift = lRefs.size();
       }
-      RelTableRef shiftTableRef = RelTableRef.of(
-          rightRef.getTable(), shift + rightRef.getEntityNumber());
+      RelTableRef shiftTableRef =
+          RelTableRef.of(rightRef.getTable(), shift + rightRef.getEntityNumber());
       assert !result.contains(shiftTableRef);
       result.add(shiftTableRef);
     }
@@ -166,13 +172,13 @@ public Set<RelTableRef> getTableReferences(TableScan rel, RelMetadataQuery mq) {
       }
       for (RelTableRef tableRef : inputTableRefs) {
         int shift = 0;
-        Collection<RelTableRef> lRefs = qualifiedNamesToRefs.get(
-            tableRef.getQualifiedName());
+        Collection<RelTableRef> lRefs =
+            qualifiedNamesToRefs.get(tableRef.getQualifiedName());
         if (lRefs != null) {
           shift = lRefs.size();
         }
-        RelTableRef shiftTableRef = RelTableRef.of(
-            tableRef.getTable(), shift + tableRef.getEntityNumber());
+        RelTableRef shiftTableRef =
+            RelTableRef.of(tableRef.getTable(), shift + tableRef.getEntityNumber());
         assert !result.contains(shiftTableRef);
         result.add(shiftTableRef);
         currentTablesMapping.put(tableRef, shiftTableRef);
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdUniqueKeys.java b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdUniqueKeys.java
index f8a845f7eef..447619cef2f 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdUniqueKeys.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdUniqueKeys.java
@@ -48,6 +48,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
+import java.util.stream.Collectors;
 
 import static java.util.Objects.requireNonNull;
 
@@ -156,12 +157,14 @@ private static Set<ImmutableBitSet> getProjectUniqueKeys(SingleRel rel, RelMetad
       // select id, id, id, unique2, unique2
       // the resulting unique keys would be {{0},{3}}, {{0},{4}}, {{0},{1},{4}}, ...
 
-      Iterable<List<ImmutableBitSet>> product = Linq4j.product(
-          Util.transform(colMask,
-              in -> Util.filter(
-                  requireNonNull(mapInToOutPos.get(in),
-                      () -> "no entry for column " + in + " in mapInToOutPos: " + mapInToOutPos)
-                      .powerSet(), bs -> !bs.isEmpty())));
+      Iterable<List<ImmutableBitSet>> product =
+          Linq4j.product(
+              Util.transform(colMask, in ->
+                  Util.filter(
+                      requireNonNull(mapInToOutPos.get(in),
+                          () -> "no entry for column " + in
+                              + " in mapInToOutPos: " + mapInToOutPos).powerSet(),
+                      bs -> !bs.isEmpty())));
 
       resultBuilder.addAll(Util.transform(product, ImmutableBitSet::union));
     }
@@ -247,7 +250,19 @@ private static Set<ImmutableBitSet> getProjectUniqueKeys(SingleRel rel, RelMetad
 
   public Set<ImmutableBitSet> getUniqueKeys(Aggregate rel, RelMetadataQuery mq,
       boolean ignoreNulls) {
-    if (Aggregate.isSimple(rel) || ignoreNulls) {
+    if (Aggregate.isSimple(rel)) {
+      final ImmutableBitSet groupKeys = rel.getGroupSet();
+      final Set<ImmutableBitSet> inputUniqueKeys = mq
+          .getUniqueKeys(rel.getInput(), ignoreNulls);
+      if (inputUniqueKeys == null) {
+        return ImmutableSet.of(groupKeys);
+      }
+
+      // Try to find more precise unique keys.
+      final Set<ImmutableBitSet> preciseUniqueKeys = inputUniqueKeys.stream()
+          .filter(groupKeys::contains).collect(Collectors.toSet());
+      return preciseUniqueKeys.isEmpty() ? ImmutableSet.of(groupKeys) : preciseUniqueKeys;
+    } else if (ignoreNulls) {
       // group by keys form a unique key
       return ImmutableSet.of(rel.getGroupSet());
     } else {
@@ -309,6 +324,12 @@ public Set<ImmutableBitSet> getUniqueKeys(Minus rel,
 
   public @Nullable Set<ImmutableBitSet> getUniqueKeys(TableScan rel, RelMetadataQuery mq,
       boolean ignoreNulls) {
+    final BuiltInMetadata.UniqueKeys.Handler handler =
+        rel.getTable().unwrap(BuiltInMetadata.UniqueKeys.Handler.class);
+    if (handler != null) {
+      return handler.getUniqueKeys(rel, mq, ignoreNulls);
+    }
+
     final List<ImmutableBitSet> keys = rel.getTable().getKeys();
     if (keys == null) {
       return null;
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdUtil.java b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdUtil.java
index 107776294c4..36b2c3ded1c 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdUtil.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdUtil.java
@@ -36,6 +36,7 @@
 import org.apache.calcite.rex.RexProgram;
 import org.apache.calcite.rex.RexUtil;
 import org.apache.calcite.rex.RexVisitorImpl;
+import org.apache.calcite.sql.SqlBasicFunction;
 import org.apache.calcite.sql.SqlFunction;
 import org.apache.calcite.sql.SqlFunctionCategory;
 import org.apache.calcite.sql.SqlKind;
@@ -67,10 +68,8 @@ public class RelMdUtil {
   //~ Static fields/initializers ---------------------------------------------
 
   public static final SqlFunction ARTIFICIAL_SELECTIVITY_FUNC =
-      new SqlFunction("ARTIFICIAL_SELECTIVITY",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("ARTIFICIAL_SELECTIVITY",
           ReturnTypes.BOOLEAN, // returns boolean since we'll AND it
-          null,
           OperandTypes.NUMERIC, // takes a numeric param
           SqlFunctionCategory.SYSTEM);
 
@@ -339,8 +338,91 @@ public static void setLeftRightBitmaps(
 
     double res = 0;
     if (dSize > 0) {
-      double expo = numSel * Math.log(1.0 - 1.0 / dSize);
-      res = (1.0 - Math.exp(expo)) * dSize;
+      // We calculate the result in 3 cases:
+      // 1) If N and n are not very large values, we directly calculate
+      //    N * [1 - exp(n * ln(1 - 1 / N))]
+      // 2) If N or n are very large values, but n / N is not close to 0,
+      //    We compute the result by expanding the exponent n * ln(1 - 1 / N)
+      //    as a Taylor series.
+      // 3) If N or n are very large values, and n / N is close to 0,
+      //    we expand the whole formula as a Taylor series.
+      // We separate the 3 cases by trying to expand the exponent as a Taylor series.
+      // If the required number of terms for convergence is too big, it is case 1.
+      // If the required number of terms is too small, it is case 3. Otherwise,
+      // it is case 2.
+
+      // To expand the component as a Taylor series, we have:
+      // n * ln(1 - 1 / N)
+      //    = n * (- 1 / N - 1 / (2 * N ^ 2) - 1 / (3 * N ^ 3) - ...)
+      //
+      // To get an approximate result, we truncate the series after the first m terms.
+      // This leads to an error of:
+      // n * (1 / [(m + 1) * N ^ (m + 1)] + 1 / [(m + 2) * dSize ^ (m + 2) + ...])
+      // < n / (m + 1) / [N ^ m * (N - 1)] <  n / (N ^ m)
+      //
+      // To get an accurate result, the error should be smaller than 1e-16, because a
+      // double can represent at most 15 digits after the decimal point. Therefore, we need
+      // n / (N ^ m ) < 1e-16, or N ^ m / n > 1e16.
+      //
+      // The smallest value of m that satisfies the above formula is the
+      // number of terms required for convergence.
+
+      final int maxTerms = 32;
+      final int minTerms = 1;
+
+      int numTerms = 1;
+      if (dSize > 10) {
+        double dPower = dSize;
+        while (dPower / numSel <= 1e16) {
+          dPower = dPower * dPower;
+          numTerms *= 2;
+        }
+      } else {
+        // for small dSize, force case 1
+        numTerms = maxTerms + 1;
+      }
+
+      if (numTerms > maxTerms) {
+        // case 1
+        double expo = numSel * Math.log(1.0 - 1.0 / dSize);
+        res = (1.0 - Math.exp(expo)) * dSize;
+      } else if (numTerms > minTerms) {
+        // case 2
+        double expo = 0;
+        double dPower = dSize;
+        for (int i = 1; i <= numTerms; i++) {
+          expo -= numSel / dPower / i;
+          dPower *= dSize;
+        }
+        res = (1.0 - Math.exp(expo)) * dSize;
+      } else {
+        // numTerms <= minTerms
+        // case 3
+
+        // Since the ratio n / N is close to 0, we can expand the exponent as
+        // n * ln(1 - 1 / N) ≈ n * (- 1 / N) = - n / N.
+        // So N * [1 - (1 - 1 / N) ^ n ] = N * [1 - exp(n * ln(1 - 1 / N))]
+        // ≈ N * [1 - exp(- n / N)].
+        // Since exp(x) = 1 + x + x ^ 2 / 2 + x ^ 3 / 6 + ..., we have
+        // N * [1 - exp(- n / N)] = N * [n / N - n ^ 2 / (2 * N ^ 2) + n ^ 3 / (6 * N ^ 3) - ...]
+        // = n - n ^ 2 / (2 * N) + n ^ 3 / (6 * N ^ 2) - ...
+        // Since n / N is close to 0, and due to the factorial in the denominator,
+        // the above series converges to 0 very quickly.
+        res = 0;
+        numTerms = 5;
+        double selPower = numSel;
+        double domPower = 1;
+        int factorial = 1;
+        int sign = 1;
+        for (int i = 1; i < numTerms; i++) {
+          res += sign * selPower / factorial / domPower;
+
+          selPower *= numSel;
+          domPower *= dSize;
+          factorial *= i + 1;
+          sign *= -1;
+        }
+      }
     }
 
     // fix the boundary cases
@@ -673,9 +755,10 @@ public static double addEpsilon(double d) {
     }
 
     if (useMaxNdv) {
-      distRowCount = NumberUtil.max(
-          mq.getDistinctRowCount(left, leftMask.build(), leftPred),
-          mq.getDistinctRowCount(right, rightMask.build(), rightPred));
+      distRowCount =
+          NumberUtil.max(
+              mq.getDistinctRowCount(left, leftMask.build(), leftPred),
+              mq.getDistinctRowCount(right, rightMask.build(), rightPred));
     } else {
       distRowCount =
         multiply(
@@ -776,8 +859,8 @@ public static double estimateFilteredRows(RelNode child, RexProgram program,
   public static double estimateFilteredRows(RelNode child, @Nullable RexNode condition,
       RelMetadataQuery mq) {
     @SuppressWarnings("unboxing.of.nullable")
-    double result = multiply(mq.getRowCount(child),
-        mq.getSelectivity(child, condition));
+    double result =
+        multiply(mq.getRowCount(child), mq.getSelectivity(child, condition));
     return result;
   }
 
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/RelMetadataQuery.java b/core/src/main/java/org/apache/calcite/rel/metadata/RelMetadataQuery.java
index b1430f5a996..63976f7b3f8 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/RelMetadataQuery.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/RelMetadataQuery.java
@@ -878,8 +878,8 @@ public Boolean isVisibleInExplain(RelNode rel,
       SqlExplainLevel explainLevel) {
     for (;;) {
       try {
-        Boolean b = explainVisibilityHandler.isVisibleInExplain(rel, this,
-            explainLevel);
+        Boolean b =
+            explainVisibilityHandler.isVisibleInExplain(rel, this, explainLevel);
         return b == null || b;
       } catch (MetadataHandlerProvider.NoHandler e) {
         explainVisibilityHandler = revise(BuiltInMetadata.ExplainVisibility.Handler.class);
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/janino/CacheGeneratorUtil.java b/core/src/main/java/org/apache/calcite/rel/metadata/janino/CacheGeneratorUtil.java
index 0ea152d323b..9a0aa8ca8dc 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/janino/CacheGeneratorUtil.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/janino/CacheGeneratorUtil.java
@@ -197,7 +197,7 @@ private enum CacheKeyStrategy {
       @Override void cacheKeyBlock(StringBuilder buff, Method method, int methodIndex) {
         buff.append("    key = ")
             .append(
-                (method.getParameterTypes().length < 6
+                (method.getParameterCount() < 6
                     ? org.apache.calcite.runtime.FlatLists.class
                     : ImmutableList.class).getName())
             .append(".of(");
diff --git a/core/src/main/java/org/apache/calcite/rel/mutable/MutableRels.java b/core/src/main/java/org/apache/calcite/rel/mutable/MutableRels.java
index 708e8816d32..183b7955f4b 100644
--- a/core/src/main/java/org/apache/calcite/rel/mutable/MutableRels.java
+++ b/core/src/main/java/org/apache/calcite/rel/mutable/MutableRels.java
@@ -53,7 +53,6 @@
 import org.apache.calcite.rex.RexInputRef;
 import org.apache.calcite.rex.RexNode;
 import org.apache.calcite.rex.RexUtil;
-import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.tools.RelBuilder;
 import org.apache.calcite.util.Util;
 import org.apache.calcite.util.mapping.Mapping;
@@ -254,7 +253,7 @@ public static RelNode fromMutable(MutableRel node, RelBuilder relBuilder) {
     case COLLECT: {
       final MutableCollect collect = (MutableCollect) node;
       final RelNode child = fromMutable(collect.getInput(), relBuilder);
-      return Collect.create(child, SqlTypeName.MULTISET, collect.fieldName);
+      return Collect.create(child, collect.rowType);
     }
     case UNCOLLECT: {
       final MutableUncollect uncollect = (MutableUncollect) node;
@@ -336,8 +335,9 @@ public static MutableRel toMutable(RelNode rel) {
       RelSubset subset = (RelSubset) rel;
       RelNode best = subset.getBest();
       if (best == null) {
-        best = requireNonNull(subset.getOriginal(),
-            () -> "subset.getOriginal() is null for " + subset);
+        best =
+            requireNonNull(subset.getOriginal(),
+                () -> "subset.getOriginal() is null for " + subset);
       }
       return toMutable(best);
     }
diff --git a/core/src/main/java/org/apache/calcite/rel/rel2sql/RelToSqlConverter.java b/core/src/main/java/org/apache/calcite/rel/rel2sql/RelToSqlConverter.java
index fc0e4c8dbbf..a1b2f8def40 100644
--- a/core/src/main/java/org/apache/calcite/rel/rel2sql/RelToSqlConverter.java
+++ b/core/src/main/java/org/apache/calcite/rel/rel2sql/RelToSqlConverter.java
@@ -103,7 +103,6 @@
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Deque;
-import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -129,8 +128,9 @@ public class RelToSqlConverter extends SqlImplementor
   @SuppressWarnings("argument.type.incompatible")
   public RelToSqlConverter(SqlDialect dialect) {
     super(dialect);
-    dispatcher = ReflectUtil.createMethodDispatcher(Result.class, this, "visit",
-        RelNode.class);
+    dispatcher =
+        ReflectUtil.createMethodDispatcher(Result.class, this, "visit",
+            RelNode.class);
   }
 
   /** Dispatches a call to the {@code visit(Xxx e)} method where {@code Xxx}
@@ -189,12 +189,18 @@ private static class AliasReplacementShuttle extends SqlShuttle {
     }
 
     @Override public SqlNode visit(SqlIdentifier id) {
+      SqlNodeList source = requireNonNull(replaceSource, "replaceSource");
+      SqlNode firstItem = source.get(0);
+      if (firstItem instanceof SqlIdentifier && ((SqlIdentifier) firstItem).isStar()) {
+        return id;
+      }
       if (tableAlias.equals(id.names.get(0))) {
-        int index = requireNonNull(
-            tableType.getField(id.names.get(1), false, false),
-            () -> "field " + id.names.get(1) + " is not found in " + tableType)
+        int index =
+            requireNonNull(tableType.getField(id.names.get(1), false, false),
+                () -> "field " + id.names.get(1) + " is not found in "
+                    + tableType)
             .getIndex();
-        SqlNode selectItem = requireNonNull(replaceSource, "replaceSource").get(index);
+        SqlNode selectItem = source.get(index);
         if (selectItem.getKind() == SqlKind.AS) {
           selectItem = ((SqlCall) selectItem).operand(0);
         }
@@ -256,8 +262,9 @@ protected Result visitAntiOrSemiJoin(Join e) {
     SqlNode sqlCondition =
         convertConditionToSqlNode(e.getCondition(), leftContext, rightContext);
     if (leftResult.neededAlias != null) {
-      SqlShuttle visitor = new AliasReplacementShuttle(leftResult.neededAlias,
-          e.getLeft().getRowType(), sqlSelect.getSelectList());
+      SqlShuttle visitor =
+          new AliasReplacementShuttle(leftResult.neededAlias,
+              e.getLeft().getRowType(), sqlSelect.getSelectList());
       sqlCondition = sqlCondition.accept(visitor);
     }
     SqlNode fromPart = rightResult.asFrom();
@@ -267,9 +274,9 @@ protected Result visitAntiOrSemiJoin(Join e) {
       existsSqlSelect.setSelectList(
           new SqlNodeList(ImmutableList.of(ONE), POS));
       if (existsSqlSelect.getWhere() != null) {
-        sqlCondition = SqlStdOperatorTable.AND.createCall(POS,
-            existsSqlSelect.getWhere(),
-            sqlCondition);
+        sqlCondition =
+            SqlStdOperatorTable.AND.createCall(POS, existsSqlSelect.getWhere(),
+                sqlCondition);
       }
       existsSqlSelect.setWhere(sqlCondition);
     } else {
@@ -278,22 +285,22 @@ protected Result visitAntiOrSemiJoin(Join e) {
               new SqlNodeList(
                   ImmutableList.of(ONE), POS),
               fromPart, sqlCondition, null,
-              null, null, null, null, null, null);
+              null, null, null, null, null, null, null);
     }
     sqlCondition = SqlStdOperatorTable.EXISTS.createCall(POS, existsSqlSelect);
     if (e.getJoinType() == JoinRelType.ANTI) {
       sqlCondition = SqlStdOperatorTable.NOT.createCall(POS, sqlCondition);
     }
     if (sqlSelect.getWhere() != null) {
-      sqlCondition = SqlStdOperatorTable.AND.createCall(POS,
-          sqlSelect.getWhere(),
-          sqlCondition);
+      sqlCondition =
+          SqlStdOperatorTable.AND.createCall(POS, sqlSelect.getWhere(),
+              sqlCondition);
     }
     sqlSelect.setWhere(sqlCondition);
     final SqlNode resultNode =
         leftResult.neededAlias == null ? sqlSelect
             : as(sqlSelect, leftResult.neededAlias);
-    return result(resultNode, leftResult, rightResult);
+    return result(resultNode,  ImmutableList.of(Clause.FROM), e, null);
   }
 
   /** Returns whether this join should be unparsed as a {@link JoinType#COMMA}.
@@ -412,8 +419,9 @@ public Result visit(Filter e) {
     if (input instanceof Aggregate) {
       final Aggregate aggregate = (Aggregate) input;
       final boolean ignoreClauses = aggregate.getInput() instanceof Project;
-      final Result x = visitInput(e, 0, isAnon(), ignoreClauses,
-          ImmutableSet.of(Clause.HAVING));
+      final Result x =
+          visitInput(e, 0, isAnon(), ignoreClauses,
+              ImmutableSet.of(Clause.HAVING));
       parseCorrelTable(e, x);
       final Builder builder = x.builder(e);
       x.asSelect().setHaving(
@@ -616,8 +624,13 @@ private List<SqlNode> generateGroupList(Builder builder,
       // a singleton CUBE and ROLLUP are the same but we prefer ROLLUP;
       // fall through
     case ROLLUP:
+      final List<Integer> rollupBits = Aggregate.Group.getRollup(aggregate.groupSets);
+      final List<SqlNode> rollupKeys = rollupBits
+          .stream()
+          .map(bit -> builder.context.field(bit))
+          .collect(Collectors.toList());
       return ImmutableList.of(
-          SqlStdOperatorTable.ROLLUP.createCall(SqlParserPos.ZERO, groupKeys));
+          SqlStdOperatorTable.ROLLUP.createCall(SqlParserPos.ZERO, rollupKeys));
     default:
     case OTHER:
       // Make sure that the group sets contains all bits.
@@ -659,9 +672,12 @@ public Result visit(TableScan e) {
     final ImmutableList<RelHint> hints = e.getHints();
     if (!hints.isEmpty()) {
       SqlParserPos pos = identifier.getParserPosition();
-      node = new SqlTableRef(pos, identifier,
-          SqlNodeList.of(pos, hints.stream().map(h -> RelToSqlConverter.toSqlHint(h, pos))
-              .collect(Collectors.toList())));
+      node =
+          new SqlTableRef(pos, identifier,
+              SqlNodeList.of(pos,
+                  hints.stream()
+                      .map(h -> RelToSqlConverter.toSqlHint(h, pos))
+                      .collect(Collectors.toList())));
     } else {
       node = identifier;
     }
@@ -768,7 +784,7 @@ public Result visit(Values e) {
             new SqlSelect(POS, null,
                 new SqlNodeList(values2, POS),
                 getDual(), null, null,
-                null, null, null, null, null, null));
+                null, null, null, null, null, null, null));
       }
       if (list.isEmpty()) {
         // In this case we need to construct the following query:
@@ -781,26 +797,31 @@ public Result visit(Values e) {
         }
         final SqlIdentifier dual = getDual();
         if (dual == null) {
-          query = new SqlSelect(POS, null,
-              new SqlNodeList(nullColumnNames, POS), null, null, null, null,
-              null, null, null, null, null);
+          query =
+              new SqlSelect(POS, null,
+                  new SqlNodeList(nullColumnNames, POS), null, null, null, null,
+                  null, null, null, null, null, null);
 
           // Wrap "SELECT 1 AS x"
           // as "SELECT * FROM (SELECT 1 AS x) AS t WHERE false"
-          query = new SqlSelect(POS, null, SqlNodeList.SINGLETON_STAR,
-              as(query, "t"), createAlwaysFalseCondition(), null, null,
-              null, null, null, null, null);
+          query =
+              new SqlSelect(POS, null, SqlNodeList.SINGLETON_STAR,
+                  as(query, "t"), createAlwaysFalseCondition(), null, null,
+                  null, null, null, null, null, null);
         } else {
-          query = new SqlSelect(POS, null,
-              new SqlNodeList(nullColumnNames, POS),
-              dual, createAlwaysFalseCondition(), null,
-              null, null, null, null, null, null);
+          query =
+              new SqlSelect(POS, null,
+                  new SqlNodeList(nullColumnNames, POS),
+                  dual, createAlwaysFalseCondition(), null,
+                  null, null, null, null, null, null, null);
         }
       } else if (list.size() == 1) {
         query = list.get(0);
       } else {
-        query = SqlStdOperatorTable.UNION_ALL.createCall(
-            new SqlNodeList(list, POS));
+        query = list.stream()
+            .map(select -> (SqlNode) select)
+            .reduce((l, r) -> SqlStdOperatorTable.UNION_ALL.createCall(POS, l, r))
+            .get();
       }
     } else {
       // Generate ANSI syntax
@@ -836,7 +857,7 @@ dual, createAlwaysFalseCondition(), null,
         query =
             new SqlSelect(POS, null, SqlNodeList.SINGLETON_STAR, query,
                 createAlwaysFalseCondition(), null, null, null,
-                null, null, null, null);
+                null, null, null, null, null);
       }
     }
     return result(query, clauses, e, null);
@@ -866,19 +887,39 @@ public Result visit(Sort e) {
       if (hasTrickyRollup(e, aggregate)) {
         // MySQL 5 does not support standard "GROUP BY ROLLUP(x, y)", only
         // the non-standard "GROUP BY x, y WITH ROLLUP".
-        // It does not allow "WITH ROLLUP" in combination with "ORDER BY",
-        // but "GROUP BY x, y WITH ROLLUP" implicitly sorts by x, y,
+        List<Integer> rollupList =
+            Aggregate.Group.getRollup(aggregate.getGroupSets());
+        List<Integer> sortList = e.getCollation()
+            .getFieldCollations()
+            .stream()
+            .map(f -> aggregate.getGroupSet().nth(f.getFieldIndex()))
+            .collect(Collectors.toList());
+        // "GROUP BY x, y WITH ROLLUP" implicitly sorts by x, y,
         // so skip the ORDER BY.
-        final Set<Integer> groupList = new LinkedHashSet<>();
-        for (RelFieldCollation fc : e.collation.getFieldCollations()) {
-          groupList.add(aggregate.getGroupSet().nth(fc.getFieldIndex()));
-        }
-        groupList.addAll(Aggregate.Group.getRollup(aggregate.getGroupSets()));
+        final boolean isImplicitlySort = Util.startsWith(rollupList, sortList);
         final Builder builder =
-            visitAggregate(aggregate, ImmutableList.copyOf(groupList),
+            visitAggregate(aggregate, rollupList,
                 Clause.GROUP_BY, Clause.OFFSET, Clause.FETCH);
-        offsetFetch(e, builder);
-        return builder.result();
+        Result result = builder.result();
+        if (sortList.isEmpty()
+            || isImplicitlySort) {
+          offsetFetch(e, builder);
+          return result;
+        }
+        // MySQL does not allow "WITH ROLLUP" in combination with "ORDER BY",
+        // so generate the grouped result apply ORDER BY to it.
+        SqlSelect sqlSelect = result.subSelect();
+        SqlNodeList sortExps = exprList(builder.context, e.getSortExps());
+        sqlSelect.setOrderBy(sortExps);
+        if (e.offset != null) {
+          SqlNode offset = builder.context.toSql(null, e.offset);
+          sqlSelect.setOffset(offset);
+        }
+        if (e.fetch != null) {
+          SqlNode fetch = builder.context.toSql(null, e.fetch);
+          sqlSelect.setFetch(fetch);
+        }
+        return result(sqlSelect, ImmutableList.of(Clause.ORDER_BY), e, null);
       }
     }
     if (e.getInput() instanceof Project) {
@@ -899,13 +940,14 @@ public Result visit(Sort e) {
                   sort2,
                   ImmutableList.of(),
                   project.getProjects(),
-                  project.getRowType());
+                  project.getRowType(),
+                  project.getVariablesSet());
           return visit(project2);
         }
       }
     }
-    final Result x = visitInput(e, 0, Clause.ORDER_BY, Clause.OFFSET,
-        Clause.FETCH);
+    final Result x =
+        visitInput(e, 0, Clause.ORDER_BY, Clause.OFFSET, Clause.FETCH);
     final Builder builder = x.builder(e);
     if (stack.size() != 1
         && builder.select.getSelectList().equals(SqlNodeList.SINGLETON_STAR)) {
@@ -1047,20 +1089,23 @@ public Result visit(Match e) {
     if (e.getOrderKeys() != null) {
       for (RelFieldCollation fc : e.getOrderKeys().getFieldCollations()) {
         if (fc.nullDirection != RelFieldCollation.NullDirection.UNSPECIFIED) {
-          boolean first = fc.nullDirection == RelFieldCollation.NullDirection.FIRST;
+          boolean first =
+              fc.nullDirection == RelFieldCollation.NullDirection.FIRST;
           SqlNode nullDirectionNode =
               dialect.emulateNullDirection(context.field(fc.getFieldIndex()),
                   first, fc.direction.isDescending());
           if (nullDirectionNode != null) {
             orderBySqlList.add(nullDirectionNode);
-            fc = new RelFieldCollation(fc.getFieldIndex(), fc.getDirection(),
-                RelFieldCollation.NullDirection.UNSPECIFIED);
+            fc =
+                new RelFieldCollation(fc.getFieldIndex(), fc.getDirection(),
+                    RelFieldCollation.NullDirection.UNSPECIFIED);
           }
         }
         orderBySqlList.add(context.toSql(fc));
       }
     }
-    final SqlNodeList orderByList = new SqlNodeList(orderBySqlList, SqlParserPos.ZERO);
+    final SqlNodeList orderByList =
+        new SqlNodeList(orderBySqlList, SqlParserPos.ZERO);
 
     final SqlLiteral rowsPerMatch = e.isAllRows()
         ? SqlMatchRecognize.RowsPerMatchOption.ALL_ROWS.symbol(POS)
@@ -1073,8 +1118,10 @@ public Result visit(Match e) {
       after = SqlLiteral.createSymbol(value, POS);
     } else {
       RexCall call = (RexCall) e.getAfter();
-      String operand = requireNonNull(stringValue(call.getOperands().get(0)),
-          () -> "non-null string value expected for 0th operand of AFTER call " + call);
+      String operand =
+          requireNonNull(stringValue(call.getOperands().get(0)),
+              () -> "non-null string expected for 0th operand of AFTER call "
+                  + call);
       after = call.getOperator().createCall(POS, new SqlIdentifier(operand, POS));
     }
 
@@ -1115,9 +1162,10 @@ public Result visit(Match e) {
       patternDefList.add(as(sqlNode, alias));
     }
 
-    final SqlNode matchRecognize = new SqlMatchRecognize(POS, tableRef,
-        pattern, strictStart, strictEnd, patternDefList, measureList, after,
-        subsetList, rowsPerMatch, partitionList, orderByList, interval);
+    final SqlNode matchRecognize =
+        new SqlMatchRecognize(POS, tableRef,
+            pattern, strictStart, strictEnd, patternDefList, measureList, after,
+            subsetList, rowsPerMatch, partitionList, orderByList, interval);
     return result(matchRecognize, Expressions.list(Clause.FROM), e, null);
   }
 
@@ -1128,9 +1176,12 @@ private static SqlCall as(SqlNode e, String alias) {
 
   public Result visit(Uncollect e) {
     final Result x = visitInput(e, 0);
-    final SqlNode unnestNode = SqlStdOperatorTable.UNNEST.createCall(POS, x.asStatement());
-    final List<SqlNode> operands = createAsFullOperands(e.getRowType(), unnestNode,
-        requireNonNull(x.neededAlias, () -> "x.neededAlias is null, node is " + x.node));
+    final SqlNode unnestNode =
+        SqlStdOperatorTable.UNNEST.createCall(POS, x.asStatement());
+    final List<SqlNode> operands =
+        createAsFullOperands(e.getRowType(), unnestNode,
+            requireNonNull(x.neededAlias,
+                () -> "x.neededAlias is null, node is " + x.node));
     final SqlNode asNode = SqlStdOperatorTable.AS.createCall(POS, operands);
     return result(asNode, ImmutableList.of(Clause.FROM), e, null);
   }
@@ -1150,7 +1201,7 @@ public Result visit(TableFunctionScan e) {
             ImmutableList.of(callNode), SqlParserPos.ZERO);
     SqlNode select =
         new SqlSelect(SqlParserPos.ZERO, null, SqlNodeList.SINGLETON_STAR,
-            tableCall, null, null, null, null, null, null, null,
+            tableCall, null, null, null, null, null, null, null, null,
             SqlNodeList.EMPTY);
     return result(select, ImmutableList.of(Clause.SELECT), e, null);
   }
@@ -1179,7 +1230,7 @@ public List<SqlNode> createAsFullOperands(RelDataType rowType, SqlNode leftOpera
   @Override public void addSelect(List<SqlNode> selectList, SqlNode node,
       RelDataType rowType) {
     String name = rowType.getFieldNames().get(selectList.size());
-    String alias = SqlValidatorUtil.getAlias(node, -1);
+    @Nullable String alias = SqlValidatorUtil.alias(node);
     if (alias == null || !alias.equals(name)) {
       node = as(node, name);
     }
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 36cb3050cbf..6af0bd989e2 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
@@ -236,7 +236,7 @@ public abstract Result visitInput(RelNode e, int i, boolean anon,
   public void addSelect(List<SqlNode> selectList, SqlNode node,
       RelDataType rowType) {
     String name = rowType.getFieldNames().get(selectList.size());
-    String alias = SqlValidatorUtil.getAlias(node, -1);
+    @Nullable String alias = SqlValidatorUtil.alias(node);
     if (alias == null || !alias.equals(name)) {
       node = as(node, name);
     }
@@ -389,7 +389,7 @@ public Result result(SqlNode node, Collection<Clause> clauses,
         || aliases instanceof LinkedHashMap
         || aliases instanceof ImmutableMap
         : "must use a Map implementation that preserves order";
-    final String alias2 = SqlValidatorUtil.getAlias(node, -1);
+    final @Nullable String alias2 = SqlValidatorUtil.alias(node);
     final String alias3 = alias2 != null ? alias2 : "t";
     final String alias4 =
         SqlValidatorUtil.uniquify(
@@ -444,7 +444,7 @@ private static RelDataType adjustedRowType(RelNode rel, SqlNode node) {
           rowType.getFieldList(),
           (selectItem, field) ->
               builder.add(
-                  Util.first(SqlValidatorUtil.getAlias(selectItem, -1),
+                  Util.first(SqlValidatorUtil.alias(selectItem),
                       field.getName()),
                   field.getType()));
       return builder.build();
@@ -490,8 +490,7 @@ private static void collectAliases(ImmutableMap.Builder<String, RelDataType> bui
       collectAliases(builder, join.getLeft(),  aliases);
       collectAliases(builder, join.getRight(), aliases);
     } else {
-      final String alias = SqlValidatorUtil.getAlias(node, -1);
-      assert alias != null;
+      final String alias = requireNonNull(SqlValidatorUtil.alias(node), "alias");
       builder.put(alias, aliases.next());
     }
   }
@@ -546,7 +545,7 @@ SqlSelect wrapSelect(SqlNode node) {
       node = as(node, "t");
     }
     return new SqlSelect(POS, SqlNodeList.EMPTY, SqlNodeList.SINGLETON_STAR,
-        node, null, null, null, SqlNodeList.EMPTY, null, null, null, null);
+        node, null, null, null, SqlNodeList.EMPTY, null, null, null, null, null);
   }
 
   /** Returns whether we need to add an alias if this node is to be the FROM
@@ -616,6 +615,13 @@ public SqlNode orderField(int ordinal) {
         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.
+        return SqlLiteral.createExactNumeric(
+            Integer.toString(ordinal + 1), SqlParserPos.ZERO);
+      }
       return node;
     }
 
@@ -793,8 +799,9 @@ private SqlNode callToSql(@Nullable RexProgram program, RexCall call0,
         break;
       }
       if (not) {
-        op = requireNonNull(getInverseOperator(call),
-            () -> "unable to negate " + call.getKind());
+        op =
+            requireNonNull(getInverseOperator(call),
+                () -> "unable to negate " + call.getKind());
       }
       final List<SqlNode> nodeList = toSql(program, call.getOperands());
       switch (call.getKind()) {
@@ -945,9 +952,11 @@ public List<SqlNode> toSql(Window.Group group, ImmutableList<RexLiteral> constan
 
       for (Window.RexWinAggCall winAggCall: group.aggCalls) {
         SqlAggFunction aggFunction = (SqlAggFunction) winAggCall.getOperator();
-        final SqlWindow sqlWindow = SqlWindow.create(null, null,
-                new SqlNodeList(partitionKeys, POS), new SqlNodeList(orderByKeys, POS),
-                isRows, lowerBound, upperBound, allowPartial, POS);
+        final SqlWindow sqlWindow =
+                SqlWindow.create(null, null,
+                    new SqlNodeList(partitionKeys, POS),
+                    new SqlNodeList(orderByKeys, POS),
+                    isRows, lowerBound, upperBound, allowPartial, POS);
         if (aggFunction.allowsFraming()) {
           lowerBound = createSqlWindowBound(group.lowerBound);
           upperBound = createSqlWindowBound(group.upperBound);
@@ -980,8 +989,8 @@ protected Context getAliasContext(RexCorrelVariable variable) {
 
     private SqlCall toSql(@Nullable RexProgram program, RexOver rexOver) {
       final RexWindow rexWindow = rexOver.getWindow();
-      final SqlNodeList partitionList = new SqlNodeList(
-          toSql(program, rexWindow.partitionKeys), POS);
+      final SqlNodeList partitionList =
+          new SqlNodeList(toSql(program, rexWindow.partitionKeys), POS);
 
       List<SqlNode> orderNodes = Expressions.list();
       if (rexWindow.orderKeys != null) {
@@ -1012,8 +1021,9 @@ private SqlCall toSql(@Nullable RexProgram program, RexOver rexOver) {
         upperBound = createSqlWindowBound(rexWindow.getUpperBound());
       }
 
-      final SqlWindow sqlWindow = SqlWindow.create(null, null, partitionList,
-          orderList, isRows, lowerBound, upperBound, allowPartial, POS);
+      final SqlWindow sqlWindow =
+          SqlWindow.create(null, null, partitionList,
+              orderList, isRows, lowerBound, upperBound, allowPartial, POS);
 
       final List<SqlNode> nodeList = toSql(program, rexOver.getOperands());
       return createOverCall(sqlAggregateFunction, nodeList, sqlWindow, rexOver.isDistinct());
@@ -1029,10 +1039,8 @@ private static SqlCall createOverCall(SqlAggFunction op, List<SqlNode> operands,
       }
       SqlCall aggFunctionCall;
       if (isDistinct) {
-        aggFunctionCall = op.createCall(
-            SqlSelectKeyword.DISTINCT.symbol(POS),
-            POS,
-            operands);
+        aggFunctionCall =
+            op.createCall(SqlSelectKeyword.DISTINCT.symbol(POS), POS, operands);
       } else {
         aggFunctionCall = op.createCall(POS, operands);
       }
@@ -1120,9 +1128,9 @@ void addOrderItem(List<SqlNode> orderByList, RelFieldCollation field) {
                 first, field.direction.isDescending());
         if (nullDirectionNode != null) {
           orderByList.add(nullDirectionNode);
-          field = new RelFieldCollation(field.getFieldIndex(),
-              field.getDirection(),
-              RelFieldCollation.NullDirection.UNSPECIFIED);
+          field =
+              new RelFieldCollation(field.getFieldIndex(), field.getDirection(),
+                  RelFieldCollation.NullDirection.UNSPECIFIED);
         }
       }
       orderByList.add(toSql(field));
@@ -1135,9 +1143,10 @@ private void addOrderItem(List<SqlNode> orderByList,
       SqlNode nullDirectionNode = null;
       if (field.getNullDirection() != RelFieldCollation.NullDirection.UNSPECIFIED) {
         final boolean first =
-                  field.getNullDirection() == RelFieldCollation.NullDirection.FIRST;
-        nullDirectionNode = dialect.emulateNullDirection(
-                node, first, field.getDirection().isDescending());
+            field.getNullDirection() == RelFieldCollation.NullDirection.FIRST;
+        nullDirectionNode =
+            dialect.emulateNullDirection(node, first,
+                field.getDirection().isDescending());
       }
       if (nullDirectionNode != null) {
         orderByList.add(nullDirectionNode);
@@ -1165,12 +1174,14 @@ public SqlNode toSql(AggregateCall aggCall) {
     /** Converts a call to an aggregate function, with a given list of operands,
      * to an expression. */
     private SqlCall toSql(SqlOperator op, boolean distinct,
-        List<SqlNode> operandList, int filterArg, RelCollation collation, boolean approximate) {
+        List<SqlNode> operandList, int filterArg, RelCollation collation,
+        boolean approximate) {
       final SqlLiteral qualifier =
           distinct ? SqlSelectKeyword.DISTINCT.symbol(POS) : null;
       if (op instanceof SqlSumEmptyIsZeroAggFunction) {
-        final SqlNode node = toSql(SqlStdOperatorTable.SUM, distinct,
-            operandList, filterArg, collation, approximate);
+        final SqlNode node =
+            toSql(SqlStdOperatorTable.SUM, distinct, operandList, filterArg,
+                collation, approximate);
         return SqlStdOperatorTable.COALESCE.createCall(POS, node, ZERO);
       }
 
@@ -1213,8 +1224,8 @@ private SqlCall toSql(SqlOperator op, boolean distinct,
         call2 = call;
       } else {
         assert dialect.supportsAggregateFunctionFilter(); // we checked above
-        call2 = SqlStdOperatorTable.FILTER.createCall(POS, call,
-            field(filterArg));
+        call2 =
+            SqlStdOperatorTable.FILTER.createCall(POS, call, field(filterArg));
       }
 
       // Handle collation
@@ -1382,8 +1393,10 @@ public static SqlNode toSql(RexLiteral literal) {
     default:
       break;
     }
-    SqlTypeFamily family = requireNonNull(typeName.getFamily(),
-        () -> "literal " + literal + " has null SqlTypeFamily, and is SqlTypeName is " + typeName);
+    SqlTypeFamily family =
+        requireNonNull(typeName.getFamily(),
+            () -> "literal " + literal
+                + " has null SqlTypeFamily, and is SqlTypeName is " + typeName);
     switch (family) {
     case CHARACTER:
       return SqlLiteral.createCharString((String) castNonNull(literal.getValue2()), POS);
@@ -1410,7 +1423,7 @@ public static SqlNode toSql(RexLiteral literal) {
       return SqlLiteral.createTime(castNonNull(literal.getValueAs(TimeString.class)),
           literal.getType().getPrecision(), POS);
     case TIMESTAMP:
-      return SqlLiteral.createTimestamp(
+      return SqlLiteral.createTimestamp(typeName,
           castNonNull(literal.getValueAs(TimestampString.class)),
           literal.getType().getPrecision(), POS);
     case ANY:
@@ -1743,8 +1756,8 @@ private Builder builder(RelNode rel, Set<Clause> clauses) {
               final String name = ((SqlIdentifier) node).getSimple();
               for (Ord<SqlNode> selectItem : Ord.zip(selectList)) {
                 if (selectItem.i != ordinal) {
-                  final String alias =
-                      SqlValidatorUtil.getAlias(selectItem.e, -1);
+                  final @Nullable String alias =
+                      SqlValidatorUtil.alias(selectItem.e);
                   if (name.equalsIgnoreCase(alias)) {
                     return SqlLiteral.createExactNumeric(
                         Integer.toString(ordinal + 1), SqlParserPos.ZERO);
@@ -1810,6 +1823,13 @@ private boolean needNewSubQuery(
         return true;
       }
 
+      if (rel instanceof Project
+          && clauses.contains(Clause.ORDER_BY)
+          && dialect.getConformance().isSortByOrdinal()) {
+        // Cannot merge a Project that contains sort by ordinal under it.
+        return hasSortByOrdinal();
+      }
+
       if (rel instanceof Aggregate) {
         final Aggregate agg = (Aggregate) rel;
         final boolean hasNestedAgg =
@@ -1830,6 +1850,30 @@ private boolean needNewSubQuery(
       return false;
     }
 
+    /**
+     * Return whether the current {@link SqlNode} in {@link Result} contains sort by column
+     * in ordinal format.
+     */
+    private boolean hasSortByOrdinal(@UnknownInitialization Result this) {
+      if (node instanceof SqlSelect) {
+        final SqlNodeList orderList = ((SqlSelect) node).getOrderList();
+        if (orderList == null) {
+          return false;
+        }
+        for (SqlNode sqlNode : orderList) {
+          if (!(sqlNode instanceof SqlBasicCall)) {
+            return false;
+          }
+          for (SqlNode operand : ((SqlBasicCall) sqlNode).getOperandList()) {
+            if (operand instanceof SqlNumericLiteral) {
+              return true;
+            }
+          }
+        }
+      }
+      return false;
+    }
+
     /** Returns whether an {@link Aggregate} contains nested operands that
      * match the predicate.
      *
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/AggregateCaseToFilterRule.java b/core/src/main/java/org/apache/calcite/rel/rules/AggregateCaseToFilterRule.java
index e11e8c512f8..1ebe303a5cb 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/AggregateCaseToFilterRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/AggregateCaseToFilterRule.java
@@ -101,34 +101,18 @@ && isThreeArgCase(project.getProjects().get(singleArg))) {
   @Override public void onMatch(RelOptRuleCall call) {
     final Aggregate aggregate = call.rel(0);
     final Project project = call.rel(1);
-    final RexBuilder rexBuilder = aggregate.getCluster().getRexBuilder();
     final List<AggregateCall> newCalls =
         new ArrayList<>(aggregate.getAggCallList().size());
     final List<RexNode> newProjects = new ArrayList<>(project.getProjects());
-    final List<RexNode> newCasts = new ArrayList<>();
-
-    for (int fieldNumber : aggregate.getGroupSet()) {
-      newCasts.add(
-          rexBuilder.makeInputRef(
-              project.getProjects().get(fieldNumber).getType(), fieldNumber));
-    }
 
     for (AggregateCall aggregateCall : aggregate.getAggCallList()) {
       AggregateCall newCall =
           transform(aggregateCall, project, newProjects);
 
-      // Possibly CAST the new aggregator to an appropriate type.
-      final int i = newCasts.size();
-      final RelDataType oldType =
-          aggregate.getRowType().getFieldList().get(i).getType();
       if (newCall == null) {
         newCalls.add(aggregateCall);
-        newCasts.add(rexBuilder.makeInputRef(oldType, i));
       } else {
         newCalls.add(newCall);
-        newCasts.add(
-            rexBuilder.makeCast(oldType,
-                rexBuilder.makeInputRef(newCall.getType(), i)));
       }
     }
 
@@ -183,8 +167,10 @@ && isThreeArgCase(project.getProjects().get(singleArg))) {
     // latter is present.
     final RexNode filter;
     if (aggregateCall.filterArg >= 0) {
-      filter = rexBuilder.makeCall(SqlStdOperatorTable.AND,
-          project.getProjects().get(aggregateCall.filterArg), filterFromCase);
+      filter =
+          rexBuilder.makeCall(SqlStdOperatorTable.AND,
+              project.getProjects().get(aggregateCall.filterArg),
+              filterFromCase);
     } else {
       filter = filterFromCase;
     }
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/AggregateExpandDistinctAggregatesRule.java b/core/src/main/java/org/apache/calcite/rel/rules/AggregateExpandDistinctAggregatesRule.java
index ae2ce09efba..51e1132ba64 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/AggregateExpandDistinctAggregatesRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/AggregateExpandDistinctAggregatesRule.java
@@ -491,9 +491,10 @@ private static void rewriteUsingGroupingSets(RelOptRuleCall call,
         RexNode expr = relBuilder.equals(nodeZ, relBuilder.literal(v));
         if (distinctFilterArg > -1) {
           // 'AND' the filter of the distinct aggregate call and the group value.
-          expr = relBuilder.and(expr,
-              relBuilder.call(SqlStdOperatorTable.IS_TRUE,
-                  relBuilder.field(distinctFilterArg)));
+          expr =
+              relBuilder.and(expr,
+                  relBuilder.call(SqlStdOperatorTable.IS_TRUE,
+                      relBuilder.field(distinctFilterArg)));
         }
         // "f" means filter.
         nodes.add(
@@ -513,16 +514,18 @@ private static void rewriteUsingGroupingSets(RelOptRuleCall call,
       if (!aggCall.isDistinct()) {
         aggregation = SqlStdOperatorTable.MIN;
         newArgList = ImmutableIntList.of(x++);
-        newFilterArg = requireNonNull(filters.get(Pair.of(groupSet, -1)),
-            "filters.get(Pair.of(groupSet, -1))");
+        newFilterArg =
+            requireNonNull(filters.get(Pair.of(groupSet, -1)),
+                "filters.get(Pair.of(groupSet, -1))");
       } else {
         aggregation = aggCall.getAggregation();
         newArgList = remap(fullGroupSet, aggCall.getArgList());
         final ImmutableBitSet newGroupSet = ImmutableBitSet.of(aggCall.getArgList())
             .setIf(aggCall.filterArg, aggCall.filterArg >= 0)
             .union(groupSet);
-        newFilterArg = requireNonNull(filters.get(Pair.of(newGroupSet, aggCall.filterArg)),
-            "filters.get(of(newGroupSet, aggCall.filterArg))");
+        newFilterArg =
+            requireNonNull(filters.get(Pair.of(newGroupSet, aggCall.filterArg)),
+                "filters.get(of(newGroupSet, aggCall.filterArg))");
       }
       final AggregateCall newCall =
           AggregateCall.create(aggregation, false,
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/AggregateExpandWithinDistinctRule.java b/core/src/main/java/org/apache/calcite/rel/rules/AggregateExpandWithinDistinctRule.java
index f6a8c2ee5ad..10892854898 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/AggregateExpandWithinDistinctRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/AggregateExpandWithinDistinctRule.java
@@ -398,13 +398,15 @@ int getCount(int filterArg) {
             b.equals(
                 b.field(grouping),
                 b.literal(
-                    groupValue(fullGroupList, union(aggregate.getGroupSet(), c.distinctKeys))));
+                    groupValue(fullGroupList,
+                        union(aggregate.getGroupSet(), c.distinctKeys))));
         filters.add(groupFilter);
       }
       RelBuilder.AggCall aggCall;
       if (c.distinctKeys == null) {
-        aggCall = b.aggregateCall(SqlStdOperatorTable.MIN,
-            b.field(registrar.getAgg(i)));
+        aggCall =
+            b.aggregateCall(SqlStdOperatorTable.MIN,
+                b.field(registrar.getAgg(i)));
       } else {
         // The inputs to this aggregate are outputs from MIN() calls from the
         // inner agg, and MIN() returns null iff it has no non-null inputs,
@@ -415,12 +417,13 @@ int getCount(int filterArg) {
         // ignore null inputs, we add a filter based on a COUNT() in the inner
         // aggregate.
         aggCall =
-            b.aggregateCall(
-                c.getAggregation(),
+            b.aggregateCall(c.getAggregation(),
                 b.fields(registrar.fields(c.getArgList(), c.filterArg)));
 
         if (mustBeCounted(c)) {
-          filters.add(b.greaterThan(b.field(registrar.getCount(c.filterArg)), b.literal(0)));
+          filters.add(
+              b.greaterThan(b.field(registrar.getCount(c.filterArg)),
+                  b.literal(0)));
         }
 
         if (config.throwIfNotUnique()) {
@@ -434,7 +437,8 @@ int getCount(int filterArg) {
             }
             String message = "more than one distinct value in agg UNIQUE_VALUE";
             filters.add(
-                b.call(SqlInternalOperators.THROW_UNLESS, isUniqueCondition, b.literal(message)));
+                b.call(SqlInternalOperators.THROW_UNLESS, isUniqueCondition,
+                    b.literal(message)));
           }
         }
       }
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/AggregateFilterTransposeRule.java b/core/src/main/java/org/apache/calcite/rel/rules/AggregateFilterTransposeRule.java
index c253abc67e2..9fe4bcc1942 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/AggregateFilterTransposeRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/AggregateFilterTransposeRule.java
@@ -98,14 +98,14 @@ public AggregateFilterTransposeRule(RelOptRuleOperand operand,
     final Aggregate newAggregate =
         aggregate.copy(aggregate.getTraitSet(), input,
             newGroupSet, null, aggregate.getAggCallList());
-    final Mappings.TargetMapping mapping = Mappings.target(
-        newGroupSet::indexOf,
-        input.getRowType().getFieldCount(),
-        newGroupSet.cardinality());
+    final Mappings.TargetMapping mapping =
+        Mappings.target(newGroupSet::indexOf,
+            input.getRowType().getFieldCount(),
+            newGroupSet.cardinality());
     final RexNode newCondition =
         RexUtil.apply(mapping, filter.getCondition());
-    final Filter newFilter = filter.copy(filter.getTraitSet(),
-        newAggregate, newCondition);
+    final Filter newFilter =
+        filter.copy(filter.getTraitSet(), newAggregate, newCondition);
     if (allColumnsInAggregate && aggregate.getGroupType() == Group.SIMPLE) {
       // Everything needed by the filter is returned by the aggregate.
       assert newGroupSet.equals(aggregate.getGroupSet());
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/AggregateJoinJoinRemoveRule.java b/core/src/main/java/org/apache/calcite/rel/rules/AggregateJoinJoinRemoveRule.java
index 97da6a0c60e..7e524e74075 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/AggregateJoinJoinRemoveRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/AggregateJoinJoinRemoveRule.java
@@ -128,8 +128,8 @@ public AggregateJoinJoinRemoveRule(
 
     int offset = bottomJoin.getRight().getRowType().getFieldCount();
     final RelBuilder relBuilder = call.builder();
-    RexNode condition = RexUtil.shift(topJoin.getCondition(),
-        leftBottomChildSize, -offset);
+    RexNode condition =
+        RexUtil.shift(topJoin.getCondition(), leftBottomChildSize, -offset);
     RelNode join = relBuilder.push(bottomJoin.getLeft())
         .push(topJoin.getRight())
         .join(topJoin.getJoinType(), condition)
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/AggregateJoinRemoveRule.java b/core/src/main/java/org/apache/calcite/rel/rules/AggregateJoinRemoveRule.java
index b052f8d1b14..2440cfbb757 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/AggregateJoinRemoveRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/AggregateJoinRemoveRule.java
@@ -103,9 +103,10 @@ public AggregateJoinRemoveRule(
 
     RelNode node;
     if (isLeftJoin) {
-      node = aggregate.copy(aggregate.getTraitSet(), join.getLeft(),
-          aggregate.getGroupSet(), aggregate.getGroupSets(),
-          aggregate.getAggCallList());
+      node =
+          aggregate.copy(aggregate.getTraitSet(), join.getLeft(),
+              aggregate.getGroupSet(), aggregate.getGroupSets(),
+              aggregate.getAggCallList());
     } else {
       final Map<Integer, Integer> map = new HashMap<>();
       allFields.forEach(index -> map.put(index, index - upper));
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/AggregateJoinTransposeRule.java b/core/src/main/java/org/apache/calcite/rel/rules/AggregateJoinTransposeRule.java
index 509094d1f24..01fd8b74804 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/AggregateJoinTransposeRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/AggregateJoinTransposeRule.java
@@ -171,8 +171,9 @@ private static boolean isJoinSupported(final Join join, final Aggregate aggregat
     // Do the columns used by the join appear in the output of the aggregate?
     final ImmutableBitSet aggregateColumns = aggregate.getGroupSet();
     final RelMetadataQuery mq = call.getMetadataQuery();
-    final ImmutableBitSet keyColumns = keyColumns(aggregateColumns,
-        mq.getPulledUpPredicates(join).pulledUpPredicates);
+    final ImmutableBitSet keyColumns =
+        keyColumns(aggregateColumns,
+            mq.getPulledUpPredicates(join).pulledUpPredicates);
     final ImmutableBitSet joinColumns =
         RelOptUtil.InputFinder.bits(join.getCondition());
     final boolean allColumnsInAggregate =
@@ -230,7 +231,7 @@ private static boolean isJoinSupported(final Join join, final Aggregate aggregat
         // metadata more robust" is fixed) places a heavy load on
         // the metadata system.
         //
-        // So we choose to imagine the the input is already unique, which is
+        // So we choose to imagine the input is already unique, which is
         // untrue but harmless.
         //
         Util.discard(Bug.CALCITE_1048_FIXED);
@@ -254,8 +255,9 @@ private static boolean isJoinSupported(final Join join, final Aggregate aggregat
               aggregation.unwrapOrThrow(SqlSplittableAggFunction.class);
           if (!aggCall.e.getArgList().isEmpty()
               && fieldSet.contains(ImmutableBitSet.of(aggCall.e.getArgList()))) {
-            final RexNode singleton = splitter.singleton(rexBuilder,
-                joinInput.getRowType(), aggCall.e.transform(mapping));
+            final RexNode singleton =
+                splitter.singleton(rexBuilder, joinInput.getRowType(),
+                    aggCall.e.transform(mapping));
 
             if (singleton instanceof RexInputRef) {
               final int index = ((RexInputRef) singleton).getIndex();
@@ -287,8 +289,9 @@ private static boolean isJoinSupported(final Join join, final Aggregate aggregat
           final AggregateCall call1;
           if (fieldSet.contains(ImmutableBitSet.of(aggCall.e.getArgList()))) {
             final AggregateCall splitCall = splitter.split(aggCall.e, mapping);
-            call1 = splitCall.adaptTo(joinInput, splitCall.getArgList(),
-                splitCall.filterArg, oldGroupKeyCount, newGroupKeyCount);
+            call1 =
+                splitCall.adaptTo(joinInput, splitCall.getArgList(),
+                    splitCall.filterArg, oldGroupKeyCount, newGroupKeyCount);
           } else {
             call1 = splitter.other(rexBuilder.getTypeFactory(), aggCall.e);
           }
@@ -315,10 +318,10 @@ private static boolean isJoinSupported(final Join join, final Aggregate aggregat
     }
 
     // Update condition
-    final Mapping mapping = (Mapping) Mappings.target(
-        map::get,
-        join.getRowType().getFieldCount(),
-        belowOffset);
+    final Mapping mapping =
+        (Mapping) Mappings.target(map::get,
+            join.getRowType().getFieldCount(),
+            belowOffset);
     final RexNode newCondition =
         RexUtil.apply(mapping, join.getCondition());
 
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/AggregateProjectConstantToDummyJoinRule.java b/core/src/main/java/org/apache/calcite/rel/rules/AggregateProjectConstantToDummyJoinRule.java
index abfb7f8a84d..72618513327 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/AggregateProjectConstantToDummyJoinRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/AggregateProjectConstantToDummyJoinRule.java
@@ -114,9 +114,8 @@ private AggregateProjectConstantToDummyJoinRule(Config config) {
 
     builder.project(newProjects);
     builder.aggregate(
-        builder.groupKey(
-            aggregate.getGroupSet(), aggregate.getGroupSets()), aggregate.getAggCallList()
-    );
+        builder.groupKey(aggregate.getGroupSet(), aggregate.getGroupSets()),
+        aggregate.getAggCallList());
 
     call.transformTo(builder.build());
   }
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/AggregateProjectPullUpConstantsRule.java b/core/src/main/java/org/apache/calcite/rel/rules/AggregateProjectPullUpConstantsRule.java
index 356286e65fc..b587d83a1af 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/AggregateProjectPullUpConstantsRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/AggregateProjectPullUpConstantsRule.java
@@ -160,7 +160,7 @@ public AggregateProjectPullUpConstantsRule(
           RelDataType originalType =
               aggregate.getRowType().getFieldList().get(projects.size()).getType();
           if (!originalType.equals(rexNode.getType())) {
-            expr = rexBuilder.makeCast(originalType, rexNode, true);
+            expr = rexBuilder.makeCast(originalType, rexNode, true, false);
           } else {
             expr = rexNode;
           }
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/AggregateReduceFunctionsRule.java b/core/src/main/java/org/apache/calcite/rel/rules/AggregateReduceFunctionsRule.java
index 6cdf849be4d..f92b2a74de6 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/AggregateReduceFunctionsRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/AggregateReduceFunctionsRule.java
@@ -436,8 +436,9 @@ private static RexNode reduceAvg(
             oldAggRel.getInput()::fieldIsNullable);
 
     final RelDataTypeFactory typeFactory = oldAggRel.getCluster().getTypeFactory();
-    final RelDataType avgType = typeFactory.createTypeWithNullability(
-        oldCall.getType(), numeratorRef.getType().isNullable());
+    final RelDataType avgType =
+        typeFactory.createTypeWithNullability(oldCall.getType(),
+            numeratorRef.getType().isNullable());
     numeratorRef = rexBuilder.ensureType(avgType, numeratorRef, true);
     final RexNode divideRef =
         rexBuilder.makeCall(SqlStdOperatorTable.DIVIDE, numeratorRef, denominatorRef);
@@ -533,8 +534,8 @@ private static RexNode reduceStddev(
     final RexNode argRef =
         rexBuilder.ensureType(oldCallType, inputExprs.get(argOrdinal), true);
 
-    final RexNode argSquared = rexBuilder.makeCall(SqlStdOperatorTable.MULTIPLY,
-        argRef, argRef);
+    final RexNode argSquared =
+        rexBuilder.makeCall(SqlStdOperatorTable.MULTIPLY, argRef, argRef);
     final int argSquaredOrdinal = lookupOrAdd(inputExprs, argSquared);
 
     final AggregateCall sumArgSquaredAggCall =
@@ -594,8 +595,8 @@ private static RexNode reduceStddev(
             aggCallMapping,
             oldAggRel.getInput()::fieldIsNullable);
 
-    final RexNode div = divide(biased, rexBuilder, sumArgSquared, sumSquaredArg,
-        countArg);
+    final RexNode div =
+        divide(biased, rexBuilder, sumArgSquared, sumSquaredArg, countArg);
 
     final RexNode result;
     if (sqrt) {
@@ -737,35 +738,44 @@ private static RexNode reduceRegrSzz(
     final RexNode argXArgY = rexBuilder.makeCall(SqlStdOperatorTable.MULTIPLY, argX, argY);
     final int argSquaredOrdinal = lookupOrAdd(inputExprs, argXArgY);
 
-    final RexNode argXAndYNotNullFilter = rexBuilder.makeCall(SqlStdOperatorTable.AND,
+    final RexNode argXAndYNotNullFilter =
         rexBuilder.makeCall(SqlStdOperatorTable.AND,
-            rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_NULL, argX),
-            rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_NULL, argY)),
+            rexBuilder.makeCall(SqlStdOperatorTable.AND,
+                rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_NULL, argX),
+                rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_NULL, argY)),
         rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_NULL, argNullFilter));
-    final int argXAndYNotNullFilterOrdinal = lookupOrAdd(inputExprs, argXAndYNotNullFilter);
-    final RexNode sumXY = getSumAggregatedRexNodeWithBinding(
-        oldAggRel, oldCall, newCalls, aggCallMapping, argXArgY.getType(),
-        argSquaredOrdinal, argXAndYNotNullFilterOrdinal);
+    final int argXAndYNotNullFilterOrdinal =
+        lookupOrAdd(inputExprs, argXAndYNotNullFilter);
+    final RexNode sumXY =
+        getSumAggregatedRexNodeWithBinding(oldAggRel, oldCall, newCalls,
+            aggCallMapping, argXArgY.getType(),
+            argSquaredOrdinal, argXAndYNotNullFilterOrdinal);
     final RexNode sumXYCast = rexBuilder.ensureType(oldCallType, sumXY, true);
 
-    final RexNode sumX = getSumAggregatedRexNode(oldAggRel, oldCall,
-        newCalls, aggCallMapping, rexBuilder, xIndex, argXAndYNotNullFilterOrdinal);
+    final RexNode sumX =
+        getSumAggregatedRexNode(oldAggRel, oldCall, newCalls, aggCallMapping,
+            rexBuilder, xIndex, argXAndYNotNullFilterOrdinal);
     final RexNode sumY = xIndex == yIndex
         ? sumX
         : getSumAggregatedRexNode(oldAggRel, oldCall, newCalls,
             aggCallMapping, rexBuilder, yIndex, argXAndYNotNullFilterOrdinal);
 
-    final RexNode sumXSumY = rexBuilder.makeCall(SqlStdOperatorTable.MULTIPLY, sumX, sumY);
+    final RexNode sumXSumY =
+        rexBuilder.makeCall(SqlStdOperatorTable.MULTIPLY, sumX, sumY);
 
-    final RexNode countArg = getRegrCountRexNode(oldAggRel, oldCall, newCalls, aggCallMapping,
-        ImmutableIntList.of(xIndex), argXAndYNotNullFilterOrdinal);
+    final RexNode countArg =
+        getRegrCountRexNode(oldAggRel, oldCall, newCalls, aggCallMapping,
+            ImmutableIntList.of(xIndex), argXAndYNotNullFilterOrdinal);
 
     RexLiteral zero = rexBuilder.makeExactLiteral(BigDecimal.ZERO);
     RexNode nul = rexBuilder.makeNullLiteral(zero.getType());
-    final RexNode avgSumXSumY = rexBuilder.makeCall(SqlStdOperatorTable.CASE,
-        rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, countArg, zero), nul,
+    final RexNode avgSumXSumY =
+        rexBuilder.makeCall(SqlStdOperatorTable.CASE,
+            rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, countArg, zero),
+            nul,
             rexBuilder.makeCall(SqlStdOperatorTable.DIVIDE, sumXSumY, countArg));
-    final RexNode avgSumXSumYCast = rexBuilder.ensureType(oldCallType, avgSumXSumY, true);
+    final RexNode avgSumXSumYCast =
+        rexBuilder.ensureType(oldCallType, avgSumXSumY, true);
     final RexNode result =
         rexBuilder.makeCall(SqlStdOperatorTable.MINUS, sumXYCast, avgSumXSumYCast);
     return rexBuilder.makeCast(oldCall.getType(), result);
@@ -798,28 +808,40 @@ private static RexNode reduceCovariance(
                 || fieldIsNullable.test(argYOrdinal));
     final RexNode argX = rexBuilder.ensureType(oldCallType, inputExprs.get(argXOrdinal), true);
     final RexNode argY = rexBuilder.ensureType(oldCallType, inputExprs.get(argYOrdinal), true);
-    final RexNode argXAndYNotNullFilter = rexBuilder.makeCall(SqlStdOperatorTable.AND,
-        rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_NULL, argX),
-        rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_NULL, argY));
-    final int argXAndYNotNullFilterOrdinal = lookupOrAdd(inputExprs, argXAndYNotNullFilter);
-    final RexNode argXY = rexBuilder.makeCall(SqlStdOperatorTable.MULTIPLY, argX, argY);
+    final RexNode argXAndYNotNullFilter =
+        rexBuilder.makeCall(SqlStdOperatorTable.AND,
+            rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_NULL, argX),
+            rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_NULL, argY));
+    final int argXAndYNotNullFilterOrdinal =
+        lookupOrAdd(inputExprs, argXAndYNotNullFilter);
+    final RexNode argXY =
+        rexBuilder.makeCall(SqlStdOperatorTable.MULTIPLY, argX, argY);
     final int argXYOrdinal = lookupOrAdd(inputExprs, argXY);
-    final RexNode sumXY = getSumAggregatedRexNodeWithBinding(oldAggRel, oldCall, newCalls,
-        aggCallMapping, argXY.getType(), argXYOrdinal, argXAndYNotNullFilterOrdinal);
-    final RexNode sumX = getSumAggregatedRexNode(oldAggRel, oldCall, newCalls,
-        aggCallMapping, rexBuilder, argXOrdinal, argXAndYNotNullFilterOrdinal);
-    final RexNode sumY = getSumAggregatedRexNode(oldAggRel, oldCall, newCalls,
-        aggCallMapping, rexBuilder, argYOrdinal, argXAndYNotNullFilterOrdinal);
-    final RexNode sumXSumY = rexBuilder.makeCall(SqlStdOperatorTable.MULTIPLY, sumX, sumY);
-    final RexNode countArg = getRegrCountRexNode(oldAggRel, oldCall, newCalls, aggCallMapping,
-        ImmutableIntList.of(argXOrdinal, argYOrdinal),
-        argXAndYNotNullFilterOrdinal);
-    final RexNode result = divide(biased, rexBuilder, sumXY, sumXSumY, countArg);
+    final RexNode sumXY =
+        getSumAggregatedRexNodeWithBinding(oldAggRel, oldCall, newCalls,
+            aggCallMapping, argXY.getType(), argXYOrdinal,
+            argXAndYNotNullFilterOrdinal);
+    final RexNode sumX =
+        getSumAggregatedRexNode(oldAggRel, oldCall, newCalls,
+            aggCallMapping, rexBuilder, argXOrdinal,
+            argXAndYNotNullFilterOrdinal);
+    final RexNode sumY =
+        getSumAggregatedRexNode(oldAggRel, oldCall, newCalls,
+            aggCallMapping, rexBuilder, argYOrdinal,
+            argXAndYNotNullFilterOrdinal);
+    final RexNode sumXSumY =
+        rexBuilder.makeCall(SqlStdOperatorTable.MULTIPLY, sumX, sumY);
+    final RexNode countArg =
+        getRegrCountRexNode(oldAggRel, oldCall, newCalls,
+            aggCallMapping, ImmutableIntList.of(argXOrdinal, argYOrdinal),
+            argXAndYNotNullFilterOrdinal);
+    final RexNode result =
+        divide(biased, rexBuilder, sumXY, sumXSumY, countArg);
     return rexBuilder.makeCast(oldCall.getType(), result);
   }
 
-  private static RexNode divide(boolean biased, RexBuilder rexBuilder, RexNode sumXY,
-      RexNode sumXSumY, RexNode countArg) {
+  private static RexNode divide(boolean biased, RexBuilder rexBuilder,
+      RexNode sumXY, RexNode sumXSumY, RexNode countArg) {
     final RexNode avgSumSquaredArg =
          rexBuilder.makeCall(SqlStdOperatorTable.DIVIDE, sumXSumY, countArg);
     final RexNode diff =
@@ -834,8 +856,9 @@ private static RexNode divide(boolean biased, RexBuilder rexBuilder, RexNode sum
           rexBuilder.makeCall(SqlStdOperatorTable.MINUS, countArg, one);
       final RexNode countEqOne =
           rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, countArg, one);
-      denominator = rexBuilder.makeCall(SqlStdOperatorTable.CASE, countEqOne,
-          nul, countMinusOne);
+      denominator =
+          rexBuilder.makeCall(SqlStdOperatorTable.CASE, countEqOne, nul,
+              countMinusOne);
     }
     return rexBuilder.makeCall(SqlStdOperatorTable.DIVIDE, diff, denominator);
   }
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/AggregateStarTableRule.java b/core/src/main/java/org/apache/calcite/rel/rules/AggregateStarTableRule.java
index 1084270744c..3b432da412b 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/AggregateStarTableRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/AggregateStarTableRule.java
@@ -105,8 +105,9 @@ protected void apply(RelOptRuleCall call, @Nullable Project postProject,
     }
     final RelOptCluster cluster = scan.getCluster();
     final RelOptTable table = scan.getTable();
-    final RelOptLattice lattice = requireNonNull(planner.getLattice(table),
-        () -> "planner.getLattice(table) is null for " + table);
+    final RelOptLattice lattice =
+        requireNonNull(planner.getLattice(table),
+            () -> "planner.getLattice(table) is null for " + table);
     final List<Lattice.Measure> measures =
         lattice.lattice.toMeasures(aggregate.getAggCallList());
     final Pair<CalciteSchema.TableEntry, TileKey> pair =
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/AggregateUnionTransposeRule.java b/core/src/main/java/org/apache/calcite/rel/rules/AggregateUnionTransposeRule.java
index 215b12af993..fda5254c20a 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/AggregateUnionTransposeRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/AggregateUnionTransposeRule.java
@@ -172,9 +172,9 @@ public AggregateUnionTransposeRule(Class<? extends Aggregate> aggregateClass,
     //   Union[...]
     //     Aggregate[groupSet=$1, ...]
     ImmutableBitSet groupSet = aggRel.getGroupSet();
-    Mapping topGroupMapping = Mappings.create(MappingType.INVERSE_SURJECTION,
-        union.getRowType().getFieldCount(),
-        aggRel.getGroupCount());
+    Mapping topGroupMapping =
+        Mappings.create(MappingType.INVERSE_SURJECTION,
+            union.getRowType().getFieldCount(), aggRel.getGroupCount());
     for (int i = 0; i < groupSet.cardinality(); i++) {
       topGroupMapping.set(groupSet.nth(i), i);
     }
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/CoreRules.java b/core/src/main/java/org/apache/calcite/rel/rules/CoreRules.java
index 2e7e3198ce8..074bb4f6350 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/CoreRules.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/CoreRules.java
@@ -570,6 +570,11 @@ private CoreRules() {}
       JOIN_PUSH_TRANSITIVE_PREDICATES =
       JoinPushTransitivePredicatesRule.Config.DEFAULT.toRule();
 
+  /** Rule that derives IS NOT NULL predicates from a inner {@link Join} and creates
+   * {@link Filter}s with those predicates as new inputs of the {@link Join}. */
+  public static final JoinDeriveIsNotNullFilterRule JOIN_DERIVE_IS_NOT_NULL_FILTER_RULE =
+      JoinDeriveIsNotNullFilterRule.Config.DEFAULT.toRule();
+
   /** Rule that reduces constants inside a {@link Join}.
    *
    * @see #FILTER_REDUCE_EXPRESSIONS
@@ -579,6 +584,12 @@ private CoreRules() {}
       ReduceExpressionsRule.JoinReduceExpressionsRule.JoinReduceExpressionsRuleConfig
           .DEFAULT.toRule();
 
+  /** Rule that creates a {@link Join#isSemiJoin semi-join} from a
+   * {@link Join}, and it's right keys are unique in its right input.
+   */
+  public static final SemiJoinRule.JoinOnUniqueToSemiJoinRule JOIN_ON_UNIQUE_TO_SEMI_JOIN =
+      SemiJoinRule.JoinOnUniqueToSemiJoinRule.JoinOnUniqueToSemiJoinRuleConfig.DEFAULT.toRule();
+
   /** Rule that converts a {@link LogicalJoin}
    * into a {@link LogicalCorrelate}. */
   public static final JoinToCorrelateRule JOIN_TO_CORRELATE =
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/DateRangeRules.java b/core/src/main/java/org/apache/calcite/rel/rules/DateRangeRules.java
index 36c51f586f7..9c51470f0a7 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/DateRangeRules.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/DateRangeRules.java
@@ -159,9 +159,10 @@ public static RexNode replaceTimeUnits(RexBuilder rexBuilder, RexNode e,
     }
     final Map<RexNode, RangeSet<Calendar>> operandRanges = new HashMap<>();
     for (TimeUnitRange timeUnit : timeUnits) {
-      e = e.accept(
-          new ExtractShuttle(rexBuilder, timeUnit, operandRanges, timeUnits,
-              timeZone));
+      e =
+          e.accept(
+              new ExtractShuttle(rexBuilder, timeUnit, operandRanges, timeUnits,
+                  timeZone));
     }
     return e;
   }
@@ -320,8 +321,9 @@ static class ExtractShuttle extends RexShuttle {
             assert op1 instanceof RexCall;
             final RexCall subCall = (RexCall) op1;
             final RexLiteral flag = (RexLiteral) subCall.operands.get(1);
-            final TimeUnitRange timeUnit = (TimeUnitRange) requireNonNull(flag.getValue(),
-                () -> "timeUnit is null for " + subCall);
+            final TimeUnitRange timeUnit =
+                requireNonNull((TimeUnitRange) flag.getValue(),
+                    () -> "timeUnit is null for " + subCall);
             return compareFloorCeil(call.getKind().reverse(),
                 subCall.getOperands().get(0), (RexLiteral) op0,
                 timeUnit, op1.getKind() == SqlKind.FLOOR);
@@ -345,8 +347,9 @@ static class ExtractShuttle extends RexShuttle {
           if (isFloorCeilCall(op0)) {
             final RexCall subCall = (RexCall) op0;
             final RexLiteral flag = (RexLiteral) subCall.operands.get(1);
-            final TimeUnitRange timeUnit = (TimeUnitRange) requireNonNull(flag.getValue(),
-                () -> "timeUnit is null for " + subCall);
+            final TimeUnitRange timeUnit =
+                requireNonNull((TimeUnitRange) flag.getValue(),
+                    () -> "timeUnit is null for " + subCall);
             return compareFloorCeil(call.getKind(),
                 subCall.getOperands().get(0), (RexLiteral) op1,
                 timeUnit, op0.getKind() == SqlKind.FLOOR);
@@ -414,9 +417,10 @@ private boolean canRewriteExtract(RexNode operand) {
         for (RexNode operand : exprs) {
           RexNode clonedOperand = operand;
           for (TimeUnitRange timeUnit : timeUnitRanges) {
-            clonedOperand = clonedOperand.accept(
-                new ExtractShuttle(rexBuilder, timeUnit, operandRanges,
-                    timeUnitRanges, timeZone));
+            clonedOperand =
+                clonedOperand.accept(
+                    new ExtractShuttle(rexBuilder, timeUnit, operandRanges,
+                        timeUnitRanges, timeZone));
           }
           if ((clonedOperand != operand) && (update != null)) {
             update[0] = true;
@@ -654,8 +658,9 @@ private Calendar timestampValue(RexLiteral timeLiteral) {
                 "timeLiteral.getValueAs(Long.class)"));
       case DATE:
         // Cast date to timestamp with local time zone
-        final DateString d = requireNonNull(timeLiteral.getValueAs(DateString.class),
-            "timeLiteral.getValueAs(DateString.class)");
+        final DateString d =
+            requireNonNull(timeLiteral.getValueAs(DateString.class),
+                "timeLiteral.getValueAs(DateString.class)");
         return Util.calendar(d.getMillisSinceEpoch());
       default:
         throw Util.unexpected(timeLiteral.getTypeName());
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/ExchangeRemoveConstantKeysRule.java b/core/src/main/java/org/apache/calcite/rel/rules/ExchangeRemoveConstantKeysRule.java
index 56dfe157e18..a99b7be85d3 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/ExchangeRemoveConstantKeysRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/ExchangeRemoveConstantKeysRule.java
@@ -95,8 +95,8 @@ private static void matchExchange(ExchangeRemoveConstantKeysRule rule,
       return;
     }
 
-    final List<Integer> distributionKeys = simplifyDistributionKeys(
-        exchange.getDistribution(), constants);
+    final List<Integer> distributionKeys =
+        simplifyDistributionKeys(exchange.getDistribution(), constants);
 
     if (distributionKeys.size() != exchange.getDistribution().getKeys()
         .size()) {
@@ -136,8 +136,8 @@ private static void matchSortExchange(ExchangeRemoveConstantKeysRule rule,
     boolean hashDistribution = sortExchange.getDistribution().getType()
         == RelDistribution.Type.HASH_DISTRIBUTED;
     if (hashDistribution) {
-      distributionKeys = simplifyDistributionKeys(
-          sortExchange.getDistribution(), constants);
+      distributionKeys =
+          simplifyDistributionKeys(sortExchange.getDistribution(), constants);
       distributionSimplified =
           distributionKeys.size() != sortExchange.getDistribution().getKeys()
               .size();
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/FilterJoinRule.java b/core/src/main/java/org/apache/calcite/rel/rules/FilterJoinRule.java
index ea02f82769a..b66c0cd484f 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/FilterJoinRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/FilterJoinRule.java
@@ -27,8 +27,11 @@
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rex.RexBuilder;
 import org.apache.calcite.rex.RexCall;
+import org.apache.calcite.rex.RexInputRef;
 import org.apache.calcite.rex.RexNode;
 import org.apache.calcite.rex.RexUtil;
+import org.apache.calcite.sql.SqlKind;
+import org.apache.calcite.sql.fun.SqlStdOperatorTable;
 import org.apache.calcite.tools.RelBuilder;
 import org.apache.calcite.tools.RelBuilderFactory;
 
@@ -40,7 +43,9 @@
 
 import java.util.ArrayList;
 import java.util.Iterator;
+import java.util.LinkedHashSet;
 import java.util.List;
+import java.util.Set;
 
 import static org.apache.calcite.plan.RelOptUtil.conjunctions;
 
@@ -67,7 +72,7 @@ protected FilterJoinRule(C config) {
 
   protected void perform(RelOptRuleCall call, @Nullable Filter filter,
       Join join) {
-    final List<RexNode> joinFilters =
+    List<RexNode> joinFilters =
         RelOptUtil.conjunctions(join.getCondition());
     final List<RexNode> origJoinFilters = ImmutableList.copyOf(joinFilters);
 
@@ -133,6 +138,10 @@ protected void perform(RelOptRuleCall call, @Nullable Filter filter,
       }
     }
 
+    if (joinType != JoinRelType.FULL) {
+      joinFilters = inferJoinEqualConditions(joinFilters, join);
+    }
+
     // Try to push down filters in ON clause. A ON clause filter can only be
     // pushed down if it does not affect the non-matching set, i.e. it is
     // not on the side which is preserved.
@@ -225,6 +234,135 @@ protected void perform(RelOptRuleCall call, @Nullable Filter filter,
     call.transformTo(relBuilder.build());
   }
 
+  /**
+   * Infers more equal conditions for the join condition.
+   *
+   * <p> For example, in {@code SELECT * FROM T1, T2, T3 WHERE T1.id = T3.id AND T2.id = T3.id},
+   * we can infer {@code T1.id = T2.id} for the first Join node from second Join node's condition:
+   * {@code T1.id = T3.id AND T2.id = T3.id}.
+   *
+   * <p>For the above SQL, the second Join's condition is {@code T1.id = T3.id AND T2.id = T3.id}.
+   * After inference, the final condition would be: {@code T1.id = T2.id AND T1.id = T3.id}, the
+   * {@code T1.id = T2.id} can be further pushed into LHS.
+   *
+   * @param rexNodes the Join condition
+   * @param join the Join node
+   * @return the newly inferred conditions
+   */
+  protected List<RexNode> inferJoinEqualConditions(List<RexNode> rexNodes, Join join) {
+    final List<RexNode> result = new ArrayList<>(rexNodes.size());
+    final List<Set<RexInputRef>> equalSets = splitEqualSets(rexNodes, result);
+
+    boolean needOptimize = false;
+    for (Set<RexInputRef> set : equalSets) {
+      if (set.size() > 2) {
+        needOptimize = true;
+        break;
+      }
+    }
+    if (!needOptimize) {
+      // Keep the conditions unchanged.
+      return rexNodes;
+    }
+
+    result.addAll(constructConditionFromEqualSets(join, equalSets));
+    return result;
+  }
+
+  /**
+   * Splits out the equal sets.
+   *
+   * @param rexNodes the original conditions
+   * @param leftNodes where the conditions not feasible for equal sets are put
+   * @return the equal sets
+   */
+  private static List<Set<RexInputRef>> splitEqualSets(List<RexNode> rexNodes,
+      List<RexNode> leftNodes) {
+    final List<Set<RexInputRef>> equalSets = new ArrayList<>();
+    for (RexNode rexNode : rexNodes) {
+      if (rexNode.isA(SqlKind.EQUALS)) {
+        final RexNode op1 = ((RexCall) rexNode).getOperands().get(0);
+        final RexNode op2 = ((RexCall) rexNode).getOperands().get(1);
+        if (op1 instanceof RexInputRef && op2 instanceof RexInputRef) {
+          final RexInputRef in1 = (RexInputRef) op1;
+          final RexInputRef in2 = (RexInputRef) op2;
+          Set<RexInputRef> set = null;
+          for (Set<RexInputRef> s : equalSets) {
+            if (s.contains(in1) || s.contains(in2)) {
+              set = s;
+              break;
+            }
+          }
+          if (set == null) {
+            // To make the result deterministic.
+            set = new LinkedHashSet<>();
+            equalSets.add(set);
+          }
+          set.add(in1);
+          set.add(in2);
+        } else {
+          leftNodes.add(rexNode);
+        }
+      } else {
+        leftNodes.add(rexNode);
+      }
+    }
+
+    return equalSets;
+  }
+
+  /**
+   * Constructs new equal conditions from the equal sets.
+   *
+   * @param join the original {@link Join} node
+   * @param equalSets the equal sets
+   * @return the newly constructed conditions from equal sets
+   */
+  private static List<RexNode> constructConditionFromEqualSets(Join join,
+      List<Set<RexInputRef>> equalSets) {
+    final RexBuilder rexBuilder = join.getCluster().getRexBuilder();
+    final List<RexNode> result = new ArrayList<>();
+    final int leftFieldCount = join.getLeft().getRowType().getFieldCount();
+    for (Set<RexInputRef> set : equalSets) {
+      final List<RexInputRef> leftSet = new ArrayList<>();
+      final List<RexInputRef> rightSet = new ArrayList<>();
+      for (RexInputRef ref : set) {
+        if (ref.getIndex() < leftFieldCount) {
+          leftSet.add(ref);
+        } else {
+          rightSet.add(ref);
+        }
+      }
+      // Add left side conditions.
+      if (leftSet.size() > 1) {
+        for (int i = 1; i < leftSet.size(); ++i) {
+          result.add(
+              rexBuilder.makeCall(SqlStdOperatorTable.EQUALS,
+                  leftSet.get(0),
+                  leftSet.get(i)));
+        }
+      }
+      // Add right side conditions.
+      if (rightSet.size() > 1) {
+        for (int i = 1; i < rightSet.size(); ++i) {
+          result.add(
+              rexBuilder.makeCall(SqlStdOperatorTable.EQUALS,
+                  rightSet.get(0),
+                  rightSet.get(i)));
+        }
+      }
+      // Only need one equal condition for each equal set.
+      if (leftSet.size() > 0 && rightSet.size() > 0) {
+        result.add(
+            rexBuilder.makeCall(SqlStdOperatorTable.EQUALS,
+                leftSet.get(0),
+                rightSet.get(0)));
+      }
+    }
+
+    return result;
+  }
+
   /**
    * Get conjunctions of filter's condition but with collapsed
    * {@code IS NOT DISTINCT FROM} expressions if needed.
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/FilterMultiJoinMergeRule.java b/core/src/main/java/org/apache/calcite/rel/rules/FilterMultiJoinMergeRule.java
index 6b551d1c803..b3d70b0eca0 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/FilterMultiJoinMergeRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/FilterMultiJoinMergeRule.java
@@ -70,9 +70,8 @@ public FilterMultiJoinMergeRule(Class<? extends Filter> filterClass,
 
     // Create a new post-join filter condition
     // Conditions are nullable, so ImmutableList can't be used here
-    List<@Nullable RexNode> filters = Arrays.asList(
-        filter.getCondition(),
-        multiJoin.getPostJoinFilter());
+    List<@Nullable RexNode> filters =
+        Arrays.asList(filter.getCondition(), multiJoin.getPostJoinFilter());
 
     final RexBuilder rexBuilder = multiJoin.getCluster().getRexBuilder();
     MultiJoin newMultiJoin =
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/FilterProjectTransposeRule.java b/core/src/main/java/org/apache/calcite/rel/rules/FilterProjectTransposeRule.java
index 13665c4809e..5be607f821d 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/FilterProjectTransposeRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/FilterProjectTransposeRule.java
@@ -187,9 +187,10 @@ protected FilterProjectTransposeRule(
     RelNode newProject =
         config.isCopyProject()
             ? project.copy(project.getTraitSet(), newFilterRel,
-                project.getProjects(), project.getRowType())
+            project.getProjects(), project.getRowType())
             : relBuilder.push(newFilterRel)
-                .project(project.getProjects(), project.getRowType().getFieldNames())
+                .project(project.getProjects(), project.getRowType().getFieldNames(), false,
+                    project.getVariablesSet())
                 .build();
 
     call.transformTo(newProject);
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/FilterTableScanRule.java b/core/src/main/java/org/apache/calcite/rel/rules/FilterTableScanRule.java
index fcb85b2c41d..cccbd6ee6e8 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/FilterTableScanRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/FilterTableScanRule.java
@@ -117,8 +117,8 @@ protected void apply(RelOptRuleCall call, Filter filter, TableScan scan) {
       projects = scan.identity();
     }
 
-    final Mapping mapping = Mappings.target(projects,
-        scan.getTable().getRowType().getFieldCount());
+    final Mapping mapping =
+        Mappings.target(projects, scan.getTable().getRowType().getFieldCount());
     filters.add(
         RexUtil.apply(mapping.inverse(), filter.getCondition()));
 
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/JoinDeriveIsNotNullFilterRule.java b/core/src/main/java/org/apache/calcite/rel/rules/JoinDeriveIsNotNullFilterRule.java
new file mode 100644
index 00000000000..bb57f79b3ef
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/rel/rules/JoinDeriveIsNotNullFilterRule.java
@@ -0,0 +1,117 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.rel.rules;
+
+import org.apache.calcite.plan.RelOptRuleCall;
+import org.apache.calcite.plan.RelOptUtil;
+import org.apache.calcite.plan.RelRule;
+import org.apache.calcite.plan.Strong;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.core.Join;
+import org.apache.calcite.rel.core.JoinRelType;
+import org.apache.calcite.rel.logical.LogicalJoin;
+import org.apache.calcite.rel.metadata.RelMetadataQuery;
+import org.apache.calcite.tools.RelBuilder;
+import org.apache.calcite.util.ImmutableBitSet;
+
+import com.google.common.collect.ImmutableList;
+
+import org.immutables.value.Value;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/**
+ * Planner rule that derives IS NOT NULL predicates from a inner
+ * {@link org.apache.calcite.rel.core.Join} and creates
+ * {@link org.apache.calcite.rel.core.Filter}s with those predicates as new inputs of the join.
+ *
+ * Since the Null value can never match in the inner join and it can lead to skewness due to
+ * too many Null values, a not-null filter can be created and pushed down into the input of join.
+ *
+ * Similar to {@link CoreRules#FILTER_INTO_JOIN}, it would try to create filters and push them into
+ * the inputs of the join to filter data as much as possible before join.
+ *
+ */
+@Value.Enclosing
+public class JoinDeriveIsNotNullFilterRule
+    extends RelRule<JoinDeriveIsNotNullFilterRule.Config> implements TransformationRule {
+
+  public JoinDeriveIsNotNullFilterRule(Config config) {
+    super(config);
+  }
+
+  @Override public void onMatch(RelOptRuleCall call) {
+    final Join join = call.rel(0);
+    final RelBuilder relBuilder = call.builder();
+    final RelMetadataQuery mq = call.getMetadataQuery();
+
+    final ImmutableBitSet.Builder notNullableKeys = ImmutableBitSet.builder();
+    RelOptUtil.conjunctions(join.getCondition()).forEach(node -> {
+      if (Strong.isStrong(node)) {
+        notNullableKeys.addAll(RelOptUtil.InputFinder.bits(node));
+      }
+    });
+    final List<Integer> leftKeys = new ArrayList<>();
+    final List<Integer> rightKeys = new ArrayList<>();
+
+    final int offset = join.getLeft().getRowType().getFieldCount();
+    notNullableKeys.build().asList().forEach(i -> {
+      if (i < offset) {
+        leftKeys.add(i);
+      } else {
+        rightKeys.add(i - offset);
+      }
+    });
+
+    relBuilder.push(join.getLeft())
+        .withPredicates(mq, r ->
+            r.filter(leftKeys.stream().map(r::field).map(r::isNotNull)
+                .collect(Collectors.toList())));
+    final RelNode newLeft = relBuilder.build();
+
+    relBuilder.push(join.getRight())
+        .withPredicates(mq, r ->
+            r.filter(rightKeys.stream().map(r::field).map(r::isNotNull)
+                .collect(Collectors.toList())));
+    final RelNode newRight = relBuilder.build();
+
+    if (newLeft != join.getLeft() || newRight != join.getRight()) {
+      final RelNode newJoin =
+          join.copy(join.getTraitSet(), ImmutableList.of(newLeft, newRight));
+      call.transformTo(newJoin);
+    }
+  }
+
+  /**
+   * Rule configuration.
+   */
+  @Value.Immutable public interface Config extends RelRule.Config {
+    ImmutableJoinDeriveIsNotNullFilterRule.Config DEFAULT =
+        ImmutableJoinDeriveIsNotNullFilterRule.Config
+        .of().withOperandSupplier(
+            b -> b.operand(LogicalJoin.class).predicate(
+                join -> join.getJoinType() == JoinRelType.INNER
+                    && !join.getCondition().isAlwaysTrue())
+            .anyInputs());
+
+    @Override default JoinDeriveIsNotNullFilterRule toRule() {
+      return new JoinDeriveIsNotNullFilterRule(this);
+    }
+  }
+}
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/JoinProjectTransposeRule.java b/core/src/main/java/org/apache/calcite/rel/rules/JoinProjectTransposeRule.java
index c7460e70162..6902a5ef805 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/JoinProjectTransposeRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/JoinProjectTransposeRule.java
@@ -357,12 +357,10 @@ protected void createProjectExprs(
         RexNode e = pair.left;
         if (adjustmentAmount != 0) {
           // shift the references by the adjustment amount
-          e = e.accept(
-              new RelOptUtil.RexInputConverter(
-                  rexBuilder,
-                  childFields,
-                  joinChildrenFields,
-                  adjustments));
+          e =
+              e.accept(
+                  new RelOptUtil.RexInputConverter(rexBuilder, childFields,
+                      joinChildrenFields, adjustments));
         }
         projects.add(Pair.of(e, pair.right));
       }
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/JoinPushTransitivePredicatesRule.java b/core/src/main/java/org/apache/calcite/rel/rules/JoinPushTransitivePredicatesRule.java
index f1ed025c32c..b112e1d9d62 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/JoinPushTransitivePredicatesRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/JoinPushTransitivePredicatesRule.java
@@ -97,8 +97,9 @@ public JoinPushTransitivePredicatesRule(Class<? extends Join> joinClass,
       call.getPlanner().onCopy(curr, right);
     }
 
-    RelNode newRel = join.copy(join.getTraitSet(), join.getCondition(),
-        left, right, join.getJoinType(), join.isSemiJoinDone());
+    RelNode newRel =
+        join.copy(join.getTraitSet(), join.getCondition(), left, right,
+            join.getJoinType(), join.isSemiJoinDone());
     call.getPlanner().onCopy(join, newRel);
 
     call.transformTo(newRel);
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/JoinToMultiJoinRule.java b/core/src/main/java/org/apache/calcite/rel/rules/JoinToMultiJoinRule.java
index f06593511fa..4504e0ceabb 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/JoinToMultiJoinRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/JoinToMultiJoinRule.java
@@ -518,8 +518,9 @@ private static ImmutableMap<Integer, ImmutableIntList> addOnJoinFieldRefCounts(
             multiJoinInputs.get(currInput).getRowType().getFieldCount();
       }
       final int key = currInput;
-      int[] refCounts = requireNonNull(refCountsMap.get(key),
-          () -> "refCountsMap.get(currInput) for " + key);
+      int[] refCounts =
+          requireNonNull(refCountsMap.get(key),
+              () -> "refCountsMap.get(currInput) for " + key);
       refCounts[i - startField] += joinCondRefCounts[i];
     }
 
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/LoptMultiJoin.java b/core/src/main/java/org/apache/calcite/rel/rules/LoptMultiJoin.java
index ed0c28db0c4..4182a120cb2 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/LoptMultiJoin.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/LoptMultiJoin.java
@@ -807,9 +807,10 @@ public boolean isRightFactorInRemovableSelfJoin(int factIdx) {
    * such a column mapping exists; otherwise, null is returned
    */
   public @Nullable Integer getRightColumnMapping(int rightFactor, int rightOffset) {
-    RemovableSelfJoin selfJoin = requireNonNull(removableSelfJoinPairs.get(rightFactor),
-        () -> "removableSelfJoinPairs.get(rightFactor) is null for " + rightFactor
-            + ", map=" + removableSelfJoinPairs);
+    RemovableSelfJoin selfJoin =
+        requireNonNull(removableSelfJoinPairs.get(rightFactor),
+            () -> "removableSelfJoinPairs.get(rightFactor) is null for "
+                + rightFactor + ", map=" + removableSelfJoinPairs);
     assert selfJoin.rightFactor == rightFactor;
     return selfJoin.columnMapping.get(rightOffset);
   }
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/LoptOptimizeJoinRule.java b/core/src/main/java/org/apache/calcite/rel/rules/LoptOptimizeJoinRule.java
index 8aebddb79f6..0ae3e76e583 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/LoptOptimizeJoinRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/LoptOptimizeJoinRule.java
@@ -535,8 +535,9 @@ private static RelNode createTopProject(
       for (int fieldPos = 0;
           fieldPos < multiJoin.getNumFieldsInJoinFactor(currFactor);
           fieldPos++) {
-        int newOffset = requireNonNull(factorToOffsetMap.get(currFactor),
-            () -> "factorToOffsetMap.get(currFactor)") + fieldPos;
+        int newOffset =
+            requireNonNull(factorToOffsetMap.get(currFactor),
+                "factorToOffsetMap.get(currFactor)") + fieldPos;
         if (leftFactor != null) {
           Integer leftOffset =
               multiJoin.getRightColumnMapping(currFactor, fieldPos);
@@ -785,7 +786,7 @@ private static int getBestNextFactor(
     int [][] factorWeights = multiJoin.getFactorWeights();
     for (int factor : BitSets.toIter(factorsToAdd)) {
       // if the factor corresponds to a dimension table whose
-      // join we can remove, make sure the the corresponding fact
+      // join we can remove, make sure the corresponding fact
       // table is in the current join tree
       Integer factIdx = multiJoin.getJoinRemovalFactor(factor);
       if (factIdx != null) {
@@ -1070,8 +1071,10 @@ private static int rowWidthCost(RelNode tree) {
     // half of the self-join.
     if (selfJoin) {
       BitSet selfJoinFactor = new BitSet(multiJoin.getNumJoinFactors());
-      Integer factor = requireNonNull(multiJoin.getOtherSelfJoinFactor(factorToAdd),
-          () -> "multiJoin.getOtherSelfJoinFactor(" + factorToAdd + ") is null");
+      Integer factor =
+          requireNonNull(multiJoin.getOtherSelfJoinFactor(factorToAdd),
+              () -> "multiJoin.getOtherSelfJoinFactor(" + factorToAdd
+                  + ") is null");
       selfJoinFactor.set(factor);
       if (multiJoin.hasAllFactors(left, selfJoinFactor)) {
         childNo = 0;
@@ -1233,8 +1236,9 @@ private static int rowWidthCost(RelNode tree) {
     // outer join condition
     RexNode condition;
     if ((joinType == JoinRelType.LEFT) || (joinType == JoinRelType.RIGHT)) {
-      condition = requireNonNull(multiJoin.getOuterJoinCond(factorToAdd),
-          "multiJoin.getOuterJoinCond(factorToAdd)");
+      condition =
+          requireNonNull(multiJoin.getOuterJoinCond(factorToAdd),
+              "multiJoin.getOuterJoinCond(factorToAdd)");
     } else {
       condition =
           addFilters(
@@ -1570,8 +1574,10 @@ private static boolean remapJoinReferences(
       return null;
     }
 
-    int factIdx = requireNonNull(multiJoin.getJoinRemovalFactor(dimIdx),
-        () -> "multiJoin.getJoinRemovalFactor(dimIdx) for " + dimIdx + ", " + multiJoin);
+    int factIdx =
+        requireNonNull(multiJoin.getJoinRemovalFactor(dimIdx),
+            () -> "multiJoin.getJoinRemovalFactor(dimIdx) for " + dimIdx
+                + ", " + multiJoin);
     final List<Integer> joinOrder = factTree.getTreeOrder();
     assert joinOrder.contains(factIdx);
 
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/LoptSemiJoinOptimizer.java b/core/src/main/java/org/apache/calcite/rel/rules/LoptSemiJoinOptimizer.java
index ce9c5c8e326..0ddebb8ac46 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/LoptSemiJoinOptimizer.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/LoptSemiJoinOptimizer.java
@@ -576,16 +576,16 @@ public boolean chooseBestSemiJoin(LoptMultiJoin multiJoin) {
         }
       }
 
-      // if a suitable dimension table has been found, associate it
+      // If a suitable dimension table has been found, associate it
       // with the fact table in the chosenSemiJoins array; also remove
-      // the entry from possibleSemiJoins so we won't chose it again;
-      // note that we create the SemiJoin using the chosen semijoins
+      // the entry from possibleSemiJoins, so we won't choose it again;
+      // note that we create the SemiJoin using the chosen semi-joins
       // already created for each factor so any chaining of filters will
-      // be accounted for
+      // be accounted for.
       if (bestDimIdx != -1) {
-        int bestDimIdxFinal = bestDimIdx;
-        LogicalJoin semiJoin = requireNonNull(possibleDimensions.get(bestDimIdxFinal),
-            () -> "possibleDimensions.get(" + bestDimIdxFinal + ") is null");
+        LogicalJoin semiJoin =
+            requireNonNull(possibleDimensions.get(bestDimIdx),
+                "possibleDimensions.get(bestDimIdx)");
         LogicalJoin chosenSemiJoin =
             LogicalJoin.create(factRel,
                 chosenSemiJoins[bestDimIdx],
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/MatchRule.java b/core/src/main/java/org/apache/calcite/rel/rules/MatchRule.java
index e6eb70c6c3b..4557590a7ab 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/MatchRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/MatchRule.java
@@ -43,13 +43,14 @@ protected MatchRule(Config config) {
 
   @Override public void onMatch(RelOptRuleCall call) {
     final LogicalMatch oldRel = call.rel(0);
-    final RelNode match = LogicalMatch.create(oldRel.getCluster(),
-        oldRel.getTraitSet(), oldRel.getInput(), oldRel.getRowType(),
-        oldRel.getPattern(), oldRel.isStrictStart(), oldRel.isStrictEnd(),
-        oldRel.getPatternDefinitions(), oldRel.getMeasures(),
-        oldRel.getAfter(), oldRel.getSubsets(), oldRel.isAllRows(),
-        oldRel.getPartitionKeys(), oldRel.getOrderKeys(),
-        oldRel.getInterval());
+    final RelNode match =
+        LogicalMatch.create(oldRel.getCluster(), oldRel.getTraitSet(),
+            oldRel.getInput(), oldRel.getRowType(),
+            oldRel.getPattern(), oldRel.isStrictStart(), oldRel.isStrictEnd(),
+            oldRel.getPatternDefinitions(), oldRel.getMeasures(),
+            oldRel.getAfter(), oldRel.getSubsets(), oldRel.isAllRows(),
+            oldRel.getPartitionKeys(), oldRel.getOrderKeys(),
+            oldRel.getInterval());
     call.transformTo(match);
   }
 
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/MaterializedViewFilterScanRule.java b/core/src/main/java/org/apache/calcite/rel/rules/MaterializedViewFilterScanRule.java
index a11ee95430c..d856b52952e 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/MaterializedViewFilterScanRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/MaterializedViewFilterScanRule.java
@@ -84,8 +84,8 @@ protected void apply(RelOptRuleCall call, Filter filter, TableScan scan) {
     final List<RelOptMaterialization> materializations =
         planner.getMaterializations();
     if (!materializations.isEmpty()) {
-      RelNode root = filter.copy(filter.getTraitSet(),
-          Collections.singletonList(scan));
+      RelNode root =
+          filter.copy(filter.getTraitSet(), Collections.singletonList(scan));
       List<RelOptMaterialization> applicableMaterializations =
           RelOptMaterializations.getApplicableMaterializations(root, materializations);
       for (RelOptMaterialization materialization : applicableMaterializations) {
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/ProjectAggregateMergeRule.java b/core/src/main/java/org/apache/calcite/rel/rules/ProjectAggregateMergeRule.java
index 100b09b9fb0..11af131f4cd 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/ProjectAggregateMergeRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/ProjectAggregateMergeRule.java
@@ -104,20 +104,21 @@ && kindCount(project.getProjects(), SqlKind.CASE) == 0) {
             final RexInputRef ref0 = (RexInputRef) isNotNull.operands.get(0);
             final RexCall cast = (RexCall) operands.get(1);
             final RexInputRef ref1 = (RexInputRef) cast.operands.get(0);
+            if (ref0.getIndex() != ref1.getIndex()) {
+              break;
+            }
+            final int aggCallIndex = ref1.getIndex() - aggregate.getGroupCount();
+            if (aggCallIndex < 0) {
+              break;
+            }
+            final AggregateCall aggCall = aggregate.getAggCallList().get(aggCallIndex);
+            if (aggCall.getAggregation().getKind() != SqlKind.SUM) {
+              break;
+            }
             final RexLiteral literal = (RexLiteral) operands.get(2);
-            if (ref0.getIndex() == ref1.getIndex()
-                && Objects.equals(literal.getValueAs(BigDecimal.class), BigDecimal.ZERO)) {
-              final int aggCallIndex =
-                  ref1.getIndex() - aggregate.getGroupCount();
-              if (aggCallIndex >= 0) {
-                final AggregateCall aggCall =
-                    aggregate.getAggCallList().get(aggCallIndex);
-                if (aggCall.getAggregation().getKind() == SqlKind.SUM) {
-                  int j =
-                      findSum0(cluster.getTypeFactory(), aggCall, aggCallList);
-                  return cluster.getRexBuilder().makeInputRef(call.type, j);
-                }
-              }
+            if (Objects.equals(literal.getValueAs(BigDecimal.class), BigDecimal.ZERO)) {
+              int j = findSum0(cluster.getTypeFactory(), aggCall, aggCallList);
+              return cluster.getRexBuilder().makeInputRef(call.type, j);
             }
           }
           break;
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/ProjectCorrelateTransposeRule.java b/core/src/main/java/org/apache/calcite/rel/rules/ProjectCorrelateTransposeRule.java
index ad293bcc85a..b80afeeb5a9 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/ProjectCorrelateTransposeRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/ProjectCorrelateTransposeRule.java
@@ -118,10 +118,11 @@ public ProjectCorrelateTransposeRule(
             correlationId);
 
     // updates RexCorrelVariable and sets actual RelDataType for RexFieldAccess
-    rightProject = rightProject.accept(
-        new RelNodesExprsHandler(
-            new RexFieldAccessReplacer(correlate.getCorrelationId(),
-                rexCorrel, rexBuilder, requiredColsMap)));
+    rightProject =
+        rightProject.accept(
+            new RelNodesExprsHandler(
+                new RexFieldAccessReplacer(correlate.getCorrelationId(),
+                    rexCorrel, rexBuilder, requiredColsMap)));
 
     // create a new correlate with the projected children
     final Correlate newCorrelate =
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/ProjectJoinJoinRemoveRule.java b/core/src/main/java/org/apache/calcite/rel/rules/ProjectJoinJoinRemoveRule.java
index 870ebe697ff..e59641ff067 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/ProjectJoinJoinRemoveRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/ProjectJoinJoinRemoveRule.java
@@ -127,12 +127,13 @@ public ProjectJoinJoinRemoveRule(
     int offset = bottomJoin.getRight().getRowType().getFieldCount();
     final RelBuilder relBuilder = call.builder();
 
-    final RexNode condition = RexUtil.shift(topJoin.getCondition(),
-        leftBottomChildSize, -offset);
-    final RelNode join = relBuilder.push(bottomJoin.getLeft())
-        .push(topJoin.getRight())
-        .join(topJoin.getJoinType(), condition)
-        .build();
+    final RexNode condition =
+        RexUtil.shift(topJoin.getCondition(), leftBottomChildSize, -offset);
+    final RelNode join =
+        relBuilder.push(bottomJoin.getLeft())
+            .push(topJoin.getRight())
+            .join(topJoin.getJoinType(), condition)
+            .build();
 
     final List<RexNode> newExprs = project.getProjects().stream()
         .map(expr -> RexUtil.shift(expr, leftBottomChildSize, -offset))
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/ProjectJoinRemoveRule.java b/core/src/main/java/org/apache/calcite/rel/rules/ProjectJoinRemoveRule.java
index 5ecd6ccdfee..33b4a92e4c2 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/ProjectJoinRemoveRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/ProjectJoinRemoveRule.java
@@ -120,8 +120,9 @@ public ProjectJoinRemoveRule(
       final List<RexNode> newExprs = project.getProjects().stream()
           .map(expr -> RexUtil.shift(expr, -offset))
           .collect(Collectors.toList());
-      node = project.copy(project.getTraitSet(), join.getRight(), newExprs,
-          project.getRowType());
+      node =
+          project.copy(project.getTraitSet(), join.getRight(), newExprs,
+              project.getRowType());
     }
     call.transformTo(node);
   }
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/ProjectJoinTransposeRule.java b/core/src/main/java/org/apache/calcite/rel/rules/ProjectJoinTransposeRule.java
index 8260e6293d1..d04b0ef0925 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/ProjectJoinTransposeRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/ProjectJoinTransposeRule.java
@@ -24,11 +24,13 @@
 import org.apache.calcite.rel.core.Project;
 import org.apache.calcite.rel.logical.LogicalJoin;
 import org.apache.calcite.rel.logical.LogicalProject;
+import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeField;
 import org.apache.calcite.rex.RexCall;
 import org.apache.calcite.rex.RexNode;
 import org.apache.calcite.rex.RexOver;
 import org.apache.calcite.rex.RexShuttle;
+import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.tools.RelBuilderFactory;
 
 import org.immutables.value.Value;
@@ -157,7 +159,24 @@ public ProjectJoinTransposeRule(
   @Value.Immutable(singleton = false)
   public interface Config extends RelRule.Config {
     Config DEFAULT = ImmutableProjectJoinTransposeRule.Config.builder()
-        .withPreserveExprCondition(expr -> !(expr instanceof RexOver))
+        .withPreserveExprCondition(expr -> {
+          // Do not push down over's expression by default
+          if (expr instanceof RexOver) {
+            return false;
+          }
+          if (SqlKind.CAST == expr.getKind()) {
+            final RelDataType relType = expr.getType();
+            final RexCall castCall = (RexCall) expr;
+            final RelDataType operand0Type = castCall.getOperands().get(0).getType();
+            if (relType.getSqlTypeName() == operand0Type.getSqlTypeName()
+                && operand0Type.isNullable() && !relType.isNullable()) {
+              // Do not push down not nullable cast's expression with the same type by default
+              // eg: CAST($1):VARCHAR(10) NOT NULL, and type of $1 is nullable VARCHAR(10)
+              return false;
+            }
+          }
+          return true;
+        })
         .build()
         .withOperandFor(LogicalProject.class, LogicalJoin.class);
 
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/ProjectRemoveRule.java b/core/src/main/java/org/apache/calcite/rel/rules/ProjectRemoveRule.java
index 67df2031622..b298f4a48cc 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/ProjectRemoveRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/ProjectRemoveRule.java
@@ -62,9 +62,10 @@ public ProjectRemoveRule(RelBuilderFactory relBuilderFactory) {
     if (stripped instanceof Project) {
       // Rename columns of child projection if desired field names are given.
       Project childProject = (Project) stripped;
-      stripped = childProject.copy(childProject.getTraitSet(),
-          childProject.getInput(), childProject.getProjects(),
-          project.getRowType());
+      stripped =
+          childProject.copy(childProject.getTraitSet(),
+              childProject.getInput(), childProject.getProjects(),
+              project.getRowType());
     }
     stripped = convert(stripped, project.getConvention());
     call.transformTo(stripped);
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/ProjectTableScanRule.java b/core/src/main/java/org/apache/calcite/rel/rules/ProjectTableScanRule.java
index eef5e27a232..9257bbe98c8 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/ProjectTableScanRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/ProjectTableScanRule.java
@@ -128,8 +128,9 @@ protected void apply(RelOptRuleCall call, Project project, TableScan scan) {
       filtersPushDown = ImmutableList.of();
       projectsPushDown = selectedColumns;
     }
-    Bindables.BindableTableScan newScan = Bindables.BindableTableScan.create(
-        scan.getCluster(), scan.getTable(), filtersPushDown, projectsPushDown);
+    Bindables.BindableTableScan newScan =
+        Bindables.BindableTableScan.create(scan.getCluster(), scan.getTable(),
+            filtersPushDown, projectsPushDown);
     Mapping mapping =
         Mappings.target(selectedColumns, scan.getRowType().getFieldCount());
     final List<RexNode> newProjectRexNodes =
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/ProjectToWindowRule.java b/core/src/main/java/org/apache/calcite/rel/rules/ProjectToWindowRule.java
index 0ed9d2d2065..c70ab6b03c9 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/ProjectToWindowRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/ProjectToWindowRule.java
@@ -156,34 +156,36 @@ public ProjectToLogicalProjectAndWindowRule(
               project.getCluster().getRexBuilder());
       // temporary LogicalCalc, never registered
       final LogicalCalc calc = LogicalCalc.create(input, program);
-      final CalcRelSplitter transform = new WindowedAggRelSplitter(calc,
-          call.builder()) {
-        @Override protected RelNode handle(RelNode rel) {
-          if (!(rel instanceof LogicalCalc)) {
-            return rel;
-          }
-          final LogicalCalc calc = (LogicalCalc) rel;
-          final RexProgram program = calc.getProgram();
-          relBuilder.push(calc.getInput());
-          if (program.getCondition() != null) {
-            relBuilder.filter(
-                program.expandLocalRef(program.getCondition()));
-          }
-          if (!program.projectsOnlyIdentity()) {
-            relBuilder.project(
-                Util.transform(program.getProjectList(), program::expandLocalRef),
-                calc.getRowType().getFieldNames());
-          }
-          return relBuilder.build();
-        }
-      };
+      final CalcRelSplitter transform =
+          new WindowedAggRelSplitter(calc, call.builder()) {
+            @Override protected RelNode handle(RelNode rel) {
+              if (!(rel instanceof LogicalCalc)) {
+                return rel;
+              }
+              final LogicalCalc calc = (LogicalCalc) rel;
+              final RexProgram program = calc.getProgram();
+              relBuilder.push(calc.getInput());
+              if (program.getCondition() != null) {
+                relBuilder.filter(
+                    program.expandLocalRef(program.getCondition()));
+              }
+              if (!program.projectsOnlyIdentity()) {
+                relBuilder.project(
+                    Util.transform(program.getProjectList(),
+                        program::expandLocalRef),
+                    calc.getRowType().getFieldNames());
+              }
+              return relBuilder.build();
+            }
+          };
       RelNode newRel = transform.execute();
       call.transformTo(newRel);
     }
 
     /** Rule configuration. */
     @Value.Immutable
-    public interface ProjectToLogicalProjectAndWindowRuleConfig extends ProjectToWindowRule.Config {
+    public interface ProjectToLogicalProjectAndWindowRuleConfig
+        extends ProjectToWindowRule.Config {
       ProjectToLogicalProjectAndWindowRuleConfig DEFAULT =
           ImmutableProjectToLogicalProjectAndWindowRuleConfig.of()
               .withOperandSupplier(b ->
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/ProjectWindowTransposeRule.java b/core/src/main/java/org/apache/calcite/rel/rules/ProjectWindowTransposeRule.java
index 761dd1df705..385e2dbba44 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/ProjectWindowTransposeRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/ProjectWindowTransposeRule.java
@@ -37,6 +37,7 @@
 import org.apache.calcite.util.ImmutableBitSet;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
 
 import org.immutables.value.Value;
 
@@ -79,13 +80,13 @@ public ProjectWindowTransposeRule(RelBuilderFactory relBuilderFactory) {
     // (Note that the constants used in LogicalWindow are not considered here)
     final ImmutableBitSet beReferred = findReference(project, window);
 
-    // If all the the window input columns are referred,
+    // If all the window input columns are referred,
     // it is impossible to trim anyone of them out
     if (beReferred.cardinality() == windowInputColumn) {
       return;
     }
 
-    // Put a DrillProjectRel below LogicalWindow
+    // Put a Project below LogicalWindow
     final List<RexNode> exps = new ArrayList<>();
     final RelDataTypeFactory.Builder builder =
         cluster.getTypeFactory().builder();
@@ -99,7 +100,7 @@ public ProjectWindowTransposeRule(RelBuilderFactory relBuilderFactory) {
 
     final LogicalProject projectBelowWindow =
         new LogicalProject(cluster, window.getTraitSet(), ImmutableList.of(),
-            window.getInput(), exps, builder.build());
+            window.getInput(), exps, builder.build(), ImmutableSet.of());
 
     // Create a new LogicalWindow with necessary inputs only
     final List<Window.Group> groups = new ArrayList<>();
@@ -172,17 +173,15 @@ public ProjectWindowTransposeRule(RelBuilderFactory relBuilderFactory) {
 
     final LogicalWindow newLogicalWindow =
         LogicalWindow.create(window.getTraitSet(), projectBelowWindow,
-        window.constants, outputBuilder.build(), groups);
+            window.constants, outputBuilder.build(), groups);
 
     // Modify the top LogicalProject
     final List<RexNode> topProjExps =
         indexAdjustment.visitList(project.getProjects());
 
-    final Project newTopProj = project.copy(
-        newLogicalWindow.getTraitSet(),
-        newLogicalWindow,
-        topProjExps,
-        project.getRowType());
+    final Project newTopProj =
+        project.copy(newLogicalWindow.getTraitSet(), newLogicalWindow,
+            topProjExps, project.getRowType());
 
     if (ProjectRemoveRule.isTrivial(newTopProj)) {
       call.transformTo(newLogicalWindow);
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/PruneEmptyRules.java b/core/src/main/java/org/apache/calcite/rel/rules/PruneEmptyRules.java
index 57b34dd3681..acfafc12241 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/PruneEmptyRules.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/PruneEmptyRules.java
@@ -27,14 +27,15 @@
 import org.apache.calcite.rel.SingleRel;
 import org.apache.calcite.rel.core.Aggregate;
 import org.apache.calcite.rel.core.Filter;
+import org.apache.calcite.rel.core.Intersect;
 import org.apache.calcite.rel.core.Join;
 import org.apache.calcite.rel.core.JoinRelType;
+import org.apache.calcite.rel.core.Minus;
 import org.apache.calcite.rel.core.Project;
 import org.apache.calcite.rel.core.Sort;
+import org.apache.calcite.rel.core.TableScan;
+import org.apache.calcite.rel.core.Union;
 import org.apache.calcite.rel.core.Values;
-import org.apache.calcite.rel.logical.LogicalIntersect;
-import org.apache.calcite.rel.logical.LogicalMinus;
-import org.apache.calcite.rel.logical.LogicalUnion;
 import org.apache.calcite.rel.logical.LogicalValues;
 import org.apache.calcite.rex.RexDynamicParam;
 import org.apache.calcite.rex.RexLiteral;
@@ -47,6 +48,8 @@
 import java.util.List;
 import java.util.function.Predicate;
 
+import static com.google.common.collect.Iterables.concat;
+
 /**
  * Collection of rules which remove sections of a query plan known never to
  * produce any rows.
@@ -81,7 +84,7 @@ public interface Config extends RelRule.Config {
 
   /**
    * Rule that removes empty children of a
-   * {@link org.apache.calcite.rel.logical.LogicalUnion}.
+   * {@link org.apache.calcite.rel.core.Union}.
    *
    * <p>Examples:
    *
@@ -91,19 +94,12 @@ public interface Config extends RelRule.Config {
    * <li>Union(Empty, Empty) becomes Empty
    * </ul>
    */
-  public static final RelOptRule UNION_INSTANCE =
-      ImmutableUnionEmptyPruneRuleConfig.of()
-          .withOperandSupplier(b0 ->
-              b0.operand(LogicalUnion.class).unorderedInputs(b1 ->
-                  b1.operand(Values.class)
-                      .predicate(Values::isEmpty).noInputs()))
-          .withDescription("Union")
-          .toRule();
+  public static final RelOptRule UNION_INSTANCE = UnionEmptyPruneRuleConfig.DEFAULT.toRule();
 
 
   /**
    * Rule that removes empty children of a
-   * {@link org.apache.calcite.rel.logical.LogicalMinus}.
+   * {@link org.apache.calcite.rel.core.Minus}.
    *
    * <p>Examples:
    *
@@ -112,18 +108,11 @@ public interface Config extends RelRule.Config {
    * <li>Minus(Empty, Rel) becomes Empty
    * </ul>
    */
-  public static final RelOptRule MINUS_INSTANCE =
-      ImmutableMinusEmptyPruneRuleConfig.of()
-          .withOperandSupplier(b0 ->
-              b0.operand(LogicalMinus.class).unorderedInputs(b1 ->
-                  b1.operand(Values.class).predicate(Values::isEmpty)
-                      .noInputs()))
-          .withDescription("Minus")
-          .toRule();
+  public static final RelOptRule MINUS_INSTANCE = MinusEmptyPruneRuleConfig.DEFAULT.toRule();
 
   /**
    * Rule that converts a
-   * {@link org.apache.calcite.rel.logical.LogicalIntersect} to
+   * {@link org.apache.calcite.rel.core.Intersect} to
    * empty if any of its children are empty.
    *
    * <p>Examples:
@@ -134,13 +123,7 @@ public interface Config extends RelRule.Config {
    * </ul>
    */
   public static final RelOptRule INTERSECT_INSTANCE =
-      ImmutableIntersectEmptyPruneRuleConfig.of()
-          .withOperandSupplier(b0 ->
-              b0.operand(LogicalIntersect.class).unorderedInputs(b1 ->
-                  b1.operand(Values.class).predicate(Values::isEmpty)
-                      .noInputs()))
-          .withDescription("Intersect")
-          .toRule();
+      IntersectEmptyPruneRuleConfig.DEFAULT.toRule();
 
   private static boolean isEmpty(RelNode node) {
     if (node instanceof Values) {
@@ -164,7 +147,17 @@ private static boolean isEmpty(RelNode node) {
   }
 
   /**
-   * Rule that converts a {@link org.apache.calcite.rel.logical.LogicalProject}
+   * Rule that converts a {@link org.apache.calcite.rel.core.TableScan}
+   * to empty if the table has no rows in it.
+   *
+   * The rule exploits the {@link org.apache.calcite.rel.metadata.RelMdMaxRowCount} to derive if
+   * the table is empty or not.
+   */
+  public static final RelOptRule EMPTY_TABLE_INSTANCE =
+      ImmutableZeroMaxRowsRuleConfig.DEFAULT.toRule();
+
+  /**
+   * Rule that converts a {@link org.apache.calcite.rel.core.Project}
    * to empty if its child is empty.
    *
    * <p>Examples:
@@ -174,13 +167,10 @@ private static boolean isEmpty(RelNode node) {
    * </ul>
    */
   public static final RelOptRule PROJECT_INSTANCE =
-      ImmutableRemoveEmptySingleRuleConfig.of()
-          .withDescription("PruneEmptyProject")
-          .withOperandFor(Project.class, project -> true)
-          .toRule();
+      RemoveEmptySingleRule.RemoveEmptySingleRuleConfig.PROJECT.toRule();
 
   /**
-   * Rule that converts a {@link org.apache.calcite.rel.logical.LogicalFilter}
+   * Rule that converts a {@link org.apache.calcite.rel.core.Filter}
    * to empty if its child is empty.
    *
    * <p>Examples:
@@ -190,10 +180,7 @@ private static boolean isEmpty(RelNode node) {
    * </ul>
    */
   public static final RelOptRule FILTER_INSTANCE =
-      ImmutableRemoveEmptySingleRuleConfig.of()
-          .withDescription("PruneEmptyFilter")
-          .withOperandFor(Filter.class, singleRel -> true)
-          .toRule();
+      RemoveEmptySingleRule.RemoveEmptySingleRuleConfig.FILTER.toRule();
 
   /**
    * Rule that converts a {@link org.apache.calcite.rel.core.Sort}
@@ -206,10 +193,7 @@ private static boolean isEmpty(RelNode node) {
    * </ul>
    */
   public static final RelOptRule SORT_INSTANCE =
-      ImmutableRemoveEmptySingleRuleConfig.of()
-          .withDescription("PruneEmptySort")
-          .withOperandFor(Sort.class, singleRel -> true)
-          .toRule();
+      RemoveEmptySingleRule.RemoveEmptySingleRuleConfig.SORT.toRule();
 
   /**
    * Rule that converts a {@link org.apache.calcite.rel.core.Sort}
@@ -222,11 +206,7 @@ private static boolean isEmpty(RelNode node) {
    * </ul>
    */
   public static final RelOptRule SORT_FETCH_ZERO_INSTANCE =
-      ImmutableSortFetchZeroRuleConfig.of()
-          .withOperandSupplier(b ->
-              b.operand(Sort.class).anyInputs())
-          .withDescription("PruneSortLimit0")
-          .toRule();
+      SortFetchZeroRuleConfig.DEFAULT.toRule();
 
   /**
    * Rule that converts an {@link org.apache.calcite.rel.core.Aggregate}
@@ -244,10 +224,7 @@ private static boolean isEmpty(RelNode node) {
    * @see AggregateValuesRule
    */
   public static final RelOptRule AGGREGATE_INSTANCE =
-      ImmutableRemoveEmptySingleRuleConfig.of()
-          .withDescription("PruneEmptyAggregate")
-          .withOperandFor(Aggregate.class, Aggregate::isNotGrandTotal)
-          .toRule();
+      RemoveEmptySingleRule.RemoveEmptySingleRuleConfig.AGGREGATE.toRule();
 
   /**
    * Rule that converts a {@link org.apache.calcite.rel.core.Join}
@@ -263,14 +240,7 @@ private static boolean isEmpty(RelNode node) {
    * </ul>
    */
   public static final RelOptRule JOIN_LEFT_INSTANCE =
-      ImmutableJoinLeftEmptyRuleConfig.of()
-          .withOperandSupplier(b0 ->
-              b0.operand(Join.class).inputs(
-                  b1 -> b1.operand(Values.class)
-                      .predicate(Values::isEmpty).noInputs(),
-                  b2 -> b2.operand(RelNode.class).anyInputs()))
-          .withDescription("PruneEmptyJoin(left)")
-          .toRule();
+      JoinLeftEmptyRuleConfig.DEFAULT.toRule();
 
   /**
    * Rule that converts a {@link org.apache.calcite.rel.core.Join}
@@ -286,14 +256,7 @@ private static boolean isEmpty(RelNode node) {
    * </ul>
    */
   public static final RelOptRule JOIN_RIGHT_INSTANCE =
-      ImmutableJoinRightEmptyRuleConfig.of()
-          .withOperandSupplier(b0 ->
-              b0.operand(Join.class).inputs(
-                  b1 -> b1.operand(RelNode.class).anyInputs(),
-                  b2 -> b2.operand(Values.class).predicate(Values::isEmpty)
-                      .noInputs()))
-          .withDescription("PruneEmptyJoin(right)")
-          .toRule();
+      JoinRightEmptyRuleConfig.DEFAULT.toRule();
 
   /** Planner rule that converts a single-rel (e.g. project, sort, aggregate or
    * filter) on top of the empty relational expression into empty. */
@@ -347,6 +310,19 @@ public <R extends SingleRel> RemoveEmptySingleRule(Class<R> clazz,
     /** Rule configuration. */
     @Value.Immutable
     public interface RemoveEmptySingleRuleConfig extends PruneEmptyRule.Config {
+      RemoveEmptySingleRuleConfig PROJECT = ImmutableRemoveEmptySingleRuleConfig.of()
+          .withDescription("PruneEmptyProject")
+          .withOperandFor(Project.class, project -> true);
+      RemoveEmptySingleRuleConfig FILTER = ImmutableRemoveEmptySingleRuleConfig.of()
+          .withDescription("PruneEmptyFilter")
+          .withOperandFor(Filter.class, singleRel -> true);
+      RemoveEmptySingleRuleConfig SORT = ImmutableRemoveEmptySingleRuleConfig.of()
+          .withDescription("PruneEmptySort")
+          .withOperandFor(Sort.class, singleRel -> true);
+      RemoveEmptySingleRuleConfig AGGREGATE = ImmutableRemoveEmptySingleRuleConfig.of()
+          .withDescription("PruneEmptyAggregate")
+          .withOperandFor(Aggregate.class, Aggregate::isNotGrandTotal);
+
       @Override default RemoveEmptySingleRule toRule() {
         return new RemoveEmptySingleRule(this);
       }
@@ -365,17 +341,24 @@ default <R extends RelNode> RemoveEmptySingleRuleConfig withOperandFor(Class<R>
   /** Configuration for a rule that prunes empty inputs from a Minus. */
   @Value.Immutable
   public interface UnionEmptyPruneRuleConfig extends PruneEmptyRule.Config {
+    UnionEmptyPruneRuleConfig DEFAULT = ImmutableUnionEmptyPruneRuleConfig.of()
+        .withOperandSupplier(b0 ->
+            b0.operand(Union.class).unorderedInputs(b1 ->
+                b1.operand(Values.class)
+                    .predicate(Values::isEmpty).noInputs()))
+        .withDescription("Union");
+
     @Override default PruneEmptyRule toRule() {
       return new PruneEmptyRule(this) {
         @Override public void onMatch(RelOptRuleCall call) {
-          final LogicalUnion union = call.rel(0);
+          final Union union = call.rel(0);
           final List<RelNode> inputs = union.getInputs();
           assert inputs != null;
-          final RelBuilder builder = call.builder();
+          final RelBuilder relBuilder = call.builder();
           int nonEmptyInputs = 0;
           for (RelNode input : inputs) {
             if (!isEmpty(input)) {
-              builder.push(input);
+              relBuilder.push(input);
               nonEmptyInputs++;
             }
           }
@@ -383,12 +366,12 @@ public interface UnionEmptyPruneRuleConfig extends PruneEmptyRule.Config {
               : "planner promised us at least one Empty child: "
               + RelOptUtil.toString(union);
           if (nonEmptyInputs == 0) {
-            builder.push(union).empty();
+            relBuilder.push(union).empty();
           } else {
-            builder.union(union.all, nonEmptyInputs);
-            builder.convert(union.getRowType(), true);
+            relBuilder.union(union.all, nonEmptyInputs);
+            relBuilder.convert(union.getRowType(), true);
           }
-          call.transformTo(builder.build());
+          call.transformTo(relBuilder.build());
         }
       };
     }
@@ -397,17 +380,23 @@ public interface UnionEmptyPruneRuleConfig extends PruneEmptyRule.Config {
   /** Configuration for a rule that prunes empty inputs from a Minus. */
   @Value.Immutable
   public interface MinusEmptyPruneRuleConfig extends PruneEmptyRule.Config {
+    MinusEmptyPruneRuleConfig DEFAULT = ImmutableMinusEmptyPruneRuleConfig.of()
+        .withOperandSupplier(
+            b0 -> b0.operand(Minus.class).unorderedInputs(
+                b1 -> b1.operand(Values.class).predicate(Values::isEmpty).noInputs()))
+        .withDescription("Minus");
+
     @Override default PruneEmptyRule toRule() {
       return new PruneEmptyRule(this) {
         @Override public void onMatch(RelOptRuleCall call) {
-          final LogicalMinus minus = call.rel(0);
+          final Minus minus = call.rel(0);
           final List<RelNode> inputs = minus.getInputs();
           assert inputs != null;
           int nonEmptyInputs = 0;
-          final RelBuilder builder = call.builder();
+          final RelBuilder relBuilder = call.builder();
           for (RelNode input : inputs) {
             if (!isEmpty(input)) {
-              builder.push(input);
+              relBuilder.push(input);
               nonEmptyInputs++;
             } else if (nonEmptyInputs == 0) {
               // If the first input of Minus is empty, the whole thing is
@@ -419,12 +408,12 @@ public interface MinusEmptyPruneRuleConfig extends PruneEmptyRule.Config {
               : "planner promised us at least one Empty child: "
               + RelOptUtil.toString(minus);
           if (nonEmptyInputs == 0) {
-            builder.push(minus).empty();
+            relBuilder.push(minus).empty();
           } else {
-            builder.minus(minus.all, nonEmptyInputs);
-            builder.convert(minus.getRowType(), true);
+            relBuilder.minus(minus.all, nonEmptyInputs);
+            relBuilder.convert(minus.getRowType(), true);
           }
-          call.transformTo(builder.build());
+          call.transformTo(relBuilder.build());
         }
       };
     }
@@ -435,13 +424,20 @@ public interface MinusEmptyPruneRuleConfig extends PruneEmptyRule.Config {
    * is empty. */
   @Value.Immutable
   public interface IntersectEmptyPruneRuleConfig extends PruneEmptyRule.Config {
+    IntersectEmptyPruneRuleConfig DEFAULT = ImmutableIntersectEmptyPruneRuleConfig.of()
+        .withOperandSupplier(b0 ->
+            b0.operand(Intersect.class).unorderedInputs(b1 ->
+                b1.operand(Values.class).predicate(Values::isEmpty)
+                    .noInputs()))
+        .withDescription("Intersect");
+
     @Override default PruneEmptyRule toRule() {
       return new PruneEmptyRule(this) {
         @Override public void onMatch(RelOptRuleCall call) {
-          LogicalIntersect intersect = call.rel(0);
-          final RelBuilder builder = call.builder();
-          builder.push(intersect).empty();
-          call.transformTo(builder.build());
+          Intersect intersect = call.rel(0);
+          final RelBuilder relBuilder = call.builder();
+          relBuilder.push(intersect).empty();
+          call.transformTo(relBuilder.build());
         }
       };
     }
@@ -450,6 +446,10 @@ public interface IntersectEmptyPruneRuleConfig extends PruneEmptyRule.Config {
   /** Configuration for a rule that prunes a Sort if it has limit 0. */
   @Value.Immutable
   public interface SortFetchZeroRuleConfig extends PruneEmptyRule.Config {
+    SortFetchZeroRuleConfig DEFAULT = ImmutableSortFetchZeroRuleConfig.of()
+        .withOperandSupplier(b -> b.operand(Sort.class).anyInputs())
+        .withDescription("PruneSortLimit0");
+
     @Override default PruneEmptyRule toRule() {
       return new PruneEmptyRule(this) {
         @Override public void onMatch(RelOptRuleCall call) {
@@ -476,16 +476,35 @@ public interface SortFetchZeroRuleConfig extends PruneEmptyRule.Config {
    * empty. */
   @Value.Immutable
   public interface JoinLeftEmptyRuleConfig extends PruneEmptyRule.Config {
+    JoinLeftEmptyRuleConfig DEFAULT = ImmutableJoinLeftEmptyRuleConfig.of()
+        .withOperandSupplier(b0 ->
+            b0.operand(Join.class).inputs(
+                b1 -> b1.operand(Values.class).predicate(Values::isEmpty).noInputs(),
+                b2 -> b2.operand(RelNode.class).anyInputs()))
+        .withDescription("PruneEmptyJoin(left)");
+
     @Override default PruneEmptyRule toRule() {
       return new PruneEmptyRule(this) {
         @Override public void onMatch(RelOptRuleCall call) {
-          Join join = call.rel(0);
+          final Join join = call.rel(0);
+          final Values empty = call.rel(1);
+          final RelNode right = call.rel(2);
+          final RelBuilder relBuilder = call.builder();
           if (join.getJoinType().generatesNullsOnLeft()) {
-            // "select * from emp right join dept" is not necessarily empty if
-            // emp is empty
+            // If "emp" is empty, "select * from emp right join dept" will have
+            // the same number of rows as "dept", and null values for the
+            // columns from "emp". The left side of the join can be removed.
+            final List<RexLiteral> nullLiterals =
+                Collections.nCopies(empty.getRowType().getFieldCount(),
+                    relBuilder.literal(null));
+            call.transformTo(
+                relBuilder.push(right)
+                    .project(concat(nullLiterals, relBuilder.fields()))
+                    .convert(join.getRowType(), true)
+                    .build());
             return;
           }
-          call.transformTo(call.builder().push(join).empty().build());
+          call.transformTo(relBuilder.push(join).empty().build());
         }
       };
     }
@@ -495,13 +514,32 @@ public interface JoinLeftEmptyRuleConfig extends PruneEmptyRule.Config {
    * empty. */
   @Value.Immutable
   public interface JoinRightEmptyRuleConfig extends PruneEmptyRule.Config {
+    JoinRightEmptyRuleConfig DEFAULT = ImmutableJoinRightEmptyRuleConfig.of()
+        .withOperandSupplier(b0 ->
+            b0.operand(Join.class).inputs(
+                b1 -> b1.operand(RelNode.class).anyInputs(),
+                b2 -> b2.operand(Values.class).predicate(Values::isEmpty).noInputs()))
+        .withDescription("PruneEmptyJoin(right)");
+
     @Override default PruneEmptyRule toRule() {
       return new PruneEmptyRule(this) {
         @Override public void onMatch(RelOptRuleCall call) {
-          Join join = call.rel(0);
+          final Join join = call.rel(0);
+          final RelNode left = call.rel(1);
+          final Values empty = call.rel(2);
+          final RelBuilder relBuilder = call.builder();
           if (join.getJoinType().generatesNullsOnRight()) {
-            // "select * from emp left join dept" is not necessarily empty if
-            // dept is empty
+            // If "dept" is empty, "select * from emp left join dept" will have
+            // the same number of rows as "emp", and null values for the
+            // columns from "dept". The right side of the join can be removed.
+            final List<RexLiteral> nullLiterals =
+                Collections.nCopies(empty.getRowType().getFieldCount(),
+                    relBuilder.literal(null));
+            call.transformTo(
+                relBuilder.push(left)
+                    .project(concat(relBuilder.fields(), nullLiterals))
+                    .convert(join.getRowType(), true)
+                    .build());
             return;
           }
           if (join.getJoinType() == JoinRelType.ANTI) {
@@ -509,7 +547,41 @@ public interface JoinRightEmptyRuleConfig extends PruneEmptyRule.Config {
             call.transformTo(join.getLeft());
             return;
           }
-          call.transformTo(call.builder().push(join).empty().build());
+          call.transformTo(relBuilder.push(join).empty().build());
+        }
+      };
+    }
+  }
+
+  /** Configuration for rule that transforms an empty relational expression into an empty values.
+   *
+   * It relies on {@link org.apache.calcite.rel.metadata.RelMdMaxRowCount} to derive if the relation
+   * is empty or not. If the stats are not available then the rule is a noop. */
+  @Value.Immutable
+  public interface ZeroMaxRowsRuleConfig extends PruneEmptyRule.Config {
+    ZeroMaxRowsRuleConfig DEFAULT = ImmutableZeroMaxRowsRuleConfig.of()
+        .withOperandSupplier(b0 -> b0.operand(TableScan.class).noInputs())
+        .withDescription("PruneZeroRowsTable");
+
+    @Override default PruneEmptyRule toRule() {
+      return new PruneEmptyRule(this) {
+        @Override public boolean matches(RelOptRuleCall call) {
+          RelNode node = call.rel(0);
+          Double maxRowCount = call.getMetadataQuery().getMaxRowCount(node);
+          return maxRowCount != null && maxRowCount == 0.0;
+        }
+
+        @Override public void onMatch(RelOptRuleCall call) {
+          RelNode node = call.rel(0);
+          RelNode emptyValues = call.builder().push(node).empty().build();
+          RelTraitSet traits = node.getTraitSet();
+          // propagate all traits (except convention) from the original tableScan
+          // into the empty values
+          if (emptyValues.getConvention() != null) {
+            traits = traits.replace(emptyValues.getConvention());
+          }
+          emptyValues = emptyValues.copy(traits, Collections.emptyList());
+          call.transformTo(emptyValues);
         }
       };
     }
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/ReduceDecimalsRule.java b/core/src/main/java/org/apache/calcite/rel/rules/ReduceDecimalsRule.java
index 37373f30452..42d8403dbc1 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/ReduceDecimalsRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/ReduceDecimalsRule.java
@@ -283,7 +283,7 @@ RexExpander getExpander(RexCall call) {
    * decoded, SqlOperators can then operate on the integer representations. The
    * value can later be recoded as a decimal.
    *
-   * <p>For example, suppose one casts 2.0 as a decima(10,4). The value is
+   * <p>For example, suppose one casts 2.0 as a decimal(10,4). The value is
    * decoded (20), multiplied by a scale factor (1000), for a result of
    * (20000) which is encoded as a decimal(10,4), in this case 2.0000
    *
@@ -842,13 +842,13 @@ private BinaryArithmeticExpander(RexBuilder builder) {
           || SqlTypeUtil.isApproximateNumeric(typeB)) {
         List<RexNode> newOperands;
         if (SqlTypeUtil.isApproximateNumeric(typeA)) {
-          newOperands = ImmutableList.of(
-              operands.get(0),
-              ensureType(real8, operands.get(1)));
+          newOperands =
+              ImmutableList.of(operands.get(0),
+                  ensureType(real8, operands.get(1)));
         } else {
-          newOperands = ImmutableList.of(
-              ensureType(real8, operands.get(0)),
-              operands.get(1));
+          newOperands =
+              ImmutableList.of(ensureType(real8, operands.get(0)),
+                  operands.get(1));
         }
         return builder.makeCall(
             call.getOperator(),
@@ -877,7 +877,7 @@ private BinaryArithmeticExpander(RexBuilder builder) {
     /**
      * Convenience method for reading characteristics of operands (such as
      * scale, precision, whole digits) into an ArithmeticExpander. The
-     * operands are restricted by the following contraints:
+     * operands are restricted by the following constraints:
      *
      * <ul>
      * <li>there are exactly two operands
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/ReduceExpressionsRule.java b/core/src/main/java/org/apache/calcite/rel/rules/ReduceExpressionsRule.java
index bc83dd714a1..44f978e5a3b 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/ReduceExpressionsRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/ReduceExpressionsRule.java
@@ -35,6 +35,7 @@
 import org.apache.calcite.rel.logical.LogicalProject;
 import org.apache.calcite.rel.logical.LogicalWindow;
 import org.apache.calcite.rel.metadata.RelMetadataQuery;
+import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeFactory;
 import org.apache.calcite.rex.RexBuilder;
 import org.apache.calcite.rex.RexCall;
@@ -574,9 +575,10 @@ public WindowReduceExpressionsRule(Class<? extends Window> windowClass,
         for (Window.RexWinAggCall aggCall : group.aggCalls) {
           final List<RexNode> expList = new ArrayList<>(aggCall.getOperands());
           if (reduceExpressions(window, expList, predicates)) {
-            aggCall = new Window.RexWinAggCall(
-                (SqlAggFunction) aggCall.getOperator(), aggCall.type, expList,
-                aggCall.ordinal, aggCall.distinct, aggCall.ignoreNulls);
+            aggCall =
+                new Window.RexWinAggCall((SqlAggFunction) aggCall.getOperator(),
+                    aggCall.type, expList,
+                    aggCall.ordinal, aggCall.distinct, aggCall.ignoreNulls);
             reduced = true;
           }
           aggCalls.add(aggCall);
@@ -706,8 +708,9 @@ protected static boolean reduceExpressions(RelNode rel, List<RexNode> expList,
 
     // Simplify predicates in place
     final RexUnknownAs unknownAs = RexUnknownAs.falseIf(unknownAsFalse);
-    final boolean reduced = reduceExpressionsInternal(rel, simplify, unknownAs,
-        expList, predicates, treatDynamicCallsAsConstant);
+    final boolean reduced =
+        reduceExpressionsInternal(rel, simplify, unknownAs,
+            expList, predicates, treatDynamicCallsAsConstant);
 
     boolean simplified = false;
     for (int i = 0; i < expList.size(); i++) {
@@ -853,7 +856,7 @@ public static RexCall pushPredicateIntoCase(RexCall call) {
     case OR:
       return call; // don't push CASE into CASE!
     case EQUALS: {
-      // checks that the EQUALS operands may be splitted and
+      // checks that the EQUALS operands may be split and
       // doesn't push EQUALS into CASE
       List<RexNode> equalsOperands = call.getOperands();
       ImmutableBitSet left = RelOptUtil.InputFinder.bits(equalsOperands.get(0));
@@ -957,8 +960,8 @@ protected static class RexReplacer extends RexShuttle {
         // If we make 'abc' of type VARCHAR(4), we may later encounter
         // the same expression in a Project's digest where it has
         // type VARCHAR(3), and that's wrong.
-        replacement =
-            simplify.rexBuilder.makeAbstractCast(call.getType(), replacement);
+        RelDataType type = call.getType();
+        replacement = simplify.rexBuilder.makeAbstractCast(type, replacement, false);
       }
       return replacement;
     }
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/SemiJoinRule.java b/core/src/main/java/org/apache/calcite/rel/rules/SemiJoinRule.java
index fc84206dcb3..2a07d7fb953 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/SemiJoinRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/SemiJoinRule.java
@@ -26,6 +26,7 @@
 import org.apache.calcite.rel.core.JoinInfo;
 import org.apache.calcite.rel.core.JoinRelType;
 import org.apache.calcite.rel.core.Project;
+import org.apache.calcite.rel.metadata.RelMetadataQuery;
 import org.apache.calcite.rex.RexBuilder;
 import org.apache.calcite.rex.RexNode;
 import org.apache.calcite.tools.RelBuilder;
@@ -42,7 +43,9 @@
 /**
  * Planner rule that creates a {@code SemiJoin} from a
  * {@link org.apache.calcite.rel.core.Join} on top of a
- * {@link org.apache.calcite.rel.logical.LogicalAggregate}.
+ * {@link org.apache.calcite.rel.logical.LogicalAggregate} or
+ * on a {@link org.apache.calcite.rel.RelNode} which is
+ * unique for join's right keys.
  */
 public abstract class SemiJoinRule
     extends RelRule<SemiJoinRule.Config>
@@ -96,7 +99,6 @@ protected void perform(RelOptRuleCall call, @Nullable Project project,
     final RelBuilder relBuilder = call.builder();
     relBuilder.push(left);
     switch (join.getJoinType()) {
-    case SEMI:
     case INNER:
       final List<Integer> newRightKeyBuilder = new ArrayList<>();
       final List<Integer> aggregateKeys = aggregate.getGroupSet().asList();
@@ -232,6 +234,83 @@ default JoinToSemiJoinRuleConfig withOperandFor(Class<Join> joinClass,
     }
   }
 
+  /**
+   * SemiJoinRule that matches a Project on top of a Join with a RelNode
+   * which is unique for Join's right keys.
+   *
+   * @see CoreRules#JOIN_ON_UNIQUE_TO_SEMI_JOIN */
+  public static class JoinOnUniqueToSemiJoinRule extends SemiJoinRule {
+
+    /** Creates a JoinOnUniqueToSemiJoinRule. */
+    protected JoinOnUniqueToSemiJoinRule(JoinOnUniqueToSemiJoinRuleConfig config) {
+      super(config);
+    }
+
+    @Override public boolean matches(RelOptRuleCall call) {
+      final Project project = call.rel(0);
+      final Join join = call.rel(1);
+      final RelNode left = call.rel(2);
+
+      final ImmutableBitSet bits =
+          RelOptUtil.InputFinder.bits(project.getProjects(), null);
+      final ImmutableBitSet rightBits =
+          ImmutableBitSet.range(left.getRowType().getFieldCount(),
+              join.getRowType().getFieldCount());
+      return !bits.intersects(rightBits);
+    }
+
+    @Override public void onMatch(RelOptRuleCall call) {
+      final Project project = call.rel(0);
+      final Join join = call.rel(1);
+      final RelNode left = call.rel(2);
+      final RelNode right = call.rel(3);
+
+      final JoinInfo joinInfo = join.analyzeCondition();
+      final RelOptCluster cluster = join.getCluster();
+      final RelMetadataQuery mq = cluster.getMetadataQuery();
+      final Boolean unique = mq.areColumnsUnique(right, joinInfo.rightSet());
+      if (unique != null && unique) {
+        final RelBuilder builder = call.builder();
+        switch (join.getJoinType()) {
+        case INNER:
+          builder.push(left);
+          builder.push(right);
+          builder.join(JoinRelType.SEMI, join.getCondition());
+          break;
+        case LEFT:
+          builder.push(left);
+          break;
+        default:
+          throw new AssertionError(join.getJoinType());
+        }
+        builder.project(project.getProjects(), project.getRowType().getFieldNames());
+        call.transformTo(builder.build());
+      }
+    }
+
+    /**
+     * Rule configuration.
+     */
+    @Value.Immutable
+    public interface JoinOnUniqueToSemiJoinRuleConfig extends SemiJoinRule.Config {
+      JoinOnUniqueToSemiJoinRuleConfig DEFAULT = ImmutableJoinOnUniqueToSemiJoinRuleConfig.of()
+          .withDescription("SemiJoinRule:unique")
+          .withOperandSupplier(b ->
+              b.operand(Project.class).oneInput(
+                  b2 -> b2.operand(Join.class).predicate(SemiJoinRule::isJoinTypeSupported).inputs(
+                      b3 -> b3.operand(RelNode.class).anyInputs(),
+                      b4 -> b4.operand(RelNode.class)
+                          // If RHS is Aggregate, it will be covered by ProjectToSemiJoinRule
+                          .predicate(n -> !(n instanceof Aggregate))
+                          .anyInputs())))
+          .as(JoinOnUniqueToSemiJoinRuleConfig.class);
+
+      @Override default JoinOnUniqueToSemiJoinRule toRule() {
+        return new JoinOnUniqueToSemiJoinRule(this);
+      }
+    }
+  }
+
   /**
    * Rule configuration.
    */
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/SortJoinCopyRule.java b/core/src/main/java/org/apache/calcite/rel/rules/SortJoinCopyRule.java
index c6049a69837..b8dc3e5dd1d 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/SortJoinCopyRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/SortJoinCopyRule.java
@@ -96,8 +96,9 @@ public SortJoinCopyRule(Class<? extends Sort> sortClass,
     if (leftFieldCollation.isEmpty()) {
       newLeftInput = join.getLeft();
     } else {
-      final RelCollation leftCollation = RelCollationTraitDef.INSTANCE.canonize(
-          RelCollations.of(leftFieldCollation));
+      final RelCollation leftCollation =
+          RelCollationTraitDef.INSTANCE.canonize(
+              RelCollations.of(leftFieldCollation));
       // If left table already sorted don't add a sort
       if (RelMdUtil.checkInputForCollationAndLimit(
           metadataQuery,
@@ -107,14 +108,11 @@ public SortJoinCopyRule(Class<? extends Sort> sortClass,
           null)) {
         newLeftInput = join.getLeft();
       } else {
-        newLeftInput = sort.copy(
-            sort.getTraitSet().replaceIf(
-                RelCollationTraitDef.INSTANCE,
-                () -> leftCollation),
-            join.getLeft(),
-            leftCollation,
-            null,
-            null);
+        newLeftInput =
+            sort.copy(
+                sort.getTraitSet().replaceIf(RelCollationTraitDef.INSTANCE,
+                    () -> leftCollation),
+                join.getLeft(), leftCollation, null, null);
       }
     }
     // Add sort to new right node only if sort collations
@@ -122,10 +120,10 @@ public SortJoinCopyRule(Class<? extends Sort> sortClass,
     if (rightFieldCollation.isEmpty()) {
       newRightInput = join.getRight();
     } else {
-      final RelCollation rightCollation = RelCollationTraitDef.INSTANCE.canonize(
-          RelCollations.shift(
-              RelCollations.of(rightFieldCollation),
-              -join.getLeft().getRowType().getFieldCount()));
+      final RelCollation rightCollation =
+          RelCollationTraitDef.INSTANCE.canonize(
+              RelCollations.shift(RelCollations.of(rightFieldCollation),
+                  -join.getLeft().getRowType().getFieldCount()));
       // If right table already sorted don't add a sort
       if (RelMdUtil.checkInputForCollationAndLimit(
           metadataQuery,
@@ -135,14 +133,11 @@ public SortJoinCopyRule(Class<? extends Sort> sortClass,
           null)) {
         newRightInput = join.getRight();
       } else {
-        newRightInput = sort.copy(
-            sort.getTraitSet().replaceIf(
-                RelCollationTraitDef.INSTANCE,
-                () -> rightCollation),
-            join.getRight(),
-            rightCollation,
-            null,
-            null);
+        newRightInput =
+            sort.copy(
+                sort.getTraitSet().replaceIf(RelCollationTraitDef.INSTANCE,
+                    () -> rightCollation),
+                join.getRight(), rightCollation, null, null);
       }
     }
     // If no change was made no need to apply the rule
@@ -150,19 +145,12 @@ public SortJoinCopyRule(Class<? extends Sort> sortClass,
       return;
     }
 
-    final RelNode joinCopy = join.copy(
-        join.getTraitSet(),
-        join.getCondition(),
-        newLeftInput,
-        newRightInput,
-        join.getJoinType(),
-        join.isSemiJoinDone());
-    final RelNode sortCopy = sort.copy(
-        sort.getTraitSet(),
-        joinCopy,
-        sort.getCollation(),
-        sort.offset,
-        sort.fetch);
+    final RelNode joinCopy =
+        join.copy(join.getTraitSet(), join.getCondition(), newLeftInput,
+            newRightInput, join.getJoinType(), join.isSemiJoinDone());
+    final RelNode sortCopy =
+        sort.copy(sort.getTraitSet(), joinCopy, sort.getCollation(),
+            sort.offset, sort.fetch);
 
     call.transformTo(sortCopy);
   }
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/SortJoinTransposeRule.java b/core/src/main/java/org/apache/calcite/rel/rules/SortJoinTransposeRule.java
index 8eb6d967f20..8fd7cff880d 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/SortJoinTransposeRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/SortJoinTransposeRule.java
@@ -77,8 +77,8 @@ public SortJoinTransposeRule(Class<? extends Sort> sortClass,
     final Sort sort = call.rel(0);
     final Join join = call.rel(1);
     final RelMetadataQuery mq = call.getMetadataQuery();
-    final JoinInfo joinInfo = JoinInfo.of(
-        join.getLeft(), join.getRight(), join.getCondition());
+    final JoinInfo joinInfo =
+        JoinInfo.of(join.getLeft(), join.getRight(), join.getCondition());
 
     // 1) If join is not a left or right outer, we bail out
     // 2) If sort is not a trivial order-by, and if there is
@@ -139,8 +139,9 @@ public SortJoinTransposeRule(Class<? extends Sort> sortClass,
           sort.getCollation(), sort.offset, sort.fetch)) {
         return;
       }
-      newLeftInput = sort.copy(sort.getTraitSet(), join.getLeft(), sort.getCollation(),
-          sort.offset, sort.fetch);
+      newLeftInput =
+          sort.copy(sort.getTraitSet(), join.getLeft(), sort.getCollation(),
+              sort.offset, sort.fetch);
       newRightInput = join.getRight();
     } else {
       final RelCollation rightCollation =
@@ -154,14 +155,17 @@ public SortJoinTransposeRule(Class<? extends Sort> sortClass,
         return;
       }
       newLeftInput = join.getLeft();
-      newRightInput = sort.copy(sort.getTraitSet().replace(rightCollation),
-          join.getRight(), rightCollation, sort.offset, sort.fetch);
+      newRightInput =
+          sort.copy(sort.getTraitSet().replace(rightCollation),
+              join.getRight(), rightCollation, sort.offset, sort.fetch);
     }
     // We copy the join and the top sort operator
-    final RelNode joinCopy = join.copy(join.getTraitSet(), join.getCondition(), newLeftInput,
-        newRightInput, join.getJoinType(), join.isSemiJoinDone());
-    final RelNode sortCopy = sort.copy(sort.getTraitSet(), joinCopy, sort.getCollation(),
-        sort.offset, sort.fetch);
+    final RelNode joinCopy =
+        join.copy(join.getTraitSet(), join.getCondition(), newLeftInput,
+            newRightInput, join.getJoinType(), join.isSemiJoinDone());
+    final RelNode sortCopy =
+        sort.copy(sort.getTraitSet(), joinCopy, sort.getCollation(),
+            sort.offset, sort.fetch);
 
     call.transformTo(sortCopy);
   }
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/SortUnionTransposeRule.java b/core/src/main/java/org/apache/calcite/rel/rules/SortUnionTransposeRule.java
index 078e0e3e040..0716b514400 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/SortUnionTransposeRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/SortUnionTransposeRule.java
@@ -86,8 +86,9 @@ public SortUnionTransposeRule(
       if (!RelMdUtil.checkInputForCollationAndLimit(mq, input,
           sort.getCollation(), sort.offset, sort.fetch)) {
         ret = false;
-        Sort branchSort = sort.copy(sort.getTraitSet(), input,
-            sort.getCollation(), sort.offset, sort.fetch);
+        Sort branchSort =
+            sort.copy(sort.getTraitSet(), input,
+                sort.getCollation(), sort.offset, sort.fetch);
         inputs.add(branchSort);
       } else {
         inputs.add(input);
@@ -100,8 +101,9 @@ public SortUnionTransposeRule(
     // create new union and sort
     Union unionCopy = (Union) union
         .copy(union.getTraitSet(), inputs, union.all);
-    Sort result = sort.copy(sort.getTraitSet(), unionCopy, sort.getCollation(),
-        sort.offset, sort.fetch);
+    Sort result =
+        sort.copy(sort.getTraitSet(), unionCopy, sort.getCollation(),
+            sort.offset, sort.fetch);
     call.transformTo(result);
   }
 
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/SpatialRules.java b/core/src/main/java/org/apache/calcite/rel/rules/SpatialRules.java
index 41fa39a7eeb..1b003de36b4 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/SpatialRules.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/SpatialRules.java
@@ -28,20 +28,20 @@
 import org.apache.calcite.rex.RexLiteral;
 import org.apache.calcite.rex.RexNode;
 import org.apache.calcite.rex.RexUtil;
-import org.apache.calcite.runtime.GeoFunctions;
-import org.apache.calcite.runtime.Geometries;
 import org.apache.calcite.runtime.HilbertCurve2D;
 import org.apache.calcite.runtime.SpaceFillingCurve2D;
+import org.apache.calcite.runtime.SpatialTypeFunctions;
 import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
 import org.apache.calcite.tools.RelBuilder;
 
-import com.esri.core.geometry.Envelope;
-import com.esri.core.geometry.Point;
 import com.google.common.collect.ImmutableList;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.immutables.value.Value;
+import org.locationtech.jts.geom.Envelope;
+import org.locationtech.jts.geom.Geometry;
+import org.locationtech.jts.geom.Point;
 
 import java.math.BigDecimal;
 import java.util.ArrayList;
@@ -101,12 +101,12 @@ private SpatialRules() {}
       FilterHilbertRule.Config.DEFAULT.toRule();
 
   /** Returns a geometry if an expression is constant, null otherwise. */
-  private static Geometries.@Nullable Geom constantGeom(RexNode e) {
+  private static @Nullable Geometry constantGeom(RexNode e) {
     switch (e.getKind()) {
     case CAST:
       return constantGeom(((RexCall) e).getOperands().get(0));
     case LITERAL:
-      return (Geometries.Geom) ((RexLiteral) e).getValue();
+      return (Geometry) ((RexLiteral) e).getValue();
     default:
       return null;
     }
@@ -198,18 +198,18 @@ protected FilterHilbertRule(Config config) {
         RexInputRef ref, RexCall hilbert) {
       final RexNode op0;
       final RexNode op1;
-      final Geometries.Geom g0;
+      final Geometry g0;
       switch (conjunction.getKind()) {
       case ST_DWITHIN:
         final RexCall within = (RexCall) conjunction;
         op0 = within.operands.get(0);
         g0 = constantGeom(op0);
         op1 = within.operands.get(1);
-        final Geometries.Geom g1 = constantGeom(op1);
+        final Geometry g1 = constantGeom(op1);
         if (RexUtil.isLiteral(within.operands.get(2), true)) {
-          final Number distance = requireNonNull(
-              (Number) value(within.operands.get(2)),
-              () -> "distance for " + within);
+          final Number distance =
+              requireNonNull((Number) value(within.operands.get(2)),
+                  () -> "distance for " + within);
           switch (Double.compare(distance.doubleValue(), 0D)) {
           case -1: // negative distance
             return ImmutableList.of(builder.getRexBuilder().makeLiteral(false));
@@ -277,28 +277,27 @@ protected FilterHilbertRule(Config config) {
      * is 0. But usually returns a list of ranges,
      * {@code ref BETWEEN c1 AND c2 OR ref BETWEEN c3 AND c4}. */
     private static RexNode hilbertPredicate(RexBuilder rexBuilder,
-        RexInputRef ref, Geometries.Geom g, Number distance) {
-      if (distance.doubleValue() == 0D
-          && Geometries.type(g.g()) == Geometries.Type.POINT) {
-        final Point p = (Point) g.g();
+        RexInputRef ref, Geometry g, Number distance) {
+      if (distance.doubleValue() == 0D && g instanceof Point) {
+        final Point p = (Point) g;
         final HilbertCurve2D hilbert = new HilbertCurve2D(8);
         final long index = hilbert.toIndex(p.getX(), p.getY());
         return rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, ref,
             rexBuilder.makeExactLiteral(BigDecimal.valueOf(index)));
       }
-      final Geometries.Geom g2 =
-          GeoFunctions.ST_Buffer(g, distance.doubleValue());
+      final Geometry g2 =
+          SpatialTypeFunctions.ST_Buffer(g, distance.doubleValue());
       return hilbertPredicate(rexBuilder, ref, g2);
     }
 
     private static RexNode hilbertPredicate(RexBuilder rexBuilder,
-        RexInputRef ref, Geometries.Geom g2) {
-      final Geometries.Geom g3 = GeoFunctions.ST_Envelope(g2);
-      final Envelope env = (Envelope) g3.g();
+        RexInputRef ref, Geometry g2) {
+      final Geometry g3 = SpatialTypeFunctions.ST_Envelope(g2);
+      final Envelope env =  g3.getEnvelopeInternal();
       final HilbertCurve2D hilbert = new HilbertCurve2D(8);
       final List<SpaceFillingCurve2D.IndexRange> ranges =
-          hilbert.toRanges(env.getXMin(), env.getYMin(), env.getXMax(),
-              env.getYMax(), new SpaceFillingCurve2D.RangeComputeHints());
+          hilbert.toRanges(env.getMinX(), env.getMinY(), env.getMaxX(),
+              env.getMaxY(), new SpaceFillingCurve2D.RangeComputeHints());
       final List<RexNode> nodes = new ArrayList<>();
       for (SpaceFillingCurve2D.IndexRange range : ranges) {
         final BigDecimal lowerBd = BigDecimal.valueOf(range.lower());
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/SubQueryRemoveRule.java b/core/src/main/java/org/apache/calcite/rel/rules/SubQueryRemoveRule.java
index b3877241539..c73da2625e0 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/SubQueryRemoveRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/SubQueryRemoveRule.java
@@ -40,7 +40,6 @@
 import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.fun.SqlQuantifyOperator;
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
-import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.sql2rel.RelDecorrelator;
 import org.apache.calcite.tools.RelBuilder;
 import org.apache.calcite.util.ImmutableBitSet;
@@ -94,13 +93,9 @@ protected RexNode apply(RexSubQuery e, Set<CorrelationId> variablesSet,
     case SCALAR_QUERY:
       return rewriteScalarQuery(e, variablesSet, builder, inputCount, offset);
     case ARRAY_QUERY_CONSTRUCTOR:
-      return rewriteCollection(e, SqlTypeName.ARRAY, variablesSet, builder,
-          inputCount, offset);
     case MAP_QUERY_CONSTRUCTOR:
-      return rewriteCollection(e, SqlTypeName.MAP, variablesSet, builder,
-          inputCount, offset);
     case MULTISET_QUERY_CONSTRUCTOR:
-      return rewriteCollection(e, SqlTypeName.MULTISET, variablesSet, builder,
+      return rewriteCollection(e, variablesSet, builder,
           inputCount, offset);
     case SOME:
       return rewriteSome(e, variablesSet, builder);
@@ -131,8 +126,8 @@ private static RexNode rewriteScalarQuery(RexSubQuery e, Set<CorrelationId> vari
       RelBuilder builder, int inputCount, int offset) {
     builder.push(e.rel);
     final RelMetadataQuery mq = e.rel.getCluster().getMetadataQuery();
-    final Boolean unique = mq.areColumnsUnique(builder.peek(),
-        ImmutableBitSet.of());
+    final Boolean unique =
+        mq.areColumnsUnique(builder.peek(), ImmutableBitSet.of());
     if (unique == null || !unique) {
       builder.aggregate(builder.groupKey(),
           builder.aggregateCall(SqlStdOperatorTable.SINGLE_VALUE,
@@ -147,7 +142,6 @@ private static RexNode rewriteScalarQuery(RexSubQuery e, Set<CorrelationId> vari
    * {@link org.apache.calcite.rel.core.Collect}.
    *
    * @param e            Sub-query to rewrite
-   * @param collectionType Collection type (ARRAY, MAP, MULTISET)
    * @param variablesSet A set of variables used by a relational
    *                     expression of the specified RexSubQuery
    * @param builder      Builder
@@ -155,11 +149,11 @@ private static RexNode rewriteScalarQuery(RexSubQuery e, Set<CorrelationId> vari
    * @return Expression that may be used to replace the RexSubQuery
    */
   private static RexNode rewriteCollection(RexSubQuery e,
-      SqlTypeName collectionType, Set<CorrelationId> variablesSet,
-      RelBuilder builder, int inputCount, int offset) {
+      Set<CorrelationId> variablesSet, RelBuilder builder,
+      int inputCount, int offset) {
     builder.push(e.rel);
     builder.push(
-        Collect.create(builder.build(), collectionType, "x"));
+        Collect.create(builder.build(), e.getKind(), "x"));
     builder.join(JoinRelType.INNER, builder.literal(true), variablesSet);
     return field(builder, inputCount, offset);
   }
@@ -249,18 +243,19 @@ private static RexNode rewriteSome(RexSubQuery e, Set<CorrelationId> variablesSe
                 builder.count(false, "d", builder.field(0)))
             .as("q")
             .join(JoinRelType.INNER);
-        caseRexNode = builder.call(SqlStdOperatorTable.CASE,
-            builder.equals(builder.field("q", "c"), builder.literal(0)),
-            literalFalse,
-            builder.call(SqlStdOperatorTable.IS_TRUE,
+        caseRexNode =
+            builder.call(SqlStdOperatorTable.CASE,
+                builder.equals(builder.field("q", "c"), builder.literal(0)),
+                literalFalse,
+                builder.call(SqlStdOperatorTable.IS_TRUE,
+                    builder.call(RexUtil.op(op.comparisonKind),
+                        e.operands.get(0), builder.field("q", "m"))),
+                literalTrue,
+                builder.greaterThan(builder.field("q", "c"),
+                    builder.field("q", "d")),
+                literalUnknown,
                 builder.call(RexUtil.op(op.comparisonKind),
-                    e.operands.get(0), builder.field("q", "m"))),
-            literalTrue,
-            builder.greaterThan(builder.field("q", "c"),
-                builder.field("q", "d")),
-            literalUnknown,
-            builder.call(RexUtil.op(op.comparisonKind),
-                e.operands.get(0), builder.field("q", "m")));
+                    e.operands.get(0), builder.field("q", "m")));
         break;
 
       case NOT_EQUALS:
@@ -291,21 +286,22 @@ private static RexNode rewriteSome(RexSubQuery e, Set<CorrelationId> variablesSe
                 builder.max(builder.field(0)).as("m"))
             .as("q")
             .join(JoinRelType.INNER);
-        caseRexNode = builder.call(SqlStdOperatorTable.CASE,
-            builder.equals(builder.field("c"), builder.literal(0)),
-            literalFalse,
-            builder.isNull(e.getOperands().get(0)),
-            literalUnknown,
-            builder.and(
-                builder.notEquals(builder.field("d"), builder.field("c")),
-                builder.lessThanOrEqual(builder.field("d"),
-                    builder.literal(1))),
-            builder.or(
+        caseRexNode =
+            builder.call(SqlStdOperatorTable.CASE,
+                builder.equals(builder.field("c"), builder.literal(0)),
+                literalFalse,
+                builder.isNull(e.getOperands().get(0)),
+                literalUnknown,
+                builder.and(
+                    builder.notEquals(builder.field("d"), builder.field("c")),
+                    builder.lessThanOrEqual(builder.field("d"),
+                        builder.literal(1))),
+                builder.or(
+                    builder.notEquals(e.operands.get(0), builder.field("q", "m")),
+                    literalUnknown),
+                builder.equals(builder.field("d"), builder.literal(1)),
                 builder.notEquals(e.operands.get(0), builder.field("q", "m")),
-                literalUnknown),
-            builder.equals(builder.field("d"), builder.literal(1)),
-            builder.notEquals(e.operands.get(0), builder.field("q", "m")),
-            literalTrue);
+                literalTrue);
         break;
 
       default:
@@ -350,20 +346,21 @@ private static RexNode rewriteSome(RexSubQuery e, Set<CorrelationId> variablesSe
         parentQueryFields.add(builder.alias(literalTrue, indicator));
         builder.project(parentQueryFields).as("q");
         builder.join(JoinRelType.LEFT, literalTrue, variablesSet);
-        caseRexNode = builder.call(SqlStdOperatorTable.CASE,
-            builder.isNull(builder.field("q", indicator)),
-            literalFalse,
-            builder.equals(builder.field("q", "c"), builder.literal(0)),
-            literalFalse,
-            builder.call(SqlStdOperatorTable.IS_TRUE,
+        caseRexNode =
+            builder.call(SqlStdOperatorTable.CASE,
+                builder.isNull(builder.field("q", indicator)),
+                literalFalse,
+                builder.equals(builder.field("q", "c"), builder.literal(0)),
+                literalFalse,
+                builder.call(SqlStdOperatorTable.IS_TRUE,
+                    builder.call(RexUtil.op(op.comparisonKind),
+                        e.operands.get(0), builder.field("q", "m"))),
+                literalTrue,
+                builder.greaterThan(builder.field("q", "c"),
+                    builder.field("q", "d")),
+                literalUnknown,
                 builder.call(RexUtil.op(op.comparisonKind),
-                    e.operands.get(0), builder.field("q", "m"))),
-            literalTrue,
-            builder.greaterThan(builder.field("q", "c"),
-                builder.field("q", "d")),
-            literalUnknown,
-            builder.call(RexUtil.op(op.comparisonKind),
-                e.operands.get(0), builder.field("q", "m")));
+                    e.operands.get(0), builder.field("q", "m")));
         break;
 
       case NOT_EQUALS:
@@ -402,23 +399,24 @@ private static RexNode rewriteSome(RexSubQuery e, Set<CorrelationId> variablesSe
         parentQueryFields.add(builder.alias(literalTrue, indicator));
         builder.project(parentQueryFields).as("q"); // TODO use projectPlus
         builder.join(JoinRelType.LEFT, literalTrue, variablesSet);
-        caseRexNode = builder.call(SqlStdOperatorTable.CASE,
-            builder.isNull(builder.field("q", indicator)),
-            literalFalse,
-            builder.equals(builder.field("c"), builder.literal(0)),
-            literalFalse,
-            builder.isNull(e.getOperands().get(0)),
-            literalUnknown,
-            builder.and(
-                builder.notEquals(builder.field("d"), builder.field("c")),
-                builder.lessThanOrEqual(builder.field("d"),
-                    builder.literal(1))),
-            builder.or(
+        caseRexNode =
+            builder.call(SqlStdOperatorTable.CASE,
+                builder.isNull(builder.field("q", indicator)),
+                literalFalse,
+                builder.equals(builder.field("c"), builder.literal(0)),
+                literalFalse,
+                builder.isNull(e.getOperands().get(0)),
+                literalUnknown,
+                builder.and(
+                    builder.notEquals(builder.field("d"), builder.field("c")),
+                    builder.lessThanOrEqual(builder.field("d"),
+                        builder.literal(1))),
+                builder.or(
+                    builder.notEquals(e.operands.get(0), builder.field("q", "m")),
+                    literalUnknown),
+                builder.equals(builder.field("d"), builder.literal(1)),
                 builder.notEquals(e.operands.get(0), builder.field("q", "m")),
-                literalUnknown),
-            builder.equals(builder.field("d"), builder.literal(1)),
-            builder.notEquals(e.operands.get(0), builder.field("q", "m")),
-            literalTrue);
+                literalTrue);
         break;
 
       default:
@@ -664,10 +662,11 @@ private static RexNode rewriteIn(RexSubQuery e, Set<CorrelationId> variablesSet,
             builder.or(
                 builder.and(conditions),
                 builder.or(isNullOperands)));
-        RexNode project = builder.and(
-            fields.stream()
-                .map(builder::isNotNull)
-                .collect(Collectors.toList()));
+        RexNode project =
+            builder.and(
+                fields.stream()
+                    .map(builder::isNotNull)
+                    .collect(Collectors.toList()));
         builder.project(builder.alias(project, "cs"));
 
         if (variablesSet.isEmpty()) {
@@ -825,8 +824,8 @@ private static void matchProject(SubQueryRemoveRule rule,
     final int fieldCount = builder.peek().getRowType().getFieldCount();
     final Set<CorrelationId>  variablesSet =
         RelOptUtil.getVariablesUsed(e.rel);
-    final RexNode target = rule.apply(e, variablesSet,
-        logic, builder, 1, fieldCount);
+    final RexNode target =
+        rule.apply(e, variablesSet, logic, builder, 1, fieldCount);
     final RexShuttle shuttle = new ReplaceSubQueryShuttle(e, target);
     builder.project(shuttle.apply(project.getProjects()),
         project.getRowType().getFieldNames());
@@ -851,8 +850,9 @@ private static void matchFilter(SubQueryRemoveRule rule,
           LogicVisitor.find(RelOptUtil.Logic.TRUE, ImmutableList.of(c), e);
       final Set<CorrelationId>  variablesSet =
           RelOptUtil.getVariablesUsed(e.rel);
-      final RexNode target = rule.apply(e, variablesSet, logic,
-          builder, 1, builder.peek().getRowType().getFieldCount());
+      final RexNode target =
+          rule.apply(e, variablesSet, logic,
+              builder, 1, builder.peek().getRowType().getFieldCount());
       final RexShuttle shuttle = new ReplaceSubQueryShuttle(e, target);
       c = c.accept(shuttle);
     }
@@ -875,8 +875,8 @@ private static void matchJoin(SubQueryRemoveRule rule, RelOptRuleCall call) {
     final int fieldCount = join.getRowType().getFieldCount();
     final Set<CorrelationId>  variablesSet =
         RelOptUtil.getVariablesUsed(e.rel);
-    final RexNode target = rule.apply(e, variablesSet,
-        logic, builder, 2, fieldCount);
+    final RexNode target =
+        rule.apply(e, variablesSet, logic, builder, 2, fieldCount);
     final RexShuttle shuttle = new ReplaceSubQueryShuttle(e, target);
     builder.join(join.getJoinType(), shuttle.apply(join.getCondition()));
     builder.project(fields(builder, join.getRowType().getFieldCount()));
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/UnionPullUpConstantsRule.java b/core/src/main/java/org/apache/calcite/rel/rules/UnionPullUpConstantsRule.java
index 1e16f566438..e236844075b 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/UnionPullUpConstantsRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/UnionPullUpConstantsRule.java
@@ -95,7 +95,11 @@ public UnionPullUpConstantsRule(Class<? extends Union> unionClass,
     for (RelDataTypeField field : fields) {
       final RexNode constant = constants.get(field.getIndex());
       if (constant != null) {
-        topChildExprs.add(constant);
+        if (constant.getType().equals(field.getType())) {
+          topChildExprs.add(constant);
+        } else {
+          topChildExprs.add(rexBuilder.makeCast(field.getType(), constant, true, false));
+        }
         topChildExprsFields.add(field.getName());
       } else {
         final RexNode expr = rexBuilder.makeInputRef(union, field.getIndex());
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/ValuesReduceRule.java b/core/src/main/java/org/apache/calcite/rel/rules/ValuesReduceRule.java
index 4426398a8c8..eedc22b5241 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/ValuesReduceRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/ValuesReduceRule.java
@@ -156,9 +156,9 @@ protected void apply(RelOptRuleCall call, @Nullable LogicalProject project,
           ++k;
           RexNode e = projectExpr.accept(shuttle);
           if (RexLiteral.isNullLiteral(e)) {
-            e = rexBuilder.makeAbstractCast(
-                project.getRowType().getFieldList().get(k).getType(),
-                e);
+            RelDataType type =
+                project.getRowType().getFieldList().get(k).getType();
+            e = rexBuilder.makeAbstractCast(type, e, false);
           }
           reducibleExps.add(e);
         }
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/materialize/MaterializedViewAggregateRule.java b/core/src/main/java/org/apache/calcite/rel/rules/materialize/MaterializedViewAggregateRule.java
index 827282fc6b2..225055e5129 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/materialize/MaterializedViewAggregateRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/materialize/MaterializedViewAggregateRule.java
@@ -184,9 +184,10 @@ public abstract class MaterializedViewAggregateRule<C extends MaterializedViewAg
         ImmutableBitSet.range(
             aggregateViewNode.getInput().getRowType().getFieldCount(),
             aggregateViewNode.getInput().getRowType().getFieldCount() + offset));
-    final Aggregate newViewNode = aggregateViewNode.copy(
-        aggregateViewNode.getTraitSet(), relBuilder.build(),
-        groupSet.build(), null, aggregateViewNode.getAggCallList());
+    final Aggregate newViewNode =
+        aggregateViewNode.copy(aggregateViewNode.getTraitSet(),
+            relBuilder.build(), groupSet.build(), null,
+            aggregateViewNode.getAggCallList());
 
     relBuilder.push(newViewNode);
     List<RexNode> nodes = new ArrayList<>();
@@ -194,11 +195,11 @@ public abstract class MaterializedViewAggregateRule<C extends MaterializedViewAg
     if (topViewProject != null) {
       // Insert existing expressions (and shift aggregation arguments),
       // then append rest of columns
-      Mappings.TargetMapping shiftMapping = Mappings.createShiftMapping(
-          newViewNode.getRowType().getFieldCount(),
-          0, 0, aggregateViewNode.getGroupCount(),
-          newViewNode.getGroupCount(), aggregateViewNode.getGroupCount(),
-          aggregateViewNode.getAggCallList().size());
+      Mappings.TargetMapping shiftMapping =
+          Mappings.createShiftMapping(newViewNode.getRowType().getFieldCount(),
+              0, 0, aggregateViewNode.getGroupCount(),
+              newViewNode.getGroupCount(), aggregateViewNode.getGroupCount(),
+              aggregateViewNode.getAggCallList().size());
       for (int i = 0; i < topViewProject.getProjects().size(); i++) {
         nodes.add(
             topViewProject.getProjects().get(i).accept(
@@ -266,9 +267,10 @@ public abstract class MaterializedViewAggregateRule<C extends MaterializedViewAg
     // are contained in the query.
     List<RexNode> queryExprs = extractReferences(rexBuilder, target);
     if (!compensationColumnsEquiPred.isAlwaysTrue()) {
-      RexNode newCompensationColumnsEquiPred = rewriteExpression(rexBuilder, mq,
-          target, target, queryExprs, queryToViewTableMapping, queryEC, false,
-          compensationColumnsEquiPred);
+      RexNode newCompensationColumnsEquiPred =
+          rewriteExpression(rexBuilder, mq, target, target, queryExprs,
+              queryToViewTableMapping, queryEC, false,
+              compensationColumnsEquiPred);
       if (newCompensationColumnsEquiPred == null) {
         // Skip it
         return null;
@@ -277,19 +279,21 @@ public abstract class MaterializedViewAggregateRule<C extends MaterializedViewAg
     }
     // For the rest, we use the query equivalence classes
     if (!otherCompensationPred.isAlwaysTrue()) {
-      RexNode newOtherCompensationPred = rewriteExpression(rexBuilder, mq,
-          target, target, queryExprs, queryToViewTableMapping, viewEC, true,
-          otherCompensationPred);
+      RexNode newOtherCompensationPred =
+          rewriteExpression(rexBuilder, mq, target, target, queryExprs,
+              queryToViewTableMapping, viewEC, true,
+              otherCompensationPred);
       if (newOtherCompensationPred == null) {
         // Skip it
         return null;
       }
       otherCompensationPred = newOtherCompensationPred;
     }
-    final RexNode queryCompensationPred = RexUtil.not(
-        RexUtil.composeConjunction(rexBuilder,
-            ImmutableList.of(compensationColumnsEquiPred,
-                otherCompensationPred)));
+    final RexNode queryCompensationPred =
+        RexUtil.not(
+            RexUtil.composeConjunction(rexBuilder,
+                ImmutableList.of(compensationColumnsEquiPred,
+                    otherCompensationPred)));
 
     // Generate query rewriting.
     RelNode rewrittenPlan = relBuilder
@@ -417,9 +421,10 @@ public abstract class MaterializedViewAggregateRule<C extends MaterializedViewAg
 
     // Create mapping from query columns to view columns
     final List<RexNode> rollupNodes = new ArrayList<>();
-    final Multimap<Integer, Integer> m = generateMapping(rexBuilder, simplify, mq,
-        queryAggregate.getInput(), viewAggregate.getInput(), indexes.build(),
-        queryToViewTableMapping, queryEC, rollupNodes);
+    final Multimap<Integer, Integer> m =
+        generateMapping(rexBuilder, simplify, mq,
+            queryAggregate.getInput(), viewAggregate.getInput(), indexes.build(),
+            queryToViewTableMapping, queryEC, rollupNodes);
     if (m == null) {
       // Bail out
       return null;
@@ -434,8 +439,10 @@ public abstract class MaterializedViewAggregateRule<C extends MaterializedViewAg
     int viewAggregateTotalFieldCount =
         viewAggregate.getRowType().getFieldCount() + rollupNodes.size();
     boolean forceRollup = false;
-    Mapping aggregateMapping = Mappings.create(MappingType.FUNCTION,
-        queryAggregate.getRowType().getFieldCount(), viewAggregateTotalFieldCount);
+    Mapping aggregateMapping =
+        Mappings.create(MappingType.FUNCTION,
+            queryAggregate.getRowType().getFieldCount(),
+            viewAggregateTotalFieldCount);
     for (int i = 0; i < queryAggregate.getGroupCount(); i++) {
       Collection<Integer> c = m.get(queryAggregate.getGroupSet().nth(i));
       for (int j : c) {
@@ -553,10 +560,10 @@ public abstract class MaterializedViewAggregateRule<C extends MaterializedViewAg
           additionalViewExprs.add(
               new RexInputRef(targetIdx, targetNode.getType()));
           // We need to create the rollup expression
-          RexNode rollupExpression = requireNonNull(
-              shuttleReferences(rexBuilder, targetNode, exprsLineage),
-              () -> "shuttleReferences produced null for targetNode="
-                  + targetNode + ", exprsLineage=" + exprsLineage);
+          RexNode rollupExpression =
+              requireNonNull(shuttleReferences(rexBuilder, targetNode, exprsLineage),
+                  () -> "shuttleReferences produced null for targetNode="
+                      + targetNode + ", exprsLineage=" + exprsLineage);
           inputViewExprs.add(rollupExpression);
         } else {
           // This expression should be referenced directly
@@ -761,10 +768,9 @@ private static int find(RelNode rel, int ref) {
       final RexNode e = Iterables.getOnlyElement(s);
       // Rewrite expr to be expressed on query tables
       final RexNode simplified = simplify.simplifyUnknownAsFalse(e);
-      final RexNode expr = RexUtil.swapTableColumnReferences(rexBuilder,
-          simplified,
-          tableMapping.inverse(),
-          equivalenceClassesMap);
+      final RexNode expr =
+          RexUtil.swapTableColumnReferences(rexBuilder, simplified,
+              tableMapping.inverse(), equivalenceClassesMap);
       exprsLineage.put(expr, i);
       SqlTypeName sqlTypeName = expr.getType().getSqlTypeName();
       if (sqlTypeName == SqlTypeName.TIMESTAMP
@@ -779,8 +785,8 @@ private static int find(RelNode rel, int ref) {
     // FLOOR(ts to DAY) via FLOOR(FLOOR(ts to HOUR) to DAY)
     for (RexNode timestampExpr : timestampExprs) {
       for (TimeUnitRange value : SUPPORTED_DATE_TIME_ROLLUP_UNITS) {
-        final SqlFunction[] functions = {getCeilSqlFunction(value),
-            getFloorSqlFunction(value)};
+        final SqlFunction[] functions =
+            {getCeilSqlFunction(value), getFloorSqlFunction(value)};
         for (SqlFunction function : functions) {
           final RexNode call =
               rexBuilder.makeCall(function,
@@ -816,8 +822,9 @@ private static int find(RelNode rel, int ref) {
       final RexNode e = Iterables.getOnlyElement(s);
       // Rewrite expr to be expressed on query tables
       final RexNode simplified = simplify.simplifyUnknownAsFalse(e);
-      RexNode targetExpr = RexUtil.swapColumnReferences(rexBuilder,
-          simplified, equivalenceClassesMap);
+      RexNode targetExpr =
+          RexUtil.swapColumnReferences(rexBuilder, simplified,
+              equivalenceClassesMap);
       final Collection<Integer> c = exprsLineage.get(targetExpr);
       if (!c.isEmpty()) {
         for (Integer j : c) {
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/materialize/MaterializedViewJoinRule.java b/core/src/main/java/org/apache/calcite/rel/rules/materialize/MaterializedViewJoinRule.java
index 8d30a9ea5d1..803033a6cc6 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/materialize/MaterializedViewJoinRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/materialize/MaterializedViewJoinRule.java
@@ -180,9 +180,10 @@ public abstract class MaterializedViewJoinRule<C extends MaterializedViewRule.Co
 
 
     if (!compensationColumnsEquiPred.isAlwaysTrue()) {
-      RexNode newCompensationColumnsEquiPred = rewriteExpression(rexBuilder, mq,
-          target, target, queryExprs, viewToQueryTableMapping.inverse(), queryEC, false,
-          compensationColumnsEquiPred);
+      RexNode newCompensationColumnsEquiPred =
+          rewriteExpression(rexBuilder, mq, target, target, queryExprs,
+              viewToQueryTableMapping.inverse(), queryEC, false,
+              compensationColumnsEquiPred);
       if (newCompensationColumnsEquiPred == null) {
         // Skip it
         return null;
@@ -191,19 +192,21 @@ public abstract class MaterializedViewJoinRule<C extends MaterializedViewRule.Co
     }
     // For the rest, we use the query equivalence classes
     if (!otherCompensationPred.isAlwaysTrue()) {
-      RexNode newOtherCompensationPred = rewriteExpression(rexBuilder, mq,
-          target, target, queryExprs, viewToQueryTableMapping.inverse(), viewEC, true,
-          otherCompensationPred);
+      RexNode newOtherCompensationPred =
+          rewriteExpression(rexBuilder, mq, target, target, queryExprs,
+              viewToQueryTableMapping.inverse(), viewEC, true,
+              otherCompensationPred);
       if (newOtherCompensationPred == null) {
         // Skip it
         return null;
       }
       otherCompensationPred = newOtherCompensationPred;
     }
-    final RexNode queryCompensationPred = RexUtil.not(
-        RexUtil.composeConjunction(rexBuilder,
-            ImmutableList.of(compensationColumnsEquiPred,
-                otherCompensationPred)));
+    final RexNode queryCompensationPred =
+        RexUtil.not(
+            RexUtil.composeConjunction(rexBuilder,
+                ImmutableList.of(compensationColumnsEquiPred,
+                    otherCompensationPred)));
 
     // Generate query rewriting.
     RelNode rewrittenPlan = relBuilder
@@ -211,8 +214,8 @@ public abstract class MaterializedViewJoinRule<C extends MaterializedViewRule.Co
         .filter(simplify.simplifyUnknownAsFalse(queryCompensationPred))
         .build();
     if (unionRewritingPullProgram != null) {
-      rewrittenPlan = newNode.copy(
-          newNode.getTraitSet(), ImmutableList.of(rewrittenPlan));
+      rewrittenPlan =
+          newNode.copy(newNode.getTraitSet(), ImmutableList.of(rewrittenPlan));
     }
     if (topProject != null) {
       return topProject.copy(topProject.getTraitSet(), ImmutableList.of(rewrittenPlan));
@@ -279,8 +282,9 @@ public abstract class MaterializedViewJoinRule<C extends MaterializedViewRule.Co
     List<RexNode> viewExprs = topViewProject == null
         ? extractReferences(rexBuilder, viewNode)
         : topViewProject.getProjects();
-    List<RexNode> rewrittenExprs = rewriteExpressions(rexBuilder, mq, input, viewNode, viewExprs,
-        queryToViewTableMapping.inverse(), queryEC, true, exprsLineage);
+    List<RexNode> rewrittenExprs =
+        rewriteExpressions(rexBuilder, mq, input, viewNode, viewExprs,
+            queryToViewTableMapping.inverse(), queryEC, true, exprsLineage);
     if (rewrittenExprs == null) {
       return null;
     }
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/materialize/MaterializedViewRule.java b/core/src/main/java/org/apache/calcite/rel/rules/materialize/MaterializedViewRule.java
index 113f95869e8..e2aa969c4ab 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/materialize/MaterializedViewRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/materialize/MaterializedViewRule.java
@@ -246,9 +246,10 @@ protected void perform(RelOptRuleCall call, @Nullable Project topProject, RelNod
           // Skip it
           continue;
         }
-        final RexNode viewPred = simplify.simplifyUnknownAsFalse(
-            RexUtil.composeConjunction(rexBuilder,
-                viewPredicateList.pulledUpPredicates));
+        final RexNode viewPred =
+            simplify.simplifyUnknownAsFalse(
+                RexUtil.composeConjunction(rexBuilder,
+                    viewPredicateList.pulledUpPredicates));
         final Pair<RexNode, RexNode> viewPreds = splitPredicates(rexBuilder, viewPred);
 
         // Extract view tables
@@ -278,10 +279,10 @@ protected void perform(RelOptRuleCall call, @Nullable Project topProject, RelNod
             }
           } else if (queryTableRefs.containsAll(viewTableRefs)) {
             matchModality = MatchModality.VIEW_PARTIAL;
-            ViewPartialRewriting partialRewritingResult = compensateViewPartial(
-                call.builder(), rexBuilder, mq, view,
-                topProject, node, queryTableRefs, qEC,
-                topViewProject, viewNode, viewTableRefs);
+            ViewPartialRewriting partialRewritingResult =
+                compensateViewPartial(call.builder(), rexBuilder, mq, view,
+                    topProject, node, queryTableRefs, qEC,
+                    topViewProject, viewNode, viewTableRefs);
             if (partialRewritingResult == null) {
               // Cannot rewrite, skip it
               continue;
@@ -328,11 +329,13 @@ protected void perform(RelOptRuleCall call, @Nullable Project topProject, RelNod
             for (Map.Entry<RexTableInputRef, RexTableInputRef> e
                 : compensationEquiColumns.entries()) {
               // Copy origin
-              RelTableRef queryTableRef = queryToViewTableMapping.inverse().get(
-                  e.getKey().getTableRef());
-              RexTableInputRef queryColumnRef = RexTableInputRef.of(
-                  requireNonNull(queryTableRef,
-                      () -> "queryTableRef is null for tableRef " + e.getKey().getTableRef()),
+              RelTableRef queryTableRef =
+                  queryToViewTableMapping.inverse().get(e.getKey().getTableRef());
+              RexTableInputRef queryColumnRef =
+                  RexTableInputRef.of(
+                      requireNonNull(queryTableRef,
+                          () -> "queryTableRef is null for tableRef "
+                              + e.getKey().getTableRef()),
                   e.getKey().getIndex(), e.getKey().getType());
               // Add to query equivalence classes and table mapping
               currQEC.addEquivalenceClass(queryColumnRef, e.getValue());
@@ -346,8 +349,9 @@ protected void perform(RelOptRuleCall call, @Nullable Project topProject, RelNod
           // are expressed using {@link RexTableInputRef} over the query.
           // First, to establish relationship, we swap column references of the view
           // predicates to point to query tables and compute equivalence classes.
-          final RexNode viewColumnsEquiPred = RexUtil.swapTableReferences(
-              rexBuilder, viewPreds.left, queryToViewTableMapping.inverse());
+          final RexNode viewColumnsEquiPred =
+              RexUtil.swapTableReferences(rexBuilder, viewPreds.left,
+                  queryToViewTableMapping.inverse());
           final EquivalenceClasses queryBasedVEC = new EquivalenceClasses();
           for (RexNode conj : RelOptUtil.conjunctions(viewColumnsEquiPred)) {
             assert conj.isA(SqlKind.EQUALS);
@@ -365,9 +369,10 @@ protected void perform(RelOptRuleCall call, @Nullable Project topProject, RelNod
             // will read some data from the view and the rest of the data from
             // the query computation. The resulting predicates are expressed
             // using {@link RexTableInputRef} over the view.
-            compensationPreds = computeCompensationPredicates(rexBuilder, simplify,
-                queryBasedVEC, viewPreds, currQEC, queryPreds,
-                queryToViewTableMapping.inverse());
+            compensationPreds =
+                computeCompensationPredicates(rexBuilder, simplify,
+                    queryBasedVEC, viewPreds, currQEC, queryPreds,
+                    queryToViewTableMapping.inverse());
             if (compensationPreds == null) {
               // This was our last chance to use the view, skip it
               continue;
@@ -378,9 +383,11 @@ protected void perform(RelOptRuleCall call, @Nullable Project topProject, RelNod
                 || !otherCompensationPred.isAlwaysTrue();
 
             // b. Generate union branch (query).
-            final RelNode unionInputQuery = rewriteQuery(call.builder(), rexBuilder,
-                simplify, mq, compensationColumnsEquiPred, otherCompensationPred,
-                topProject, node, queryToViewTableMapping, queryBasedVEC, currQEC);
+            final RelNode unionInputQuery =
+                rewriteQuery(call.builder(), rexBuilder, simplify, mq,
+                    compensationColumnsEquiPred, otherCompensationPred,
+                    topProject, node, queryToViewTableMapping, queryBasedVEC,
+                    currQEC);
             if (unionInputQuery == null) {
               // Skip it
               continue;
@@ -390,17 +397,19 @@ protected void perform(RelOptRuleCall call, @Nullable Project topProject, RelNod
             // We trigger the unifying method. This method will either create a Project
             // or an Aggregate operator on top of the view. It will also compute the
             // output expressions for the query.
-            final RelNode unionInputView = rewriteView(call.builder(), rexBuilder, simplify, mq,
-                matchModality, true, view, topProject, node, topViewProject, viewNode,
-                queryToViewTableMapping, currQEC);
+            final RelNode unionInputView =
+                rewriteView(call.builder(), rexBuilder, simplify, mq,
+                    matchModality, true, view, topProject, node, topViewProject,
+                    viewNode, queryToViewTableMapping, currQEC);
             if (unionInputView == null) {
               // Skip it
               continue;
             }
 
             // d. Generate final rewriting (union).
-            final RelNode result = createUnion(call.builder(), rexBuilder,
-                topProject, unionInputQuery, unionInputView);
+            final RelNode result =
+                createUnion(call.builder(), rexBuilder, topProject,
+                    unionInputQuery, unionInputView);
             if (result == null) {
               // Skip it
               continue;
@@ -421,9 +430,10 @@ protected void perform(RelOptRuleCall call, @Nullable Project topProject, RelNod
               // For compensationColumnsEquiPred, we use the view equivalence classes,
               // since we want to enforce the rest
               if (!compensationColumnsEquiPred.isAlwaysTrue()) {
-                compensationColumnsEquiPred = rewriteExpression(rexBuilder, mq,
-                    view, viewNode, viewExprs, queryToViewTableMapping.inverse(), queryBasedVEC,
-                    false, compensationColumnsEquiPred);
+                compensationColumnsEquiPred =
+                    rewriteExpression(rexBuilder, mq, view, viewNode, viewExprs,
+                        queryToViewTableMapping.inverse(), queryBasedVEC,
+                        false, compensationColumnsEquiPred);
                 if (compensationColumnsEquiPred == null) {
                   // Skip it
                   continue;
@@ -431,9 +441,10 @@ protected void perform(RelOptRuleCall call, @Nullable Project topProject, RelNod
               }
               // For the rest, we use the query equivalence classes
               if (!otherCompensationPred.isAlwaysTrue()) {
-                otherCompensationPred = rewriteExpression(rexBuilder, mq,
-                    view, viewNode, viewExprs, queryToViewTableMapping.inverse(), currQEC,
-                    true, otherCompensationPred);
+                otherCompensationPred =
+                    rewriteExpression(rexBuilder, mq, view, viewNode, viewExprs,
+                        queryToViewTableMapping.inverse(), currQEC,
+                        true, otherCompensationPred);
                 if (otherCompensationPred == null) {
                   // Skip it
                   continue;
@@ -471,9 +482,10 @@ protected void perform(RelOptRuleCall call, @Nullable Project topProject, RelNod
             } else {
               viewWithFilter = builder.push(view).build();
             }
-            final RelNode result = rewriteView(builder, rexBuilder, simplify, mq, matchModality,
-                false, viewWithFilter, topProject, node, topViewProject, viewNode,
-                queryToViewTableMapping, currQEC);
+            final RelNode result =
+                rewriteView(builder, rexBuilder, simplify, mq, matchModality,
+                    false, viewWithFilter, topProject, node, topViewProject,
+                    viewNode, queryToViewTableMapping, currQEC);
             if (result == null) {
               // Skip it
               continue;
@@ -826,8 +838,8 @@ && castNonNull(sourceEC.getEquivalenceClassesMap().get(uniqueKeyColumnRef))
     // 1. Establish relationship between source and target equivalence classes.
     // If every target equivalence class is not a subset of a source
     // equivalence class, we bail out.
-    compensationColumnsEquiPred = generateEquivalenceClasses(
-        rexBuilder, sourceEC, targetEC);
+    compensationColumnsEquiPred =
+        generateEquivalenceClasses(rexBuilder, sourceEC, targetEC);
     if (compensationColumnsEquiPred == null) {
       // Cannot rewrite
       return null;
@@ -835,13 +847,15 @@ && castNonNull(sourceEC.getEquivalenceClassesMap().get(uniqueKeyColumnRef))
 
     // 2. We check that that residual predicates of the source are satisfied within the target.
     // Compute compensating predicates.
-    final RexNode queryPred = RexUtil.swapColumnReferences(
-        rexBuilder, sourcePreds.right, sourceEC.getEquivalenceClassesMap());
-    final RexNode viewPred = RexUtil.swapTableColumnReferences(
-        rexBuilder, targetPreds.right, sourceToTargetTableMapping.inverse(),
-        sourceEC.getEquivalenceClassesMap());
-    compensationPred = SubstitutionVisitor.splitFilter(
-        simplify, queryPred, viewPred);
+    final RexNode queryPred =
+        RexUtil.swapColumnReferences(rexBuilder, sourcePreds.right,
+            sourceEC.getEquivalenceClassesMap());
+    final RexNode viewPred =
+        RexUtil.swapTableColumnReferences(rexBuilder, targetPreds.right,
+            sourceToTargetTableMapping.inverse(),
+            sourceEC.getEquivalenceClassesMap());
+    compensationPred =
+        SubstitutionVisitor.splitFilter(simplify, queryPred, viewPred);
     if (compensationPred == null) {
       // Cannot rewrite
       return null;
@@ -863,20 +877,26 @@ && castNonNull(sourceEC.getEquivalenceClassesMap().get(uniqueKeyColumnRef))
    */
   protected @Nullable RexNode generateEquivalenceClasses(RexBuilder rexBuilder,
       EquivalenceClasses sourceEC, EquivalenceClasses targetEC) {
-    if (sourceEC.getEquivalenceClasses().isEmpty() && targetEC.getEquivalenceClasses().isEmpty()) {
+    if (sourceEC.getEquivalenceClasses().isEmpty()
+        && targetEC.getEquivalenceClasses().isEmpty()) {
       // No column equality predicates in query and view
       // Empty mapping and compensation predicate
       return rexBuilder.makeLiteral(true);
     }
-    if (sourceEC.getEquivalenceClasses().isEmpty() && !targetEC.getEquivalenceClasses().isEmpty()) {
-      // No column equality predicates in source, but column equality predicates in target
+    if (sourceEC.getEquivalenceClasses().isEmpty()
+        && !targetEC.getEquivalenceClasses().isEmpty()) {
+      // No column equality predicates in source, but column equality predicates
+      // in target
       return null;
     }
 
-    final List<Set<RexTableInputRef>> sourceEquivalenceClasses = sourceEC.getEquivalenceClasses();
-    final List<Set<RexTableInputRef>> targetEquivalenceClasses = targetEC.getEquivalenceClasses();
-    final Multimap<Integer, Integer> mapping = extractPossibleMapping(
-        sourceEquivalenceClasses, targetEquivalenceClasses);
+    final List<Set<RexTableInputRef>> sourceEquivalenceClasses =
+        sourceEC.getEquivalenceClasses();
+    final List<Set<RexTableInputRef>> targetEquivalenceClasses =
+        targetEC.getEquivalenceClasses();
+    final Multimap<Integer, Integer> mapping =
+        extractPossibleMapping(sourceEquivalenceClasses,
+            targetEquivalenceClasses);
     if (mapping == null) {
       // Did not find mapping between the equivalence classes,
       // bail out
@@ -888,25 +908,29 @@ && castNonNull(sourceEC.getEquivalenceClassesMap().get(uniqueKeyColumnRef))
     for (int i = 0; i < sourceEquivalenceClasses.size(); i++) {
       if (!mapping.containsKey(i)) {
         // Add all predicates
-        Iterator<RexTableInputRef> it = sourceEquivalenceClasses.get(i).iterator();
+        Iterator<RexTableInputRef> it =
+            sourceEquivalenceClasses.get(i).iterator();
         RexTableInputRef e0 = it.next();
         while (it.hasNext()) {
-          RexNode equals = rexBuilder.makeCall(SqlStdOperatorTable.EQUALS,
-              e0, it.next());
-          compensationPredicate = rexBuilder.makeCall(SqlStdOperatorTable.AND,
-              compensationPredicate, equals);
+          RexNode equals =
+              rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, e0, it.next());
+          compensationPredicate =
+              rexBuilder.makeCall(SqlStdOperatorTable.AND,
+                  compensationPredicate, equals);
         }
       } else {
         // Add only predicates that are not there
         for (int j : mapping.get(i)) {
-          Set<RexTableInputRef> difference = new HashSet<>(
-              sourceEquivalenceClasses.get(i));
+          Set<RexTableInputRef> difference =
+              new HashSet<>(sourceEquivalenceClasses.get(i));
           difference.removeAll(targetEquivalenceClasses.get(j));
           for (RexTableInputRef e : difference) {
-            RexNode equals = rexBuilder.makeCall(SqlStdOperatorTable.EQUALS,
-                e, targetEquivalenceClasses.get(j).iterator().next());
-            compensationPredicate = rexBuilder.makeCall(SqlStdOperatorTable.AND,
-                compensationPredicate, equals);
+            RexNode equals =
+                rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, e,
+                    targetEquivalenceClasses.get(j).iterator().next());
+            compensationPredicate =
+                rexBuilder.makeCall(SqlStdOperatorTable.AND,
+                    compensationPredicate, equals);
           }
         }
       }
@@ -968,8 +992,9 @@ && castNonNull(sourceEC.getEquivalenceClassesMap().get(uniqueKeyColumnRef))
       EquivalenceClasses ec,
       boolean swapTableColumn,
       RexNode exprToRewrite) {
-    List<RexNode> rewrittenExprs = rewriteExpressions(rexBuilder, mq, targetNode, node, nodeExprs,
-        tableMapping, ec, swapTableColumn, ImmutableList.of(exprToRewrite));
+    List<RexNode> rewrittenExprs =
+        rewriteExpressions(rexBuilder, mq, targetNode, node, nodeExprs,
+            tableMapping, ec, swapTableColumn, ImmutableList.of(exprToRewrite));
     if (rewrittenExprs == null) {
       return null;
     }
@@ -1001,17 +1026,20 @@ && castNonNull(sourceEC.getEquivalenceClassesMap().get(uniqueKeyColumnRef))
       List<RexNode> exprsToRewrite) {
     NodeLineage nodeLineage;
     if (swapTableColumn) {
-      nodeLineage = generateSwapTableColumnReferencesLineage(rexBuilder, mq, node,
-          tableMapping, ec, nodeExprs);
+      nodeLineage =
+          generateSwapTableColumnReferencesLineage(rexBuilder, mq, node,
+              tableMapping, ec, nodeExprs);
     } else {
-      nodeLineage = generateSwapColumnTableReferencesLineage(rexBuilder, mq, node,
-          tableMapping, ec, nodeExprs);
+      nodeLineage =
+          generateSwapColumnTableReferencesLineage(rexBuilder, mq, node,
+              tableMapping, ec, nodeExprs);
     }
 
     List<RexNode> rewrittenExprs = new ArrayList<>(exprsToRewrite.size());
     for (RexNode exprToRewrite : exprsToRewrite) {
-      RexNode rewrittenExpr = replaceWithOriginalReferences(
-          rexBuilder, targetNode, nodeLineage, exprToRewrite);
+      RexNode rewrittenExpr =
+          replaceWithOriginalReferences(rexBuilder, targetNode, nodeLineage,
+              exprToRewrite);
       if (RexUtil.containsTableInputRef(rewrittenExpr) != null) {
         // Some expressions were not present in view output
         return null;
@@ -1048,8 +1076,10 @@ protected NodeLineage generateSwapTableColumnReferencesLineage(
       }
       // Rewrite expr. First we swap the table references following the table
       // mapping, then we take first element from the corresponding equivalence class
-      final RexNode e = RexUtil.swapTableColumnReferences(rexBuilder,
-          lineages.iterator().next(), tableMapping, ec.getEquivalenceClassesMap());
+      final RexNode e =
+          RexUtil.swapTableColumnReferences(rexBuilder,
+              lineages.iterator().next(), tableMapping,
+              ec.getEquivalenceClassesMap());
       exprsLineage.put(e, i);
       if (RexUtil.isLosslessCast(e)) {
         exprsLineageLosslessCasts.put(((RexCall) e).getOperands().get(0), i);
@@ -1083,10 +1113,13 @@ protected NodeLineage generateSwapColumnTableReferencesLineage(
             + "thus expression lineage should map to a single expression, got: '"
             + lineages + "' for expr '" + expr + "' in node '" + node + "'");
       }
-      // Rewrite expr. First we take first element from the corresponding equivalence class,
-      // then we swap the table references following the table mapping
-      final RexNode e = RexUtil.swapColumnTableReferences(rexBuilder,
-          lineages.iterator().next(), ec.getEquivalenceClassesMap(), tableMapping);
+      // Rewrite expr. First we take first element from the corresponding
+      // equivalence class, then we swap the table references following the
+      // table mapping
+      final RexNode e =
+          RexUtil.swapColumnTableReferences(rexBuilder,
+              lineages.iterator().next(), ec.getEquivalenceClassesMap(),
+              tableMapping);
       exprsLineage.put(e, i);
       if (RexUtil.isLosslessCast(e)) {
         exprsLineageLosslessCasts.put(((RexCall) e).getOperands().get(0), i);
diff --git a/core/src/main/java/org/apache/calcite/rel/stream/StreamRules.java b/core/src/main/java/org/apache/calcite/rel/stream/StreamRules.java
index 3f3fbd23820..86983ee5ede 100644
--- a/core/src/main/java/org/apache/calcite/rel/stream/StreamRules.java
+++ b/core/src/main/java/org/apache/calcite/rel/stream/StreamRules.java
@@ -86,7 +86,8 @@ protected DeltaProjectTransposeRule(DeltaProjectTransposeRuleConfig config) {
           LogicalProject.create(newDelta,
               project.getHints(),
               project.getProjects(),
-              project.getRowType().getFieldNames());
+              project.getRowType().getFieldNames(),
+              project.getVariablesSet());
       call.transformTo(newProject);
     }
 
@@ -382,24 +383,18 @@ public DeltaJoinTransposeRule() {
       final RelNode right = join.getRight();
 
       final LogicalDelta rightWithDelta = LogicalDelta.create(right);
-      final LogicalJoin joinL = LogicalJoin.create(left,
-          rightWithDelta,
-          join.getHints(),
-          join.getCondition(),
-          join.getVariablesSet(),
-          join.getJoinType(),
-          join.isSemiJoinDone(),
-          ImmutableList.copyOf(join.getSystemFieldList()));
+      final LogicalJoin joinL =
+          LogicalJoin.create(left, rightWithDelta, join.getHints(),
+              join.getCondition(), join.getVariablesSet(), join.getJoinType(),
+              join.isSemiJoinDone(),
+              ImmutableList.copyOf(join.getSystemFieldList()));
 
       final LogicalDelta leftWithDelta = LogicalDelta.create(left);
-      final LogicalJoin joinR = LogicalJoin.create(leftWithDelta,
-          right,
-          join.getHints(),
-          join.getCondition(),
-          join.getVariablesSet(),
-          join.getJoinType(),
-          join.isSemiJoinDone(),
-          ImmutableList.copyOf(join.getSystemFieldList()));
+      final LogicalJoin joinR =
+          LogicalJoin.create(leftWithDelta, right, join.getHints(),
+              join.getCondition(), join.getVariablesSet(), join.getJoinType(),
+              join.isSemiJoinDone(),
+              ImmutableList.copyOf(join.getSystemFieldList()));
 
       List<RelNode> inputsToUnion = new ArrayList<>();
       inputsToUnion.add(joinL);
diff --git a/core/src/main/java/org/apache/calcite/rel/type/DelegatingTypeSystem.java b/core/src/main/java/org/apache/calcite/rel/type/DelegatingTypeSystem.java
index 76af9dfd761..96b8628a9ba 100644
--- a/core/src/main/java/org/apache/calcite/rel/type/DelegatingTypeSystem.java
+++ b/core/src/main/java/org/apache/calcite/rel/type/DelegatingTypeSystem.java
@@ -96,4 +96,8 @@ protected DelegatingTypeSystem(RelDataTypeSystem typeSystem) {
   @Override public boolean shouldConvertRaggedUnionTypesToVarying() {
     return typeSystem.shouldConvertRaggedUnionTypesToVarying();
   }
+
+  @Override public TimeFrameSet deriveTimeFrameSet(TimeFrameSet frameSet) {
+    return typeSystem.deriveTimeFrameSet(frameSet);
+  }
 }
diff --git a/core/src/main/java/org/apache/calcite/rel/type/RelCrossType.java b/core/src/main/java/org/apache/calcite/rel/type/RelCrossType.java
index 31445cc3d3a..f39f2b67737 100644
--- a/core/src/main/java/org/apache/calcite/rel/type/RelCrossType.java
+++ b/core/src/main/java/org/apache/calcite/rel/type/RelCrossType.java
@@ -31,7 +31,7 @@
 public class RelCrossType extends RelDataTypeImpl {
   //~ Instance fields --------------------------------------------------------
 
-  public final ImmutableList<RelDataType> types;
+  private final ImmutableList<RelDataType> types;
 
   //~ Constructors -----------------------------------------------------------
 
@@ -58,6 +58,15 @@ public RelCrossType(
     return false;
   }
 
+  /**
+   * Returns the contained types.
+   *
+   * @return data types.
+   */
+  public List<RelDataType> getTypes() {
+    return types;
+  }
+
   @Override protected void generateTypeString(StringBuilder sb, boolean withDetail) {
     sb.append("CrossType(");
     for (Ord<RelDataType> type : Ord.zip(types)) {
diff --git a/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeFactory.java b/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeFactory.java
index 2000ccfa172..182422e4cc1 100644
--- a/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeFactory.java
+++ b/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeFactory.java
@@ -132,6 +132,14 @@ RelDataType createMapType(
       RelDataType keyType,
       RelDataType valueType);
 
+  /**
+   * Creates a measure type.
+   *
+   * @param valueType type of the values of the measure
+   * @return canonical measure type descriptor
+   */
+  RelDataType createMeasureType(RelDataType valueType);
+
   /**
    * Creates a multiset type. Multisets are unordered collections of elements.
    *
@@ -560,8 +568,9 @@ public Builder nullableRecord(boolean nullableRecord) {
      * Makes sure that field names are unique.
      */
     public Builder uniquify() {
-      final List<String> uniqueNames = SqlValidatorUtil.uniquify(names,
-          typeFactory.getTypeSystem().isSchemaCaseSensitive());
+      final List<String> uniqueNames =
+          SqlValidatorUtil.uniquify(names,
+              typeFactory.getTypeSystem().isSchemaCaseSensitive());
       if (uniqueNames != names) {
         names.clear();
         names.addAll(uniqueNames);
diff --git a/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeFactoryImpl.java b/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeFactoryImpl.java
index d4715f2ea07..3bf1a902e83 100644
--- a/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeFactoryImpl.java
+++ b/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeFactoryImpl.java
@@ -251,9 +251,9 @@ private RelDataType createStructType(
       // first type?
       final int k = j;
 
-      RelDataType type = leastRestrictive(
-          Util.transform(types, t -> t.getFieldList().get(k).getType())
-      );
+      RelDataType type =
+          leastRestrictive(
+              Util.transform(types, t -> t.getFieldList().get(k).getType()));
       if (type == null) {
         return null;
       }
@@ -274,11 +274,12 @@ private RelDataType createStructType(
       }
       isNullable |= type.isNullable();
     }
-    final RelDataType type = leastRestrictive(
-        Util.transform(types,
-            t -> t instanceof ArraySqlType
-                ? ((ArraySqlType) t).getComponentType()
-                : ((MultisetSqlType) t).getComponentType()));
+    final RelDataType type =
+        leastRestrictive(
+            Util.transform(types,
+                t -> t instanceof ArraySqlType
+                    ? ((ArraySqlType) t).getComponentType()
+                    : ((MultisetSqlType) t).getComponentType()));
     if (type == null) {
       return null;
     }
@@ -297,13 +298,15 @@ private RelDataType createStructType(
       }
       isNullable |= type.isNullable();
     }
-    final RelDataType keyType = leastRestrictive(
-        Util.transform(types, t -> ((MapSqlType) t).getKeyType()));
+    final RelDataType keyType =
+        leastRestrictive(
+            Util.transform(types, t -> ((MapSqlType) t).getKeyType()));
     if (keyType == null) {
       return null;
     }
-    final RelDataType valueType = leastRestrictive(
-        Util.transform(types, t -> ((MapSqlType) t).getValueType()));
+    final RelDataType valueType =
+        leastRestrictive(
+            Util.transform(types, t -> ((MapSqlType) t).getValueType()));
     if (valueType == null) {
       return null;
     }
@@ -418,8 +421,8 @@ protected RelDataType canonize(final StructKind kind,
       final List<String> names,
       final List<RelDataType> types,
       final boolean nullable) {
-    final RelDataType type = KEY2TYPE_CACHE.getIfPresent(
-        new Key(kind, names, types, nullable));
+    final RelDataType type =
+        KEY2TYPE_CACHE.getIfPresent(new Key(kind, names, types, nullable));
     if (type != null) {
       return type;
     }
@@ -449,11 +452,11 @@ private static List<RelDataTypeField> getFieldList(List<RelDataType> types) {
    * Returns a list of all atomic types in a list.
    */
   private static void getTypeList(
-      ImmutableList<RelDataType> inTypes,
+      List<RelDataType> inTypes,
       List<RelDataType> flatTypes) {
     for (RelDataType inType : inTypes) {
       if (inType instanceof RelCrossType) {
-        getTypeList(((RelCrossType) inType).types, flatTypes);
+        getTypeList(((RelCrossType) inType).getTypes(), flatTypes);
       } else {
         flatTypes.add(inType);
       }
@@ -470,15 +473,16 @@ private static void addFields(
       List<RelDataTypeField> fieldList) {
     if (type instanceof RelCrossType) {
       final RelCrossType crossType = (RelCrossType) type;
-      for (RelDataType type1 : crossType.types) {
+      for (RelDataType type1 : crossType.getTypes()) {
         addFields(type1, fieldList);
       }
     } else {
       List<RelDataTypeField> fields = type.getFieldList();
       for (RelDataTypeField field : fields) {
         if (field.getIndex() != fieldList.size()) {
-          field = new RelDataTypeFieldImpl(field.getName(), fieldList.size(),
-              field.getType());
+          field =
+              new RelDataTypeFieldImpl(field.getName(), fieldList.size(),
+                  field.getType());
         }
         fieldList.add(field);
       }
diff --git a/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeHolder.java b/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeHolder.java
index d08a68de02b..6358f570bfc 100644
--- a/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeHolder.java
+++ b/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeHolder.java
@@ -67,10 +67,11 @@ Pair<RelDataTypeField, Boolean> getFieldOrInsert(String fieldName, boolean caseS
         ? SqlTypeName.DYNAMIC_STAR : SqlTypeName.ANY;
 
     // This field does not exist in our field list; add it
-    RelDataTypeField newField = new RelDataTypeFieldImpl(
-        fieldName,
-        fields.size(),
-        typeFactory.createTypeWithNullability(typeFactory.createSqlType(typeName), true));
+    RelDataTypeField newField =
+        new RelDataTypeFieldImpl(fieldName,
+            fields.size(),
+            typeFactory.createTypeWithNullability(
+                typeFactory.createSqlType(typeName), true));
 
     // Add the name to our list of field names
     fields.add(newField);
diff --git a/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeImpl.java b/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeImpl.java
index 0b0bbac6a84..274a6b72c8c 100644
--- a/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeImpl.java
+++ b/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeImpl.java
@@ -307,9 +307,7 @@ protected abstract void generateTypeString(
    * subclass constructor once the type is fully defined.
    */
   @SuppressWarnings("method.invocation.invalid")
-  protected void computeDigest(
-      @UnknownInitialization RelDataTypeImpl this
-  ) {
+  protected void computeDigest(@UnknownInitialization RelDataTypeImpl this) {
     StringBuilder sb = new StringBuilder();
     generateTypeString(sb, true);
     if (!isNullable()) {
diff --git a/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeSystem.java b/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeSystem.java
index 5f6095da763..9332eaba20f 100644
--- a/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeSystem.java
+++ b/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeSystem.java
@@ -111,10 +111,8 @@ RelDataType deriveCovarType(RelDataTypeFactory typeFactory,
    *
    * <p>Pre-condition: <code>createDecimalProduct(type1, type2) != null</code>
    */
-  default boolean shouldUseDoubleMultiplication(
-          RelDataTypeFactory typeFactory,
-          RelDataType type1,
-          RelDataType type2) {
+  default boolean shouldUseDoubleMultiplication(RelDataTypeFactory typeFactory,
+      RelDataType type1, RelDataType type2) {
     assert deriveDecimalMultiplyType(typeFactory, type1, type2) != null;
     return false;
   }
@@ -150,9 +148,9 @@ default boolean shouldUseDoubleMultiplication(
   default @Nullable RelDataType deriveDecimalPlusType(RelDataTypeFactory typeFactory,
       RelDataType type1, RelDataType type2) {
     if (SqlTypeUtil.isExactNumeric(type1)
-            && SqlTypeUtil.isExactNumeric(type2)) {
+        && SqlTypeUtil.isExactNumeric(type2)) {
       if (SqlTypeUtil.isDecimal(type1)
-              || SqlTypeUtil.isDecimal(type2)) {
+          || SqlTypeUtil.isDecimal(type2)) {
         // Java numeric will always have invalid precision/scale,
         // use its default decimal precision/scale instead.
         type1 = RelDataTypeFactoryImpl.isJavaType(type1)
@@ -168,16 +166,10 @@ default boolean shouldUseDoubleMultiplication(
         int scale = Math.max(s1, s2);
         assert scale <= getMaxNumericScale();
         int precision = Math.max(p1 - s1, p2 - s2) + scale + 1;
-        precision =
-                Math.min(
-                        precision,
-                        getMaxNumericPrecision());
+        precision = Math.min(precision, getMaxNumericPrecision());
         assert precision > 0;
 
-        return typeFactory.createSqlType(
-                SqlTypeName.DECIMAL,
-                precision,
-                scale);
+        return typeFactory.createSqlType(SqlTypeName.DECIMAL, precision, scale);
       }
     }
     return null;
@@ -219,9 +211,9 @@ default boolean shouldUseDoubleMultiplication(
   default @Nullable RelDataType deriveDecimalMultiplyType(RelDataTypeFactory typeFactory,
       RelDataType type1, RelDataType type2) {
     if (SqlTypeUtil.isExactNumeric(type1)
-            && SqlTypeUtil.isExactNumeric(type2)) {
+        && SqlTypeUtil.isExactNumeric(type2)) {
       if (SqlTypeUtil.isDecimal(type1)
-              || SqlTypeUtil.isDecimal(type2)) {
+          || SqlTypeUtil.isDecimal(type2)) {
         // Java numeric will always have invalid precision/scale,
         // use its default decimal precision/scale instead.
         type1 = RelDataTypeFactoryImpl.isJavaType(type1)
@@ -238,16 +230,10 @@ default boolean shouldUseDoubleMultiplication(
         int scale = s1 + s2;
         scale = Math.min(scale, getMaxNumericScale());
         int precision = p1 + p2;
-        precision =
-                Math.min(
-                        precision,
-                        getMaxNumericPrecision());
+        precision = Math.min(precision, getMaxNumericPrecision());
 
         RelDataType ret;
-        ret = typeFactory.createSqlType(
-                        SqlTypeName.DECIMAL,
-                        precision,
-                        scale);
+        ret = typeFactory.createSqlType(SqlTypeName.DECIMAL, precision, scale);
 
         return ret;
       }
@@ -292,9 +278,9 @@ default boolean shouldUseDoubleMultiplication(
       RelDataType type1, RelDataType type2) {
 
     if (SqlTypeUtil.isExactNumeric(type1)
-            && SqlTypeUtil.isExactNumeric(type2)) {
+        && SqlTypeUtil.isExactNumeric(type2)) {
       if (SqlTypeUtil.isDecimal(type1)
-              || SqlTypeUtil.isDecimal(type2)) {
+          || SqlTypeUtil.isDecimal(type2)) {
         // Java numeric will always have invalid precision/scale,
         // use its default decimal precision/scale instead.
         type1 = RelDataTypeFactoryImpl.isJavaType(type1)
@@ -310,15 +296,15 @@ default boolean shouldUseDoubleMultiplication(
 
         final int maxNumericPrecision = getMaxNumericPrecision();
         int dout =
-                Math.min(
-                        p1 - s1 + s2,
-                        maxNumericPrecision);
+            Math.min(
+                p1 - s1 + s2,
+                maxNumericPrecision);
 
         int scale = Math.max(6, s1 + p2 + 1);
         scale =
-                Math.min(
-                        scale,
-                        maxNumericPrecision - dout);
+            Math.min(
+                scale,
+                maxNumericPrecision - dout);
         scale = Math.min(scale, getMaxNumericScale());
 
         int precision = dout + scale;
@@ -327,10 +313,10 @@ default boolean shouldUseDoubleMultiplication(
 
         RelDataType ret;
         ret = typeFactory.
-                createSqlType(
-                        SqlTypeName.DECIMAL,
-                        precision,
-                        scale);
+            createSqlType(
+            SqlTypeName.DECIMAL,
+            precision,
+            scale);
 
         return ret;
       }
@@ -373,17 +359,17 @@ default boolean shouldUseDoubleMultiplication(
   default @Nullable RelDataType deriveDecimalModType(RelDataTypeFactory typeFactory,
       RelDataType type1, RelDataType type2) {
     if (SqlTypeUtil.isExactNumeric(type1)
-            && SqlTypeUtil.isExactNumeric(type2)) {
+        && SqlTypeUtil.isExactNumeric(type2)) {
       if (SqlTypeUtil.isDecimal(type1)
-              || SqlTypeUtil.isDecimal(type2)) {
+          || SqlTypeUtil.isDecimal(type2)) {
         // Java numeric will always have invalid precision/scale,
         // use its default decimal precision/scale instead.
         type1 = RelDataTypeFactoryImpl.isJavaType(type1)
-                ? typeFactory.decimalOf(type1)
-                : type1;
+            ? typeFactory.decimalOf(type1)
+            : type1;
         type2 = RelDataTypeFactoryImpl.isJavaType(type2)
-                ? typeFactory.decimalOf(type2)
-                : type2;
+            ? typeFactory.decimalOf(type2)
+            : type2;
         int p1 = type1.getPrecision();
         int p2 = type2.getPrecision();
         int s1 = type1.getScale();
@@ -401,10 +387,27 @@ default boolean shouldUseDoubleMultiplication(
         assert precision > 0;
 
         return typeFactory.createSqlType(SqlTypeName.DECIMAL,
-                precision, scale);
+            precision, scale);
       }
     }
     return null;
   }
 
+  /** Returns a list of supported time frames.
+   *
+   * <p>The validator calls this method with {@link TimeFrames#CORE} as an
+   * argument, and the default implementation of this method returns its input,
+   * and therefore {@link TimeFrames#CORE CORE} is the default time frame set.
+   *
+   * <p>If you wish to use a custom time frame set, create an instance of
+   * {@code RelDataTypeSystem} that overrides this method. Your method should
+   * call {@link TimeFrameSet#builder()}, will probably add all or most of the
+   * time frames in the {@code frameSet} argument, and then call
+   * {@link TimeFrameSet.Builder#build()}.
+   *
+   * @param frameSet Set of built-in time frames
+   */
+  default TimeFrameSet deriveTimeFrameSet(TimeFrameSet frameSet) {
+    return frameSet;
+  }
 }
diff --git a/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeSystemImpl.java b/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeSystemImpl.java
index a817293eb41..55702ce9cdb 100644
--- a/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeSystemImpl.java
+++ b/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeSystemImpl.java
@@ -226,12 +226,16 @@ && getDefaultPrecision(typeName) != -1) {
           && argumentType.getPrecision() != RelDataType.PRECISION_NOT_SPECIFIED) {
         int precision = typeFactory.getTypeSystem().getMaxPrecision(typeName);
         if (typeName.allowsScale()) {
-          argumentType = typeFactory.createTypeWithNullability(
-              typeFactory.createSqlType(typeName, precision, argumentType.getScale()),
-              argumentType.isNullable());
+          argumentType =
+              typeFactory.createTypeWithNullability(
+                  typeFactory.createSqlType(typeName, precision,
+                      argumentType.getScale()),
+                  argumentType.isNullable());
         } else {
-          argumentType = typeFactory.createTypeWithNullability(
-              typeFactory.createSqlType(typeName, precision), argumentType.isNullable());
+          argumentType =
+              typeFactory.createTypeWithNullability(
+                  typeFactory.createSqlType(typeName, precision),
+                  argumentType.isNullable());
         }
       }
     }
diff --git a/core/src/main/java/org/apache/calcite/rel/type/TimeFrame.java b/core/src/main/java/org/apache/calcite/rel/type/TimeFrame.java
new file mode 100644
index 00000000000..1ea43217d76
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/rel/type/TimeFrame.java
@@ -0,0 +1,113 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.rel.type;
+
+import org.apache.calcite.avatica.util.TimeUnit;
+
+import org.apache.commons.math3.fraction.BigFraction;
+
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+/** Time frame.
+ *
+ * <p>Belongs to a {@link TimeFrameSet}.
+ * The default set is {@link TimeFrames#CORE};
+ * to create custom time frame sets, call {@link TimeFrameSet#builder()}. */
+public interface TimeFrame {
+  /** Returns the time frame set that this frame belongs to. */
+  TimeFrameSet frameSet();
+
+  /** Name of this time frame.
+   *
+   * <p>A time frame based on a built-in Avatica
+   * {@link org.apache.calcite.avatica.util.TimeUnit} will have the same
+   * name.
+   *
+   * @see TimeFrameSet#get(TimeUnit) */
+  String name();
+
+  /** If this time frame has units in common with another time frame, returns
+   * the number of this time frame in one of that time frame.
+   *
+   * <p>For example, {@code MONTH.per(YEAR)} returns 12;
+   * {@code YEAR.per(MONTH)} returns 1 / 12.
+   */
+  @Nullable BigFraction per(TimeFrame timeFrame);
+
+  /** Returns a date where this time frame is at the start of a cycle.
+   *
+   * <p>For example, the {@code WEEK} time frame starts on a Monday,
+   * and {@code 1970-01-05} was a Monday,
+   * and the date {@code 1970-01-05} is represented as integer 5,
+   * so for the {@code WEEK} time frame this method returns 5.
+   * But it would also be valid to return the date value of {@code 1900/01/01},
+   * which was also a Monday.  Because we know that a week is 7 days, we can
+   * compute every other point at which a week advances. */
+  default int dateEpoch() {
+    return 0;
+  }
+
+  /** Returns a timestamp where this time frame is at the start of a cycle.
+   *
+   * @see #dateEpoch() */
+  default long timestampEpoch() {
+    return 0L;
+  }
+
+  /** Returns a month number where this time frame is at the start of a cycle.
+   *
+   * @see #dateEpoch()
+   */
+  default int monthEpoch() {
+    return 0;
+  }
+
+  /** Whether this frame can roll up to {@code toFrame}.
+   *
+   * <p>Examples:
+   * <ul>
+   *   <li>{@code SECOND} can roll up to {@code MINUTE}, {@code HOUR},
+   *   {@code DAY}, {@code WEEK}, {@code MONTH}, {@code MILLENNIUM};
+   *   <li>{@code SECOND} cannot roll up to {@code MILLISECOND} (because it is
+   *   finer grained);
+   *   <li>{@code WEEK} cannot roll up to {@code MONTH}, {@code YEAR},
+   *   {@code MILLENNIUM} (because weeks cross month boundaries).
+   * </ul>
+   *
+   * <p>If two time frames have the same core, and one is an integer simple
+   * multiple of another, and they have the same offset, then they can roll up.
+   * For example, suppose that {@code MINUTE15} and {@code HOUR3} are both based
+   * on {@code SECOND};
+   * {@code MINUTE15} is 15 * 60 seconds and
+   * {@code HOUR3} is 3 * 60 * 60 seconds;
+   * therefore one {@code HOUR3} interval equals twelve {@code MINUTE15}
+   * intervals.
+   * They have the same offset (both start at {@code 1970-01-01 00:00:00}) and
+   * therefore {@code MINUTE15} can roll up to {@code HOUR3}.
+   *
+   * <p>Even if two frames are not multiples, if they are aligned then they can
+   * roll up. {@code MONTH} and {@code DAY} are an example. For more about
+   * alignment, see {@link TimeFrameSet.Builder#addRollup(String, String)}.
+   */
+  boolean canRollUpTo(TimeFrame toFrame);
+
+  /** Returns the built-in unit of this frame, or null if it does not correspond
+   * to a built-in unit. */
+  default @Nullable TimeUnit unit() {
+    return frameSet().getUnit(this);
+  }
+}
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
new file mode 100644
index 00000000000..07869b8504a
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/rel/type/TimeFrameSet.java
@@ -0,0 +1,364 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.rel.type;
+
+import org.apache.calcite.avatica.util.DateTimeUtils;
+import org.apache.calcite.avatica.util.TimeUnit;
+import org.apache.calcite.avatica.util.TimeUnitRange;
+import org.apache.calcite.util.NameMap;
+import org.apache.calcite.util.TimestampString;
+import org.apache.calcite.util.Util;
+
+import org.apache.commons.math3.fraction.BigFraction;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableMultimap;
+import com.google.common.collect.Iterables;
+
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+import java.math.BigInteger;
+import java.util.NavigableMap;
+import java.util.Objects;
+
+import static org.apache.calcite.avatica.util.DateTimeUtils.MILLIS_PER_DAY;
+
+import static java.lang.Math.floorDiv;
+import static java.lang.Math.floorMod;
+import static java.util.Objects.requireNonNull;
+
+/** Set of {@link TimeFrame} definitions.
+ *
+ * <p>Every SQL statement has a time frame set, and is accessed via
+ * {@link RelDataTypeSystem#deriveTimeFrameSet(TimeFrameSet)}. If you want to
+ * use a custom set of time frames, you should override that method. */
+public class TimeFrameSet {
+  final ImmutableMap<String, TimeFrames.TimeFrameImpl> map;
+  final ImmutableMultimap<TimeFrames.TimeFrameImpl, TimeFrames.TimeFrameImpl> rollupMap;
+  private final NameMap<TimeFrames.TimeFrameImpl> nameMap;
+
+  TimeFrameSet(ImmutableMap<String, TimeFrames.TimeFrameImpl> map,
+      ImmutableMultimap<TimeFrames.TimeFrameImpl, TimeFrames.TimeFrameImpl> rollupMap) {
+    this.map = requireNonNull(map, "map");
+    this.nameMap = NameMap.immutableCopyOf(map);
+    this.rollupMap = requireNonNull(rollupMap, "rollupMap");
+  }
+
+  /** Creates a Builder. */
+  public static Builder builder() {
+    return new TimeFrames.BuilderImpl();
+  }
+
+  /** Returns the time frame with the given name (case-insensitive),
+   * or returns null. */
+  public @Nullable TimeFrame getOpt(String name) {
+    final NavigableMap<String, TimeFrames.TimeFrameImpl> range =
+        nameMap.range(name, false);
+    @Nullable TimeFrame timeFrame =
+        Iterables.getFirst(range.values(), null);
+    while (timeFrame instanceof TimeFrames.AliasFrame) {
+      timeFrame = ((TimeFrames.AliasFrame) timeFrame).frame;
+    }
+    return timeFrame;
+  }
+
+  /** Returns the time frame with the given name,
+   * or throws {@link IllegalArgumentException} if not found.
+   * If {@code name} is an alias, resolves to the underlying frame. */
+  public TimeFrame get(String name) {
+    TimeFrame timeFrame = getOpt(name);
+    if (timeFrame == null) {
+      throw new IllegalArgumentException("unknown frame: " + name);
+    }
+    return timeFrame;
+  }
+
+  /** Returns the time frame with the given name,
+   * or throws {@link IllegalArgumentException}. */
+  public TimeFrame get(TimeUnit timeUnit) {
+    return get(timeUnit.name());
+  }
+
+  /** Computes "FLOOR(date TO frame)", where {@code date} is the number of
+   * days since UNIX Epoch. */
+  public int floorDate(int date, TimeFrame frame) {
+    return floorCeilDate(date, frame, false);
+  }
+
+  /** Computes "FLOOR(date TO frame)", where {@code date} is the number of
+   * days since UNIX Epoch. */
+  public int ceilDate(int date, TimeFrame frame) {
+    return floorCeilDate(date, frame, true);
+  }
+
+  /** Computes "FLOOR(timestamp TO frame)" or "FLOOR(timestamp TO frame)",
+   * where {@code date} is the number of days since UNIX Epoch. */
+  private int floorCeilDate(int date, TimeFrame frame, boolean ceil) {
+    final TimeFrame dayFrame = get(TimeUnit.DAY);
+    final BigFraction perDay = frame.per(dayFrame);
+    if (perDay != null
+        && perDay.getNumerator().equals(BigInteger.ONE)) {
+      final int m = perDay.getDenominator().intValueExact(); // 7 for WEEK
+      final int mod = floorMod(date - frame.dateEpoch(), m);
+      return date - mod + (ceil ? m : 0);
+    }
+    final TimeFrame monthFrame = get(TimeUnit.MONTH);
+    final BigFraction perMonth = frame.per(monthFrame);
+    if (perMonth != null
+        && perMonth.getNumerator().equals(BigInteger.ONE)) {
+      final int y2 =
+          (int) DateTimeUtils.unixDateExtract(TimeUnitRange.YEAR, date);
+      final int m2 =
+          (int) DateTimeUtils.unixDateExtract(TimeUnitRange.MONTH, date);
+      final int fullMonth = TimeFrames.fullMonth(y2, m2);
+
+      final int m = perMonth.getDenominator().intValueExact(); // e.g. 12 for YEAR
+      final int mod = floorMod(fullMonth - frame.monthEpoch(), m);
+      return TimeFrames.mdToUnixDate(fullMonth - mod + (ceil ? m : 0), 1);
+    }
+    final TimeFrame isoYearFrame = get(TimeUnit.ISOYEAR);
+    final BigFraction perIsoYear = frame.per(isoYearFrame);
+    if (perIsoYear != null
+        && perIsoYear.getNumerator().equals(BigInteger.ONE)) {
+      return TimeFrames.floorCeilIsoYear(date, ceil);
+    }
+    return date;
+  }
+
+  /** Computes "FLOOR(timestamp TO frame)", where {@code ts} is the number of
+   * milliseconds since UNIX Epoch. */
+  public long floorTimestamp(long ts, TimeFrame frame) {
+    return floorCeilTimestamp(ts, frame, false);
+  }
+
+  /** Computes "CEIL(timestamp TO frame)", where {@code ts} is the number of
+   * milliseconds since UNIX Epoch. */
+  public long ceilTimestamp(long ts, TimeFrame frame) {
+    return floorCeilTimestamp(ts, frame, true);
+  }
+
+  /** Computes "FLOOR(ts TO frame)" or "CEIL(ts TO frame)",
+   * where {@code ts} is the number of milliseconds since UNIX Epoch. */
+  private long floorCeilTimestamp(long ts, TimeFrame frame, boolean ceil) {
+    final TimeFrame millisecondFrame = get(TimeUnit.MILLISECOND);
+    final BigFraction perMillisecond = frame.per(millisecondFrame);
+    if (perMillisecond != null
+        && perMillisecond.getNumerator().equals(BigInteger.ONE)) {
+      final long m = perMillisecond.getDenominator().longValue(); // e.g. 60,000 for MINUTE
+      final long mod = floorMod(ts - frame.timestampEpoch(), m);
+      return ts - mod + (ceil ? m : 0);
+    }
+    final TimeFrame monthFrame = get(TimeUnit.MONTH);
+    final BigFraction perMonth = frame.per(monthFrame);
+    if (perMonth != null
+        && perMonth.getNumerator().equals(BigInteger.ONE)) {
+      final long ts2 = floorTimestamp(ts, get(TimeUnit.DAY));
+      final int d2 = (int) (ts2 / DateTimeUtils.MILLIS_PER_DAY);
+      final int y2 =
+          (int) DateTimeUtils.unixDateExtract(TimeUnitRange.YEAR, d2);
+      final int m2 =
+          (int) DateTimeUtils.unixDateExtract(TimeUnitRange.MONTH, d2);
+      final int fullMonth = TimeFrames.fullMonth(y2, m2);
+
+      final int m = perMonth.getDenominator().intValueExact(); // e.g. 12 for YEAR
+      final int mod = floorMod(fullMonth - frame.monthEpoch(), m);
+      return TimeFrames.unixTimestamp(fullMonth - mod + (ceil ? m : 0), 1, 0, 0, 0);
+    }
+    final TimeFrame isoYearFrame = get(TimeUnit.ISOYEAR);
+    final BigFraction perIsoYear = frame.per(isoYearFrame);
+    if (perIsoYear != null
+        && perIsoYear.getNumerator().equals(BigInteger.ONE)) {
+      final long ts2 = floorTimestamp(ts, get(TimeUnit.DAY));
+      final int d2 = (int) (ts2 / DateTimeUtils.MILLIS_PER_DAY);
+      return (long) TimeFrames.floorCeilIsoYear(d2, ceil) * MILLIS_PER_DAY;
+    }
+    return ts;
+  }
+
+  /** Returns the time unit that this time frame is based upon, or null. */
+  public @Nullable TimeUnit getUnit(TimeFrame timeFrame) {
+    final TimeUnit timeUnit = Util.enumVal(TimeUnit.class, timeFrame.name());
+    if (timeUnit == null) {
+      return null;
+    }
+    TimeFrame timeFrame1 = getOpt(timeUnit.name());
+    return Objects.equals(timeFrame1, timeFrame) ? timeUnit : null;
+  }
+
+  public int addDate(int date, int interval, TimeFrame frame) {
+    final TimeFrame dayFrame = get(TimeUnit.DAY);
+    final BigFraction perDay = frame.per(dayFrame);
+    if (perDay != null
+        && perDay.getNumerator().equals(BigInteger.ONE)) {
+      final int m = perDay.getDenominator().intValueExact(); // 7 for WEEK
+      return date + interval * m;
+    }
+
+    final TimeFrame monthFrame = get(TimeUnit.MONTH);
+    final BigFraction perMonth = frame.per(monthFrame);
+    if (perMonth != null
+        && perMonth.getNumerator().equals(BigInteger.ONE)) {
+      final int m = perMonth.getDenominator().intValueExact(); // e.g. 12 for YEAR
+      return DateTimeUtils.addMonths(date, interval * m);
+    }
+
+    // Unknown time frame. Return the original value unchanged.
+    return date;
+  }
+
+  public long addTimestamp(long timestamp, long interval, TimeFrame frame) {
+    final TimeFrame msFrame = get(TimeUnit.MILLISECOND);
+    final BigFraction perMilli = frame.per(msFrame);
+    if (perMilli != null
+        && perMilli.getNumerator().equals(BigInteger.ONE)) {
+      // 1,000 for SECOND, 86,400,000 for DAY
+      final long m = perMilli.getDenominator().longValueExact();
+      return timestamp + interval * m;
+    }
+    final TimeFrame monthFrame = get(TimeUnit.MONTH);
+    final BigFraction perMonth = frame.per(monthFrame);
+    if (perMonth != null
+        && perMonth.getNumerator().equals(BigInteger.ONE)) {
+      final long m = perMonth.getDenominator().longValueExact(); // e.g. 12 for YEAR
+      return DateTimeUtils.addMonths(timestamp, (int) (interval * m));
+    }
+
+    // Unknown time frame. Return the original value unchanged.
+    return timestamp;
+  }
+
+  public int diffDate(int date, int date2, TimeFrame frame) {
+    final TimeFrame dayFrame = get(TimeUnit.DAY);
+    final BigFraction perDay = frame.per(dayFrame);
+    if (perDay != null
+        && perDay.getNumerator().equals(BigInteger.ONE)) {
+      final int m = perDay.getDenominator().intValueExact(); // 7 for WEEK
+      final int delta = date2 - date;
+      return floorDiv(delta, m);
+    }
+
+    final TimeFrame monthFrame = get(TimeUnit.MONTH);
+    final BigFraction perMonth = frame.per(monthFrame);
+    if (perMonth != null
+        && perMonth.getNumerator().equals(BigInteger.ONE)) {
+      final int m = perMonth.getDenominator().intValueExact(); // e.g. 12 for YEAR
+      final int delta = DateTimeUtils.subtractMonths(date2, date);
+      return floorDiv(delta, m);
+    }
+
+    // Unknown time frame. Return the original value unchanged.
+    return date;
+  }
+
+  public long diffTimestamp(long timestamp, long timestamp2, TimeFrame frame) {
+    final TimeFrame msFrame = get(TimeUnit.MILLISECOND);
+    final BigFraction perMilli = frame.per(msFrame);
+    if (perMilli != null
+        && perMilli.getNumerator().equals(BigInteger.ONE)) {
+      // 1,000 for SECOND, 86,400,000 for DAY
+      final long m = perMilli.getDenominator().longValueExact();
+      final long delta = timestamp2 - timestamp;
+      return floorDiv(delta, m);
+    }
+    final TimeFrame monthFrame = get(TimeUnit.MONTH);
+    final BigFraction perMonth = frame.per(monthFrame);
+    if (perMonth != null
+        && perMonth.getNumerator().equals(BigInteger.ONE)) {
+      final long m = perMonth.getDenominator().longValueExact(); // e.g. 12 for YEAR
+      final long delta = DateTimeUtils.subtractMonths(timestamp2, timestamp);
+      return floorDiv(delta, m);
+    }
+
+    // Unknown time frame. Return the original value unchanged.
+    return timestamp;
+  }
+
+  /** Builds a collection of time frames. */
+  public interface Builder {
+    /** Creates a {@code TimeFrameSet}. */
+    TimeFrameSet build();
+
+    /** Defines a core time frame. */
+    Builder addCore(String name);
+
+    /** Defines a time frame that is the number of a minor unit within a major
+     * frame. For example, the "DOY" frame has minor "DAY" and major "YEAR". */
+    Builder addQuotient(String name, String minorName,
+        String majorName);
+
+    /** Defines a time frame that consists of {@code count} instances of
+     * a base frame. */
+    Builder addMultiple(String name, Number count, String baseName);
+
+    /** Defines a time frame such that each base frame consists of {@code count}
+     * instances of the new frame. */
+    Builder addDivision(String name, Number count, String baseName);
+
+    /** Defines a rollup from one frame to another.
+     *
+     * <p>An explicit rollup is not necessary for frames where one is a multiple
+     * of another (such as {@code MILLISECOND} to {@code HOUR}). Only use this
+     * method for frames that are not multiples (such as {@code DAY} to
+     * {@code MONTH}).
+     *
+     * <p>How do we automatically roll up from say, "minute15" to "hour7"?
+     * Because we know the following:
+     * <ul>
+     *   <li>"minute15" and "hour7" are based on the same core frame (seconds);
+     *   <li>"minute15" is 15 * 60 seconds, "hour7" is 7 * 60 * 60 seconds,
+     *     and the one divides the other;
+     *   <li>They have the same offset, 1970-01-01 00:00:00. (Different offsets
+     *     would be OK too, as they are a whole multiple apart.)
+     * </ul>
+     *
+     * <p>A month is not a fixed multiple of days, but a rollup is still
+     * possible, because the start of a month is always aligned with the start
+     * of a day. This means that you can compute a month total by adding up the
+     * day totals for all days in that month. This is useful if you have an
+     * aggregate table on DAY and you want to answer a query on {@code MONTH}.
+     *
+     * <p>There is no rollup from {@code WEEK} to {@code YEAR}, because of a
+     * lack of alignment: a year does not start on the first day of a week, and
+     * so you cannot compute the total for, say, the year 2022 by adding the
+     * totals for all weeks that fall in 2022.
+     *
+     * <p>Incidentally, {@code ISOWEEK} and {@code ISOYEAR} are designed so that
+     * {@code ISOWEEK} can roll up to {@code ISOYEAR}. Every {@code ISOYEAR} and
+     * {@code ISOWEEK} start on a Monday, so they are aligned. An
+     * {@code ISOYEAR} consists of either 52 or 53 {@code ISOWEEK} instances,
+     * but the variable multiple is not a problem; the alignment ensures that
+     * rollup is valid. */
+    Builder addRollup(String fromName, String toName);
+
+    /** Adds all time frames in {@code timeFrameSet} to this {@code Builder}. */
+    Builder addAll(TimeFrameSet timeFrameSet);
+
+    /** Replaces the epoch of the most recently added frame. */
+    Builder withEpoch(TimestampString epoch);
+
+    /** Defines an alias for an existing frame.
+     *
+     * <p>For example, {@code add("Y", "YEAR")} adds "Y" as an alias for the
+     * built-in frame {@code YEAR}.
+     *
+     * @param name The alias
+     * @param originalName Name of the existing frame
+     */
+    Builder addAlias(String name, String originalName);
+  }
+
+}
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
new file mode 100644
index 00000000000..f69e66f3c6e
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/rel/type/TimeFrames.java
@@ -0,0 +1,659 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.rel.type;
+
+import org.apache.calcite.avatica.util.DateTimeUtils;
+import org.apache.calcite.avatica.util.TimeUnit;
+import org.apache.calcite.avatica.util.TimeUnitRange;
+import org.apache.calcite.linq4j.Ord;
+import org.apache.calcite.util.MonotonicSupplier;
+import org.apache.calcite.util.Pair;
+import org.apache.calcite.util.TimestampString;
+
+import org.apache.commons.math3.fraction.BigFraction;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.ImmutableMultimap;
+import com.google.common.collect.Iterables;
+
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+import java.math.BigInteger;
+import java.util.Calendar;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Supplier;
+
+import static org.apache.calcite.avatica.util.DateTimeUtils.EPOCH_JULIAN;
+
+import static java.lang.Math.floorDiv;
+import static java.lang.Math.floorMod;
+import static java.util.Objects.requireNonNull;
+
+/** Utilities for {@link TimeFrame}. */
+public class TimeFrames {
+  private TimeFrames() {
+  }
+
+  /** The names of the frames that are WEEK starting on each week day.
+   * Entry 0 is "WEEK_SUNDAY" and entry 6 is "WEEK_SATURDAY". */
+  public static final List<String> WEEK_FRAME_NAMES =
+      ImmutableList.of("WEEK_SUNDAY",
+          "WEEK_MONDAY",
+          "WEEK_TUESDAY",
+          "WEEK_WEDNESDAY",
+          "WEEK_THURSDAY",
+          "WEEK_FRIDAY",
+          "WEEK_SATURDAY");
+
+  /** The core time frame set. Includes the time frames for all Avatica time
+   * units plus ISOWEEK and week offset for each week day:
+   *
+   * <ul>
+   *   <li>SECOND, and multiples MINUTE, HOUR, DAY, WEEK (starts on a Sunday),
+   *   sub-multiples MILLISECOND, MICROSECOND, NANOSECOND,
+   *   quotients DOY, DOW;
+   *   <li>MONTH, and multiples QUARTER, YEAR, DECADE, CENTURY, MILLENNIUM;
+   *   <li>ISOYEAR, and sub-unit ISOWEEK (starts on a Monday), quotient ISODOW;
+   *   <li>WEEK(<i>weekday</i>) with <i>weekday</i> being one of
+   *   SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY.
+   * </ul>
+   *
+   * <p>Does not include EPOCH.
+   */
+  public static final TimeFrameSet CORE =
+      addTsi(addCore(new BuilderImpl())).build();
+
+  private static BuilderImpl addCore(BuilderImpl b) {
+    b.addCore(TimeUnit.SECOND);
+    b.addSub(TimeUnit.MINUTE, false, 60, TimeUnit.SECOND);
+    b.addSub(TimeUnit.HOUR, false, 60, TimeUnit.MINUTE);
+    b.addSub(TimeUnit.DAY, false, 24, TimeUnit.HOUR);
+    b.addSub(TimeUnit.WEEK, false, 7, TimeUnit.DAY,
+        new TimestampString(1970, 1, 4, 0, 0, 0)); // a sunday
+    b.addSub(TimeUnit.MILLISECOND, true, 1_000, TimeUnit.SECOND);
+    b.addSub(TimeUnit.MICROSECOND, true, 1_000, TimeUnit.MILLISECOND);
+    b.addSub(TimeUnit.NANOSECOND, true, 1_000, TimeUnit.MICROSECOND);
+
+    b.addSub(TimeUnit.EPOCH, false, 1, TimeUnit.SECOND,
+        new TimestampString(1970, 1, 1, 0, 0, 0));
+
+    b.addCore(TimeUnit.MONTH);
+    b.addSub(TimeUnit.QUARTER, false, 3, TimeUnit.MONTH);
+    b.addSub(TimeUnit.YEAR, false, 12, TimeUnit.MONTH);
+    b.addSub(TimeUnit.DECADE, false, 10, TimeUnit.YEAR);
+    b.addSub(TimeUnit.CENTURY, false, 100, TimeUnit.YEAR,
+        new TimestampString(2001, 1, 1, 0, 0, 0));
+    b.addSub(TimeUnit.MILLENNIUM, false, 1_000, TimeUnit.YEAR,
+        new TimestampString(2001, 1, 1, 0, 0, 0));
+
+    b.addCore(TimeUnit.ISOYEAR);
+    b.addSub("ISOWEEK", false, 7, TimeUnit.DAY.name(),
+        new TimestampString(1970, 1, 5, 0, 0, 0)); // a monday
+
+    // Add "WEEK(SUNDAY)" through "WEEK(SATURDAY)"
+    Ord.forEach(WEEK_FRAME_NAMES, (frameName, i) ->
+        b.addSub(frameName, false, 7,
+            "DAY", new TimestampString(1970, 1, 4 + i, 0, 0, 0)));
+
+    b.addQuotient(TimeUnit.DOY, TimeUnit.DAY, TimeUnit.YEAR);
+    b.addQuotient(TimeUnit.DOW, TimeUnit.DAY, TimeUnit.WEEK);
+    b.addQuotient(TimeUnit.ISODOW.name(), TimeUnit.DAY.name(), "ISOWEEK");
+
+    b.addRollup(TimeUnit.DAY, TimeUnit.MONTH);
+    b.addRollup("ISOWEEK", TimeUnit.ISOYEAR.name());
+
+    return b;
+  }
+
+  /** Adds abbreviations used by {@code TIMESTAMPADD}, {@code TIMESTAMPDIFF}
+   * functions. */
+  private static BuilderImpl addTsi(BuilderImpl b) {
+    b.addAlias("FRAC_SECOND", TimeUnit.MICROSECOND.name());
+    b.addAlias("SQL_TSI_FRAC_SECOND", TimeUnit.NANOSECOND.name());
+    b.addAlias("SQL_TSI_MICROSECOND", TimeUnit.MICROSECOND.name());
+    b.addAlias("SQL_TSI_SECOND", TimeUnit.SECOND.name());
+    b.addAlias("SQL_TSI_MINUTE", TimeUnit.MINUTE.name());
+    b.addAlias("SQL_TSI_HOUR", TimeUnit.HOUR.name());
+    b.addAlias("SQL_TSI_DAY", TimeUnit.DAY.name());
+    b.addAlias("SQL_TSI_WEEK", TimeUnit.WEEK.name());
+    b.addAlias("SQL_TSI_MONTH", TimeUnit.MONTH.name());
+    b.addAlias("SQL_TSI_QUARTER", TimeUnit.QUARTER.name());
+    b.addAlias("SQL_TSI_YEAR", TimeUnit.YEAR.name());
+    return b;
+  }
+
+  /** Given a date, returns the date of the first day of its ISO Year.
+   * Usually occurs in the same calendar year, but may be as early as Dec 29
+   * of the previous calendar year.
+   *
+   * <p>After
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5369">[CALCITE-5369]
+   * In Avatica DateTimeUtils, add support for FLOOR and CEIL to ISOYEAR</a> is
+   * fixed, we can use {@link DateTimeUtils#unixDateFloor} instead of this
+   * method. */
+  static int floorCeilIsoYear(int date, boolean ceil) {
+    final int year =
+        (int) DateTimeUtils.unixDateExtract(TimeUnitRange.YEAR, date);
+    return (int) firstMondayOfFirstWeek(year + (ceil ? 1 : 0)) - EPOCH_JULIAN;
+  }
+
+  /** Returns the first day of the first week of a year.
+   * Per ISO-8601 it is the Monday of the week that contains Jan 4,
+   * or equivalently, it is a Monday between Dec 29 and Jan 4.
+   * Sometimes it is in the year before the given year. */
+  // Note: copied from DateTimeUtils
+  static long firstMondayOfFirstWeek(int year) {
+    final long janFirst = DateTimeUtils.ymdToJulian(year, 1, 1);
+    final long janFirstDow = floorMod(janFirst + 1, (long) 7); // sun=0, sat=6
+    return janFirst + (11 - janFirstDow) % 7 - 3;
+  }
+
+  /** Returns the number of months since 1 BCE.
+   *
+   * <p>Parameters mean the same as in
+   * {@link DateTimeUtils#ymdToJulian(int, int, int)}.
+   *
+   * @param year Year (e.g. 2020 means 2020 CE, 0 means 1 BCE)
+   * @param month Month (e.g. 1 means January)
+   */
+  static int fullMonth(int year, int month) {
+    return year * 12 + (month - 1);
+  }
+
+  /** Given a {@link #fullMonth(int, int)} value, returns the month
+   * (1 means January). */
+  static int fullMonthToMonth(int fullMonth) {
+    return floorMod(fullMonth, 12) + 1;
+  }
+
+  /** Given a {@link #fullMonth(int, int)} value, returns the year
+   * (2020 means 2020 CE). */
+  static int fullMonthToYear(int fullMonth) {
+    return floorDiv(fullMonth, 12);
+  }
+
+  /** As {@link DateTimeUtils#unixTimestamp(int, int, int, int, int, int)}
+   * but based on a fullMonth value (per {@link #fullMonth(int, int)}). */
+  static long unixTimestamp(int fullMonth, int day, int hour,
+      int minute, int second) {
+    final int year = fullMonthToYear(fullMonth);
+    final int month = fullMonthToMonth(fullMonth);
+    return DateTimeUtils.unixTimestamp(year, month, day, hour, minute, second);
+  }
+
+  static int mdToUnixDate(int fullMonth, int day) {
+    final int year = fullMonthToYear(fullMonth);
+    final int month = fullMonthToMonth(fullMonth);
+    return DateTimeUtils.ymdToUnixDate(year, month, day);
+  }
+
+  private static boolean canDirectlyRollUp(TimeFrameImpl from,
+      TimeFrameImpl to) {
+    if (from.core().equals(to.core())) {
+      if (divisible(from.coreMultiplier(), to.coreMultiplier())) {
+        BigFraction diff = new BigFraction(from.core().epochDiff(from, to));
+        return divisible(from.coreMultiplier(), diff);
+      }
+      return false;
+    }
+    return false;
+  }
+
+  /** Returns whether {@code numerator} is divisible by {@code denominator}.
+   *
+   * <p>For example, {@code divisible(6, 2)} returns {@code true};
+   * {@code divisible(0, 2)} also returns {@code true};
+   * {@code divisible(2, 6)} returns {@code false}. */
+  private static boolean divisible(BigFraction numerator,
+      BigFraction denominator) {
+    return denominator.equals(BigFraction.ZERO)
+        || numerator
+        .divide(denominator)
+        .getNumerator()
+        .abs()
+        .equals(BigInteger.ONE);
+  }
+
+  /** Implementation of {@link TimeFrameSet.Builder}. */
+  static class BuilderImpl implements TimeFrameSet.Builder {
+    BuilderImpl() {
+    }
+
+    final MonotonicSupplier<TimeFrameSet> frameSetSupplier =
+        new MonotonicSupplier<>();
+    final Map<String, TimeFrameImpl> map = new LinkedHashMap<>();
+    final ImmutableMultimap.Builder<TimeFrameImpl, TimeFrameImpl> rollupList =
+        ImmutableMultimap.builder();
+
+    @Override public TimeFrameSet build() {
+      final TimeFrameSet frameSet =
+          new TimeFrameSet(ImmutableMap.copyOf(map), rollupList.build());
+      frameSetSupplier.accept(frameSet);
+      return frameSet;
+    }
+
+    /** Converts a number to an exactly equivalent {@code BigInteger}.
+     * May silently lose precision if n is a {@code Float} or {@code Double}. */
+    static BigInteger toBigInteger(Number number) {
+      return number instanceof BigInteger ? (BigInteger) number
+          : BigInteger.valueOf(number.longValue());
+    }
+
+    /** Returns the time frame with the given name,
+     * or throws {@link IllegalArgumentException}. */
+    TimeFrameImpl getFrame(String name) {
+      final TimeFrameImpl timeFrame = map.get(name);
+      if (timeFrame == null) {
+        throw new IllegalArgumentException("unknown frame: " + name);
+      }
+      return timeFrame;
+    }
+
+    /** Adds a frame.
+     *
+     * <p>If a frame with this name already exists, throws
+     * {@link IllegalArgumentException} and leaves the builder in the same
+     * state.
+     *
+     * <p>It is very important that we don't allow replacement of frames.
+     * If replacement were allowed, people would be able to create a DAG
+     * (e.g. two routes from DAY to MONTH with different multipliers)
+     * or a cycle (e.g. one SECOND equals 1,000 MILLISECOND
+     * and one MILLISECOND equals 20 SECOND). Those scenarios give rise to
+     * inconsistent multipliers. */
+    private BuilderImpl addFrame(String name, TimeFrameImpl frame) {
+      final TimeFrameImpl previousFrame =
+          map.put(name, requireNonNull(frame, "frame"));
+      if (previousFrame != null) {
+        // There was already a frame with that name. Replace the old frame
+        // (so that that builder is still valid usable) and throw.
+        map.put(name, previousFrame);
+        throw new IllegalArgumentException("duplicate frame: " + name);
+      }
+      return this;
+    }
+
+    @Override public BuilderImpl addCore(String name) {
+      return addFrame(name, new CoreFrame(frameSetSupplier, name));
+    }
+
+    /** Defines a time unit that consists of {@code count} instances of
+     * {@code baseUnit}. */
+    BuilderImpl addSub(String name, boolean divide, Number count,
+        String baseName, TimestampString epoch) {
+      final TimeFrameImpl baseFrame = getFrame(baseName);
+      final BigInteger factor = toBigInteger(count);
+
+      final CoreFrame coreFrame = baseFrame.core();
+      final BigFraction coreFactor = divide
+          ? baseFrame.coreMultiplier().divide(factor)
+          : baseFrame.coreMultiplier().multiply(factor);
+
+      return addFrame(name,
+          new SubFrame(name, baseFrame, divide, factor, coreFrame, coreFactor,
+              epoch));
+    }
+
+    @Override public BuilderImpl addQuotient(String name,
+        String minorName, String majorName) {
+      final TimeFrameImpl minorFrame = getFrame(minorName);
+      final TimeFrameImpl majorFrame = getFrame(majorName);
+      return addFrame(name, new QuotientFrame(name, minorFrame, majorFrame));
+    }
+
+    @Override public BuilderImpl addMultiple(String name, Number count,
+        String baseName) {
+      return addSub(name, false, count, baseName, TimestampString.EPOCH);
+    }
+
+    @Override public BuilderImpl addDivision(String name, Number count,
+        String baseName) {
+      return addSub(name, true, count, baseName, TimestampString.EPOCH);
+    }
+
+    @Override public BuilderImpl addRollup(String fromName, String toName) {
+      final TimeFrameImpl fromFrame = getFrame(fromName);
+      final TimeFrameImpl toFrame = getFrame(toName);
+      rollupList.put(fromFrame, toFrame);
+      return this;
+    }
+
+    @Override public BuilderImpl addAll(TimeFrameSet timeFrameSet) {
+      timeFrameSet.map.values().forEach(frame -> frame.replicate(this));
+      return this;
+    }
+
+    @Override public BuilderImpl withEpoch(TimestampString epoch) {
+      final Map.Entry<String, TimeFrameImpl> entry =
+          Iterables.getLast(map.entrySet());
+      final String name = entry.getKey();
+      final SubFrame value =
+          requireNonNull((SubFrame) map.remove(name));
+      value.replicateWithEpoch(this, epoch);
+      return this;
+    }
+
+    @Override public BuilderImpl addAlias(String name, String originalName) {
+      final TimeFrameImpl frame = getFrame(originalName);
+      return addFrame(name, new AliasFrame(name, frame));
+    }
+
+    // Extra methods for Avatica's built-in time frames.
+
+    void addCore(TimeUnit unit) {
+      addCore(unit.name());
+    }
+
+    void addSub(TimeUnit unit, boolean divide, Number count,
+        TimeUnit baseUnit) {
+      addSub(unit, divide, count, baseUnit, TimestampString.EPOCH);
+    }
+
+    void addSub(TimeUnit unit, boolean divide, Number count,
+        TimeUnit baseUnit, TimestampString epoch) {
+      addSub(unit.name(), divide, count, baseUnit.name(), epoch);
+    }
+
+    void addRollup(TimeUnit fromUnit, TimeUnit toUnit) {
+      addRollup(fromUnit.name(), toUnit.name());
+    }
+
+    void addQuotient(TimeUnit unit, TimeUnit minor, TimeUnit major) {
+      addQuotient(unit.name(), minor.name(), major.name());
+    }
+  }
+
+  /** Implementation of {@link TimeFrame}. */
+  abstract static class TimeFrameImpl implements TimeFrame {
+    final String name;
+    final Supplier<TimeFrameSet> frameSetSupplier;
+
+    TimeFrameImpl(Supplier<TimeFrameSet> frameSetSupplier, String name) {
+      this.frameSetSupplier =
+          requireNonNull(frameSetSupplier, "frameSetSupplier");
+      this.name = requireNonNull(name, "name");
+    }
+
+    @Override public String toString() {
+      return name;
+    }
+
+    @Override public TimeFrameSet frameSet() {
+      return frameSetSupplier.get();
+    }
+
+    @Override public String name() {
+      return name;
+    }
+
+    @Override public @Nullable BigFraction per(TimeFrame timeFrame) {
+      // Note: The following algorithm is not very efficient. It becomes less
+      // efficient as the number of time frames increases. A more efficient
+      // algorithm would be for TimeFrameSet.Builder.build() to call this method
+      // for each pair of time frames and cache the results in a list:
+      //
+      //   (coreFrame,
+      //   [(subFrame0, multiplier0),
+      //    ...
+      //    (subFrameN, multiplierN)])
+
+      final Map<TimeFrame, BigFraction> map = new HashMap<>();
+      final Map<TimeFrame, BigFraction> map2 = new HashMap<>();
+      expand(map, BigFraction.ONE);
+      ((TimeFrameImpl) timeFrame).expand(map2, BigFraction.ONE);
+      final Set<BigFraction> fractions = new HashSet<>();
+      for (Map.Entry<TimeFrame, BigFraction> entry : map.entrySet()) {
+        final BigFraction value2 = map2.get(entry.getKey());
+        if (value2 != null) {
+          fractions.add(value2.divide(entry.getValue()));
+        }
+      }
+
+      switch (fractions.size()) {
+      case 0:
+        // There is no path from this TimeFrame to that.
+        return null;
+      case 1:
+        return Iterables.getOnlyElement(fractions);
+      default:
+        // If there are multiple units in common, the multipliers must be the
+        // same for all. If they are not, the must have somehow created a
+        // TimeFrameSet that has multiple paths between units (i.e. a DAG),
+        // or has a cycle. TimeFrameSet.Builder is supposed to prevent all of
+        // these, and so we throw an AssertionError.
+        throw new AssertionError("inconsistent multipliers for " + this
+            + ".per(" + timeFrame + "): " + fractions);
+      }
+    }
+
+    protected void expand(Map<TimeFrame, BigFraction> map, BigFraction f) {
+      map.put(this, f);
+    }
+
+    /** Adds a time frame like this to a builder. */
+    abstract void replicate(BuilderImpl b);
+
+    protected abstract CoreFrame core();
+
+    protected abstract BigFraction coreMultiplier();
+
+    @Override public boolean canRollUpTo(TimeFrame toFrame) {
+      if (toFrame == this) {
+        return true;
+      }
+      if (toFrame instanceof TimeFrameImpl) {
+        final TimeFrameImpl toFrame1 = (TimeFrameImpl) toFrame;
+        if (canDirectlyRollUp(this, toFrame1)) {
+          return true;
+        }
+        final TimeFrameSet frameSet = frameSet();
+        if (frameSet.rollupMap.entries().contains(Pair.of(this, toFrame1))) {
+          return true;
+        }
+        // Hard-code roll-up via DAY-to-MONTH bridge, for now.
+        final TimeFrameImpl day =
+            requireNonNull(frameSet.map.get(TimeUnit.DAY.name()));
+        final TimeFrameImpl month =
+            requireNonNull(frameSet.map.get(TimeUnit.MONTH.name()));
+        if (canDirectlyRollUp(this, day)
+            && canDirectlyRollUp(month, toFrame1)) {
+          return true;
+        }
+        // Hard-code roll-up via ISOWEEK-to-ISOYEAR bridge, for now.
+        final TimeFrameImpl isoYear =
+            requireNonNull(frameSet.map.get(TimeUnit.ISOYEAR.name()));
+        final TimeFrameImpl isoWeek =
+            requireNonNull(frameSet.map.get("ISOWEEK"));
+        if (canDirectlyRollUp(this, isoWeek)
+            && canDirectlyRollUp(isoYear, toFrame1)) {
+          return true;
+        }
+      }
+      return false;
+    }
+  }
+
+  /** Core time frame (such as SECOND, MONTH, ISOYEAR). */
+  static class CoreFrame extends TimeFrameImpl {
+    CoreFrame(Supplier<TimeFrameSet> frameSetSupplier, String name) {
+      super(frameSetSupplier, name);
+    }
+
+    @Override void replicate(BuilderImpl b) {
+      b.addCore(name);
+    }
+
+    @Override protected CoreFrame core() {
+      return this;
+    }
+
+    @Override protected BigFraction coreMultiplier() {
+      return BigFraction.ONE;
+    }
+
+    /** Returns the difference between the epochs of two frames, in the
+     * units of this core frame. */
+    BigInteger epochDiff(TimeFrameImpl from, TimeFrameImpl to) {
+      assert from.core() == this;
+      assert to.core() == this;
+      switch (name) {
+      case "MONTH":
+        return BigInteger.valueOf(from.monthEpoch())
+            .subtract(BigInteger.valueOf(to.monthEpoch()));
+      default:
+        return BigInteger.valueOf(from.timestampEpoch())
+            .subtract(BigInteger.valueOf(to.timestampEpoch()));
+      }
+    }
+  }
+
+  /** A time frame that is composed of another time frame.
+   *
+   * <p>For example, {@code MINUTE} is composed of 60 {@code SECOND};
+   * (factor = 60, divide = false);
+   * {@code MILLISECOND} is composed of 1 / 1000 {@code SECOND}
+   * (factor = 1000, divide = true).
+   *
+   * <p>A sub-time frame S is aligned with its parent frame P;
+   * that is, every instance of S belongs to one instance of P.
+   * Every {@code MINUTE} belongs to one {@code HOUR};
+   * not every {@code WEEK} belongs to precisely one {@code MONTH} or
+   * {@code MILLENNIUM}.
+   */
+  static class SubFrame extends TimeFrameImpl {
+    private final TimeFrameImpl base;
+    private final boolean divide;
+    private final BigInteger multiplier;
+    private final CoreFrame coreFrame;
+
+    /** The number of core frames that are equivalent to one of these. For
+     * example, MINUTE, HOUR, MILLISECOND all have core = SECOND, and have
+     * multipliers 60, 3,600, 1 / 1,000 respectively. */
+    private final BigFraction coreMultiplier;
+    private final TimestampString epoch;
+
+    SubFrame(String name, TimeFrameImpl base, boolean divide,
+        BigInteger multiplier, CoreFrame coreFrame,
+        BigFraction coreMultiplier, TimestampString epoch) {
+      super(base.frameSetSupplier, name);
+      this.base = requireNonNull(base, "base");
+      this.divide = divide;
+      this.multiplier = requireNonNull(multiplier, "multiplier");
+      this.coreFrame = requireNonNull(coreFrame, "coreFrame");
+      this.coreMultiplier = requireNonNull(coreMultiplier, "coreMultiplier");
+      this.epoch = requireNonNull(epoch, "epoch");
+    }
+
+    @Override public String toString() {
+      return name + ", composedOf " + multiplier + " " + base.name;
+    }
+
+    @Override public int dateEpoch() {
+      return (int) floorDiv(epoch.getMillisSinceEpoch(),
+          DateTimeUtils.MILLIS_PER_DAY);
+    }
+
+    @Override public int monthEpoch() {
+      final Calendar calendar = epoch.toCalendar();
+      int y = calendar.get(Calendar.YEAR); // 2020 CE is represented by 2020
+      int m = calendar.get(Calendar.MONTH) + 1; // January is represented by 1
+      return fullMonth(y, m);
+    }
+
+    @Override public long timestampEpoch() {
+      return epoch.getMillisSinceEpoch();
+    }
+
+    @Override void replicate(BuilderImpl b) {
+      b.addSub(name, divide, multiplier, base.name, epoch);
+    }
+
+    /** Returns a copy of this TimeFrameImpl with a given epoch. */
+    void replicateWithEpoch(BuilderImpl b, TimestampString epoch) {
+      b.addSub(name, divide, multiplier, base.name, epoch);
+    }
+
+    @Override protected void expand(Map<TimeFrame, BigFraction> map,
+        BigFraction f) {
+      super.expand(map, f);
+      base.expand(map, divide ? f.divide(multiplier) : f.multiply(multiplier));
+    }
+
+    @Override protected CoreFrame core() {
+      return coreFrame;
+    }
+
+    @Override protected BigFraction coreMultiplier() {
+      return coreMultiplier;
+    }
+  }
+
+  /** Frame that defines is based on a minor frame and resets whenever the major
+   * frame resets. For example, "DOY" (day of year) is based on DAY and resets
+   * every YEAR. */
+  static class QuotientFrame extends TimeFrameImpl {
+    private final TimeFrameImpl minorFrame;
+    private final TimeFrameImpl majorFrame;
+
+    QuotientFrame(String name, TimeFrameImpl minorFrame,
+        TimeFrameImpl majorFrame) {
+      super(minorFrame.frameSetSupplier, name);
+      this.minorFrame = requireNonNull(minorFrame, "minorFrame");
+      this.majorFrame = requireNonNull(majorFrame, "majorFrame");
+    }
+
+    @Override void replicate(BuilderImpl b) {
+      b.addQuotient(name, minorFrame.name, majorFrame.name);
+    }
+
+    @Override protected CoreFrame core() {
+      return minorFrame.core();
+    }
+
+    @Override protected BigFraction coreMultiplier() {
+      return minorFrame.coreMultiplier();
+    }
+  }
+
+  /** Frame that defines an alias. */
+  static class AliasFrame extends TimeFrameImpl {
+    final TimeFrameImpl frame;
+
+    AliasFrame(String name, TimeFrameImpl frame) {
+      super(frame.frameSetSupplier, name);
+      this.frame = requireNonNull(frame, "frame");
+    }
+
+    @Override void replicate(BuilderImpl b) {
+      b.addAlias(name, frame.name);
+    }
+
+    @Override protected CoreFrame core() {
+      throw new UnsupportedOperationException();
+    }
+
+    @Override protected BigFraction coreMultiplier() {
+      throw new UnsupportedOperationException();
+    }
+  }
+}
diff --git a/core/src/main/java/org/apache/calcite/rex/RexAnalyzer.java b/core/src/main/java/org/apache/calcite/rex/RexAnalyzer.java
index 9d46f83da4d..733288b7d56 100644
--- a/core/src/main/java/org/apache/calcite/rex/RexAnalyzer.java
+++ b/core/src/main/java/org/apache/calcite/rex/RexAnalyzer.java
@@ -19,12 +19,12 @@
 import org.apache.calcite.linq4j.Linq4j;
 import org.apache.calcite.plan.RelOptPredicateList;
 import org.apache.calcite.rel.metadata.NullSentinel;
+import org.apache.calcite.util.Compatible;
 import org.apache.calcite.util.NlsString;
 import org.apache.calcite.util.Pair;
 import org.apache.calcite.util.Util;
 
 import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
 
 import java.math.BigDecimal;
 import java.util.LinkedHashSet;
@@ -59,7 +59,7 @@ public Iterable<Map<RexNode, Comparable>> assignments() {
             .collect(Util.toImmutableList());
     final Iterable<List<Comparable>> product = Linq4j.product(generators);
     return Util.transform(product,
-        values -> ImmutableMap.copyOf(Pair.zip(variables, values)));
+        values -> Compatible.copyOf(Pair.zip(variables, values)));
   }
 
   private static List<Comparable> getComparables(RexNode variable) {
diff --git a/core/src/main/java/org/apache/calcite/rex/RexBuilder.java b/core/src/main/java/org/apache/calcite/rex/RexBuilder.java
index b4d8e66f1db..c19a1001c69 100644
--- a/core/src/main/java/org/apache/calcite/rex/RexBuilder.java
+++ b/core/src/main/java/org/apache/calcite/rex/RexBuilder.java
@@ -27,7 +27,6 @@
 import org.apache.calcite.rel.type.RelDataTypeFactory;
 import org.apache.calcite.rel.type.RelDataTypeField;
 import org.apache.calcite.runtime.FlatLists;
-import org.apache.calcite.runtime.Geometries;
 import org.apache.calcite.sql.SqlAggFunction;
 import org.apache.calcite.sql.SqlCollation;
 import org.apache.calcite.sql.SqlIntervalQualifier;
@@ -36,6 +35,7 @@
 import org.apache.calcite.sql.SqlSpecialOperator;
 import org.apache.calcite.sql.SqlUtil;
 import org.apache.calcite.sql.fun.SqlCountAggFunction;
+import org.apache.calcite.sql.fun.SqlLibraryOperators;
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
 import org.apache.calcite.sql.type.ArraySqlType;
 import org.apache.calcite.sql.type.MapSqlType;
@@ -60,6 +60,7 @@
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.checkerframework.checker.nullness.qual.PolyNull;
+import org.locationtech.jts.geom.Geometry;
 
 import java.math.BigDecimal;
 import java.math.MathContext;
@@ -73,8 +74,12 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.function.IntPredicate;
+import java.util.stream.Collectors;
 
 import static org.apache.calcite.linq4j.Nullness.castNonNull;
+import static org.apache.calcite.util.Util.verifyNotNull;
+
+import static java.util.Objects.requireNonNull;
 
 /**
  * Factory for row expressions.
@@ -332,7 +337,7 @@ public RexNode addAggCall(final AggregateCall aggCall, int groupCount,
       Map<AggregateCall, RexNode> aggCallMapping,
       final @Nullable List<RelDataType> aggArgTypes) {
     return addAggCall(aggCall, groupCount, aggCalls, aggCallMapping, i ->
-        Objects.requireNonNull(aggArgTypes, "aggArgTypes")
+        requireNonNull(aggArgTypes, "aggArgTypes")
             .get(aggCall.getArgList().indexOf(i)).isNullable());
   }
 
@@ -392,8 +397,8 @@ public RexNode makeOver(
             lowerBound,
             upperBound,
             rows);
-    final RexOver over = new RexOver(type, operator, exprs, window,
-        distinct, ignoreNulls);
+    final RexOver over =
+        new RexOver(type, operator, exprs, window, distinct, ignoreNulls);
     RexNode result = over;
 
     // This should be correct but need time to go over test results.
@@ -401,26 +406,18 @@ public RexNode makeOver(
     if (nullWhenCountZero) {
       final RelDataType bigintType =
           typeFactory.createSqlType(SqlTypeName.BIGINT);
-      result = makeCall(
-          SqlStdOperatorTable.CASE,
-          makeCall(
-              SqlStdOperatorTable.GREATER_THAN,
-              new RexOver(
-                  bigintType,
-                  SqlStdOperatorTable.COUNT,
-                  exprs,
-                  window,
-                  distinct,
-                  ignoreNulls),
-              makeLiteral(
-                  BigDecimal.ZERO,
-                  bigintType,
-                  SqlTypeName.DECIMAL)),
-          ensureType(type, // SUM0 is non-nullable, thus need a cast
-              new RexOver(typeFactory.createTypeWithNullability(type, false),
-                  operator, exprs, window, distinct, ignoreNulls),
-              false),
-          makeNullLiteral(type));
+      result =
+          makeCall(SqlStdOperatorTable.CASE,
+              makeCall(SqlStdOperatorTable.GREATER_THAN,
+                  new RexOver(bigintType, SqlStdOperatorTable.COUNT, exprs,
+                      window, distinct, ignoreNulls),
+                  makeLiteral(BigDecimal.ZERO, bigintType,
+                      SqlTypeName.DECIMAL)),
+              ensureType(type, // SUM0 is non-nullable, thus need a cast
+                  new RexOver(typeFactory.createTypeWithNullability(type, false),
+                      operator, exprs, window, distinct, ignoreNulls),
+                  false),
+              makeNullLiteral(type));
     }
     if (!allowPartial) {
       Preconditions.checkArgument(rows, "DISALLOW PARTIAL over RANGE");
@@ -532,12 +529,20 @@ public RexNode makeNewInvocation(
   public RexNode makeCast(
       RelDataType type,
       RexNode exp) {
-    return makeCast(type, exp, false);
+    return makeCast(type, exp, false, false);
+  }
+
+  @Deprecated // to be removed before 2.0
+  public RexNode makeCast(
+      RelDataType type,
+      RexNode exp,
+      boolean matchNullability) {
+    return makeCast(type, exp, matchNullability, false);
   }
 
   /**
    * Creates a call to the CAST operator, expanding if possible, and optionally
-   * also preserving nullability.
+   * also preserving nullability, and optionally in safe mode.
    *
    * <p>Tries to expand the cast, and therefore the result may be something
    * other than a {@link RexCall} to the CAST operator, such as a
@@ -547,12 +552,14 @@ public RexNode makeCast(
    * @param exp  Expression being cast
    * @param matchNullability Whether to ensure the result has the same
    * nullability as {@code type}
+   * @param safe Whether to return NULL if cast fails
    * @return Call to CAST operator
    */
   public RexNode makeCast(
       RelDataType type,
       RexNode exp,
-      boolean matchNullability) {
+      boolean matchNullability,
+      boolean safe) {
     final SqlTypeName sqlType = type.getSqlTypeName();
     if (exp instanceof RexLiteral) {
       RexLiteral literal = (RexLiteral) exp;
@@ -612,7 +619,7 @@ public RexNode makeCast(
         if (type.isNullable()
             && !literal2.getType().isNullable()
             && matchNullability) {
-          return makeAbstractCast(type, literal2);
+          return makeAbstractCast(type, literal2, safe);
         }
         return literal2;
       }
@@ -626,7 +633,7 @@ public RexNode makeCast(
         && SqlTypeUtil.isExactNumeric(type)) {
       return makeCastBooleanToExact(type, exp);
     }
-    return makeAbstractCast(type, exp);
+    return makeAbstractCast(type, exp, safe);
   }
 
   /** Returns the lowest granularity unit for the given unit.
@@ -711,10 +718,10 @@ private RexNode makeCastExactToBoolean(RelDataType toType, RexNode exp) {
   }
 
   private RexNode makeCastBooleanToExact(RelDataType toType, RexNode exp) {
-    final RexNode casted = makeCall(SqlStdOperatorTable.CASE,
-        exp,
-        makeExactLiteral(BigDecimal.ONE, toType),
-        makeZeroLiteral(toType));
+    final RexNode casted =
+        makeCall(SqlStdOperatorTable.CASE, exp,
+            makeExactLiteral(BigDecimal.ONE, toType),
+            makeZeroLiteral(toType));
     if (!exp.getType().isNullable()) {
       return casted;
     }
@@ -729,8 +736,8 @@ private RexNode makeCastIntervalToExact(RelDataType toType, RexNode exp) {
     final TimeUnit baseUnit = baseUnit(exp.getType().getSqlTypeName());
     final BigDecimal multiplier = baseUnit.multiplier;
     final BigDecimal divider = endUnit.multiplier;
-    RexNode value = multiplyDivide(decodeIntervalOrDecimal(exp),
-        multiplier, divider);
+    RexNode value =
+        multiplyDivide(decodeIntervalOrDecimal(exp), multiplier, divider);
     return ensureType(toType, value, false);
   }
 
@@ -796,20 +803,24 @@ public RexNode decodeIntervalOrDecimal(RexNode node) {
         matchNullability(bigintType, node), node, makeLiteral(false));
   }
 
+  @Deprecated // to be removed before 2.0
+  public RexNode makeAbstractCast(RelDataType type, RexNode exp) {
+    return makeAbstractCast(type, exp, false);
+  }
+
   /**
-   * Creates a call to the CAST operator.
+   * Creates a call to CAST or SAFE_CAST operator.
    *
    * @param type Type to cast to
    * @param exp  Expression being cast
+   * @param safe Whether to return NULL if cast fails
    * @return Call to CAST operator
    */
-  public RexNode makeAbstractCast(
-      RelDataType type,
-      RexNode exp) {
-    return new RexCall(
-        type,
-        SqlStdOperatorTable.CAST,
-        ImmutableList.of(exp));
+  public RexNode makeAbstractCast(RelDataType type, RexNode exp, boolean safe) {
+    SqlOperator operator =
+        safe ? SqlLibraryOperators.SAFE_CAST
+            : SqlStdOperatorTable.CAST;
+    return new RexCall(type, operator, ImmutableList.of(exp));
   }
 
   /**
@@ -847,7 +858,7 @@ public RexNode makeNotNull(RexNode exp) {
     }
     final RelDataType notNullType =
         typeFactory.createTypeWithNullability(type, false);
-    return makeAbstractCast(notNullType, exp);
+    return makeAbstractCast(notNullType, exp, false);
   }
 
   /**
@@ -981,10 +992,9 @@ protected RexLiteral makeLiteral(
         Charset charset = type.getCharset();
         assert charset != null : "type.getCharset() must not be null";
         assert type.getCollation() != null : "type.getCollation() must not be null";
-        o = new NlsString(
-            nlsString.getValue(),
-            charset.name(),
-            type.getCollation());
+        o =
+            new NlsString(nlsString.getValue(), charset.name(),
+                type.getCollation());
       }
       break;
     case TIME:
@@ -1108,7 +1118,7 @@ public RexLiteral makeApproxLiteral(@Nullable BigDecimal bd, RelDataType type) {
    * Creates a search argument literal.
    */
   public RexLiteral makeSearchArgumentLiteral(Sarg s, RelDataType type) {
-    return makeLiteral(Objects.requireNonNull(s, "s"), type, SqlTypeName.SARG);
+    return makeLiteral(requireNonNull(s, "s"), type, SqlTypeName.SARG);
   }
 
   /**
@@ -1217,7 +1227,8 @@ public RexLiteral makeDateLiteral(Calendar calendar) {
    * Creates a Date literal.
    */
   public RexLiteral makeDateLiteral(DateString date) {
-    return makeLiteral(Objects.requireNonNull(date, "date"),
+    return makeLiteral(
+        requireNonNull(date, "date"),
         typeFactory.createSqlType(SqlTypeName.DATE), SqlTypeName.DATE);
   }
 
@@ -1232,7 +1243,8 @@ public RexLiteral makeTimeLiteral(Calendar calendar, int precision) {
    * Creates a Time literal.
    */
   public RexLiteral makeTimeLiteral(TimeString time, int precision) {
-    return makeLiteral(Objects.requireNonNull(time, "time"),
+    return makeLiteral(
+        requireNonNull(time, "time"),
         typeFactory.createSqlType(SqlTypeName.TIME, precision),
         SqlTypeName.TIME);
   }
@@ -1243,7 +1255,8 @@ public RexLiteral makeTimeLiteral(TimeString time, int precision) {
   public RexLiteral makeTimeWithLocalTimeZoneLiteral(
       TimeString time,
       int precision) {
-    return makeLiteral(Objects.requireNonNull(time, "time"),
+    return makeLiteral(
+        requireNonNull(time, "time"),
         typeFactory.createSqlType(SqlTypeName.TIME_WITH_LOCAL_TIME_ZONE, precision),
         SqlTypeName.TIME_WITH_LOCAL_TIME_ZONE);
   }
@@ -1261,7 +1274,8 @@ public RexLiteral makeTimestampLiteral(Calendar calendar, int precision) {
    */
   public RexLiteral makeTimestampLiteral(TimestampString timestamp,
       int precision) {
-    return makeLiteral(Objects.requireNonNull(timestamp, "timestamp"),
+    return makeLiteral(
+        requireNonNull(timestamp, "timestamp"),
         typeFactory.createSqlType(SqlTypeName.TIMESTAMP, precision),
         SqlTypeName.TIMESTAMP);
   }
@@ -1272,7 +1286,8 @@ public RexLiteral makeTimestampLiteral(TimestampString timestamp,
   public RexLiteral makeTimestampWithLocalTimeZoneLiteral(
       TimestampString timestamp,
       int precision) {
-    return makeLiteral(Objects.requireNonNull(timestamp, "timestamp"),
+    return makeLiteral(
+        requireNonNull(timestamp, "timestamp"),
         typeFactory.createSqlType(SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE, precision),
         SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE);
   }
@@ -1283,7 +1298,10 @@ public RexLiteral makeTimestampWithLocalTimeZoneLiteral(
    */
   public RexLiteral makeIntervalLiteral(
       SqlIntervalQualifier intervalQualifier) {
-    assert intervalQualifier != null;
+    verifyNotNull(intervalQualifier);
+    if (intervalQualifier.timeFrameName != null) {
+      return makePreciseStringLiteral(intervalQualifier.timeFrameName);
+    }
     return makeFlag(intervalQualifier.timeUnitRange);
   }
 
@@ -1355,10 +1373,14 @@ public RexNode makeIn(RexNode arg, List<? extends RexNode> ranges) {
     if (areAssignable(arg, ranges)) {
       final Sarg sarg = toSarg(Comparable.class, ranges, RexUnknownAs.UNKNOWN);
       if (sarg != null) {
-        final RexNode range0 = ranges.get(0);
-        return makeCall(SqlStdOperatorTable.SEARCH,
-            arg,
-            makeSearchArgumentLiteral(sarg, range0.getType()));
+        final List<RelDataType> types = ranges.stream()
+            .map(RexNode::getType)
+            .collect(Collectors.toList());
+        RelDataType sargType =
+            requireNonNull(typeFactory.leastRestrictive(types),
+                () -> "Can't find leastRestrictive type for SARG among " + types);
+        return makeCall(SqlStdOperatorTable.SEARCH, arg,
+            makeSearchArgumentLiteral(sarg, sargType));
       }
     }
     return RexUtil.composeDisjunction(this, ranges.stream()
@@ -1395,8 +1417,12 @@ && areAssignable(arg, Arrays.asList(lower, upper))) {
           Sarg.of(RexUnknownAs.UNKNOWN,
               ImmutableRangeSet.<Comparable>of(
                   Range.closed(lowerValue, upperValue)));
+      List<RelDataType> types = ImmutableList.of(lower.getType(), upper.getType());
+      RelDataType sargType =
+          requireNonNull(typeFactory.leastRestrictive(types),
+              () -> "Can't find leastRestrictive type for SARG among " + types);
       return makeCall(SqlStdOperatorTable.SEARCH, arg,
-          makeSearchArgumentLiteral(sarg, lower.getType()));
+          makeSearchArgumentLiteral(sarg, sargType));
     }
     return makeCall(SqlStdOperatorTable.AND,
         makeCall(SqlStdOperatorTable.GREATER_THAN_OR_EQUAL, arg, lower),
@@ -1574,7 +1600,7 @@ public RexNode makeLiteral(@Nullable Object value, RelDataType type,
           typeFactory.createTypeWithNullability(type, false);
       if (allowCast) {
         RexNode literalNotNull = makeLiteral(value, typeNotNull, allowCast);
-        return makeAbstractCast(type, literalNotNull);
+        return makeAbstractCast(type, literalNotNull, false);
       }
       type = typeNotNull;
     }
@@ -1834,7 +1860,7 @@ private RelDataType guessType(@Nullable Object value) {
       return typeFactory.createSqlType(SqlTypeName.BINARY,
           ((ByteString) value).length());
     }
-    if (value instanceof Geometries.Geom) {
+    if (value instanceof Geometry) {
       return typeFactory.createSqlType(SqlTypeName.GEOMETRY);
     }
     throw new AssertionError("unknown type " + value.getClass());
diff --git a/core/src/main/java/org/apache/calcite/rex/RexCallBinding.java b/core/src/main/java/org/apache/calcite/rex/RexCallBinding.java
index a4cd8b1b1ec..66df15f55f6 100644
--- a/core/src/main/java/org/apache/calcite/rex/RexCallBinding.java
+++ b/core/src/main/java/org/apache/calcite/rex/RexCallBinding.java
@@ -74,6 +74,7 @@ public static RexCallBinding create(RelDataTypeFactory typeFactory,
             : call.getOperands();
     switch (call.getKind()) {
     case CAST:
+    case SAFE_CAST:
       return new RexCastCallBinding(typeFactory, call.getOperator(),
           operands, call.getType(), inputCollations);
     default:
diff --git a/core/src/main/java/org/apache/calcite/rex/RexExecutorImpl.java b/core/src/main/java/org/apache/calcite/rex/RexExecutorImpl.java
index d0ea92224ab..eaa3c7dd46c 100644
--- a/core/src/main/java/org/apache/calcite/rex/RexExecutorImpl.java
+++ b/core/src/main/java/org/apache/calcite/rex/RexExecutorImpl.java
@@ -129,8 +129,8 @@ public static RexExecutable getExecutable(RexBuilder rexBuilder, List<RexNode> e
    */
   @Override public void reduce(RexBuilder rexBuilder, List<RexNode> constExps,
       List<RexNode> reducedValues) {
-    final String code = compile(rexBuilder, constExps,
-        (list, index, storageType) -> {
+    final String code =
+        compile(rexBuilder, constExps, (list, index, storageType) -> {
           throw new UnsupportedOperationException();
         });
 
@@ -156,14 +156,14 @@ private static class DataContextInputGetter implements InputGetter {
     }
 
     @Override public Expression field(BlockBuilder list, int index, @Nullable Type storageType) {
-      MethodCallExpression recFromCtx = Expressions.call(
-          DataContext.ROOT,
-          BuiltInMethod.DATA_CONTEXT_GET.method,
-          Expressions.constant("inputRecord"));
+      MethodCallExpression recFromCtx =
+          Expressions.call(DataContext.ROOT,
+              BuiltInMethod.DATA_CONTEXT_GET.method,
+              Expressions.constant("inputRecord"));
       Expression recFromCtxCasted =
           EnumUtils.convert(recFromCtx, Object[].class);
-      IndexExpression recordAccess = Expressions.arrayIndex(recFromCtxCasted,
-          Expressions.constant(index));
+      IndexExpression recordAccess =
+          Expressions.arrayIndex(recFromCtxCasted, Expressions.constant(index));
       if (storageType == null) {
         final RelDataType fieldType =
             rowType.getFieldList().get(index).getType();
diff --git a/core/src/main/java/org/apache/calcite/rex/RexLiteral.java b/core/src/main/java/org/apache/calcite/rex/RexLiteral.java
index e74eee4d021..7c6bf04962d 100644
--- a/core/src/main/java/org/apache/calcite/rex/RexLiteral.java
+++ b/core/src/main/java/org/apache/calcite/rex/RexLiteral.java
@@ -25,8 +25,7 @@
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeField;
 import org.apache.calcite.runtime.FlatLists;
-import org.apache.calcite.runtime.GeoFunctions;
-import org.apache.calcite.runtime.Geometries;
+import org.apache.calcite.runtime.SpatialTypeFunctions;
 import org.apache.calcite.sql.SqlCollation;
 import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.SqlOperator;
@@ -51,6 +50,7 @@
 import org.checkerframework.checker.nullness.qual.PolyNull;
 import org.checkerframework.checker.nullness.qual.RequiresNonNull;
 import org.checkerframework.dataflow.qual.Pure;
+import org.locationtech.jts.geom.Geometry;
 
 import java.io.PrintWriter;
 import java.math.BigDecimal;
@@ -298,8 +298,7 @@ public final String computeDigest(
    */
   @RequiresNonNull("type")
   RexDigestIncludeType digestIncludesType(
-      @UnknownInitialization RexLiteral this
-  ) {
+      @UnknownInitialization RexLiteral this) {
     return shouldIncludeType(value, type);
   }
 
@@ -384,7 +383,7 @@ public static boolean valueMatchesType(
     case MULTISET:
       return value instanceof List;
     case GEOMETRY:
-      return value instanceof Geometries.Geom;
+      return value instanceof Geometry;
     case ANY:
       // Literal of type ANY is not legal. "CAST(2 AS ANY)" remains
       // an integer literal surrounded by a cast function.
@@ -446,7 +445,7 @@ private static String toJavaString(
   }
 
   /**
-   * Computes if data type can be omitted from the digset.
+   * Computes if data type can be omitted from the digest.
    * <p>For instance, {@code 1:BIGINT} has to keep data type while {@code 1:INT}
    * should be represented as just {@code 1}.
    *
@@ -724,7 +723,7 @@ private static void appendAsJava(@Nullable Comparable value, StringBuilder sb,
               sb3.append(list.get(i).computeDigest(includeType))));
       break;
     case GEOMETRY:
-      final String wkt = GeoFunctions.ST_AsWKT((Geometries.Geom) castNonNull(value));
+      final String wkt = SpatialTypeFunctions.ST_AsWKT((Geometry) castNonNull(value));
       sb.append(wkt);
       break;
     default:
@@ -844,9 +843,9 @@ private static RexLiteral toLiteral(RelDataType type, Comparable<?> value) {
       final Comparable v;
       switch (typeName) {
       case DATE:
-        final Calendar cal = DateTimeUtils.parseDateFormat(literal,
-            new SimpleDateFormat(format, Locale.ROOT),
-            tz);
+        final Calendar cal =
+            DateTimeUtils.parseDateFormat(literal,
+                new SimpleDateFormat(format, Locale.ROOT), tz);
         if (cal == null) {
           throw new AssertionError("fromJdbcString: invalid date/time value '"
               + literal + "'");
diff --git a/core/src/main/java/org/apache/calcite/rex/RexOver.java b/core/src/main/java/org/apache/calcite/rex/RexOver.java
index e085f34a095..b93d94a8373 100644
--- a/core/src/main/java/org/apache/calcite/rex/RexOver.java
+++ b/core/src/main/java/org/apache/calcite/rex/RexOver.java
@@ -217,8 +217,9 @@ private static class Finder extends RexVisitorImpl<Void> {
 
   @Override public int hashCode() {
     if (hash == 0) {
-      hash = Objects.hash(super.hashCode(), window,
-          distinct, ignoreNulls, op.allowsFraming());
+      hash =
+          Objects.hash(super.hashCode(), window, distinct, ignoreNulls,
+              op.allowsFraming());
     }
     return hash;
   }
diff --git a/core/src/main/java/org/apache/calcite/rex/RexProgram.java b/core/src/main/java/org/apache/calcite/rex/RexProgram.java
index 511e49fc018..d001e49f185 100644
--- a/core/src/main/java/org/apache/calcite/rex/RexProgram.java
+++ b/core/src/main/java/org/apache/calcite/rex/RexProgram.java
@@ -245,10 +245,10 @@ public static RexProgram create(
    * In this case, the input is mainly from the output json string of {@link RelJsonWriter}
    */
   public static RexProgram create(RelInput input) {
-    final List<RexNode> exprs = requireNonNull(input.getExpressionList("exprs"), "exprs");
-    final List<RexNode> projectRexNodes = requireNonNull(
-        input.getExpressionList("projects"),
-        "projects");
+    final List<RexNode> exprs =
+        requireNonNull(input.getExpressionList("exprs"), "exprs");
+    final List<RexNode> projectRexNodes =
+        requireNonNull(input.getExpressionList("projects"), "projects");
     final List<RexLocalRef> projects = new ArrayList<>(projectRexNodes.size());
     for (RexNode rexNode: projectRexNodes) {
       projects.add((RexLocalRef) rexNode);
diff --git a/core/src/main/java/org/apache/calcite/rex/RexProgramBuilder.java b/core/src/main/java/org/apache/calcite/rex/RexProgramBuilder.java
index 6accf23d36d..e1a3bce3c69 100644
--- a/core/src/main/java/org/apache/calcite/rex/RexProgramBuilder.java
+++ b/core/src/main/java/org/apache/calcite/rex/RexProgramBuilder.java
@@ -141,9 +141,10 @@ private RexProgramBuilder(
     // Register the condition, if there is one.
     if (condition != null) {
       if (simplify != null) {
-        condition = simplify.simplify(
-            rexBuilder.makeCall(SqlStdOperatorTable.IS_TRUE,
-                condition.accept(expander)));
+        condition =
+            simplify.simplify(
+                rexBuilder.makeCall(SqlStdOperatorTable.IS_TRUE,
+                    condition.accept(expander)));
         if (condition.isAlwaysTrue()) {
           condition = null;
         }
@@ -554,8 +555,8 @@ public static RexProgramBuilder create(
       boolean simplify_) {
     RexSimplify simplify = null;
     if (simplify_) {
-      simplify = new RexSimplify(rexBuilder, RelOptPredicateList.EMPTY,
-          RexUtil.EXECUTOR);
+      simplify =
+          new RexSimplify(rexBuilder, RelOptPredicateList.EMPTY, RexUtil.EXECUTOR);
     }
     return new RexProgramBuilder(rexBuilder, inputRowType, exprList,
         projectList, condition, outputRowType, normalize, simplify);
diff --git a/core/src/main/java/org/apache/calcite/rex/RexSimplify.java b/core/src/main/java/org/apache/calcite/rex/RexSimplify.java
index 9019dc0201a..38b2b2b0401 100644
--- a/core/src/main/java/org/apache/calcite/rex/RexSimplify.java
+++ b/core/src/main/java/org/apache/calcite/rex/RexSimplify.java
@@ -82,7 +82,8 @@ public class RexSimplify {
   final RexUnknownAs defaultUnknownAs;
   final boolean predicateElimination;
   private final RexExecutor executor;
-  private final Strong strong;
+
+  private static final Strong STRONG = new Strong();
 
   /**
    * Creates a RexSimplify.
@@ -106,7 +107,6 @@ private RexSimplify(RexBuilder rexBuilder, RelOptPredicateList predicates,
     this.predicateElimination = predicateElimination;
     this.paranoid = paranoid;
     this.executor = requireNonNull(executor, "executor");
-    this.strong = new Strong();
   }
 
   @Deprecated // to be removed before 2.0
@@ -192,7 +192,7 @@ public RexNode simplifyPreservingType(RexNode e, RexUnknownAs unknownAs,
         && SqlTypeUtil.equalSansNullability(rexBuilder.typeFactory, e2.getType(), e.getType())) {
       return e2;
     }
-    final RexNode e3 = rexBuilder.makeCast(e.getType(), e2, matchNullability);
+    final RexNode e3 = rexBuilder.makeCast(e.getType(), e2, matchNullability, false);
     if (e3.equals(e)) {
       return e;
     }
@@ -260,7 +260,7 @@ public RexNode simplifyUnknownAs(RexNode e, RexUnknownAs unknownAs) {
    * Verify adds an overhead that is only acceptable for a top-level call.
    */
   RexNode simplify(RexNode e, RexUnknownAs unknownAs) {
-    if (strong.isNull(e)) {
+    if (STRONG.isNull(e)) {
       // Only boolean NULL (aka UNKNOWN) can be converted to FALSE. Even in
       // unknownAs=FALSE mode, we must not convert a NULL integer (say) to FALSE
       if (e.getType().getSqlTypeName() == SqlTypeName.BOOLEAN) {
@@ -286,6 +286,7 @@ RexNode simplify(RexNode e, RexUnknownAs unknownAs) {
     case COALESCE:
       return simplifyCoalesce((RexCall) e);
     case CAST:
+    case SAFE_CAST:
       return simplifyCast((RexCall) e);
     case CEIL:
     case FLOOR:
@@ -515,17 +516,19 @@ private <C extends Comparable<C>> RexNode simplifyComparison(RexCall e,
       case GREATER_THAN_OR_EQUAL:
       case LESS_THAN_OR_EQUAL:
         // "x = x" simplifies to "null or x is not null" (similarly <= and >=)
-        newExpr = rexBuilder.makeCall(SqlStdOperatorTable.OR,
-            rexBuilder.makeNullLiteral(e.getType()),
-            rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_NULL, o0));
+        newExpr =
+            rexBuilder.makeCall(SqlStdOperatorTable.OR,
+                rexBuilder.makeNullLiteral(e.getType()),
+                rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_NULL, o0));
         return simplify(newExpr, unknownAs);
       case NOT_EQUALS:
       case LESS_THAN:
       case GREATER_THAN:
         // "x != x" simplifies to "null and x is null" (similarly < and >)
-        newExpr = rexBuilder.makeCall(SqlStdOperatorTable.AND,
-            rexBuilder.makeNullLiteral(e.getType()),
-            rexBuilder.makeCall(SqlStdOperatorTable.IS_NULL, o0));
+        newExpr =
+            rexBuilder.makeCall(SqlStdOperatorTable.AND,
+                rexBuilder.makeNullLiteral(e.getType()),
+                rexBuilder.makeCall(SqlStdOperatorTable.IS_NULL, o0));
         return simplify(newExpr, unknownAs);
       default:
         // unknown kind
@@ -671,8 +674,9 @@ private void simplifyAndTerms(List<RexNode> terms, RexUnknownAs unknownAs) {
         continue;
       }
       terms.set(i, simplify.simplify(t, unknownAs));
-      RelOptPredicateList newPredicates = simplify.predicates.union(rexBuilder,
-          RelOptPredicateList.of(rexBuilder, terms.subList(i, i + 1)));
+      RelOptPredicateList newPredicates =
+          simplify.predicates.union(rexBuilder,
+              RelOptPredicateList.of(rexBuilder, terms.subList(i, i + 1)));
       simplify = simplify.withPredicates(newPredicates);
     }
     for (int i = 0; i < terms.size(); i++) {
@@ -707,8 +711,9 @@ private void simplifyOrTerms(List<RexNode> terms, RexUnknownAs unknownAs) {
       terms.set(i, t2);
       final RexNode inverse =
           simplify.simplify(isNotTrue(t2), RexUnknownAs.UNKNOWN);
-      final RelOptPredicateList newPredicates = simplify.predicates.union(rexBuilder,
-          RelOptPredicateList.of(rexBuilder, ImmutableList.of(inverse)));
+      final RelOptPredicateList newPredicates =
+          simplify.predicates.union(rexBuilder,
+              RelOptPredicateList.of(rexBuilder, ImmutableList.of(inverse)));
       simplify = simplify.withPredicates(newPredicates);
     }
     for (int i = 0; i < terms.size(); i++) {
@@ -1193,7 +1198,7 @@ && isSafeExpression(newCond)) {
       if (sameTypeOrNarrowsNullability(caseType, value.getType())) {
         return value;
       } else {
-        return rexBuilder.makeAbstractCast(caseType, value);
+        return rexBuilder.makeAbstractCast(caseType, value, false);
       }
     }
 
@@ -1413,7 +1418,7 @@ static boolean isSafeExpression(RexNode r) {
       final RexNode cond = isTrue(branch.cond);
       final RexNode value;
       if (!branchType.equals(branch.value.getType())) {
-        value = rexBuilder.makeAbstractCast(branchType, branch.value);
+        value = rexBuilder.makeAbstractCast(branchType, branch.value, false);
       } else {
         value = branch.value;
       }
@@ -1603,8 +1608,9 @@ private <C extends Comparable<C>> RexNode simplifyAnd2ForUnknownAsFalse(
           && comparison.kind != SqlKind.NOT_EQUALS) { // not supported yet
         final C v0 = comparison.literal.getValueAs(clazz);
         if (v0 != null) {
-          final RexNode result = processRange(rexBuilder, terms, rangeTerms,
-              predicate, comparison.ref, v0, comparison.kind);
+          final RexNode result =
+              processRange(rexBuilder, terms, rangeTerms,
+                  predicate, comparison.ref, v0, comparison.kind);
           if (result != null) {
             // Not satisfiable
             return result;
@@ -1704,8 +1710,9 @@ private <C extends Comparable<C>> RexNode simplifyAnd2ForUnknownAsFalse(
           if (constant == null) {
             break;
           }
-          final RexNode result = processRange(rexBuilder, terms, rangeTerms,
-              term, comparison.ref, constant, comparison.kind);
+          final RexNode result =
+              processRange(rexBuilder, terms, rangeTerms,
+                  term, comparison.ref, constant, comparison.kind);
           if (result != null) {
             // Not satisfiable
             return result;
@@ -2014,12 +2021,15 @@ private RexNode simplifyOrs(List<RexNode> terms, RexUnknownAs unknownAs) {
                   && comparable1.compareTo(comparable2) != 0) {
                 // X <> A OR X <> B => X IS NOT NULL OR NULL
                 final RexNode isNotNull =
-                    rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_NULL, notEqualsComparison.ref);
+                    rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_NULL,
+                        notEqualsComparison.ref);
                 final RexNode constantNull =
                     rexBuilder.makeNullLiteral(trueLiteral.getType());
-                final RexNode newCondition = simplify(
-                    rexBuilder.makeCall(SqlStdOperatorTable.OR, isNotNull, constantNull),
-                    unknownAs);
+                final RexNode newCondition =
+                    simplify(
+                        rexBuilder.makeCall(SqlStdOperatorTable.OR, isNotNull,
+                            constantNull),
+                        unknownAs);
                 if (newCondition.isAlwaysTrue()) {
                   return trueLiteral;
                 }
@@ -2142,7 +2152,7 @@ private RexNode simplifyCast(RexCall e) {
       return operand;
     }
     if (RexUtil.isLosslessCast(operand)) {
-      // x :: y below means cast(x as y) (which is PostgreSQL-specifiic cast by the way)
+      // x :: y below means cast(x as y) (which is PostgreSQL-specific cast by the way)
       // A) Remove lossless casts:
       // A.1) intExpr :: bigint :: int => intExpr
       // A.2) char2Expr :: char(5) :: char(2) => char2Expr
@@ -2184,6 +2194,7 @@ && sameTypeOrNarrowsNullability(e.getType(), intExpr.getType())) {
         return rexBuilder.makeCast(e.getType(), intExpr);
       }
     }
+    final boolean safe = e.getKind() == SqlKind.SAFE_CAST;
     switch (operand.getKind()) {
     case LITERAL:
       final RexLiteral literal = (RexLiteral) operand;
@@ -2212,7 +2223,8 @@ && sameTypeOrNarrowsNullability(e.getType(), intExpr.getType())) {
         break;
       }
       final List<RexNode> reducedValues = new ArrayList<>();
-      final RexNode simplifiedExpr = rexBuilder.makeCast(e.getType(), operand);
+      final RexNode simplifiedExpr =
+          rexBuilder.makeCast(e.getType(), operand, safe, safe);
       executor.reduce(rexBuilder, ImmutableList.of(simplifiedExpr), reducedValues);
       return requireNonNull(
           Iterables.getOnlyElement(reducedValues));
@@ -2220,7 +2232,7 @@ && sameTypeOrNarrowsNullability(e.getType(), intExpr.getType())) {
       if (operand == e.getOperands().get(0)) {
         return e;
       } else {
-        return rexBuilder.makeCast(e.getType(), operand);
+        return rexBuilder.makeCast(e.getType(), operand, safe, safe);
       }
     }
   }
@@ -2371,8 +2383,9 @@ public RexNode removeNullabilityCast(RexNode e) {
               return rexBuilder.makeLiteral(false);
             }
             // a <= x < b OR a < x < b
-            r = Range.range(r.lowerEndpoint(), r.lowerBoundType(),
-                    v0, BoundType.OPEN);
+            r =
+                Range.range(r.lowerEndpoint(), r.lowerBoundType(), v0,
+                    BoundType.OPEN);
           } else {
             // x < b
             r = Range.lessThan(v0);
@@ -2405,8 +2418,9 @@ public RexNode removeNullabilityCast(RexNode e) {
               return rexBuilder.makeLiteral(false);
             }
             // a <= x <= b OR a < x <= b
-            r = Range.range(r.lowerEndpoint(), r.lowerBoundType(),
-                    v0, BoundType.CLOSED);
+            r =
+                Range.range(r.lowerEndpoint(), r.lowerBoundType(), v0,
+                    BoundType.CLOSED);
           } else {
             // x <= b
             r = Range.atMost(v0);
@@ -2440,8 +2454,9 @@ public RexNode removeNullabilityCast(RexNode e) {
               return rexBuilder.makeLiteral(false);
             }
             // a < x <= b OR a < x < b
-            r = Range.range(v0, BoundType.OPEN,
-                    r.upperEndpoint(), r.upperBoundType());
+            r =
+                Range.range(v0, BoundType.OPEN, r.upperEndpoint(),
+                    r.upperBoundType());
           } else {
             // x > a
             r = Range.greaterThan(v0);
@@ -2474,8 +2489,9 @@ public RexNode removeNullabilityCast(RexNode e) {
               return rexBuilder.makeLiteral(false);
             }
             // a <= x <= b OR a <= x < b
-            r = Range.range(v0, BoundType.CLOSED,
-                    r.upperEndpoint(), r.upperBoundType());
+            r =
+                Range.range(v0, BoundType.CLOSED, r.upperEndpoint(),
+                    r.upperBoundType());
           } else {
             // x >= a
             r = Range.atLeast(v0);
@@ -2902,14 +2918,16 @@ private boolean accept2b(RexNode e, SqlKind kind,
     boolean needToFix() {
       // Fix and converts to SEARCH if:
       // 1. A Sarg has complexity greater than 1;
-      // 2. The terms are reduced as simpler Sarg points;
-      // 3. The terms are reduced as simpler Sarg comparison.
+      // 2. A Sarg was merged with another Sarg or range;
+      // 3. The terms are reduced as simpler Sarg points;
+      // 4. The terms are reduced as simpler Sarg comparison.
 
       // Ignore 'negate' just to be compatible with previous versions of this
       // method. "build().complexity()" would be a better estimate, if we could
       // switch to it breaking lots of plans.
       final Collection<RexSargBuilder> builders = map.values();
-      return builders.stream().anyMatch(b -> b.build(false).complexity() > 1)
+      return builders.stream()
+          .anyMatch(b -> b.build(false).complexity() > 1 || b.mergedSarg)
           || newTermsCount == 1
           && builders.stream().allMatch(b -> simpleSarg(b.build()));
     }
@@ -2919,7 +2937,9 @@ boolean needToFix() {
      * the IN call or single comparison.
      */
     private static boolean simpleSarg(Sarg sarg) {
-      return sarg.isPoints() || RangeSets.isOpenInterval(sarg.rangeSet);
+      return sarg.isPoints()
+          || RangeSets.isOpenInterval(sarg.rangeSet)
+          || sarg.isComplementedPoints();
     }
 
     /** If a term is a call to {@code SEARCH} on a {@link RexSargBuilder},
@@ -2970,6 +2990,8 @@ private static class RexSargBuilder extends RexNode {
     final boolean negate;
     final List<RelDataType> types = new ArrayList<>();
     final RangeSet<Comparable> rangeSet = TreeRangeSet.create();
+    boolean hasSarg;
+    boolean mergedSarg;
     RexUnknownAs nullAs = FALSE;
 
     RexSargBuilder(RexNode ref, RexBuilder rexBuilder, boolean negate) {
@@ -3031,6 +3053,7 @@ void addAll() {
     void addRange(Range<Comparable> range, RelDataType type) {
       types.add(type);
       rangeSet.add(range);
+      mergedSarg |= hasSarg;
       nullAs = nullAs.or(UNKNOWN);
     }
 
@@ -3047,6 +3070,8 @@ void addSarg(Sarg sarg, boolean negate, RelDataType type) {
       }
       types.add(type);
       rangeSet.addAll(r);
+      mergedSarg |= !rangeSet.isEmpty();
+      hasSarg = true;
       switch (nullAs) {
       case TRUE:
         this.nullAs = this.nullAs.or(TRUE);
diff --git a/core/src/main/java/org/apache/calcite/rex/RexSubQuery.java b/core/src/main/java/org/apache/calcite/rex/RexSubQuery.java
index 564e2b63b13..3bb6f2892da 100644
--- a/core/src/main/java/org/apache/calcite/rex/RexSubQuery.java
+++ b/core/src/main/java/org/apache/calcite/rex/RexSubQuery.java
@@ -26,6 +26,7 @@
 import org.apache.calcite.sql.fun.SqlQuantifyOperator;
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
 import org.apache.calcite.sql.type.SqlTypeName;
+import org.apache.calcite.sql.type.SqlTypeUtil;
 
 import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableList;
@@ -123,7 +124,9 @@ public static RexSubQuery scalar(RelNode rel) {
   public static RexSubQuery array(RelNode rel) {
     final RelDataTypeFactory typeFactory = rel.getCluster().getTypeFactory();
     final RelDataType type =
-        typeFactory.createArrayType(rel.getRowType(), -1L);
+        typeFactory.createArrayType(
+            SqlTypeUtil.deriveCollectionQueryComponentType(SqlTypeName.ARRAY, rel.getRowType()),
+            -1L);
     return new RexSubQuery(type, SqlStdOperatorTable.ARRAY_QUERY,
         ImmutableList.of(), rel);
   }
@@ -132,7 +135,9 @@ public static RexSubQuery array(RelNode rel) {
   public static RexSubQuery multiset(RelNode rel) {
     final RelDataTypeFactory typeFactory = rel.getCluster().getTypeFactory();
     final RelDataType type =
-        typeFactory.createMultisetType(rel.getRowType(), -1L);
+        typeFactory.createMultisetType(
+            SqlTypeUtil.deriveCollectionQueryComponentType(SqlTypeName.MULTISET, rel.getRowType()),
+            -1L);
     return new RexSubQuery(type, SqlStdOperatorTable.MULTISET_QUERY,
         ImmutableList.of(), rel);
   }
diff --git a/core/src/main/java/org/apache/calcite/rex/RexToSqlNodeConverterImpl.java b/core/src/main/java/org/apache/calcite/rex/RexToSqlNodeConverterImpl.java
index 426ff6d8f95..d18d7745ae2 100644
--- a/core/src/main/java/org/apache/calcite/rex/RexToSqlNodeConverterImpl.java
+++ b/core/src/main/java/org/apache/calcite/rex/RexToSqlNodeConverterImpl.java
@@ -85,7 +85,7 @@ public RexToSqlNodeConverterImpl(RexSqlConvertletTable convertletTable) {
     // Timestamp
     if (SqlTypeFamily.TIMESTAMP.getTypeNames().contains(
         literal.getTypeName())) {
-      return SqlLiteral.createTimestamp(
+      return SqlLiteral.createTimestamp(literal.getTypeName(),
           requireNonNull(literal.getValueAs(TimestampString.class),
               "literal.getValueAs(TimestampString.class)"),
           0,
diff --git a/core/src/main/java/org/apache/calcite/rex/RexUtil.java b/core/src/main/java/org/apache/calcite/rex/RexUtil.java
index d5b4bc3cc73..02fb508f2be 100644
--- a/core/src/main/java/org/apache/calcite/rex/RexUtil.java
+++ b/core/src/main/java/org/apache/calcite/rex/RexUtil.java
@@ -209,6 +209,20 @@ public static boolean isNull(RexNode expr) {
     }
   }
 
+  /**
+   * Returns whether a node represents a {@link SqlTypeName#SYMBOL} literal.
+   */
+  public static boolean isSymbolLiteral(RexNode expr) {
+    switch (expr.getKind()) {
+    case LITERAL:
+      return ((RexLiteral) expr).getTypeName() == SqlTypeName.SYMBOL;
+    case CAST:
+      return isSymbolLiteral(((RexCall) expr).operands.get(0));
+    default:
+      return false;
+    }
+  }
+
   /**
    * Returns whether a node represents a literal.
    *
@@ -386,24 +400,27 @@ private static void decompose(Set<RexNode> set, RexNode rexNode) {
   private static <C extends RexNode> void gatherConstraints(Class<C> clazz,
       RexNode predicate, Map<RexNode, C> map, Set<RexNode> excludeSet,
       RexBuilder rexBuilder) {
-    if (predicate.getKind() != SqlKind.EQUALS
-            && predicate.getKind() != SqlKind.IS_NULL) {
-      decompose(excludeSet, predicate);
-      return;
-    }
-    final List<RexNode> operands = ((RexCall) predicate).getOperands();
     final RexNode left;
     final RexNode right;
-    if (predicate.getKind() == SqlKind.EQUALS) {
-      left = operands.get(0);
-      right = operands.get(1);
-    } else { // is null
-      left = operands.get(0);
+    switch (predicate.getKind()) {
+    case EQUALS:
+    case IS_NOT_DISTINCT_FROM:
+      left = ((RexCall) predicate).getOperands().get(0);
+      right = ((RexCall) predicate).getOperands().get(1);
+      break;
+
+    case IS_NULL:
+      left = ((RexCall) predicate).getOperands().get(0);
       if (!left.getType().isNullable()) {
         // There's no sense in inferring $0=null when $0 is not nullable
         return;
       }
       right = rexBuilder.makeNullLiteral(left.getType());
+      break;
+
+    default:
+      decompose(excludeSet, predicate);
+      return;
     }
     // Note that literals are immutable too, and they can only be compared
     // through values.
@@ -471,8 +488,10 @@ private static boolean canAssignFrom(RelDataType type1, RelDataType type2,
     final SqlTypeName name1 = type1.getSqlTypeName();
     final SqlTypeName name2 = type2.getSqlTypeName();
     final RelDataType type1Final = type1;
-    SqlTypeFamily family = requireNonNull(name1.getFamily(),
-        () -> "SqlTypeFamily is null for type " + type1Final + ", SqlTypeName " + name1);
+    SqlTypeFamily family =
+        requireNonNull(name1.getFamily(),
+            () -> "SqlTypeFamily is null for type " + type1Final
+                + ", SqlTypeName " + name1);
     if (family == name2.getFamily()) {
       switch (family) {
       case NUMERIC:
@@ -1138,8 +1157,9 @@ public static RelDataType createStructType(
       @Nullable List<? extends @Nullable String> names,
       SqlValidatorUtil.@Nullable Suggester suggester) {
     if (names != null && suggester != null) {
-      names = SqlValidatorUtil.uniquify(names, suggester,
-          typeFactory.getTypeSystem().isSchemaCaseSensitive());
+      names =
+          SqlValidatorUtil.uniquify(names, suggester,
+              typeFactory.getTypeSystem().isSchemaCaseSensitive());
     }
     final RelDataTypeFactory.Builder builder = typeFactory.builder();
     for (int i = 0; i < exprs.size(); i++) {
@@ -2138,13 +2158,12 @@ public static RexNode andNot(final RexBuilder rexBuilder, RexNode e,
     case EQUALS:
       final RexCall call = (RexCall) e;
       if (call.getOperands().get(1) instanceof RexLiteral) {
-        notTerms = Util.filter(notTerms,
-            e2 -> {
+        notTerms =
+            Util.filter(notTerms, e2 -> {
               switch (e2.getKind()) {
               case EQUALS:
                 RexCall call2 = (RexCall) e2;
-                if (call2.getOperands().get(0)
-                    .equals(call.getOperands().get(0))
+                if (call2.getOperands().get(0).equals(call.getOperands().get(0))
                     && call2.getOperands().get(1) instanceof RexLiteral
                     && !call.getOperands().get(1)
                           .equals(call2.getOperands().get(1))) {
@@ -2265,11 +2284,13 @@ public static RexNode swapTableColumnReferences(final RexBuilder rexBuilder,
           @Override public RexNode visitTableInputRef(RexTableInputRef inputRef) {
             if (tableMapping != null) {
               RexTableInputRef inputRefFinal = inputRef;
-              inputRef = RexTableInputRef.of(
-                  requireNonNull(tableMapping.get(inputRef.getTableRef()),
-                      () -> "tableMapping.get(...) for " + inputRefFinal.getTableRef()),
-                  inputRef.getIndex(),
-                  inputRef.getType());
+              inputRef =
+                  RexTableInputRef.of(
+                      requireNonNull(tableMapping.get(inputRef.getTableRef()),
+                          () -> "tableMapping.get(...) for "
+                              + inputRefFinal.getTableRef()),
+                      inputRef.getIndex(),
+                      inputRef.getType());
             }
             if (ec != null) {
               Set<RexTableInputRef> s = ec.get(inputRef);
@@ -2303,9 +2324,11 @@ public static RexNode swapColumnTableReferences(final RexBuilder rexBuilder,
             }
             if (tableMapping != null) {
               RexTableInputRef inputRefFinal = inputRef;
-              inputRef = RexTableInputRef.of(
-                  requireNonNull(tableMapping.get(inputRef.getTableRef()),
-                      () -> "tableMapping.get(...) for " + inputRefFinal.getTableRef()),
+              inputRef =
+                  RexTableInputRef.of(
+                      requireNonNull(tableMapping.get(inputRef.getTableRef()),
+                          () -> "tableMapping.get(...) for "
+                              + inputRefFinal.getTableRef()),
                   inputRef.getIndex(),
                   inputRef.getType());
             }
@@ -2950,7 +2973,8 @@ public ExprSimplifier(RexSimplify simplify, RexUnknownAs unknownAs,
       if (simplifiedNode.getType().equals(call.getType())) {
         return simplifiedNode;
       }
-      return simplify.rexBuilder.makeCast(call.getType(), simplifiedNode, matchNullability);
+      return simplify.rexBuilder.makeCast(call.getType(), simplifiedNode,
+          matchNullability, false);
     }
   }
 
diff --git a/core/src/main/java/org/apache/calcite/runtime/AccumOperation.java b/core/src/main/java/org/apache/calcite/runtime/AccumOperation.java
new file mode 100644
index 00000000000..aa2f7c638a5
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/runtime/AccumOperation.java
@@ -0,0 +1,41 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.runtime;
+
+import org.locationtech.jts.geom.Geometry;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Used at run time by the ST_Accum function.
+ */
+public class AccumOperation {
+
+  public List<Geometry> init() {
+    return new ArrayList<>();
+  }
+
+  public List<Geometry> add(List<Geometry> accumulator, Geometry geometry) {
+    accumulator.add(geometry);
+    return accumulator;
+  }
+
+  public List<Geometry> result(List<Geometry> accumulator) {
+    return accumulator;
+  }
+}
diff --git a/core/src/main/java/org/apache/calcite/runtime/AddPointOperation.java b/core/src/main/java/org/apache/calcite/runtime/AddPointOperation.java
new file mode 100644
index 00000000000..940ba4c26c8
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/runtime/AddPointOperation.java
@@ -0,0 +1,51 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.runtime;
+
+import org.locationtech.jts.geom.Coordinate;
+import org.locationtech.jts.geom.Geometry;
+import org.locationtech.jts.geom.util.GeometryEditor;
+
+/**
+ * Geometry editor operation that adds a point to a geometry.
+ */
+public class AddPointOperation extends GeometryEditor.CoordinateOperation {
+
+  private final Geometry point;
+
+  private final int index;
+
+  public AddPointOperation(Geometry point, int index) {
+    this.point = point;
+    this.index = index;
+  }
+
+  @Override public Coordinate[] edit(Coordinate[] coordinates, Geometry geometry) {
+    if (index < 0 || index > coordinates.length) {
+      throw new IllegalArgumentException("Invalid index: " + index);
+    }
+    Coordinate[] newCoordinates = new Coordinate[coordinates.length + 1];
+    for (int i = 0; i < index; i++) {
+      newCoordinates[i] = (Coordinate) coordinates[i].clone();
+    }
+    newCoordinates[index] = point.getCoordinate();
+    for (int i = index; i < coordinates.length; i++) {
+      newCoordinates[i + 1] = (Coordinate) coordinates[i].clone();
+    }
+    return newCoordinates;
+  }
+}
diff --git a/core/src/main/java/org/apache/calcite/runtime/AddZTransformer.java b/core/src/main/java/org/apache/calcite/runtime/AddZTransformer.java
new file mode 100644
index 00000000000..db3b02bb2f2
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/runtime/AddZTransformer.java
@@ -0,0 +1,48 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.runtime;
+
+import org.locationtech.jts.geom.Coordinate;
+import org.locationtech.jts.geom.CoordinateSequence;
+import org.locationtech.jts.geom.Geometry;
+import org.locationtech.jts.geom.impl.CoordinateArraySequence;
+import org.locationtech.jts.geom.util.GeometryTransformer;
+
+/**
+ * Operation that adds a z value to a geometry.
+ */
+public class AddZTransformer extends GeometryTransformer {
+
+  private final double zToAdd;
+
+  public AddZTransformer(double zToAdd) {
+    this.zToAdd = zToAdd;
+  }
+
+  @Override protected CoordinateSequence transformCoordinates(
+      CoordinateSequence coordinates, Geometry parent) {
+    Coordinate[] newCoordinates = new Coordinate[coordinates.size()];
+    for (int i = 0; i < coordinates.size(); i++) {
+      Coordinate current = coordinates.getCoordinate(i);
+      if (!Double.isNaN(current.z)) {
+        newCoordinates[i] = new Coordinate(current.x, current.y, current.z + zToAdd);
+      }
+    }
+    return new CoordinateArraySequence(newCoordinates);
+  }
+
+}
diff --git a/core/src/main/java/org/apache/calcite/runtime/BufferStyle.java b/core/src/main/java/org/apache/calcite/runtime/BufferStyle.java
new file mode 100644
index 00000000000..314a6bd2506
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/runtime/BufferStyle.java
@@ -0,0 +1,123 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.runtime;
+
+import org.locationtech.jts.operation.buffer.BufferParameters;
+
+import java.util.Locale;
+
+/**
+ * A parser for buffer styles as defined by PostGIS.
+ */
+public class BufferStyle {
+
+  private int quadrantSegments = BufferParameters.DEFAULT_QUADRANT_SEGMENTS;
+
+  private int endCapStyle = BufferParameters.CAP_ROUND;
+
+  private int joinStyle = BufferParameters.JOIN_ROUND;
+
+  private int side = 0;
+
+  public BufferStyle(String style) {
+    String[] parameters = style.toLowerCase(Locale.ROOT).split(" ");
+    for (String parameter : parameters) {
+      if (parameter == null || parameter.isEmpty()) {
+        continue;
+      }
+      String[] keyValue = parameter.split("=");
+      if (keyValue.length != 2) {
+        throw new IllegalArgumentException("Invalid buffer style: " + style);
+      }
+      String key = keyValue[0];
+      String value = keyValue[1];
+      switch (key) {
+      case "quad_segs":
+        try {
+          quadrantSegments = Integer.parseInt(value);
+          break;
+        } catch (NumberFormatException e) {
+          throw new IllegalArgumentException("Invalid buffer style: " + style);
+        }
+      case "endcap":
+        switch (value) {
+        case "round":
+          endCapStyle = BufferParameters.CAP_ROUND;
+          break;
+        case "flat":
+          endCapStyle = BufferParameters.CAP_FLAT;
+          break;
+        case "square":
+          endCapStyle = BufferParameters.CAP_SQUARE;
+          break;
+        default:
+          throw new IllegalArgumentException("Invalid buffer style: " + style);
+        }
+        break;
+      case "join":
+        switch (value) {
+        case "round":
+          joinStyle = BufferParameters.JOIN_ROUND;
+          break;
+        case "mitre":
+          joinStyle = BufferParameters.JOIN_MITRE;
+          break;
+        case "bevel":
+          joinStyle = BufferParameters.JOIN_BEVEL;
+          break;
+        default:
+          throw new IllegalArgumentException("Invalid buffer style: " + style);
+        }
+        break;
+      case "side":
+        switch (value) {
+        case "left":
+          side += 1;
+          break;
+        case "right":
+          side -= 1;
+          break;
+        case "both":
+          side = 0;
+          break;
+        default:
+          throw new IllegalArgumentException("Invalid buffer style: " + style);
+        }
+        break;
+      }
+    }
+  }
+
+  /**
+   * Returns a sided distance.
+   */
+  public double asSidedDistance(double distance) {
+    return side != 0 ? distance * side : distance;
+  }
+
+  /**
+   * Returns buffer parameters.
+   */
+  public BufferParameters asBufferParameters() {
+    BufferParameters params = new BufferParameters();
+    params.setQuadrantSegments(quadrantSegments);
+    params.setEndCapStyle(endCapStyle);
+    params.setJoinStyle(joinStyle);
+    params.setSingleSided(side != 0);
+    return params;
+  }
+}
diff --git a/core/src/main/java/org/apache/calcite/runtime/CalciteResource.java b/core/src/main/java/org/apache/calcite/runtime/CalciteResource.java
index 7f9d54f8613..02a7b4aa497 100644
--- a/core/src/main/java/org/apache/calcite/runtime/CalciteResource.java
+++ b/core/src/main/java/org/apache/calcite/runtime/CalciteResource.java
@@ -42,13 +42,16 @@ public interface CalciteResource {
   @BaseMessage("''LIMIT start, count'' is not allowed under the current SQL conformance level")
   ExInst<CalciteException> limitStartCountNotAllowed();
 
+  @BaseMessage("''OFFSET start LIMIT count'' is not allowed under the current SQL conformance level")
+  ExInst<CalciteException> offsetLimitNotAllowed();
+
   @BaseMessage("APPLY operator is not allowed under the current SQL conformance level")
   ExInst<CalciteException> applyNotAllowed();
 
-  @BaseMessage("JSON path expression must be specified after the JSON value expression")
-  ExInst<CalciteException> jsonPathMustBeSpecified();
+  @BaseMessage("VALUE is not allowed under the current SQL conformance level")
+  ExInst<CalciteException> valueNotAllowed();
 
-  @BaseMessage("Illegal {0} literal {1}: {2}")
+  @BaseMessage("Illegal {0} literal ''{1}'': {2}")
   ExInst<CalciteException> illegalLiteral(String a0, String a1, String a2);
 
   @BaseMessage("Length of identifier ''{0}'' must be less than or equal to {1,number,#} characters")
@@ -63,6 +66,9 @@ public interface CalciteResource {
   @BaseMessage("Geo-spatial extensions and the GEOMETRY data type are not enabled")
   ExInst<SqlValidatorException> geometryDisabled();
 
+  @BaseMessage("Proj4J EPSG is missing from the classpath; to resolve this problem, download the EPSG data set and agree to its terms of use")
+  ExInst<CalciteException> proj4jEpsgIsMissing();
+
   @BaseMessage("Illegal INTERVAL literal {0}; at {1}")
   @Property(name = "SQLSTATE", value = "42000")
   ExInst<CalciteException> illegalIntervalLiteral(String a0, String a1);
@@ -79,6 +85,12 @@ public interface CalciteResource {
   @BaseMessage("Query expression encountered in illegal context")
   ExInst<CalciteException> illegalQueryExpression();
 
+  @BaseMessage("Join expression encountered in illegal context")
+  ExInst<CalciteException> illegalJoinExpression();
+
+  @BaseMessage("Expected query or join")
+  ExInst<CalciteException> expectedQueryOrJoinExpression();
+
   @BaseMessage("CURSOR expression encountered in illegal context")
   ExInst<CalciteException> illegalCursorExpression();
 
@@ -88,6 +100,9 @@ public interface CalciteResource {
   @BaseMessage("Illegal binary string {0}")
   ExInst<CalciteException> illegalBinaryString(String a0);
 
+  @BaseMessage("Illegal array expression ''{0}''")
+  ExInst<CalciteException> illegalArrayExpression(String a0);
+
   @BaseMessage("''FROM'' without operands preceding it is illegal")
   ExInst<CalciteException> illegalFromEmpty();
 
@@ -310,7 +325,7 @@ ExInst<CalciteException> invalidCompare(String a0, String a1, String a2,
   @BaseMessage("Cannot specify NATURAL keyword with ON or USING clause")
   ExInst<SqlValidatorException> naturalDisallowsOnOrUsing();
 
-  @BaseMessage("Column name ''{0}'' in USING clause is not unique on one side of join")
+  @BaseMessage("Column name ''{0}'' in NATURAL join or USING clause is not unique on one side of join")
   ExInst<SqlValidatorException> columnInUsingNotUnique(String a0);
 
   @BaseMessage("Column ''{0}'' matched using NATURAL keyword or USING clause has incompatible types: cannot compare ''{1}'' to ''{2}''")
@@ -320,6 +335,9 @@ ExInst<SqlValidatorException> naturalOrUsingColumnNotCompatible(String a0,
   @BaseMessage("OVER clause is necessary for window functions")
   ExInst<SqlValidatorException> absentOverClause();
 
+  @BaseMessage("Argument to function ''{0}'' must be a measure")
+  ExInst<SqlValidatorException> argumentMustBeMeasure(String functionName);
+
   @BaseMessage("Window ''{0}'' not found")
   ExInst<SqlValidatorException> windowNotFound(String a0);
 
@@ -350,6 +368,12 @@ ExInst<SqlValidatorException> naturalOrUsingColumnNotCompatible(String a0,
   @BaseMessage("Aggregate expressions cannot be nested")
   ExInst<SqlValidatorException> nestedAggIllegal();
 
+  @BaseMessage("Measure expressions can only occur within AGGREGATE function")
+  ExInst<SqlValidatorException> measureIllegal();
+
+  @BaseMessage("Measure expressions can only occur within a GROUP BY query")
+  ExInst<SqlValidatorException> measureMustBeInAggregateQuery();
+
   @BaseMessage("FILTER must not contain aggregate expression")
   ExInst<SqlValidatorException> aggregateInFilterIllegal();
 
@@ -454,6 +478,9 @@ ExInst<SqlValidatorException> intervalFieldExceedsPrecision(Number a0,
   @BaseMessage("Duplicate window specification not allowed in the same window clause")
   ExInst<SqlValidatorException> dupWindowSpec();
 
+  @BaseMessage("QUALIFY expression ''{0}'' must contain a window function")
+  ExInst<SqlValidatorException> qualifyExpressionMustContainWindowFunction(String a0);
+
   @BaseMessage("ROW/RANGE not allowed with RANK, DENSE_RANK or ROW_NUMBER functions")
   ExInst<SqlValidatorException> rankWithFrame();
 
@@ -571,6 +598,10 @@ ExInst<SqlValidatorException> intervalFractionalSecondPrecisionOutOfRange(
   ExInst<SqlValidatorException> argumentMustBeValidPrecision(String a0, int a1,
       int a2);
 
+  @BaseMessage("Call to function ''{0}'' with argument of type ''{1}'' requires extra delimiter argument")
+  ExInst<SqlValidatorException> delimiterIsRequired(String functionName,
+      String argumentTypeName);
+
   @BaseMessage("Wrong arguments for table function ''{0}'' call. Expected ''{1}'', actual ''{2}''")
   ExInst<CalciteException> illegalArgumentForTableFunctionCall(String a0,
       String a1, String a2);
@@ -578,8 +609,8 @@ ExInst<CalciteException> illegalArgumentForTableFunctionCall(String a0,
   @BaseMessage("Cannot call table function here: ''{0}''")
   ExInst<CalciteException> cannotCallTableFunctionHere(String a0);
 
-  @BaseMessage("''{0}'' is not a valid datetime format")
-  ExInst<CalciteException> invalidDatetimeFormat(String a0);
+  @BaseMessage("''{0}'' is not a valid time frame")
+  ExInst<SqlValidatorException> invalidTimeFrame(String a0);
 
   @BaseMessage("Cannot INSERT into generated column ''{0}''")
   ExInst<SqlValidatorException> insertIntoAlwaysGenerated(String a0);
@@ -845,6 +876,12 @@ ExInst<CalciteException> illegalArgumentForTableFunctionCall(String a0,
   @BaseMessage("Dialect does not support feature: ''{0}''")
   ExInst<SqlValidatorException> dialectDoesNotSupportFeature(String featureName);
 
+  @BaseMessage("Second argument for LPAD/RPAD must not be negative")
+  ExInst<CalciteException> illegalNegativePadLength();
+
+  @BaseMessage("Third argument (pad pattern) for LPAD/RPAD must not be empty")
+  ExInst<CalciteException> illegalEmptyPadPattern();
+
   @BaseMessage("Substring error: negative substring length not allowed")
   ExInst<CalciteException> illegalNegativeSubstringLength();
 
@@ -926,30 +963,39 @@ ExInstWithCause<CalciteException> failedToAccessField(
   @BaseMessage("While executing SQL [{0}] on JDBC sub-schema")
   ExInst<RuntimeException> exceptionWhilePerformingQueryOnJdbcSubSchema(String sql);
 
-  @BaseMessage("Not a valid input for JSON_TYPE: ''{0}''")
+  @BaseMessage("Invalid input for JSON_TYPE: ''{0}''")
   ExInst<CalciteException> invalidInputForJsonType(String value);
 
-  @BaseMessage("Not a valid input for JSON_DEPTH: ''{0}''")
+  @BaseMessage("Invalid input for JSON_DEPTH: ''{0}''")
   ExInst<CalciteException> invalidInputForJsonDepth(String value);
 
   @BaseMessage("Cannot serialize object to JSON: ''{0}''")
   ExInst<CalciteException> exceptionWhileSerializingToJson(String value);
 
-  @BaseMessage("Not a valid input for JSON_LENGTH: ''{0}''")
+  @BaseMessage("Invalid input for JSON_LENGTH: ''{0}''")
   ExInst<CalciteException> invalidInputForJsonLength(String value);
 
-  @BaseMessage("Not a valid input for JSON_KEYS: ''{0}''")
+  @BaseMessage("Invalid input for JSON_KEYS: ''{0}''")
   ExInst<CalciteException> invalidInputForJsonKeys(String value);
 
   @BaseMessage("Invalid input for JSON_REMOVE: document: ''{0}'', jsonpath expressions: ''{1}''")
   ExInst<CalciteException> invalidInputForJsonRemove(String value, String pathSpecs);
 
-  @BaseMessage("Not a valid input for JSON_STORAGE_SIZE: ''{0}''")
+  @BaseMessage("Invalid input for JSON_STORAGE_SIZE: ''{0}''")
   ExInst<CalciteException> invalidInputForJsonStorageSize(String value);
 
-  @BaseMessage("Not a valid input for REGEXP_REPLACE: ''{0}''")
+  @BaseMessage("Invalid input for REGEXP_REPLACE: ''{0}''")
   ExInst<CalciteException> invalidInputForRegexpReplace(String value);
 
+  @BaseMessage("Invalid input for JSON_INSERT: jsonDoc: ''{0}'', kvs: ''{1}''")
+  ExInst<CalciteException> invalidInputForJsonInsert(String jsonDoc, String kvs);
+
+  @BaseMessage("Invalid input for JSON_REPLACE: jsonDoc: ''{0}'', kvs: ''{1}''")
+  ExInst<CalciteException> invalidInputForJsonReplace(String jsonDoc, String kvs);
+
+  @BaseMessage("Invalid input for JSON_SET: jsonDoc: ''{0}'', kvs: ''{1}''")
+  ExInst<CalciteException> invalidInputForJsonSet(String jsonDoc, String kvs);
+
   @BaseMessage("Illegal xslt specified : ''{0}''")
   ExInst<CalciteException> illegalXslt(String xslt);
 
@@ -971,4 +1017,12 @@ ExInstWithCause<CalciteException> failedToAccessField(
   @BaseMessage("No operator for ''{0}'' with kind: ''{1}'', syntax: ''{2}'' during JSON deserialization")
   ExInst<CalciteException> noOperator(String name, String kind, String syntax);
 
+  @BaseMessage("Only tables with set semantics may be partitioned. Invalid PARTITION BY clause in the {0,number,#}-th operand of table function ''{1}''")
+  ExInst<SqlValidatorException> invalidPartitionKeys(int idx, String funcName);
+
+  @BaseMessage("Only tables with set semantics may be ordered. Invalid ORDER BY clause in the {0,number,#}-th operand of table function ''{1}''")
+  ExInst<SqlValidatorException> invalidOrderBy(int idx, String funcName);
+
+  @BaseMessage("A table function at most has one input table with row semantics. Table function ''{0}'' has multiple input tables with row semantics")
+  ExInst<SqlValidatorException> multipleRowSemanticsTables(String funcName);
 }
diff --git a/core/src/main/java/org/apache/calcite/runtime/CollectOperation.java b/core/src/main/java/org/apache/calcite/runtime/CollectOperation.java
new file mode 100644
index 00000000000..fc4ab27d8d6
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/runtime/CollectOperation.java
@@ -0,0 +1,44 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.runtime;
+
+import org.locationtech.jts.geom.Geometry;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.apache.calcite.runtime.SpatialTypeUtils.GEOMETRY_FACTORY;
+
+/**
+ * Used at run time by the ST_Collect function.
+ */
+public class CollectOperation {
+
+  public List<Geometry> init() {
+    return new ArrayList<>();
+  }
+
+  public List<Geometry> add(List<Geometry> accumulator, Geometry geometry) {
+    accumulator.add(geometry);
+    return accumulator;
+  }
+
+  public Geometry result(List<Geometry> accumulator) {
+    Geometry[] array = accumulator.toArray(new Geometry[accumulator.size()]);
+    return GEOMETRY_FACTORY.createGeometryCollection(array);
+  }
+}
diff --git a/core/src/main/java/org/apache/calcite/runtime/CompressionFunctions.java b/core/src/main/java/org/apache/calcite/runtime/CompressionFunctions.java
index d20b50a0905..1df63573eeb 100644
--- a/core/src/main/java/org/apache/calcite/runtime/CompressionFunctions.java
+++ b/core/src/main/java/org/apache/calcite/runtime/CompressionFunctions.java
@@ -39,7 +39,7 @@ private CompressionFunctions() {
 
   /**
    * MySql Compression is based on zlib.
-   * <a href="https://docs.oracle.com/javase/8/docs/api/java/util/zip/Deflater.html">Deflater</a>
+   * <a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/zip/Deflater.html">Deflater</a>
    * is used to implement compression.
    */
   public static @Nullable ByteString compress(@Nullable String data) {
diff --git a/core/src/main/java/org/apache/calcite/runtime/CoordinateTransformer.java b/core/src/main/java/org/apache/calcite/runtime/CoordinateTransformer.java
new file mode 100644
index 00000000000..b82efd4b6fe
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/runtime/CoordinateTransformer.java
@@ -0,0 +1,51 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.runtime;
+
+import org.locationtech.jts.geom.Coordinate;
+import org.locationtech.jts.geom.CoordinateSequence;
+import org.locationtech.jts.geom.Geometry;
+import org.locationtech.jts.geom.impl.CoordinateArraySequence;
+import org.locationtech.jts.geom.util.GeometryTransformer;
+
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+/**
+ * Transforms the coordinates of a geometry.
+ */
+public class CoordinateTransformer extends GeometryTransformer {
+
+  private final Function<Coordinate, Coordinate> transform;
+
+  /**
+   * Creates a transformer that applies the {@code transform} to all coordinates.
+   */
+  public CoordinateTransformer(Function<Coordinate, Coordinate> transform) {
+    this.transform = transform;
+  }
+
+  @Override protected CoordinateSequence transformCoordinates(
+      CoordinateSequence coordinateSequence, Geometry parent) {
+    Coordinate[] coordinateArray =
+        Stream.of(coordinateSequence.toCoordinateArray())
+            .map(transform)
+            .toArray(Coordinate[]::new);
+    return new CoordinateArraySequence(coordinateArray);
+  }
+
+}
diff --git a/core/src/main/java/org/apache/calcite/runtime/FlipCoordinatesTransformer.java b/core/src/main/java/org/apache/calcite/runtime/FlipCoordinatesTransformer.java
new file mode 100644
index 00000000000..a3f250c50ad
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/runtime/FlipCoordinatesTransformer.java
@@ -0,0 +1,41 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.runtime;
+
+import org.locationtech.jts.geom.Coordinate;
+import org.locationtech.jts.geom.CoordinateSequence;
+import org.locationtech.jts.geom.Geometry;
+import org.locationtech.jts.geom.impl.CoordinateArraySequence;
+import org.locationtech.jts.geom.util.GeometryTransformer;
+
+import java.util.stream.Stream;
+
+/**
+ * Flips the coordinates of a geometry.
+ */
+public class FlipCoordinatesTransformer extends GeometryTransformer {
+
+  @Override protected CoordinateSequence transformCoordinates(
+      CoordinateSequence coordinateSequence, Geometry parent) {
+    Coordinate[] coordinateArray =
+        Stream.of(coordinateSequence.toCoordinateArray())
+            .map(c -> new Coordinate(c.y, c.x))
+            .toArray(Coordinate[]::new);
+    return new CoordinateArraySequence(coordinateArray);
+  }
+
+}
diff --git a/core/src/main/java/org/apache/calcite/runtime/GeoFunctions.java b/core/src/main/java/org/apache/calcite/runtime/GeoFunctions.java
deleted file mode 100644
index 87291b5746a..00000000000
--- a/core/src/main/java/org/apache/calcite/runtime/GeoFunctions.java
+++ /dev/null
@@ -1,595 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to you under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.calcite.runtime;
-
-import org.apache.calcite.linq4j.AbstractEnumerable;
-import org.apache.calcite.linq4j.Enumerator;
-import org.apache.calcite.linq4j.function.Deterministic;
-import org.apache.calcite.linq4j.function.Experimental;
-import org.apache.calcite.linq4j.function.Hints;
-import org.apache.calcite.linq4j.function.SemiStrict;
-import org.apache.calcite.linq4j.function.Strict;
-import org.apache.calcite.runtime.Geometries.CapStyle;
-import org.apache.calcite.runtime.Geometries.Geom;
-import org.apache.calcite.runtime.Geometries.JoinStyle;
-
-import com.esri.core.geometry.Envelope;
-import com.esri.core.geometry.Geometry;
-import com.esri.core.geometry.GeometryEngine;
-import com.esri.core.geometry.Line;
-import com.esri.core.geometry.OperatorBoundary;
-import com.esri.core.geometry.Point;
-import com.esri.core.geometry.Polygon;
-import com.esri.core.geometry.Polyline;
-import com.esri.core.geometry.SpatialReference;
-import com.esri.core.geometry.WktExportFlags;
-import com.esri.core.geometry.WktImportFlags;
-
-import org.checkerframework.checker.nullness.qual.Nullable;
-
-import java.math.BigDecimal;
-import java.util.Objects;
-
-import static org.apache.calcite.runtime.Geometries.NO_SRID;
-import static org.apache.calcite.runtime.Geometries.bind;
-import static org.apache.calcite.runtime.Geometries.buffer;
-import static org.apache.calcite.runtime.Geometries.envelope;
-import static org.apache.calcite.runtime.Geometries.intersects;
-import static org.apache.calcite.runtime.Geometries.makeLine;
-import static org.apache.calcite.runtime.Geometries.point;
-import static org.apache.calcite.runtime.Geometries.todo;
-
-/**
- * Helper methods to implement Geo-spatial functions in generated code.
- *
- * <p>Remaining tasks:
- *
- * <ul>
- *   <li>Determine type code for
- *   {@link org.apache.calcite.sql.type.ExtraSqlTypes#GEOMETRY}
- *   <li>Should we create aliases for functions in upper-case?
- *   Without ST_ prefix?
- *   <li>Consider adding spatial literals, e.g. `GEOMETRY 'POINT (30 10)'`
- *   <li>Integer arguments, e.g. SELECT ST_MakePoint(1, 2, 1.5),
- *     ST_MakePoint(1, 2)
- *   <li>Are GEOMETRY values comparable? If so add ORDER BY test
- *   <li>We have to add 'Z' to create 3D objects. This is inconsistent with
- *   PostGIS. Who is right? At least document the difference.
- *   <li>Should add GeometryEngine.intersects; similar to disjoint etc.
- *   <li>Make {@link #ST_MakeLine(Geom, Geom)} varargs</li>
- * </ul>
- */
-@SuppressWarnings({"WeakerAccess", "unused"})
-@Deterministic
-@Strict
-@Experimental
-public class GeoFunctions {
-
-  private GeoFunctions() {}
-
-  // Geometry conversion functions (2D and 3D) ================================
-
-  public static String ST_AsText(Geom g) {
-    return ST_AsWKT(g);
-  }
-
-  public static String ST_AsWKT(Geom g) {
-    return GeometryEngine.geometryToWkt(g.g(),
-        WktExportFlags.wktExportDefaults);
-  }
-
-  public static @Nullable Geom ST_GeomFromText(String s) {
-    return ST_GeomFromText(s, NO_SRID);
-  }
-
-  public static @Nullable Geom ST_GeomFromText(String s, int srid) {
-    final Geometry g = fromWkt(s,
-        WktImportFlags.wktImportDefaults, Geometry.Type.Unknown);
-    return g == null ? null : bind(g, srid);
-  }
-
-  public static @Nullable Geom ST_LineFromText(String s) {
-    return ST_GeomFromText(s, NO_SRID);
-  }
-
-  public static @Nullable Geom ST_LineFromText(String wkt, int srid) {
-    final Geometry g = fromWkt(wkt,
-        WktImportFlags.wktImportDefaults,
-        Geometry.Type.Line);
-    return g == null ? null : bind(g, srid);
-  }
-
-  public static @Nullable Geom ST_MPointFromText(String s) {
-    return ST_GeomFromText(s, NO_SRID);
-  }
-
-  public static @Nullable Geom ST_MPointFromText(String wkt, int srid) {
-    final Geometry g = fromWkt(wkt,
-        WktImportFlags.wktImportDefaults,
-        Geometry.Type.MultiPoint);
-    return g == null ? null : bind(g, srid);
-  }
-
-  public static @Nullable Geom ST_PointFromText(String s) {
-    return ST_GeomFromText(s, NO_SRID);
-  }
-
-  public static @Nullable Geom ST_PointFromText(String wkt, int srid) {
-    final Geometry g =
-        fromWkt(wkt, WktImportFlags.wktImportDefaults, Geometry.Type.Point);
-    return g == null ? null : bind(g, srid);
-  }
-
-  public static @Nullable Geom ST_PolyFromText(String s) {
-    return ST_GeomFromText(s, NO_SRID);
-  }
-
-  public static @Nullable Geom ST_PolyFromText(String wkt, int srid) {
-    final Geometry g = fromWkt(wkt,
-        WktImportFlags.wktImportDefaults,
-        Geometry.Type.Polygon);
-    return g == null ? null : bind(g, srid);
-  }
-
-  public static @Nullable Geom ST_MLineFromText(String s) {
-    return ST_GeomFromText(s, NO_SRID);
-  }
-
-  public static @Nullable Geom ST_MLineFromText(String wkt, int srid) {
-    final Geometry g = fromWkt(wkt,
-        WktImportFlags.wktImportDefaults,
-        Geometry.Type.Unknown); // NOTE: there is no Geometry.Type.MultiLine
-    return g == null ? null : bind(g, srid);
-  }
-
-  public static @Nullable Geom ST_MPolyFromText(String s) {
-    return ST_GeomFromText(s, NO_SRID);
-  }
-
-  public static @Nullable Geom ST_MPolyFromText(String wkt, int srid) {
-    final Geometry g = fromWkt(wkt,
-        WktImportFlags.wktImportDefaults,
-        Geometry.Type.Unknown); // NOTE: there is no Geometry.Type.MultiPolygon
-    return g == null ? null : bind(g, srid);
-  }
-
-  // Geometry creation functions ==============================================
-
-  /** Calculates a regular grid of polygons based on {@code geom}. */
-  private static void ST_MakeGrid(final Geom geom,
-      final BigDecimal deltaX, final BigDecimal deltaY) {
-    // This is a dummy function. We cannot include table functions in this
-    // package, because they have too many dependencies. See the real definition
-    // in SqlGeoFunctions.
-  }
-
-  /** Calculates a regular grid of points based on {@code geom}. */
-  private static void ST_MakeGridPoints(final Geom geom,
-      final BigDecimal deltaX, final BigDecimal deltaY) {
-    // This is a dummy function. We cannot include table functions in this
-    // package, because they have too many dependencies. See the real definition
-    // in SqlGeoFunctions.
-  }
-
-  /** Creates a rectangular Polygon. */
-  public static Geom ST_MakeEnvelope(BigDecimal xMin, BigDecimal yMin,
-      BigDecimal xMax, BigDecimal yMax, int srid) {
-    Geom geom = ST_GeomFromText("POLYGON(("
-        + xMin + " " + yMin + ", "
-        + xMin + " " + yMax + ", "
-        + xMax + " " + yMax + ", "
-        + xMax + " " + yMin + ", "
-        + xMin + " " + yMin + "))", srid);
-    return Objects.requireNonNull(geom, "geom");
-  }
-
-  /** Creates a rectangular Polygon. */
-  public static Geom ST_MakeEnvelope(BigDecimal xMin, BigDecimal yMin,
-      BigDecimal xMax, BigDecimal yMax) {
-    return ST_MakeEnvelope(xMin, yMin, xMax, yMax, NO_SRID);
-  }
-
-  /** Creates a line-string from the given POINTs (or MULTIPOINTs). */
-  @Hints({"SqlKind:ST_MAKE_LINE"})
-  public static Geom ST_MakeLine(Geom geom1, Geom geom2) {
-    return makeLine(geom1, geom2);
-  }
-
-  @Hints({"SqlKind:ST_MAKE_LINE"})
-  public static Geom ST_MakeLine(Geom geom1, Geom geom2, Geom geom3) {
-    return makeLine(geom1, geom2, geom3);
-  }
-
-  @Hints({"SqlKind:ST_MAKE_LINE"})
-  public static Geom ST_MakeLine(Geom geom1, Geom geom2, Geom geom3,
-      Geom geom4) {
-    return makeLine(geom1, geom2, geom3, geom4);
-  }
-
-  @Hints({"SqlKind:ST_MAKE_LINE"})
-  public static Geom ST_MakeLine(Geom geom1, Geom geom2, Geom geom3,
-      Geom geom4, Geom geom5) {
-    return makeLine(geom1, geom2, geom3, geom4, geom5);
-  }
-
-  @Hints({"SqlKind:ST_MAKE_LINE"})
-  public static Geom ST_MakeLine(Geom geom1, Geom geom2, Geom geom3,
-      Geom geom4, Geom geom5, Geom geom6) {
-    return makeLine(geom1, geom2, geom3, geom4, geom5, geom6);
-  }
-
-  /** Alias for {@link #ST_Point(BigDecimal, BigDecimal)}. */
-  @Hints({"SqlKind:ST_POINT"})
-  public static Geom ST_MakePoint(BigDecimal x, BigDecimal y) {
-    return ST_Point(x, y);
-  }
-
-  /** Alias for {@link #ST_Point(BigDecimal, BigDecimal, BigDecimal)}. */
-  @Hints({"SqlKind:ST_POINT3"})
-  public static Geom ST_MakePoint(BigDecimal x, BigDecimal y, BigDecimal z) {
-    return ST_Point(x, y, z);
-  }
-
-  /** Constructs a 2D point from coordinates. */
-  @Hints({"SqlKind:ST_POINT"})
-  public static Geom ST_Point(BigDecimal x, BigDecimal y) {
-    // NOTE: Combine the double and BigDecimal variants of this function
-    return point(x.doubleValue(), y.doubleValue());
-  }
-
-  /** Constructs a 3D point from coordinates. */
-  @Hints({"SqlKind:ST_POINT3"})
-  public static Geom ST_Point(BigDecimal x, BigDecimal y, BigDecimal z) {
-    final Geometry g = new Point(x.doubleValue(), y.doubleValue(),
-        z.doubleValue());
-    return new Geometries.SimpleGeom(g);
-  }
-
-  // Geometry properties (2D and 3D) ==========================================
-
-  /** Returns whether {@code geom} has at least one z-coordinate. */
-  public static boolean ST_Is3D(Geom geom) {
-    return geom.g().hasZ();
-  }
-
-  /** Returns the x-value of the first coordinate of {@code geom}. */
-  public static @Nullable Double ST_X(Geom geom) {
-    return geom.g() instanceof Point ? ((Point) geom.g()).getX() : null;
-  }
-
-  /** Returns the y-value of the first coordinate of {@code geom}. */
-  public static @Nullable Double ST_Y(Geom geom) {
-    return geom.g() instanceof Point ? ((Point) geom.g()).getY() : null;
-  }
-
-  /** Returns the z-value of the first coordinate of {@code geom}. */
-  public static @Nullable Double ST_Z(Geom geom) {
-    return geom.g().getDescription().hasZ() && geom.g() instanceof Point
-        ? ((Point) geom.g()).getZ() : null;
-  }
-
-  /** Returns the boundary of {@code geom}. */
-  public static Geom ST_Boundary(Geom geom) {
-    OperatorBoundary op = OperatorBoundary.local();
-    Geometry result = op.execute(geom.g(), null);
-    return geom.wrap(result);
-  }
-
-  /** Returns the distance between {@code geom1} and {@code geom2}. */
-  public static double ST_Distance(Geom geom1, Geom geom2) {
-    return GeometryEngine.distance(geom1.g(), geom2.g(), geom1.sr());
-  }
-
-  /** Returns the type of {@code geom}. */
-  public static String ST_GeometryType(Geom geom) {
-    return Geometries.type(geom.g()).name();
-  }
-
-  /** Returns the OGC SFS type code of {@code geom}. */
-  public static int ST_GeometryTypeCode(Geom geom) {
-    return Geometries.type(geom.g()).code;
-  }
-
-  /** Returns the minimum bounding box of {@code geom} (which may be a
-   *  GEOMETRYCOLLECTION). */
-  public static Geom ST_Envelope(Geom geom) {
-    final Envelope env = envelope(geom.g());
-    return geom.wrap(env);
-  }
-
-  // Geometry predicates ======================================================
-
-  /** Returns whether {@code geom1} contains {@code geom2}. */
-  @Hints({"SqlKind:ST_CONTAINS"})
-  public static boolean ST_Contains(Geom geom1, Geom geom2) {
-    return GeometryEngine.contains(geom1.g(), geom2.g(), geom1.sr());
-  }
-
-  /** Returns whether {@code geom1} contains {@code geom2} but does not
-   * intersect its boundary. */
-  public static boolean ST_ContainsProperly(Geom geom1, Geom geom2) {
-    return GeometryEngine.contains(geom1.g(), geom2.g(), geom1.sr())
-        && !GeometryEngine.crosses(geom1.g(), geom2.g(), geom1.sr());
-  }
-
-  /** Returns whether no point in {@code geom2} is outside {@code geom1}. */
-  private static boolean ST_Covers(Geom geom1, Geom geom2)  {
-    throw todo();
-  }
-
-  /** Returns whether {@code geom1} crosses {@code geom2}. */
-  public static boolean ST_Crosses(Geom geom1, Geom geom2)  {
-    return GeometryEngine.crosses(geom1.g(), geom2.g(), geom1.sr());
-  }
-
-  /** Returns whether {@code geom1} and {@code geom2} are disjoint. */
-  public static boolean ST_Disjoint(Geom geom1, Geom geom2)  {
-    return GeometryEngine.disjoint(geom1.g(), geom2.g(), geom1.sr());
-  }
-
-  /** Returns whether the envelope of {@code geom1} intersects the envelope of
-   *  {@code geom2}. */
-  public static boolean ST_EnvelopesIntersect(Geom geom1, Geom geom2)  {
-    final Geometry e1 = envelope(geom1.g());
-    final Geometry e2 = envelope(geom2.g());
-    return intersects(e1, e2, geom1.sr());
-  }
-
-  /** Returns whether {@code geom1} equals {@code geom2}. */
-  public static boolean ST_Equals(Geom geom1, Geom geom2)  {
-    return GeometryEngine.equals(geom1.g(), geom2.g(), geom1.sr());
-  }
-
-  /** Returns whether {@code geom1} intersects {@code geom2}. */
-  public static boolean ST_Intersects(Geom geom1, Geom geom2)  {
-    final Geometry g1 = geom1.g();
-    final Geometry g2 = geom2.g();
-    final SpatialReference sr = geom1.sr();
-    return intersects(g1, g2, sr);
-  }
-
-  /** Returns whether {@code geom1} equals {@code geom2} and their coordinates
-   * and component Geometries are listed in the same order. */
-  public static boolean ST_OrderingEquals(Geom geom1, Geom geom2)  {
-    return GeometryEngine.equals(geom1.g(), geom2.g(), geom1.sr());
-  }
-
-  /** Returns {@code geom1} overlaps {@code geom2}. */
-  public static boolean ST_Overlaps(Geom geom1, Geom geom2)  {
-    return GeometryEngine.overlaps(geom1.g(), geom2.g(), geom1.sr());
-  }
-
-  /** Returns whether {@code geom1} touches {@code geom2}. */
-  public static boolean ST_Touches(Geom geom1, Geom geom2)  {
-    return GeometryEngine.touches(geom1.g(), geom2.g(), geom1.sr());
-  }
-
-  /** Returns whether {@code geom1} is within {@code geom2}. */
-  public static boolean ST_Within(Geom geom1, Geom geom2)  {
-    return GeometryEngine.within(geom1.g(), geom2.g(), geom1.sr());
-  }
-
-  /** Returns whether {@code geom1} and {@code geom2} are within
-   * {@code distance} of each other. */
-  @Hints({"SqlKind:ST_DWITHIN"})
-  public static boolean ST_DWithin(Geom geom1, Geom geom2, double distance) {
-    final double distance1 =
-        GeometryEngine.distance(geom1.g(), geom2.g(), geom1.sr());
-    return distance1 <= distance;
-  }
-
-  // Geometry operators (2D and 3D) ===========================================
-
-  /** Computes a buffer around {@code geom}. */
-  public static Geom ST_Buffer(Geom geom, double distance) {
-    final Polygon g = GeometryEngine.buffer(geom.g(), geom.sr(), distance);
-    return geom.wrap(g);
-  }
-
-  /** Computes a buffer around {@code geom} with . */
-  public static Geom ST_Buffer(Geom geom, double distance, int quadSegs) {
-    throw todo();
-  }
-
-  /** Computes a buffer around {@code geom}. */
-  public static Geom ST_Buffer(Geom geom, double bufferSize, String style) {
-    int quadSegCount = 8;
-    CapStyle endCapStyle = CapStyle.ROUND;
-    JoinStyle joinStyle = JoinStyle.ROUND;
-    float mitreLimit = 5f;
-    int i = 0;
-    parse:
-    for (;;) {
-      int equals = style.indexOf('=', i);
-      if (equals < 0) {
-        break;
-      }
-      int space = style.indexOf(' ', equals);
-      if (space < 0) {
-        space = style.length();
-      }
-      String name = style.substring(i, equals);
-      String value = style.substring(equals + 1, space);
-      switch (name) {
-      case "quad_segs":
-        quadSegCount = Integer.parseInt(value);
-        break;
-      case "endcap":
-        endCapStyle = CapStyle.of(value);
-        break;
-      case "join":
-        joinStyle = JoinStyle.of(value);
-        break;
-      case "mitre_limit":
-      case "miter_limit":
-        mitreLimit = Float.parseFloat(value);
-        break;
-      default:
-        // ignore the value
-      }
-      i = space;
-      for (;;) {
-        if (i >= style.length()) {
-          break parse;
-        }
-        if (style.charAt(i) != ' ') {
-          break;
-        }
-        ++i;
-      }
-    }
-    return buffer(geom, bufferSize, quadSegCount, endCapStyle, joinStyle,
-        mitreLimit);
-  }
-
-  /** Computes the union of {@code geom1} and {@code geom2}. */
-  public static Geom ST_Union(Geom geom1, Geom geom2) {
-    SpatialReference sr = geom1.sr();
-    final Geometry g =
-        GeometryEngine.union(new Geometry[]{geom1.g(), geom2.g()}, sr);
-    return bind(g, sr);
-  }
-
-  /** Computes the union of the geometries in {@code geomCollection}. */
-  @SemiStrict public static Geom ST_Union(Geom geomCollection) {
-    SpatialReference sr = geomCollection.sr();
-    final Geometry g =
-        GeometryEngine.union(new Geometry[] {geomCollection.g()}, sr);
-    return bind(g, sr);
-  }
-
-  // Geometry projection functions ============================================
-
-  /** Transforms {@code geom} from one coordinate reference
-   * system (CRS) to the CRS specified by {@code srid}. */
-  public static Geom ST_Transform(Geom geom, int srid) {
-    return geom.transform(srid);
-  }
-
-  /** Returns a copy of {@code geom} with a new SRID. */
-  public static Geom ST_SetSRID(Geom geom, int srid) {
-    return geom.transform(srid);
-  }
-
-  // Space-filling curves
-
-  /** Returns the position of a point on the Hilbert curve,
-   * or null if it is not a 2-dimensional point. */
-  @Hints({"SqlKind:HILBERT"})
-  public static @Nullable Long hilbert(Geom geom) {
-    final Geometry g = geom.g();
-    if (g instanceof Point) {
-      final double x = ((Point) g).getX();
-      final double y = ((Point) g).getY();
-      return new HilbertCurve2D(8).toIndex(x, y);
-    }
-    return null;
-  }
-
-  /** Returns the position of a point on the Hilbert curve. */
-  @Hints({"SqlKind:HILBERT"})
-  public static long hilbert(BigDecimal x, BigDecimal y) {
-    return new HilbertCurve2D(8).toIndex(x.doubleValue(), y.doubleValue());
-  }
-
-  /** Creates a geometry from a WKT.
-   * If the engine returns a null, throws; never returns null. */
-  private static @Nullable Geometry fromWkt(String wkt, int importFlags,
-      Geometry.Type geometryType) {
-    return GeometryEngine.geometryFromWkt(wkt, importFlags, geometryType);
-  }
-
-  // Inner classes ============================================================
-
-  /** Used at run time by the {@link #ST_MakeGrid} and
-   * {@link #ST_MakeGridPoints} functions. */
-  public static class GridEnumerable extends AbstractEnumerable<Object[]> {
-    private final Envelope envelope;
-    private final boolean point;
-    private final double deltaX;
-    private final double deltaY;
-    private final double minX;
-    private final double minY;
-    private final int baseX;
-    private final int baseY;
-    private final int spanX;
-    private final int spanY;
-    private final int area;
-
-    public GridEnumerable(Envelope envelope, BigDecimal deltaX,
-        BigDecimal deltaY, boolean point) {
-      this.envelope = envelope;
-      this.deltaX = deltaX.doubleValue();
-      this.deltaY = deltaY.doubleValue();
-      this.point = point;
-      this.spanX = (int) Math.floor((envelope.getXMax() - envelope.getXMin())
-          / this.deltaX) + 1;
-      this.baseX = (int) Math.floor(envelope.getXMin() / this.deltaX);
-      this.minX = this.deltaX * baseX;
-      this.spanY = (int) Math.floor((envelope.getYMax() - envelope.getYMin())
-          / this.deltaY) + 1;
-      this.baseY = (int) Math.floor(envelope.getYMin() / this.deltaY);
-      this.minY = this.deltaY * baseY;
-      this.area = this.spanX * this.spanY;
-    }
-
-    @Override public Enumerator<Object[]> enumerator() {
-      return new Enumerator<Object[]>() {
-        int id = -1;
-
-        @Override public Object[] current() {
-          final Geom geom;
-          final int x = id % spanX;
-          final int y = id / spanX;
-          if (point) {
-            final double xCurrent = minX + (x + 0.5D) * deltaX;
-            final double yCurrent = minY + (y + 0.5D) * deltaY;
-            geom = ST_MakePoint(BigDecimal.valueOf(xCurrent),
-                BigDecimal.valueOf(yCurrent));
-          } else {
-            final Polygon polygon = new Polygon();
-            final double left = minX + x * deltaX;
-            final double right = left + deltaX;
-            final double bottom = minY + y * deltaY;
-            final double top = bottom + deltaY;
-
-            final Polyline polyline = new Polyline();
-            polyline.addSegment(new Line(left, bottom, right, bottom), true);
-            polyline.addSegment(new Line(right, bottom, right, top), false);
-            polyline.addSegment(new Line(right, top, left, top), false);
-            polyline.addSegment(new Line(left, top, left, bottom), false);
-            polygon.add(polyline, false);
-            geom = new Geometries.SimpleGeom(polygon);
-          }
-          return new Object[] {geom, id, x + 1, y + 1, baseX + x, baseY + y};
-        }
-
-        @Override public boolean moveNext() {
-          return ++id < area;
-        }
-
-        @Override public void reset() {
-          id = -1;
-        }
-
-        @Override public void close() {
-        }
-      };
-    }
-  }
-
-}
diff --git a/core/src/main/java/org/apache/calcite/runtime/Geometries.java b/core/src/main/java/org/apache/calcite/runtime/Geometries.java
deleted file mode 100644
index b762ba2f1b7..00000000000
--- a/core/src/main/java/org/apache/calcite/runtime/Geometries.java
+++ /dev/null
@@ -1,293 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to you under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.calcite.runtime;
-
-import org.apache.calcite.linq4j.function.Deterministic;
-import org.apache.calcite.linq4j.function.Experimental;
-import org.apache.calcite.linq4j.function.Strict;
-import org.apache.calcite.util.Util;
-
-import com.esri.core.geometry.Envelope;
-import com.esri.core.geometry.Geometry;
-import com.esri.core.geometry.Line;
-import com.esri.core.geometry.MapGeometry;
-import com.esri.core.geometry.Operator;
-import com.esri.core.geometry.OperatorFactoryLocal;
-import com.esri.core.geometry.OperatorIntersects;
-import com.esri.core.geometry.Point;
-import com.esri.core.geometry.Polyline;
-import com.esri.core.geometry.SpatialReference;
-import com.google.common.collect.ImmutableList;
-
-import java.util.Objects;
-
-/**
- * Utilities for geometry.
- */
-@SuppressWarnings({"WeakerAccess", "unused"})
-@Deterministic
-@Strict
-@Experimental
-public class Geometries {
-  static final int NO_SRID = 0;
-  private static final SpatialReference SPATIAL_REFERENCE =
-      SpatialReference.create(4326);
-
-  private Geometries() {}
-
-  static UnsupportedOperationException todo() {
-    return new UnsupportedOperationException();
-  }
-
-  /** Returns a Geom that is a Geometry bound to a SRID. */
-  protected static Geom bind(Geometry geometry, int srid) {
-    if (srid == NO_SRID) {
-      return new SimpleGeom(geometry);
-    }
-    return bind(geometry, SpatialReference.create(srid));
-  }
-
-  static MapGeom bind(Geometry geometry, SpatialReference sr) {
-    return new MapGeom(new MapGeometry(geometry, sr));
-  }
-
-  static Geom makeLine(Geom... geoms) {
-    return makeLine(ImmutableList.copyOf(geoms));
-  }
-
-  public static Geom makeLine(Iterable<? extends Geom> geoms) {
-    final Polyline g = new Polyline();
-    Point p = null;
-    for (Geom geom : geoms) {
-      if (geom.g() instanceof Point) {
-        final Point prev = p;
-        p = (Point) geom.g();
-        if (prev != null) {
-          final Line line = new Line();
-          line.setStart(prev);
-          line.setEnd(p);
-          g.addSegment(line, false);
-        }
-      }
-    }
-    return new SimpleGeom(g);
-  }
-
-  static Geom point(double x, double y) {
-    final Geometry g = new Point(x, y);
-    return new SimpleGeom(g);
-  }
-
-  /** Returns the OGC type of a geometry. */
-  public static Type type(Geometry g) {
-    switch (g.getType()) {
-    case Point:
-      return Type.POINT;
-    case Polyline:
-      return Type.LINESTRING;
-    case Polygon:
-      return Type.POLYGON;
-    case MultiPoint:
-      return Type.MULTIPOINT;
-    case Envelope:
-      return Type.POLYGON;
-    case Line:
-      return Type.LINESTRING;
-    case Unknown:
-      return Type.Geometry;
-    default:
-      throw new AssertionError(g);
-    }
-  }
-
-  static Envelope envelope(Geometry g) {
-    final Envelope env = new Envelope();
-    g.queryEnvelope(env);
-    return env;
-  }
-
-  static boolean intersects(Geometry g1, Geometry g2,
-      SpatialReference sr) {
-    final OperatorIntersects op = (OperatorIntersects) OperatorFactoryLocal
-        .getInstance().getOperator(Operator.Type.Intersects);
-    return op.execute(g1, g2, sr, null);
-  }
-
-  static Geom buffer(Geom geom, double bufferSize,
-      int quadSegCount, CapStyle endCapStyle, JoinStyle joinStyle,
-      float mitreLimit) {
-    Util.discard(endCapStyle + ":" + joinStyle + ":" + mitreLimit
-        + ":" + quadSegCount);
-    throw todo();
-  }
-
-  /** How the "buffer" command terminates the end of a line. */
-  enum CapStyle {
-    ROUND, FLAT, SQUARE;
-
-    static CapStyle of(String value) {
-      switch (value) {
-      case "round":
-        return ROUND;
-      case "flat":
-      case "butt":
-        return FLAT;
-      case "square":
-        return SQUARE;
-      default:
-        throw new IllegalArgumentException("unknown endcap value: " + value);
-      }
-    }
-  }
-
-  /** How the "buffer" command decorates junctions between line segments. */
-  enum JoinStyle {
-    ROUND, MITRE, BEVEL;
-
-    static JoinStyle of(String value) {
-      switch (value) {
-      case "round":
-        return ROUND;
-      case "mitre":
-      case "miter":
-        return MITRE;
-      case "bevel":
-        return BEVEL;
-      default:
-        throw new IllegalArgumentException("unknown join value: " + value);
-      }
-    }
-  }
-
-  /** Geometry types, with the names and codes assigned by OGC. */
-  public enum Type {
-    Geometry(0),
-    POINT(1),
-    LINESTRING(2),
-    POLYGON(3),
-    MULTIPOINT(4),
-    MULTILINESTRING(5),
-    MULTIPOLYGON(6),
-    GEOMCOLLECTION(7),
-    CURVE(13),
-    SURFACE(14),
-    POLYHEDRALSURFACE(15);
-
-    final int code;
-
-    Type(int code) {
-      this.code = code;
-    }
-  }
-
-  /** Geometry. It may or may not have a spatial reference
-   * associated with it. */
-  public interface Geom extends Comparable<Geom> {
-    Geometry g();
-
-    Type type();
-
-    SpatialReference sr();
-
-    Geom transform(int srid);
-
-    Geom wrap(Geometry g);
-  }
-
-  /** Sub-class of geometry that has no spatial reference. */
-  static class SimpleGeom implements Geom {
-    final Geometry g;
-
-    SimpleGeom(Geometry g) {
-      this.g = Objects.requireNonNull(g, "g");
-    }
-
-    @Override public String toString() {
-      return g.toString();
-    }
-
-    @Override public int compareTo(Geom o) {
-      return toString().compareTo(o.toString());
-    }
-
-    @Override public Geometry g() {
-      return g;
-    }
-
-    @Override public Type type() {
-      return Geometries.type(g);
-    }
-
-    @Override public SpatialReference sr() {
-      return SPATIAL_REFERENCE;
-    }
-
-    @Override public Geom transform(int srid) {
-      if (srid == SPATIAL_REFERENCE.getID()) {
-        return this;
-      }
-      return bind(g, srid);
-    }
-
-    @Override public Geom wrap(Geometry g) {
-      return new SimpleGeom(g);
-    }
-  }
-
-  /** Sub-class of geometry that has a spatial reference. */
-  static class MapGeom implements Geom {
-    final MapGeometry mg;
-
-    MapGeom(MapGeometry mg) {
-      this.mg = Objects.requireNonNull(mg, "mg");
-    }
-
-    @Override public String toString() {
-      return mg.toString();
-    }
-
-    @Override public int compareTo(Geom o) {
-      return toString().compareTo(o.toString());
-    }
-
-    @Override public Geometry g() {
-      return mg.getGeometry();
-    }
-
-    @Override public Type type() {
-      return Geometries.type(mg.getGeometry());
-    }
-
-    @Override public SpatialReference sr() {
-      return mg.getSpatialReference();
-    }
-
-    @Override public Geom transform(int srid) {
-      if (srid == NO_SRID) {
-        return new SimpleGeom(mg.getGeometry());
-      }
-      if (srid == mg.getSpatialReference().getID()) {
-        return this;
-      }
-      return bind(Objects.requireNonNull(mg.getGeometry()), srid);
-    }
-
-    @Override public Geom wrap(Geometry g) {
-      return bind(g, this.mg.getSpatialReference());
-    }
-  }
-}
diff --git a/core/src/main/java/org/apache/calcite/runtime/HttpUtils.java b/core/src/main/java/org/apache/calcite/runtime/HttpUtils.java
index d23b93805df..9191dc1a3ae 100644
--- a/core/src/main/java/org/apache/calcite/runtime/HttpUtils.java
+++ b/core/src/main/java/org/apache/calcite/runtime/HttpUtils.java
@@ -115,8 +115,8 @@ public static InputStream executeMethod(
       return conn.getInputStream();
     }
     conn.setDoOutput(true);
-    try (Writer w = new OutputStreamWriter(conn.getOutputStream(),
-        StandardCharsets.UTF_8)) {
+    try (Writer w =
+             new OutputStreamWriter(conn.getOutputStream(), StandardCharsets.UTF_8)) {
       w.write(data.toString());
       w.flush(); // Get the response
       return conn.getInputStream();
diff --git a/core/src/main/java/org/apache/calcite/runtime/JsonFunctions.java b/core/src/main/java/org/apache/calcite/runtime/JsonFunctions.java
index 9108d6b5902..348938db2fd 100644
--- a/core/src/main/java/org/apache/calcite/runtime/JsonFunctions.java
+++ b/core/src/main/java/org/apache/calcite/runtime/JsonFunctions.java
@@ -77,6 +77,8 @@ public class JsonFunctions {
       new DefaultPrettyPrinter().withObjectIndenter(
           DefaultIndenter.SYSTEM_LINEFEED_INSTANCE.withLinefeed("\n"));
 
+  private static final String JSON_ROOT_PATH = "$";
+
   private JsonFunctions() {
   }
 
@@ -136,24 +138,24 @@ public static JsonPathContext jsonApiCommonSyntax(JsonValueContext input, String
         if (input.hasException()) {
           return JsonPathContext.withStrictException(pathSpec, input.exc);
         }
-        ctx = JsonPath.parse(input.obj(),
-            Configuration
-                .builder()
-                .jsonProvider(JSON_PATH_JSON_PROVIDER)
-                .mappingProvider(JSON_PATH_MAPPING_PROVIDER)
-                .build());
+        ctx =
+            JsonPath.parse(input.obj(),
+                Configuration.builder()
+                    .jsonProvider(JSON_PATH_JSON_PROVIDER)
+                    .mappingProvider(JSON_PATH_MAPPING_PROVIDER)
+                    .build());
         break;
       case LAX:
         if (input.hasException()) {
           return JsonPathContext.withJavaObj(PathMode.LAX, null);
         }
-        ctx = JsonPath.parse(input.obj(),
-            Configuration
-                .builder()
-                .options(Option.SUPPRESS_EXCEPTIONS)
-                .jsonProvider(JSON_PATH_JSON_PROVIDER)
-                .mappingProvider(JSON_PATH_MAPPING_PROVIDER)
-                .build());
+        ctx =
+            JsonPath.parse(input.obj(),
+                Configuration.builder()
+                    .options(Option.SUPPRESS_EXCEPTIONS)
+                    .jsonProvider(JSON_PATH_JSON_PROVIDER)
+                    .mappingProvider(JSON_PATH_MAPPING_PROVIDER)
+                    .build());
         break;
       default:
         throw RESOURCE.illegalJsonPathModeInPathSpec(mode.toString(), pathSpec).ex();
@@ -264,8 +266,9 @@ public static JsonPathContext jsonApiCommonSyntax(JsonValueContext input, String
         }
       } else if (context.mode == PathMode.STRICT
           && !isScalarObject(value)) {
-        exc = RESOURCE.scalarValueRequiredInStrictModeOfJsonValueFunc(
-            value.toString()).ex();
+        exc =
+            RESOURCE.scalarValueRequiredInStrictModeOfJsonValueFunc(
+                value.toString()).ex();
       } else {
         return value;
       }
@@ -350,8 +353,9 @@ && isScalarObject(value)) {
               emptyBehavior.toString()).ex();
         }
       } else if (context.mode == PathMode.STRICT && isScalarObject(value)) {
-        exc = RESOURCE.arrayOrObjectValueRequiredInStrictModeOfJsonQueryFunc(
-            value.toString()).ex();
+        exc =
+            RESOURCE.arrayOrObjectValueRequiredInStrictModeOfJsonQueryFunc(
+                value.toString()).ex();
       } else {
         try {
           return jsonize(value);
@@ -626,13 +630,13 @@ public static String jsonRemove(String input, String... pathSpecs) {
 
   public static String jsonRemove(JsonValueContext input, String... pathSpecs) {
     try {
-      DocumentContext ctx = JsonPath.parse(input.obj(),
-          Configuration
-              .builder()
-              .options(Option.SUPPRESS_EXCEPTIONS)
-              .jsonProvider(JSON_PATH_JSON_PROVIDER)
-              .mappingProvider(JSON_PATH_MAPPING_PROVIDER)
-              .build());
+      DocumentContext ctx =
+          JsonPath.parse(input.obj(),
+              Configuration.builder()
+                  .options(Option.SUPPRESS_EXCEPTIONS)
+                  .jsonProvider(JSON_PATH_JSON_PROVIDER)
+                  .mappingProvider(JSON_PATH_MAPPING_PROVIDER)
+                  .build());
       for (String pathSpec : pathSpecs) {
         if ((pathSpec != null) && (ctx.read(pathSpec) != null)) {
           ctx.delete(pathSpec);
@@ -658,6 +662,130 @@ public static Integer jsonStorageSize(JsonValueContext input) {
     }
   }
 
+  private static String jsonModify(JsonValueContext jsonDoc, JsonModifyMode type, Object... kvs) {
+    int step = type == JsonModifyMode.REMOVE ? 1 : 2;
+    assert kvs.length % step == 0;
+    String result = null;
+    DocumentContext ctx =
+        JsonPath.parse(jsonDoc.obj(),
+            Configuration.builder()
+                .options(Option.SUPPRESS_EXCEPTIONS)
+                .jsonProvider(JSON_PATH_JSON_PROVIDER)
+                .mappingProvider(JSON_PATH_MAPPING_PROVIDER)
+                .build());
+
+    for (int i = 0; i < kvs.length; i += step) {
+      String k = (String) kvs[i];
+      Object v = kvs[i + step - 1];
+      if (!(JsonPath.isPathDefinite(k) && k.contains(JSON_ROOT_PATH))) {
+        throw RESOURCE.validationError(k).ex();
+      }
+      switch (type) {
+      case REPLACE:
+        if (k.equals(JSON_ROOT_PATH)) {
+          result = jsonize(v);
+        } else {
+          if (ctx.read(k) != null) {
+            ctx.set(k, v);
+          }
+        }
+        break;
+      case INSERT:
+        if (!k.equals(JSON_ROOT_PATH) && ctx.read(k) == null) {
+          insertToJson(ctx, k, v);
+        }
+        break;
+      case SET:
+        if (k.equals(JSON_ROOT_PATH)) {
+          result = jsonize(v);
+        } else {
+          if (ctx.read(k) != null) {
+            ctx.set(k, v);
+          } else {
+            insertToJson(ctx, k, v);
+          }
+        }
+        break;
+      case REMOVE:
+        if (ctx.read(k) != null) {
+          ctx.delete(k);
+        }
+        break;
+      }
+    }
+
+    return result == null || result.isEmpty() ? ctx.jsonString() : result;
+  }
+
+  private static void insertToJson(DocumentContext ctx, String path, Object value) {
+    final String parentPath;
+    final String key;
+
+    //The following paragraph of logic is mainly used to obtain the parent node path of path and
+    //the key value that should be inserted when the preant Path is map.
+    //eg: path is $.a ,parentPath is $
+    //eg: path is $.a[1] ,parentPath is $.a
+    Integer dotIndex = path.lastIndexOf(".");
+    Integer leftBracketIndex = path.lastIndexOf("[");
+    if (dotIndex.equals(-1) && leftBracketIndex.equals(-1)) {
+      parentPath = path;
+      key = path;
+    } else if (!dotIndex.equals(-1) && leftBracketIndex.equals(-1)) {
+      parentPath = path.substring(0, dotIndex);
+      key = path.substring(dotIndex + 1);
+    } else if (dotIndex.equals(-1) && !leftBracketIndex.equals(-1)) {
+      parentPath = path.substring(0, leftBracketIndex);
+      key = path.substring(leftBracketIndex + 1);
+    } else {
+      int position = dotIndex > leftBracketIndex ? dotIndex : leftBracketIndex;
+      parentPath = path.substring(0, position);
+      key = path.substring(position);
+    }
+
+    Object obj = ctx.read(parentPath);
+    if (obj instanceof Map) {
+      ctx.put(parentPath, key, value.toString());
+    } else if (obj instanceof Collection) {
+      ctx.add(parentPath, value);
+    }
+  }
+
+  public static String jsonReplace(String jsonDoc, Object... kvs) {
+    return jsonReplace(jsonValueExpression(jsonDoc), kvs);
+  }
+
+  public static String jsonReplace(JsonValueContext input, Object... kvs) {
+    try {
+      return jsonModify(input, JsonModifyMode.REPLACE, kvs);
+    } catch (Exception ex) {
+      throw RESOURCE.invalidInputForJsonReplace(input.toString(), jsonize(kvs)).ex();
+    }
+  }
+
+  public static String jsonInsert(String jsonDoc, Object... kvs) {
+    return jsonInsert(jsonValueExpression(jsonDoc), kvs);
+  }
+
+  public static String jsonInsert(JsonValueContext input, Object... kvs) {
+    try {
+      return jsonModify(input, JsonModifyMode.INSERT, kvs);
+    } catch (Exception ex) {
+      throw RESOURCE.invalidInputForJsonInsert(input.toString(), jsonize(kvs)).ex();
+    }
+  }
+
+  public static String jsonSet(String jsonDoc, Object... kvs) {
+    return jsonSet(jsonValueExpression(jsonDoc), kvs);
+  }
+
+  public static String jsonSet(JsonValueContext input, Object... kvs) {
+    try {
+      return jsonModify(input, JsonModifyMode.SET, kvs);
+    } catch (Exception ex) {
+      throw RESOURCE.invalidInputForJsonSet(input.toString(), jsonize(kvs)).ex();
+    }
+  }
+
   public static boolean isJsonValue(String input) {
     try {
       dejsonize(input);
@@ -818,4 +946,14 @@ public enum PathMode {
     UNKNOWN,
     NONE
   }
+
+  /**
+   * Used in the JsonModify function.
+   */
+  public enum JsonModifyMode {
+    REPLACE,
+    INSERT,
+    SET,
+    REMOVE
+  }
 }
diff --git a/core/src/main/java/org/apache/calcite/runtime/Like.java b/core/src/main/java/org/apache/calcite/runtime/Like.java
index 34f20deb727..2fa8665629b 100644
--- a/core/src/main/java/org/apache/calcite/runtime/Like.java
+++ b/core/src/main/java/org/apache/calcite/runtime/Like.java
@@ -127,7 +127,7 @@ private static void similarEscapeRuleChecking(
       return;
     }
     if (SQL_SIMILAR_SPECIALS.indexOf(escapeChar) >= 0) {
-      // The the escape character is a special character
+      // The escape character is a special character
       // SQL 2003 Part 2 Section 8.6 General Rule 3.b
       for (int i = 0; i < sqlPattern.length(); i++) {
         if (sqlPattern.charAt(i) == escapeChar) {
@@ -278,11 +278,9 @@ static String sqlToRegexSimilar(
         case '[':
           javaPattern.append('[');
           insideCharacterEnumeration = true;
-          i = sqlSimilarRewriteCharEnumeration(
-              sqlPattern,
-              javaPattern,
-              i,
-              escapeChar);
+          i =
+              sqlSimilarRewriteCharEnumeration(sqlPattern, javaPattern,
+                  i, escapeChar);
           break;
         case ']':
           if (!insideCharacterEnumeration) {
diff --git a/core/src/main/java/org/apache/calcite/runtime/Matcher.java b/core/src/main/java/org/apache/calcite/runtime/Matcher.java
index e99df30640f..fd864b0eefd 100644
--- a/core/src/main/java/org/apache/calcite/runtime/Matcher.java
+++ b/core/src/main/java/org/apache/calcite/runtime/Matcher.java
@@ -122,8 +122,8 @@ protected List<PartialMatch<E>> matchOneWithSymbols(MemoryFactory.Memory<E> rows
 
           for (DeterministicAutomaton.Transition transition : transitions) {
             // System.out.println("Append new transition to ");
-            final PartialMatch<E> newMatch = pm.append(transition.symbol,
-                rows.get(), transition.toState);
+            final PartialMatch<E> newMatch =
+                pm.append(transition.symbol, rows.get(), transition.toState);
             newMatches.add(newMatch);
           }
         }
@@ -137,9 +137,9 @@ protected List<PartialMatch<E>> matchOneWithSymbols(MemoryFactory.Memory<E> rows
                 .collect(Collectors.toList());
 
         for (DeterministicAutomaton.Transition transition : transitions) {
-          final PartialMatch<E> newMatch = new PartialMatch<>(-1L,
-              ImmutableList.of(transition.symbol), ImmutableList.of(rows.get()),
-              transition.toState);
+          final PartialMatch<E> newMatch =
+              new PartialMatch<>(-1L, ImmutableList.of(transition.symbol),
+                  ImmutableList.of(rows.get()), transition.toState);
           newMatches.add(newMatch);
         }
       }
diff --git a/core/src/main/java/org/apache/calcite/runtime/ProjectionTransformer.java b/core/src/main/java/org/apache/calcite/runtime/ProjectionTransformer.java
new file mode 100644
index 00000000000..825d5e7de1b
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/runtime/ProjectionTransformer.java
@@ -0,0 +1,166 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.runtime;
+
+import org.locationtech.jts.geom.Coordinate;
+import org.locationtech.jts.geom.CoordinateSequence;
+import org.locationtech.jts.geom.Geometry;
+import org.locationtech.jts.geom.GeometryCollection;
+import org.locationtech.jts.geom.LineString;
+import org.locationtech.jts.geom.LinearRing;
+import org.locationtech.jts.geom.MultiLineString;
+import org.locationtech.jts.geom.MultiPoint;
+import org.locationtech.jts.geom.MultiPolygon;
+import org.locationtech.jts.geom.Point;
+import org.locationtech.jts.geom.Polygon;
+import org.locationtech.jts.geom.impl.CoordinateArraySequence;
+import org.locationtech.jts.geom.util.GeometryTransformer;
+import org.locationtech.proj4j.CRSFactory;
+import org.locationtech.proj4j.CoordinateReferenceSystem;
+import org.locationtech.proj4j.CoordinateTransform;
+import org.locationtech.proj4j.CoordinateTransformFactory;
+import org.locationtech.proj4j.ProjCoordinate;
+
+import java.util.Locale;
+import java.util.stream.Stream;
+
+/**
+ * Transforms the projection of a geometry.
+ */
+public class ProjectionTransformer extends GeometryTransformer {
+
+  private final CoordinateTransform coordinateTransform;
+
+  /**
+   * Creates a transformer that reprojects geometries with the provided SRIDs.
+   *
+   * @param sourceSrid the source SRID
+   * @param targetSrid the target SRID
+   */
+  public ProjectionTransformer(int sourceSrid, int targetSrid) {
+    CRSFactory crsFactory = new CRSFactory();
+    CoordinateReferenceSystem source = crsFactory
+        .createFromName(String.format(Locale.ROOT, "epsg:%s", sourceSrid));
+    CoordinateReferenceSystem target = crsFactory
+        .createFromName(String.format(Locale.ROOT, "epsg:%s", targetSrid));
+    CoordinateTransformFactory ctFactory = new CoordinateTransformFactory();
+    coordinateTransform = ctFactory.createTransform(source, target);
+  }
+
+  @Override protected CoordinateSequence transformCoordinates(
+      CoordinateSequence coordinateSequence, Geometry parent) {
+    Coordinate[] coordinateArray =
+        Stream.of(coordinateSequence.toCoordinateArray())
+            .map(this::transformCoordinate)
+            .toArray(Coordinate[]::new);
+    return new CoordinateArraySequence(coordinateArray);
+  }
+
+  private Coordinate transformCoordinate(Coordinate coordinate) {
+    ProjCoordinate c1 = new ProjCoordinate(coordinate.x, coordinate.y);
+    ProjCoordinate c2 = coordinateTransform.transform(c1, new ProjCoordinate());
+    return new Coordinate(c2.x, c2.y);
+  }
+
+  @Override protected Geometry transformPoint(Point geom, Geometry parent) {
+    try {
+      Geometry geometry = super.transformPoint(geom, parent);
+      return withTargetSRID(geometry);
+    } catch (Exception e) {
+      return parent.getFactory().createEmpty(0);
+    }
+  }
+
+  @Override protected Geometry transformMultiPoint(MultiPoint geom, Geometry parent) {
+    try {
+      Geometry geometry = super.transformMultiPoint(geom, parent);
+      if (geometry instanceof Point) {
+        geometry = factory.createMultiPoint(new Point[]{(Point) geometry});
+      }
+      return withTargetSRID(geometry);
+    } catch (Exception e) {
+      return parent.getFactory().createEmpty(0);
+    }
+  }
+
+  @Override protected Geometry transformLinearRing(LinearRing geom, Geometry parent) {
+    try {
+      Geometry geometry = super.transformLinearRing(geom, parent);
+      return withTargetSRID(geometry);
+    } catch (Exception e) {
+      return parent.getFactory().createEmpty(0);
+    }
+  }
+
+  @Override protected Geometry transformLineString(LineString geom, Geometry parent) {
+    try {
+      Geometry geometry = super.transformLineString(geom, parent);
+      return withTargetSRID(geometry);
+    } catch (Exception e) {
+      return parent.getFactory().createEmpty(0);
+    }
+  }
+
+  @Override protected Geometry transformMultiLineString(MultiLineString geom, Geometry parent) {
+    try {
+      Geometry geometry = super.transformMultiLineString(geom, parent);
+      if (geometry instanceof LineString) {
+        geometry = factory.createMultiLineString(new LineString[]{(LineString) geometry});
+      }
+      return withTargetSRID(geometry);
+    } catch (Exception e) {
+      return parent.getFactory().createEmpty(0);
+    }
+  }
+
+  @Override protected Geometry transformPolygon(Polygon geom, Geometry parent) {
+    try {
+      Geometry geometry = super.transformPolygon(geom, parent);
+      return withTargetSRID(geometry);
+    } catch (Exception e) {
+      return parent.getFactory().createEmpty(0);
+    }
+  }
+
+  @Override protected Geometry transformMultiPolygon(MultiPolygon geom, Geometry parent) {
+    try {
+      Geometry geometry = super.transformMultiPolygon(geom, parent);
+      if (geometry instanceof Polygon) {
+        geometry = factory.createMultiPolygon(new Polygon[]{(Polygon) geometry});
+      }
+      return withTargetSRID(geometry);
+    } catch (Exception e) {
+      return parent.getFactory().createEmpty(0);
+    }
+  }
+
+  @Override protected Geometry transformGeometryCollection(
+      GeometryCollection geom, Geometry parent) {
+    try {
+      Geometry geometry = super.transformGeometryCollection(geom, parent);
+      return withTargetSRID(geometry);
+    } catch (Exception e) {
+      return parent.getFactory().createEmpty(0);
+    }
+  }
+
+  private Geometry withTargetSRID(Geometry outputGeom) {
+    int srid = coordinateTransform.getTargetCRS().getProjection().getEPSGCode();
+    outputGeom.setSRID(srid);
+    return outputGeom;
+  }
+}
diff --git a/core/src/main/java/org/apache/calcite/runtime/RemoveHoleTransformer.java b/core/src/main/java/org/apache/calcite/runtime/RemoveHoleTransformer.java
new file mode 100644
index 00000000000..db188c3b45f
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/runtime/RemoveHoleTransformer.java
@@ -0,0 +1,41 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.runtime;
+
+import org.locationtech.jts.geom.Geometry;
+import org.locationtech.jts.geom.LinearRing;
+import org.locationtech.jts.geom.Polygon;
+import org.locationtech.jts.geom.util.GeometryTransformer;
+
+/**
+ * Removes the holes of a geometry.
+ */
+public class RemoveHoleTransformer extends GeometryTransformer {
+
+  @Override protected Geometry transformPolygon(Polygon geom, Geometry parent) {
+    if (geom == null || geom.isEmpty()) {
+      return factory.createPolygon();
+    }
+
+    LinearRing exteriorRing = geom.getExteriorRing();
+    if (exteriorRing == null || exteriorRing.isEmpty()) {
+      return factory.createPolygon();
+    }
+
+    return factory.createPolygon(exteriorRing);
+  }
+}
diff --git a/core/src/main/java/org/apache/calcite/runtime/RemovePointOperation.java b/core/src/main/java/org/apache/calcite/runtime/RemovePointOperation.java
new file mode 100644
index 00000000000..0dbab299229
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/runtime/RemovePointOperation.java
@@ -0,0 +1,47 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.runtime;
+
+import org.locationtech.jts.geom.Coordinate;
+import org.locationtech.jts.geom.Geometry;
+import org.locationtech.jts.geom.util.GeometryEditor;
+
+/**
+ * Geometry editor operation that removes a point to a geometry.
+ */
+public class RemovePointOperation extends GeometryEditor.CoordinateOperation {
+
+  private final int index;
+
+  public RemovePointOperation(int index) {
+    this.index = index;
+  }
+
+  @Override public Coordinate[] edit(Coordinate[] coordinates, Geometry geometry) {
+    if (index < 0 || index > coordinates.length - 1) {
+      throw new IllegalArgumentException("Invalid index: " + index);
+    }
+    Coordinate[] newCoordinates = new Coordinate[coordinates.length - 1];
+    for (int i = 0; i < index; i++) {
+      newCoordinates[i] = (Coordinate) coordinates[i].clone();
+    }
+    for (int i = index + 1; i < coordinates.length; i++) {
+      newCoordinates[i - 1] = (Coordinate) coordinates[i].clone();
+    }
+    return newCoordinates;
+  }
+}
diff --git a/core/src/main/java/org/apache/calcite/runtime/RemoveRepeatedPointsTransformer.java b/core/src/main/java/org/apache/calcite/runtime/RemoveRepeatedPointsTransformer.java
new file mode 100644
index 00000000000..dd898822037
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/runtime/RemoveRepeatedPointsTransformer.java
@@ -0,0 +1,66 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.runtime;
+
+import org.locationtech.jts.geom.Coordinate;
+import org.locationtech.jts.geom.CoordinateSequence;
+import org.locationtech.jts.geom.Geometry;
+import org.locationtech.jts.geom.impl.CoordinateArraySequence;
+import org.locationtech.jts.geom.util.GeometryTransformer;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Removes repeated points from a geometry.
+ */
+public class RemoveRepeatedPointsTransformer extends GeometryTransformer {
+
+  private double tolerance = 0;
+
+  public RemoveRepeatedPointsTransformer() {
+    super();
+  }
+
+  public RemoveRepeatedPointsTransformer(double tolerance) {
+    super();
+    this.tolerance = tolerance;
+  }
+
+  @Override protected CoordinateSequence transformCoordinates(
+      CoordinateSequence coordinates, Geometry parent) {
+    List<Coordinate> list = new ArrayList<>();
+    Coordinate previous = coordinates.getCoordinate(0);
+    list.add(previous);
+    for (int i = 1; i < coordinates.size(); i++) {
+      Coordinate current = coordinates.getCoordinate(i);
+      double distance = current.distance(previous);
+      if (distance > tolerance) {
+        list.add(current);
+        previous = current;
+      }
+    }
+    Coordinate last = coordinates.getCoordinate(coordinates.size() - 1);
+    double distance = last.distance(previous);
+    if (distance <= tolerance) {
+      list.set(list.size() - 1, last);
+    }
+    Coordinate[] array = list.toArray(new Coordinate[list.size()]);
+    return new CoordinateArraySequence(array);
+  }
+
+}
diff --git a/core/src/main/java/org/apache/calcite/runtime/ResultSetEnumerable.java b/core/src/main/java/org/apache/calcite/runtime/ResultSetEnumerable.java
index 554bdb13f9c..2f991773527 100644
--- a/core/src/main/java/org/apache/calcite/runtime/ResultSetEnumerable.java
+++ b/core/src/main/java/org/apache/calcite/runtime/ResultSetEnumerable.java
@@ -68,8 +68,8 @@ public class ResultSetEnumerable<T> extends AbstractEnumerable<T> {
   private final Function1<ResultSet, Function0<T>> rowBuilderFactory;
   private final @Nullable PreparedStatementEnricher preparedStatementEnricher;
 
-  private static final Logger LOGGER = LoggerFactory.getLogger(
-      ResultSetEnumerable.class);
+  private static final Logger LOGGER =
+      LoggerFactory.getLogger(ResultSetEnumerable.class);
 
   private @Nullable Long queryStart;
   private long timeout;
diff --git a/core/src/main/java/org/apache/calcite/runtime/SpatialTypeFunctions.java b/core/src/main/java/org/apache/calcite/runtime/SpatialTypeFunctions.java
new file mode 100644
index 00000000000..5587711d914
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/runtime/SpatialTypeFunctions.java
@@ -0,0 +1,1881 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.runtime;
+
+import org.apache.calcite.avatica.util.ByteString;
+import org.apache.calcite.linq4j.AbstractEnumerable;
+import org.apache.calcite.linq4j.Enumerator;
+import org.apache.calcite.linq4j.function.Deterministic;
+import org.apache.calcite.linq4j.function.Experimental;
+import org.apache.calcite.linq4j.function.Hints;
+import org.apache.calcite.linq4j.function.SemiStrict;
+import org.apache.calcite.linq4j.function.Strict;
+import org.apache.calcite.runtime.SpatialTypeUtils.SpatialType;
+
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.locationtech.jts.algorithm.InteriorPoint;
+import org.locationtech.jts.algorithm.MinimumBoundingCircle;
+import org.locationtech.jts.algorithm.MinimumDiameter;
+import org.locationtech.jts.densify.Densifier;
+import org.locationtech.jts.geom.Coordinate;
+import org.locationtech.jts.geom.CoordinateSequence;
+import org.locationtech.jts.geom.Envelope;
+import org.locationtech.jts.geom.Geometry;
+import org.locationtech.jts.geom.GeometryCollection;
+import org.locationtech.jts.geom.GeometryComponentFilter;
+import org.locationtech.jts.geom.GeometryFactory;
+import org.locationtech.jts.geom.GeometryFilter;
+import org.locationtech.jts.geom.LineSegment;
+import org.locationtech.jts.geom.LineString;
+import org.locationtech.jts.geom.LinearRing;
+import org.locationtech.jts.geom.MultiLineString;
+import org.locationtech.jts.geom.MultiPoint;
+import org.locationtech.jts.geom.MultiPolygon;
+import org.locationtech.jts.geom.OctagonalEnvelope;
+import org.locationtech.jts.geom.Point;
+import org.locationtech.jts.geom.Polygon;
+import org.locationtech.jts.geom.PrecisionModel;
+import org.locationtech.jts.geom.util.AffineTransformation;
+import org.locationtech.jts.geom.util.GeometryEditor;
+import org.locationtech.jts.geom.util.GeometryFixer;
+import org.locationtech.jts.linearref.LengthIndexedLine;
+import org.locationtech.jts.operation.buffer.BufferOp;
+import org.locationtech.jts.operation.buffer.BufferParameters;
+import org.locationtech.jts.operation.buffer.OffsetCurve;
+import org.locationtech.jts.operation.distance.DistanceOp;
+import org.locationtech.jts.operation.linemerge.LineMerger;
+import org.locationtech.jts.operation.overlay.snap.GeometrySnapper;
+import org.locationtech.jts.operation.polygonize.Polygonizer;
+import org.locationtech.jts.precision.GeometryPrecisionReducer;
+import org.locationtech.jts.simplify.DouglasPeuckerSimplifier;
+import org.locationtech.jts.simplify.TopologyPreservingSimplifier;
+import org.locationtech.jts.triangulate.DelaunayTriangulationBuilder;
+import org.locationtech.jts.triangulate.polygon.ConstrainedDelaunayTriangulator;
+import org.locationtech.jts.triangulate.quadedge.QuadEdgeSubdivision;
+import org.locationtech.jts.triangulate.tri.Tri;
+import org.locationtech.jts.util.GeometricShapeFactory;
+
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Objects;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+import static org.apache.calcite.runtime.SpatialTypeUtils.GEOMETRY_FACTORY;
+import static org.apache.calcite.runtime.SpatialTypeUtils.NO_SRID;
+import static org.apache.calcite.runtime.SpatialTypeUtils.asEwkt;
+import static org.apache.calcite.runtime.SpatialTypeUtils.asGeoJson;
+import static org.apache.calcite.runtime.SpatialTypeUtils.asGml;
+import static org.apache.calcite.runtime.SpatialTypeUtils.asWkb;
+import static org.apache.calcite.runtime.SpatialTypeUtils.asWkt;
+import static org.apache.calcite.runtime.SpatialTypeUtils.fromEwkt;
+import static org.apache.calcite.runtime.SpatialTypeUtils.fromGeoJson;
+import static org.apache.calcite.runtime.SpatialTypeUtils.fromGml;
+import static org.apache.calcite.runtime.SpatialTypeUtils.fromWkb;
+import static org.apache.calcite.runtime.SpatialTypeUtils.fromWkt;
+import static org.apache.calcite.util.Static.RESOURCE;
+
+/**
+ * Helper methods to implement spatial type (ST) functions in generated code.
+ *
+ * <p>Remaining tasks:
+ *
+ * <ul>
+ *   <li>Determine type code for
+ *   {@link org.apache.calcite.sql.type.ExtraSqlTypes#GEOMETRY}
+ *   <li>Should we create aliases for functions in upper-case?
+ *   Without ST_ prefix?
+ *   <li>Consider adding spatial literals, e.g. `GEOMETRY 'POINT (30 10)'`
+ *   <li>Integer arguments, e.g. SELECT ST_MakePoint(1, 2, 1.5),
+ *     ST_MakePoint(1, 2)
+ *   <li>Are GEOMETRY values comparable? If so add ORDER BY test
+ *   <li>We have to add 'Z' to create 3D objects. This is inconsistent with
+ *   PostGIS. Who is right? At least document the difference.
+ *   <li>Should add GeometryEngine.intersects; similar to disjoint etc.
+ *   <li>Make {@link #ST_MakeLine(Geometry, Geometry)} varargs</li>
+ * </ul>
+ */
+@SuppressWarnings({"WeakerAccess", "unused"})
+@Deterministic
+@Strict
+@Experimental
+public class SpatialTypeFunctions {
+
+  private SpatialTypeFunctions() {
+  }
+
+  // Geometry conversion functions (2D)
+
+  public static @Nullable ByteString ST_AsBinary(Geometry geometry) {
+    return ST_AsWKB(geometry);
+  }
+
+  public static @Nullable String ST_AsEWKT(Geometry geometry) {
+    return asEwkt(geometry);
+  }
+
+  public static @Nullable String ST_AsGeoJSON(Geometry geometry) {
+    return asGeoJson(geometry);
+  }
+
+  public static @Nullable String ST_AsGML(Geometry geometry) {
+    return asGml(geometry);
+  }
+
+  public static @Nullable String ST_AsText(Geometry geometry) {
+    return ST_AsWKT(geometry);
+  }
+
+  public static @Nullable ByteString ST_AsEWKB(Geometry geometry) {
+    return ST_AsWKB(geometry);
+  }
+
+  public static @Nullable ByteString ST_AsWKB(Geometry geometry) {
+    return asWkb(geometry);
+  }
+
+  public static @Nullable String ST_AsWKT(Geometry geometry) {
+    return asWkt(geometry);
+  }
+
+  public static @Nullable Geometry ST_Force2D(Geometry geometry) {
+    Function<Coordinate, Coordinate> transform =
+        coordinate -> new Coordinate(coordinate.getX(), coordinate.getY());
+    CoordinateTransformer transformer = new CoordinateTransformer(transform);
+    return transformer.transform(geometry);
+  }
+
+  public static @Nullable Geometry ST_GeomFromEWKB(ByteString ewkb) {
+    return ST_GeomFromWKB(ewkb);
+  }
+
+  public static @Nullable Geometry ST_GeomFromEWKT(String ewkt) {
+    return fromEwkt(ewkt);
+  }
+
+  public static @Nullable Geometry ST_GeomFromGeoJSON(String geojson) {
+    return fromGeoJson(geojson);
+  }
+
+  public static @Nullable Geometry ST_GeomFromGML(String gml) {
+    return ST_GeomFromGML(gml, NO_SRID);
+  }
+
+  public static @Nullable Geometry ST_GeomFromGML(String gml, int srid) {
+    Geometry geometry = fromGml(gml);
+    geometry.setSRID(srid);
+    return geometry;
+  }
+
+  public static @Nullable Geometry ST_GeomFromText(String wkt) {
+    return ST_GeomFromWKT(wkt);
+  }
+
+  public static @Nullable Geometry ST_GeomFromText(String wkt, int srid) {
+    return ST_GeomFromWKT(wkt, srid);
+  }
+
+  public static @Nullable Geometry ST_GeomFromWKB(ByteString wkb) {
+    return fromWkb(wkb);
+  }
+
+  public static @Nullable Geometry ST_GeomFromWKB(ByteString wkb, int srid) {
+    Geometry geometry = fromWkb(wkb);
+    geometry.setSRID(srid);
+    return geometry;
+  }
+
+  public static @Nullable Geometry ST_GeomFromWKT(String wkt) {
+    return ST_GeomFromWKT(wkt, NO_SRID);
+  }
+
+  public static @Nullable Geometry ST_GeomFromWKT(String wkt, int srid) {
+    Geometry geometry = fromWkt(wkt);
+    geometry.setSRID(srid);
+    return geometry;
+  }
+
+  public static @Nullable Geometry ST_LineFromText(String wkt) {
+    Geometry geometry = ST_GeomFromWKT(wkt);
+    return geometry instanceof LineString ? geometry : null;
+  }
+
+  public static @Nullable Geometry ST_LineFromText(String wkt, int srid) {
+    Geometry geometry = ST_GeomFromWKT(wkt, srid);
+    return geometry instanceof LineString ? geometry : null;
+  }
+
+  public static @Nullable Geometry ST_LineFromWKB(ByteString wkb) {
+    Geometry geometry = ST_GeomFromWKB(wkb);
+    return geometry instanceof LineString ? geometry : null;
+  }
+
+  public static @Nullable Geometry ST_LineFromWKB(ByteString wkt, int srid) {
+    Geometry geometry = ST_GeomFromWKB(wkt, srid);
+    return geometry instanceof LineString ? geometry : null;
+  }
+
+  public static @Nullable Geometry ST_MLineFromText(String wkt) {
+    Geometry geometry = ST_GeomFromWKT(wkt);
+    return geometry instanceof MultiLineString ? geometry : null;
+  }
+
+  public static @Nullable Geometry ST_MLineFromText(String wkt, int srid) {
+    Geometry geometry = ST_GeomFromWKT(wkt, srid);
+    return geometry instanceof MultiLineString ? geometry : null;
+  }
+
+  public static @Nullable Geometry ST_MPointFromText(String wkt) {
+    Geometry geometry = ST_GeomFromWKT(wkt);
+    return geometry instanceof MultiPoint ? geometry : null;
+  }
+
+  public static @Nullable Geometry ST_MPointFromText(String wkt, int srid) {
+    Geometry geometry = ST_GeomFromWKT(wkt, srid);
+    return geometry instanceof MultiPoint ? geometry : null;
+  }
+
+  public static @Nullable Geometry ST_MPolyFromText(String wkt) {
+    Geometry geometry = ST_GeomFromWKT(wkt);
+    return geometry instanceof MultiPolygon ? geometry : null;
+  }
+
+  public static @Nullable Geometry ST_MPolyFromText(String wkt, int srid) {
+    Geometry geometry = ST_GeomFromWKT(wkt, srid);
+    return geometry instanceof MultiPolygon ? geometry : null;
+  }
+
+  public static @Nullable Geometry ST_PointFromText(String wkt) {
+    Geometry geometry = ST_GeomFromWKT(wkt);
+    return geometry instanceof Point ? geometry : null;
+  }
+
+  public static @Nullable Geometry ST_PointFromText(String wkt, int srid) {
+    Geometry geometry = ST_GeomFromWKT(wkt, srid);
+    return geometry instanceof Point ? geometry : null;
+  }
+
+  public static @Nullable Geometry ST_PointFromWKB(ByteString wkb) {
+    Geometry geometry = ST_GeomFromWKB(wkb);
+    return geometry instanceof Point ? geometry : null;
+  }
+
+  public static @Nullable Geometry ST_PointFromWKB(ByteString wkb, int srid) {
+    Geometry geometry = ST_GeomFromWKB(wkb, srid);
+    return geometry instanceof Point ? geometry : null;
+  }
+
+  public static @Nullable Geometry ST_PolyFromText(String wkt) {
+    Geometry geometry = ST_GeomFromWKT(wkt);
+    return geometry instanceof Polygon ? geometry : null;
+  }
+
+  public static @Nullable Geometry ST_PolyFromText(String wkt, int srid) {
+    Geometry geometry = ST_GeomFromWKT(wkt, srid);
+    return geometry instanceof Polygon ? geometry : null;
+  }
+
+  public static @Nullable Geometry ST_PolyFromWKB(ByteString wkb) {
+    Geometry geometry = ST_GeomFromWKB(wkb);
+    return geometry instanceof Polygon ? geometry : null;
+  }
+
+  public static @Nullable Geometry ST_PolyFromWKB(ByteString wkb, int srid) {
+    Geometry geometry = ST_GeomFromWKB(wkb, srid);
+    return geometry instanceof Polygon ? geometry : null;
+  }
+
+  /**
+   * Reduces the precision of a {@code geom} to the provided {@code gridSize}.
+   */
+  public static Geometry ST_ReducePrecision(Geometry geom, BigDecimal gridSize) {
+    PrecisionModel precisionModel = new PrecisionModel(1 / gridSize.doubleValue());
+    GeometryPrecisionReducer reducer = new GeometryPrecisionReducer(precisionModel);
+    reducer.setPointwise(true);
+    return reducer.reduce(geom);
+  }
+
+  /**
+   * Converts the coordinates of a {@code geom} into a MULTIPOINT.
+   */
+  public static @Nullable Geometry ST_ToMultiPoint(Geometry geom) {
+    CoordinateSequence coordinateSequence = GEOMETRY_FACTORY
+        .getCoordinateSequenceFactory().create(geom.getCoordinates());
+    return GEOMETRY_FACTORY.createMultiPoint(coordinateSequence);
+  }
+
+  /**
+   * Converts the a {@code geom} into a MULTILINESTRING.
+   */
+  public static @Nullable Geometry ST_ToMultiLine(Geometry geom) {
+    GeometryFactory factory = geom.getFactory();
+    ArrayList<LineString> lines = new ArrayList<>();
+    geom.apply((GeometryComponentFilter) inputGeom -> {
+      if (inputGeom instanceof LineString) {
+        lines.add(factory.createLineString(inputGeom.getCoordinates()));
+      }
+    });
+    if (lines.isEmpty()) {
+      return factory.createMultiLineString();
+    } else {
+      return factory.createMultiLineString(lines.toArray(new LineString[lines.size()]));
+    }
+  }
+
+  /**
+   * Converts a {@code geom} into a set of distinct segments stored in a MULTILINESTRING.
+   */
+  public static @Nullable Geometry ST_ToMultiSegments(Geometry geom) {
+    GeometryFactory factory = geom.getFactory();
+    ArrayList<LineString> lines = new ArrayList<>();
+    geom.apply((GeometryComponentFilter) inputGeom -> {
+      if (inputGeom instanceof LineString) {
+        Coordinate[] coordinates = inputGeom.getCoordinates();
+        for (int i = 1; i < coordinates.length; i++) {
+          Coordinate[] pair = new Coordinate[]{coordinates[i - 1], coordinates[i]};
+          lines.add(factory.createLineString(pair));
+        }
+      }
+    });
+    if (lines.isEmpty()) {
+      return factory.createMultiLineString();
+    } else {
+      return factory.createMultiLineString(lines.toArray(new LineString[lines.size()]));
+    }
+  }
+
+  // Geometry conversion functions (3D)
+
+  public static @Nullable Geometry ST_Force3D(Geometry geometry) {
+    Function<Coordinate, Coordinate> transform =
+        coordinate -> new Coordinate(
+            coordinate.getX(),
+            coordinate.getY(),
+            Double.isNaN(coordinate.getZ()) ? 0d : coordinate.getZ());
+    CoordinateTransformer transformer = new CoordinateTransformer(transform);
+    return transformer.transform(geometry);
+  }
+
+  // Geometry creation functions ==============================================
+
+  /**
+   * Calculates a regular grid of polygons based on {@code geom}.
+   */
+  private static void ST_MakeGrid(final Geometry geom,
+      final BigDecimal deltaX, final BigDecimal deltaY) {
+    // This is a dummy function. We cannot include table functions in this
+    // package, because they have too many dependencies. See the real definition
+    // in SqlSpatialTypeFunctions.
+  }
+
+  /**
+   * Calculates a regular grid of points based on {@code geom}.
+   */
+  private static void ST_MakeGridPoints(final Geometry geom,
+      final BigDecimal deltaX, final BigDecimal deltaY) {
+    // This is a dummy function. We cannot include table functions in this
+    // package, because they have too many dependencies. See the real definition
+    // in SqlSpatialTypeFunctions.
+  }
+
+  // Geometry creation functions (2D)
+
+  /**
+   * Returns the minimum bounding circle of {@code geom}.
+   */
+  public static Geometry ST_BoundingCircle(Geometry geom) {
+    return new MinimumBoundingCircle(geom).getCircle();
+  }
+
+  /**
+   * Expands {@code geom}'s envelope.
+   */
+  public static Geometry ST_Expand(Geometry geom, BigDecimal distance) {
+    Envelope envelope = geom.getEnvelopeInternal().copy();
+    envelope.expandBy(distance.doubleValue());
+    return geom.getFactory().toGeometry(envelope);
+  }
+
+  /**
+   * Makes an ellipse.
+   */
+  public static @Nullable Geometry ST_MakeEllipse(Geometry point, BigDecimal width,
+      BigDecimal height) {
+    if (!(point instanceof Point)) {
+      return null;
+    }
+    GeometricShapeFactory factory = new GeometricShapeFactory(point.getFactory());
+    factory.setCentre(point.getCoordinate());
+    factory.setWidth(width.doubleValue());
+    factory.setHeight(height.doubleValue());
+    return factory.createEllipse();
+  }
+
+  /**
+   * Makes a polygon.
+   */
+  public static @Nullable Geometry ST_MakePolygon(Geometry shell) {
+    return makePolygon(shell);
+  }
+
+  /**
+   * Makes a polygon.
+   */
+  public static @Nullable Geometry ST_MakePolygon(Geometry shell, Geometry hole0) {
+    return makePolygon(shell, hole0);
+  }
+
+  /**
+   * Makes a polygon.
+   */
+  public static @Nullable Geometry ST_MakePolygon(Geometry shell,
+      Geometry hole0, Geometry hole1) {
+    return makePolygon(shell,
+        hole0, hole1);
+  }
+
+  /**
+   * Makes a polygon.
+   */
+  public static @Nullable Geometry ST_MakePolygon(Geometry shell,
+      Geometry hole0, Geometry hole1, Geometry hole2) {
+    return makePolygon(shell,
+        hole0, hole1, hole2);
+  }
+
+  /**
+   * Makes a polygon.
+   */
+  public static @Nullable Geometry ST_MakePolygon(Geometry shell,
+      Geometry hole0, Geometry hole1, Geometry hole2, Geometry hole3) {
+    return makePolygon(shell,
+        hole0, hole1, hole2, hole3);
+  }
+
+  /**
+   * Makes a polygon.
+   */
+  public static @Nullable Geometry ST_MakePolygon(Geometry shell,
+      Geometry hole0, Geometry hole1, Geometry hole2, Geometry hole3, Geometry hole4) {
+    return makePolygon(shell,
+        hole0, hole1, hole2, hole3, hole4);
+  }
+
+  /**
+   * Makes a polygon.
+   */
+  public static @Nullable Geometry ST_MakePolygon(Geometry shell,
+      Geometry hole0, Geometry hole1, Geometry hole2, Geometry hole3, Geometry hole4,
+      Geometry hole5) {
+    return makePolygon(shell,
+        hole0, hole1, hole2, hole3, hole4,
+        hole5);
+  }
+
+  /**
+   * Makes a polygon.
+   */
+  public static @Nullable Geometry ST_MakePolygon(Geometry shell,
+      Geometry hole0, Geometry hole1, Geometry hole2, Geometry hole3, Geometry hole4,
+      Geometry hole5, Geometry hole6) {
+    return makePolygon(shell,
+        hole0, hole1, hole2, hole3, hole4,
+        hole5, hole6);
+  }
+
+  /**
+   * Makes a polygon.
+   */
+  public static @Nullable Geometry ST_MakePolygon(Geometry shell,
+      Geometry hole0, Geometry hole1, Geometry hole2, Geometry hole3, Geometry hole4,
+      Geometry hole5, Geometry hole6, Geometry hole7) {
+    return makePolygon(shell,
+        hole0, hole1, hole2, hole3, hole4,
+        hole5, hole6, hole7);
+  }
+
+  /**
+   * Makes a polygon.
+   */
+  public static @Nullable Geometry ST_MakePolygon(Geometry shell,
+      Geometry hole0, Geometry hole1, Geometry hole2, Geometry hole3, Geometry hole4,
+      Geometry hole5, Geometry hole6, Geometry hole7, Geometry hole8) {
+    return makePolygon(shell,
+        hole0, hole1, hole2, hole3, hole4,
+        hole5, hole6, hole7, hole8);
+  }
+
+  /**
+   * Makes a polygon.
+   */
+  public static @Nullable Geometry ST_MakePolygon(Geometry shell,
+      Geometry hole0, Geometry hole1, Geometry hole2, Geometry hole3, Geometry hole4,
+      Geometry hole5, Geometry hole6, Geometry hole7, Geometry hole8, Geometry hole9) {
+    return makePolygon(shell,
+        hole0, hole1, hole2, hole3, hole4,
+        hole5, hole6, hole7, hole8, hole9);
+  }
+
+  private static @Nullable Geometry makePolygon(Geometry shell, Geometry... holes) {
+    if (!(shell instanceof LineString)) {
+      throw new RuntimeException("Only supports LINESTRINGs.");
+    }
+    if (!((LineString) shell).isClosed()) {
+      throw new RuntimeException("The LINESTRING must be closed.");
+    }
+    for (Geometry hole : holes) {
+      if (!(hole instanceof LineString)) {
+        throw new RuntimeException("Only supports LINESTRINGs.");
+      }
+      if (!((LineString) hole).isClosed()) {
+        throw new RuntimeException("The LINESTRING must be closed.");
+      }
+    }
+    LinearRing shellRing = shell.getFactory().createLinearRing(shell.getCoordinates());
+    LinearRing[] holeRings = new LinearRing[holes.length];
+    for (int i = 0; i < holes.length; i++) {
+      holeRings[i] = holes[i].getFactory().createLinearRing(holes[i].getCoordinates());
+    }
+    return shell.getFactory().createPolygon(shellRing, holeRings);
+  }
+
+  /**
+   * Returns the minimum diameter of {@code geom}.
+   */
+  public static @Nullable Geometry ST_MinimumDiameter(Geometry geom) {
+    return new MinimumDiameter(geom).getDiameter();
+  }
+
+  /**
+   * Returns the minimum rectangle enclosing {@code geom}.
+   */
+  public static @Nullable Geometry ST_MinimumRectangle(Geometry geom) {
+    return new MinimumDiameter(geom).getMinimumRectangle();
+  }
+
+  /**
+   * Returns the octagonal envelope of {@code geom}.
+   */
+  public static @Nullable Geometry ST_OctagonalEnvelope(Geometry geom) {
+    return new OctagonalEnvelope(geom).toGeometry(geom.getFactory());
+  }
+
+  /**
+   * Expands {@code geom}'s envelope.
+   */
+  public static Geometry ST_Expand(Geometry geom, BigDecimal deltaX, BigDecimal deltaY) {
+    Envelope envelope = geom.getEnvelopeInternal().copy();
+    envelope.expandBy(deltaX.doubleValue(), deltaY.doubleValue());
+    return geom.getFactory().toGeometry(envelope);
+  }
+
+  /**
+   * Creates a rectangular Polygon.
+   */
+  public static Geometry ST_MakeEnvelope(BigDecimal xMin, BigDecimal yMin,
+      BigDecimal xMax, BigDecimal yMax, int srid) {
+    Geometry geom = ST_GeomFromText("POLYGON(("
+        + xMin + " " + yMin + ", "
+        + xMin + " " + yMax + ", "
+        + xMax + " " + yMax + ", "
+        + xMax + " " + yMin + ", "
+        + xMin + " " + yMin + "))", srid);
+    return Objects.requireNonNull(geom, "geom");
+  }
+
+  /**
+   * Creates a rectangular Polygon.
+   */
+  public static Geometry ST_MakeEnvelope(BigDecimal xMin, BigDecimal yMin,
+      BigDecimal xMax, BigDecimal yMax) {
+    return ST_MakeEnvelope(xMin, yMin, xMax, yMax, NO_SRID);
+  }
+
+  /**
+   * Creates a line-string from the given POINTs (or MULTIPOINTs).
+   */
+  @Hints({"SqlKind:ST_MAKE_LINE"})
+  public static Geometry ST_MakeLine(Geometry geom1, Geometry geom2) {
+    return GEOMETRY_FACTORY.createLineString(new Coordinate[]{
+        geom1.getCoordinate(),
+        geom2.getCoordinate(),
+    });
+  }
+
+  @Hints({"SqlKind:ST_MAKE_LINE"})
+  public static Geometry ST_MakeLine(Geometry geom1, Geometry geom2, Geometry geom3) {
+    return GEOMETRY_FACTORY.createLineString(new Coordinate[]{
+        geom1.getCoordinate(),
+        geom2.getCoordinate(),
+        geom3.getCoordinate(),
+    });
+  }
+
+  @Hints({"SqlKind:ST_MAKE_LINE"})
+  public static Geometry ST_MakeLine(Geometry geom1, Geometry geom2, Geometry geom3,
+      Geometry geom4) {
+    return GEOMETRY_FACTORY.createLineString(new Coordinate[]{
+        geom1.getCoordinate(),
+        geom2.getCoordinate(),
+        geom3.getCoordinate(),
+        geom4.getCoordinate(),
+    });
+  }
+
+  @Hints({"SqlKind:ST_MAKE_LINE"})
+  public static Geometry ST_MakeLine(Geometry geom1, Geometry geom2, Geometry geom3,
+      Geometry geom4, Geometry geom5) {
+    return GEOMETRY_FACTORY.createLineString(new Coordinate[]{
+        geom1.getCoordinate(),
+        geom2.getCoordinate(),
+        geom3.getCoordinate(),
+        geom4.getCoordinate(),
+        geom5.getCoordinate(),
+    });
+  }
+
+  @Hints({"SqlKind:ST_MAKE_LINE"})
+  public static Geometry ST_MakeLine(Geometry geom1, Geometry geom2, Geometry geom3,
+      Geometry geom4, Geometry geom5, Geometry geom6) {
+    return GEOMETRY_FACTORY.createLineString(new Coordinate[]{
+        geom1.getCoordinate(),
+        geom2.getCoordinate(),
+        geom3.getCoordinate(),
+        geom4.getCoordinate(),
+        geom5.getCoordinate(),
+        geom6.getCoordinate(),
+    });
+  }
+
+  /**
+   * Alias for {@link #ST_Point(BigDecimal, BigDecimal)}.
+   */
+  @Hints({"SqlKind:ST_POINT"})
+  public static Geometry ST_MakePoint(BigDecimal x, BigDecimal y) {
+    return ST_Point(x, y);
+  }
+
+  /**
+   * Alias for {@link #ST_Point(BigDecimal, BigDecimal, BigDecimal)}.
+   */
+  @Hints({"SqlKind:ST_POINT3"})
+  public static Geometry ST_MakePoint(BigDecimal x, BigDecimal y, BigDecimal z) {
+    return ST_Point(x, y, z);
+  }
+
+  /**
+   * Constructs a 2D point from coordinates.
+   */
+  @Hints({"SqlKind:ST_POINT"})
+  public static Geometry ST_Point(BigDecimal x, BigDecimal y) {
+    // NOTE: Combine the double and BigDecimal variants of this function
+    return GEOMETRY_FACTORY.createPoint(new Coordinate(x.doubleValue(), y.doubleValue()));
+  }
+
+  /**
+   * Constructs a 3D point from coordinates.
+   */
+  @Hints({"SqlKind:ST_POINT3"})
+  public static Geometry ST_Point(BigDecimal x, BigDecimal y, BigDecimal z) {
+    final Geometry g =
+        GEOMETRY_FACTORY.createPoint(
+            new Coordinate(x.doubleValue(), y.doubleValue(), z.doubleValue()));
+    return g;
+  }
+
+  // Geometry properties (2D)
+
+  /**
+   * Returns the minimum bounding box that encloses geom as a Geometry.
+   */
+  public static @Nullable Geometry ST_Extent(Geometry geom) {
+    // Note: check whether the extent and the envelope are the same.
+    return geom.getEnvelope();
+  }
+
+  /**
+   * Returns the nth geometry of a geometry collection.
+   */
+  public static @Nullable Geometry ST_GeometryN(Geometry geom, int n) {
+    if (!(geom instanceof GeometryCollection)) {
+      return null;
+    }
+    return geom.getGeometryN(n - 1);
+  }
+
+  /**
+   * Returns the exterior ring of {@code geom}, or null if {@code geom} is not a polygon.
+   */
+  public static @Nullable Geometry ST_ExteriorRing(Geometry geom) {
+    if (geom instanceof Polygon) {
+      return ((Polygon) geom).getExteriorRing();
+    }
+    return null;
+  }
+
+  /**
+   * Returns the first point of {@code geom}.
+   */
+  public static Geometry ST_EndPoint(Geometry geom) {
+    return ST_PointN(geom, -1);
+  }
+
+  /**
+   * Returns the nth interior ring of {@code geom}, or null if {@code geom} is not a polygon.
+   */
+  public static @Nullable Geometry ST_InteriorRing(Geometry geom, int n) {
+    if (geom instanceof Polygon) {
+      return ((Polygon) geom).getInteriorRingN(n);
+    }
+    return null;
+  }
+
+  /**
+   * Returns whether {@code geom} is a closed LINESTRING or MULTILINESTRING.
+   */
+  public static boolean ST_IsClosed(Geometry geom) {
+    if (geom instanceof LineString) {
+      return ((LineString) geom).isClosed();
+    }
+    if (geom instanceof MultiLineString) {
+      return ((MultiLineString) geom).isClosed();
+    }
+    return false;
+  }
+
+  /**
+   * Returns whether {@code geom} has at least one z-coordinate.
+   */
+  public static boolean ST_Is3D(Geometry geom) {
+    return ST_CoordDim(geom) == 3;
+  }
+
+  /**
+   * Returns true if geom is empty.
+   */
+  public static boolean ST_IsEmpty(Geometry geom) {
+    return geom.isEmpty();
+  }
+
+  /**
+   * Returns true if geom is rectangle.
+   */
+  public static boolean ST_IsRectangle(Geometry geom) {
+    return geom.isRectangle();
+  }
+
+  /**
+   * Returns whether {@code geom} is a closed and simple linestring or multi-linestring.
+   */
+  public static boolean ST_IsRing(Geometry geom) {
+    if (geom instanceof LineString) {
+      return ((LineString) geom).isClosed() && geom.isSimple();
+    }
+    if (geom instanceof MultiLineString) {
+      return ((MultiLineString) geom).isClosed() && geom.isSimple();
+    }
+    return false;
+  }
+
+  /**
+   * Returns true if geom is simple.
+   */
+  public static boolean ST_IsSimple(Geometry geom) {
+    return geom.isSimple();
+  }
+
+  /**
+   * Returns true if geom is valid.
+   */
+  public static boolean ST_IsValid(Geometry geom) {
+    return geom.isValid();
+  }
+
+  /**
+   * Returns the number of points in {@code geom}.
+   */
+  public static int ST_NPoints(Geometry geom) {
+    return ST_NumPoints(geom);
+  }
+
+  /**
+   * Returns the number of geometries in {@code geom} (1 if it is not a GEOMETRYCOLLECTION).
+   */
+  public static int ST_NumGeometries(Geometry geom) {
+    return geom.getNumGeometries();
+  }
+
+  /**
+   * Returns the number of interior rings of {@code geom}.
+   */
+  public static int ST_NumInteriorRing(Geometry geom) {
+    return ST_NumInteriorRings(geom);
+  }
+
+  /**
+   * Returns the number of interior rings of {@code geom}.
+   */
+  public static int ST_NumInteriorRings(Geometry geom) {
+    int[] num = new int[]{0};
+    geom.apply(new GeometryFilter() {
+      @Override public void filter(Geometry geom) {
+        if (geom instanceof Polygon) {
+          num[0] += ((Polygon) geom).getNumInteriorRing();
+        }
+      }
+    });
+    return num[0];
+  }
+
+  /**
+   * Returns the number of points in {@code geom}.
+   */
+  public static int ST_NumPoints(Geometry geom) {
+    return geom.getCoordinates().length;
+  }
+
+  /**
+   * Returns the nth point of a {@code geom}.
+   */
+  public static Geometry ST_PointN(Geometry geom, int n) {
+    Coordinate[] coordinates = geom.getCoordinates();
+    int i = (coordinates.length + (n % coordinates.length)) % coordinates.length;
+    return geom.getFactory().createPoint(coordinates[i]);
+  }
+
+  /**
+   * Returns an interior or boundary point of {@code geom}.
+   */
+  public static Geometry ST_PointOnSurface(Geometry geom) {
+    return geom.getFactory().createPoint(InteriorPoint.getInteriorPoint(geom));
+  }
+
+  /**
+   * Returns SRID value or 0 if input Geometry does not have one.
+   */
+  public static int ST_SRID(Geometry geom) {
+    return geom.getSRID();
+  }
+
+  /**
+   * Returns the first point of {@code geom}.
+   */
+  public static Geometry ST_StartPoint(Geometry geom) {
+    return ST_PointN(geom, 0);
+  }
+
+  /**
+   * Return the X coordinate of the point, or NULL if not available. Input must be a point..
+   */
+  public static @Nullable Double ST_X(Geometry geom) {
+    return geom instanceof Point ? ((Point) geom).getX() : null;
+  }
+
+  /**
+   * Returns the X maxima of a 2D or 3D bounding box or a geometry.
+   */
+  public static @Nullable Double ST_XMax(Geometry geom) {
+    return geom.getEnvelopeInternal().getMaxX();
+  }
+
+  /**
+   * Returns the X minima of a 2D or 3D bounding box or a geometry.
+   */
+  public static @Nullable Double ST_XMin(Geometry geom) {
+    return geom.getEnvelopeInternal().getMinX();
+  }
+
+  /**
+   * Returns the y-value of the first coordinate of {@code geom}.
+   */
+  public static @Nullable Double ST_Y(Geometry geom) {
+    return geom instanceof Point ? ((Point) geom).getY() : null;
+  }
+
+  /**
+   * Returns the Y maxima of a 2D or 3D bounding box or a geometry.
+   */
+  public static @Nullable Double ST_YMax(Geometry geom) {
+    return geom.getEnvelopeInternal().getMaxY();
+  }
+
+  /**
+   * Returns the Y minima of a 2D or 3D bounding box or a geometry.
+   */
+  public static @Nullable Double ST_YMin(Geometry geom) {
+    return geom.getEnvelopeInternal().getMinY();
+  }
+
+  /**
+   * Returns the z-value of the first coordinate of {@code geom}.
+   */
+  public static Double ST_Z(Geometry geom) {
+    if (geom.getCoordinate() != null) {
+      return geom.getCoordinate().getZ();
+    } else {
+      return Double.NaN;
+    }
+  }
+
+  /**
+   * Returns the maximum z-value of {@code geom}.
+   */
+  public static Double ST_ZMax(Geometry geom) {
+    return Arrays.stream(geom.getCoordinates())
+        .filter(c -> !Double.isNaN(c.getZ()))
+        .map(c -> c.getZ())
+        .max(Double::compareTo)
+        .orElse(Double.NaN);
+  }
+
+  /**
+   * Returns the minimum z-value of {@code geom}.
+   */
+  public static Double ST_ZMin(Geometry geom) {
+    return Arrays.stream(geom.getCoordinates())
+        .filter(c -> !Double.isNaN(c.getZ()))
+        .map(c -> c.getZ())
+        .min(Double::compareTo)
+        .orElse(Double.NaN);
+  }
+
+  // Geometry properties (2D)
+
+  /**
+   * Returns the boundary of {@code geom}.
+   */
+  public static Geometry ST_Boundary(Geometry geom) {
+    return geom.getBoundary();
+  }
+
+  /**
+   * Returns the centroid of {@code geom}.
+   */
+  public static Geometry ST_Centroid(Geometry geom) {
+    return geom.getCentroid();
+  }
+
+  /**
+   * Returns the dimension of the coordinates of {@code geom}.
+   */
+  public static int ST_CoordDim(Geometry geom) {
+    Coordinate coordinate = geom.getCoordinate();
+    if (coordinate != null && !Double.isNaN(coordinate.getZ())) {
+      return 3;
+    }
+    return 2;
+  }
+
+  /**
+   * Returns the dimension of {@code geom}.
+   */
+  public static int ST_Dimension(Geometry geom) {
+    return geom.getDimension();
+  }
+
+  /**
+   * Returns the distance between {@code geom1} and {@code geom2}.
+   */
+  public static double ST_Distance(Geometry geom1, Geometry geom2) {
+    return geom1.distance(geom2);
+  }
+
+  /**
+   * Returns the type of {@code geom}.
+   */
+  public static String ST_GeometryType(Geometry geom) {
+    return SpatialType.fromGeometry(geom).name();
+  }
+
+  /**
+   * Returns the OGC SFS type code of {@code geom}.
+   */
+  public static int ST_GeometryTypeCode(Geometry geom) {
+    return SpatialType.fromGeometry(geom).code();
+  }
+
+  /**
+   * Returns the minimum bounding box of {@code geom} (which may be a GEOMETRYCOLLECTION).
+   */
+  public static Geometry ST_Envelope(Geometry geom) {
+    return geom.getEnvelope();
+  }
+
+  /**
+   * Explodes the {@code geom} into multiple geometries.
+   */
+  private static void ST_Explode(final Geometry geom) {
+    // This is a dummy function. We cannot include table functions in this
+    // package, because they have too many dependencies. See the real definition
+    // in SqlSpatialTypeFunctions.
+  }
+
+  // Geometry predicates ======================================================
+
+  /**
+   * Returns whether {@code geom1} contains {@code geom2}.
+   */
+  @Hints({"SqlKind:ST_CONTAINS"})
+  public static boolean ST_Contains(Geometry geom1, Geometry geom2) {
+    return geom1.contains(geom2);
+  }
+
+  /**
+   * Returns whether {@code geom1} contains {@code geom2} but does not intersect its boundary.
+   */
+  public static boolean ST_ContainsProperly(Geometry geom1, Geometry geom2) {
+    return geom1.contains(geom2)
+        && !geom1.crosses(geom2);
+  }
+
+  /**
+   * Returns whether no point in {@code geom1} is outside {@code geom2}.
+   */
+  public static boolean ST_CoveredBy(Geometry geom1, Geometry geom2) {
+    return geom1.coveredBy(geom2);
+  }
+
+  /**
+   * Returns whether no point in {@code geom2} is outside {@code geom1}.
+   */
+  public static boolean ST_Covers(Geometry geom1, Geometry geom2) {
+    return geom1.covers(geom2);
+  }
+
+  /**
+   * Returns whether {@code geom1} crosses {@code geom2}.
+   */
+  public static boolean ST_Crosses(Geometry geom1, Geometry geom2) {
+    return geom1.crosses(geom2);
+  }
+
+  /**
+   * Returns whether {@code geom1} and {@code geom2} are disjoint.
+   */
+  public static boolean ST_Disjoint(Geometry geom1, Geometry geom2) {
+    return geom1.disjoint(geom2);
+  }
+
+  /**
+   * Returns whether the envelope of {@code geom1} intersects the envelope of {@code geom2}.
+   */
+  public static boolean ST_EnvelopesIntersect(Geometry geom1, Geometry geom2) {
+    final Geometry e1 = geom1.getEnvelope();
+    final Geometry e2 = geom2.getEnvelope();
+    return e1.intersects(e2);
+  }
+
+  /**
+   * Returns whether {@code geom1} equals {@code geom2}.
+   */
+  public static boolean ST_Equals(Geometry geom1, Geometry geom2) {
+    return geom1.equals(geom2);
+  }
+
+  /**
+   * Returns whether {@code geom1} intersects {@code geom2}.
+   */
+  public static boolean ST_Intersects(Geometry geom1, Geometry geom2) {
+    return geom1.intersects(geom2);
+  }
+
+  /**
+   * Returns whether {@code geom1} equals {@code geom2} and their coordinates and component
+   * Geometries are listed in the same order.
+   */
+  public static boolean ST_OrderingEquals(Geometry geom1, Geometry geom2) {
+    if (!geom1.equals(geom2)) {
+      return false;
+    }
+    Coordinate[] coordinates1 = geom1.getCoordinates();
+    Coordinate[] coordinates2 = geom2.getCoordinates();
+    for (int i = 0; i < coordinates1.length; i++) {
+      if (!coordinates1[i].equals(coordinates2[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Returns {@code geom1} overlaps {@code geom2}.
+   */
+  public static boolean ST_Overlaps(Geometry geom1, Geometry geom2) {
+    return geom1.overlaps(geom2);
+  }
+
+  /**
+   * Returns whether {@code geom1} touches {@code geom2}.
+   */
+  public static boolean ST_Touches(Geometry geom1, Geometry geom2) {
+    return geom1.touches(geom2);
+  }
+
+  /**
+   * Returns whether {@code geom1} is within {@code geom2}.
+   */
+  public static boolean ST_Within(Geometry geom1, Geometry geom2) {
+    return geom1.within(geom2);
+  }
+
+  /**
+   * Returns whether {@code geom1} and {@code geom2} are within {@code distance} of each other.
+   */
+  @Hints({"SqlKind:ST_DWITHIN"})
+  public static boolean ST_DWithin(Geometry geom1, Geometry geom2, double distance) {
+    final double distance1 = geom1.distance(geom2);
+    return distance1 <= distance;
+  }
+
+  // Geometry operators (2D and 3D) ===========================================
+
+  /**
+   * Computes a buffer around {@code geom}.
+   */
+  public static Geometry ST_Buffer(Geometry geom, double distance, String bufferStyle) {
+    BufferStyle style = new BufferStyle(bufferStyle);
+    BufferParameters params = style.asBufferParameters();
+    double sidedDistance = style.asSidedDistance(distance);
+    Geometry result = new BufferOp(geom, params).getResultGeometry(sidedDistance);
+    return result;
+  }
+
+  /**
+   * Computes a buffer around {@code geom}.
+   */
+  public static Geometry ST_Buffer(Geometry geom, double distance) {
+    return geom.buffer(distance);
+  }
+
+  /**
+   * Computes a buffer around {@code geom}.
+   */
+  public static Geometry ST_Buffer(Geometry geom, double distance, int quadSegs) {
+    return geom.buffer(distance, quadSegs);
+  }
+
+  /**
+   * Computes a buffer around {@code geom}.
+   */
+  public static Geometry ST_Buffer(Geometry geom, double distance, int quadSegs, int endCapStyle) {
+    return geom.buffer(distance, quadSegs, endCapStyle);
+  }
+
+  /**
+   * Computes the smallest convex POLYGON that contains all the points of geom.
+   */
+  public static Geometry ST_ConvexHull(Geometry geom) {
+    return geom.convexHull();
+  }
+
+  /**
+   * Computes the difference between geom1 and geom2.
+   */
+  public static Geometry ST_Difference(Geometry geom1, Geometry geom2) {
+    return geom1.difference(geom2);
+  }
+
+  /**
+   * Computes the symmetric difference between geom1 and geom2.
+   */
+  public static Geometry ST_SymDifference(Geometry geom1, Geometry geom2) {
+    return geom1.symDifference(geom2);
+  }
+
+  /**
+   * Computes the intersection between geom1 and geom2.
+   */
+  public static Geometry ST_Intersection(Geometry geom1, Geometry geom2) {
+    return geom1.intersection(geom2);
+  }
+
+  /**
+   * Computes an offset line for {@code linestring}.
+   */
+  public static Geometry ST_OffsetCurve(Geometry linestring, double distance, String bufferStyle) {
+    if (!(linestring instanceof LineString)) {
+      throw new IllegalArgumentException("ST_OffsetCurve only accepts LineString");
+    }
+    BufferStyle style = new BufferStyle(bufferStyle);
+    BufferParameters params = style.asBufferParameters();
+    double sidedDistance = style.asSidedDistance(distance);
+    Coordinate[] coordinates =
+        OffsetCurve.rawOffset((LineString) linestring, sidedDistance, params);
+    return GEOMETRY_FACTORY.createLineString(coordinates);
+  }
+
+  /**
+   * Returns the DE-9IM intersection matrix for geom1 and geom2.
+   */
+  public static String ST_Relate(Geometry geom1, Geometry geom2) {
+    return geom1.relate(geom2).toString();
+  }
+
+  /**
+   * Returns true if geom1 and geom2 are related by the intersection matrix specified by iMatrix.
+   */
+  public static boolean ST_Relate(Geometry geom1, Geometry geom2, String iMatrix) {
+    return geom1.relate(geom2, iMatrix);
+  }
+
+  /**
+   * Computes the union of {@code geom1} and {@code geom2}.
+   */
+  public static Geometry ST_UnaryUnion(Geometry geom1, Geometry geom2) {
+    return geom1.union(geom2);
+  }
+
+  /**
+   * Computes the union of the geometries in {@code geomCollection}.
+   */
+  @SemiStrict
+  public static Geometry ST_UnaryUnion(Geometry geomCollection) {
+    return geomCollection.union();
+  }
+
+  // Geometry projection functions ============================================
+
+  /**
+   * Transforms {@code geom} from one coordinate reference system (CRS) to the CRS specified by
+   * {@code srid}.
+   */
+  public static Geometry ST_Transform(Geometry geom, int srid) {
+    try {
+      ProjectionTransformer projectionTransformer = new ProjectionTransformer(geom.getSRID(), srid);
+      return projectionTransformer.transform(geom);
+    } catch (IllegalStateException e) {
+      throw RESOURCE.proj4jEpsgIsMissing().ex();
+    }
+  }
+
+  /**
+   * Returns a copy of {@code geom} with a new SRID.
+   */
+  public static Geometry ST_SetSRID(Geometry geom, int srid) {
+    geom.setSRID(srid);
+    return geom;
+  }
+
+  // Process Geometries
+
+  /**
+   * Merges a collection of linear components to form a line-string of maximal length.
+   */
+  public static Geometry ST_LineMerge(Geometry geom) {
+    LineMerger merger = new LineMerger();
+    merger.add(geom);
+    LineString[] geometries = ((Stream<Object>) merger.getMergedLineStrings().stream())
+        .map(LineString.class::cast)
+        .toArray(size -> new LineString[size]);
+    return GEOMETRY_FACTORY.createMultiLineString(geometries);
+  }
+
+  /**
+   * Makes a valid geometry of a given invalid geometry.
+   */
+  public static Geometry ST_MakeValid(Geometry geometry) {
+    return new GeometryFixer(geometry).getResult();
+  }
+
+  /**
+   * Creates a multipolygon from the geometry.
+   */
+  public static Geometry ST_Polygonize(Geometry geometry) {
+    Polygonizer polygonizer = new Polygonizer(true);
+    polygonizer.add(geometry);
+    return polygonizer.getGeometry();
+  }
+
+  /**
+   * Reduces the geometry's precision to n decimal places.
+   */
+  public static Geometry ST_PrecisionReducer(Geometry geometry, BigDecimal decimal) {
+    double scale = Math.pow(10, decimal.doubleValue());
+    PrecisionModel precisionModel = new PrecisionModel(scale);
+    GeometryPrecisionReducer precisionReducer = new GeometryPrecisionReducer(precisionModel);
+    return precisionReducer.reduce(geometry);
+  }
+
+  /**
+   * Simplifies geom a geometry using the Douglas-Peuker algorithm.
+   */
+  public static Geometry ST_Simplify(Geometry geom, BigDecimal distance) {
+    DouglasPeuckerSimplifier simplifier = new DouglasPeuckerSimplifier(geom);
+    simplifier.setDistanceTolerance(distance.doubleValue());
+    return simplifier.getResultGeometry();
+  }
+
+  /**
+   * Simplifies a geometry and preserves its topology.
+   */
+  public static Geometry ST_SimplifyPreserveTopology(Geometry geom, BigDecimal distance) {
+    TopologyPreservingSimplifier simplifier = new TopologyPreservingSimplifier(geom);
+    simplifier.setDistanceTolerance(distance.doubleValue());
+    return simplifier.getResultGeometry();
+  }
+
+  /**
+   * Snaps geom1 and geom2 together with the given snapTolerance.
+   */
+  public static Geometry ST_Snap(Geometry geom1, Geometry geom2, BigDecimal snapTolerance) {
+    GeometrySnapper snapper = new GeometrySnapper(geom1);
+    return snapper.snapTo(geom2, snapTolerance.doubleValue());
+  }
+
+  /**
+   * Splits {@code geom} by {@code blade}.
+   */
+  public static Geometry ST_Split(Geometry geom, Geometry blade) {
+    return new SplitOperation(geom, blade).split();
+  }
+
+
+  // Affine transformation functions (3D and 2D)
+
+  /**
+   * Rotates geom counter-clockwise by angle (in radians) about the point origin.
+   */
+  public static Geometry ST_Rotate(Geometry geom, BigDecimal angle) {
+    AffineTransformation transformation = new AffineTransformation();
+    transformation.rotate(angle.doubleValue());
+    return transformation.transform(geom);
+  }
+
+  /**
+   * Rotates geom counter-clockwise by angle (in radians) about the point origin.
+   */
+  public static Geometry ST_Rotate(Geometry geom, BigDecimal angle, Geometry origin) {
+    // Note: check whether we can add support for the Point type.
+    if (!(origin instanceof Point)) {
+      throw new RuntimeException("The origin must be a point");
+    }
+    Point point = (Point) origin;
+    AffineTransformation transformation = new AffineTransformation();
+    transformation.rotate(angle.doubleValue(), point.getX(), point.getY());
+    return transformation.transform(geom);
+  }
+
+  /**
+   * Rotates geom counter-clockwise by angle (in radians) about the point origin.
+   */
+  public static Geometry ST_Rotate(Geometry geom, BigDecimal angle, BigDecimal x, BigDecimal y) {
+    AffineTransformation transformation = new AffineTransformation();
+    transformation.rotate(angle.doubleValue(), x.doubleValue(), y.doubleValue());
+    return transformation.transform(geom);
+  }
+
+  /**
+   * Scales geom Geometry by multiplying the ordinates by the indicated scale factors.
+   */
+  public static Geometry ST_Scale(Geometry geom, BigDecimal xFactor, BigDecimal yFactor) {
+    AffineTransformation transformation = new AffineTransformation();
+    transformation.scale(xFactor.doubleValue(), yFactor.doubleValue());
+    return transformation.transform(geom);
+  }
+
+  /**
+   * Translates geom by the vector (x, y).
+   */
+  public static Geometry ST_Translate(Geometry geom, BigDecimal x, BigDecimal y) {
+    AffineTransformation transformation = new AffineTransformation();
+    transformation.translate(x.doubleValue(), y.doubleValue());
+    Geometry translated = transformation.transform(geom);
+    return translated;
+  }
+
+  // Geometry editing functions (2D)
+
+  /**
+   * Adds {@code point} to {@code linestring} at the end.
+   */
+  public static Geometry ST_AddPoint(Geometry linestring, Geometry point) {
+    if (!(linestring instanceof LineString)) {
+      throw new RuntimeException("Only supports LINESTRING.");
+    }
+    if (!(point instanceof Point)) {
+      throw new RuntimeException("Only supports POINT.");
+    }
+    LineString lineString = (LineString) linestring;
+    int numPoints = lineString.getNumPoints();
+    return new GeometryEditor().edit(linestring, new AddPointOperation(point, numPoints));
+  }
+
+  /**
+   * Adds {@code point} to {@code linestring} at a given {@code index}.
+   */
+  public static Geometry ST_AddPoint(Geometry linestring, Geometry point, int index) {
+    if (!(linestring instanceof LineString)) {
+      throw new RuntimeException("Only supports LINESTRING.");
+    }
+    if (!(point instanceof Point)) {
+      throw new RuntimeException("Only supports POINT.");
+    }
+    return new GeometryEditor().edit(linestring, new AddPointOperation(point, index));
+  }
+
+  /**
+   * Densifies a {@code geom} by inserting extra vertices along the line segments.
+   */
+  public static Geometry ST_Densify(Geometry geom, BigDecimal tolerance) {
+    return Densifier.densify(geom, tolerance.doubleValue());
+  }
+
+  /**
+   * Flips the X and Y coordinates of the {@code geom}.
+   */
+  public static Geometry ST_FlipCoordinates(Geometry geom) {
+    FlipCoordinatesTransformer transformer = new FlipCoordinatesTransformer();
+    return transformer.transform(geom);
+  }
+
+  /**
+   * Returns the holes in the {@code geom} (which may be a GEOMETRYCOLLECTION).
+   */
+  public static Geometry ST_Holes(Geometry geom) {
+    List<Geometry> acc = new ArrayList<>();
+    extractGeometryHoles(geom, acc);
+    Geometry[] array = acc.toArray(new Geometry[acc.size()]);
+    return GEOMETRY_FACTORY.createGeometryCollection(array);
+  }
+
+  private static void extractGeometryHoles(Geometry geom, List<Geometry> acc) {
+    if (geom instanceof GeometryCollection) {
+      GeometryCollection geometryCollection = (GeometryCollection) geom;
+      for (int i = 0; i < geometryCollection.getNumGeometries(); i++) {
+        Geometry child = geometryCollection.getGeometryN(i);
+        extractGeometryHoles(child, acc);
+      }
+    } else if (geom instanceof Polygon) {
+      Polygon polygon = (Polygon) geom;
+      extractPolygonHoles(polygon, acc);
+    }
+  }
+
+  private static void extractPolygonHoles(Polygon polygon, List<Geometry> acc) {
+    int size = polygon.getNumInteriorRing();
+    for (int i = 0; i < size; i++) {
+      acc.add(polygon.getInteriorRingN(i));
+    }
+  }
+
+  /**
+   * Converts the {@code geom} to normal form.
+   */
+  public static Geometry ST_Normalize(Geometry geom) {
+    return geom.norm();
+  }
+
+  /**
+   * Removes duplicated coordinates from the {@code geom}.
+   */
+  public static Geometry ST_RemoveRepeatedPoints(Geometry geom) {
+    return new RemoveRepeatedPointsTransformer().transform(geom);
+  }
+
+  /**
+   * Removes duplicated coordinates from the {@code geom}.
+   */
+  public static Geometry ST_RemoveRepeatedPoints(Geometry geom, BigDecimal tolerance) {
+    return new RemoveRepeatedPointsTransformer(tolerance.doubleValue()).transform(geom);
+  }
+
+  /**
+   * Removes the holes of the {@code geom}.
+   */
+  public static Geometry ST_RemoveHoles(Geometry geom) {
+    RemoveHoleTransformer transformer = new RemoveHoleTransformer();
+    return transformer.transform(geom);
+  }
+
+  /**
+   * Remove {@code point} at given {@code index} in {@code linestring}.
+   */
+  public static Geometry ST_RemovePoint(Geometry linestring, int index) {
+    if (!(linestring instanceof LineString)) {
+      throw new RuntimeException("Only supports LINESTRING.");
+    }
+    return new GeometryEditor().edit(linestring, new RemovePointOperation(index));
+  }
+
+  /**
+   * Reverses the order of the coordinates of the {@code geom}.
+   */
+  public static Geometry ST_Reverse(Geometry geom) {
+    return geom.reverse();
+  }
+
+  // Geometry editing functions (3D)
+
+  /**
+   * Adds {@code zToAdd} to the z-coordinate of the {@code geom}.
+   */
+  public static Geometry ST_AddZ(Geometry geom, BigDecimal zToAdd) {
+    return new AddZTransformer(zToAdd.doubleValue()).transform(geom);
+  }
+
+  // Geometry measurement functions
+
+  /**
+   * Returns the area of the {@code geom}.
+   */
+  public static @Nullable Double ST_Area(Geometry geom) {
+    return geom.getArea();
+  }
+
+  /**
+   * Returns the coordinate(s) of {@code geom} closest to {@code point}.
+   */
+  public static @Nullable Geometry ST_ClosestCoordinate(Geometry point, Geometry geom) {
+    List<Coordinate> closestCoordinates = new ArrayList<>();
+    double minDistance = Double.MAX_VALUE;
+    for (Coordinate coordinate : geom.getCoordinates()) {
+      double distance = point.getCoordinate().distance(coordinate);
+      if (distance < minDistance) {
+        minDistance = distance;
+        closestCoordinates.clear();
+        closestCoordinates.add(coordinate);
+      } else if (distance == minDistance && !closestCoordinates.contains(coordinate)) {
+        closestCoordinates.add(coordinate);
+      }
+    }
+    if (closestCoordinates.size() == 1) {
+      return GEOMETRY_FACTORY.createPoint(closestCoordinates.get(0));
+    } else {
+      Coordinate[] coordinates = closestCoordinates.toArray(new Coordinate[0]);
+      return GEOMETRY_FACTORY.createMultiPointFromCoords(coordinates);
+    }
+  }
+
+  /**
+   * Returns the point of {@code geom1} closest to {@code geom2}.
+   */
+  public static @Nullable Geometry ST_ClosestPoint(Geometry geom1, Geometry geom2) {
+    return GEOMETRY_FACTORY.createPoint(DistanceOp.nearestPoints(geom1, geom2)[0]);
+  }
+
+  /**
+   * Returns the coordinate(s) of {@code geom} furthest from {@code point}.
+   */
+  public static @Nullable Geometry ST_FurthestCoordinate(Geometry point, Geometry geom) {
+    List<Coordinate> closestCoordinates = new ArrayList<>();
+    double maxDistance = Double.MIN_VALUE;
+    for (Coordinate coordinate : geom.getCoordinates()) {
+      double distance = point.getCoordinate().distance(coordinate);
+      if (distance > maxDistance) {
+        maxDistance = distance;
+        closestCoordinates.clear();
+        closestCoordinates.add(coordinate);
+      } else if (distance == maxDistance && !closestCoordinates.contains(coordinate)) {
+        closestCoordinates.add(coordinate);
+      }
+    }
+    if (closestCoordinates.size() == 1) {
+      return GEOMETRY_FACTORY.createPoint(closestCoordinates.get(0));
+    } else {
+      Coordinate[] coordinates = closestCoordinates.toArray(new Coordinate[0]);
+      return GEOMETRY_FACTORY.createMultiPointFromCoords(coordinates);
+    }
+  }
+
+  /**
+   * Returns the length of the {@code geom}.
+   */
+  public static @Nullable Double ST_Length(Geometry geom) {
+    return geom.getLength();
+  }
+
+  /**
+   * Returns a MULTIPOINT containing points along the line segments of {@code geom}
+   * at {@code segmentLengthFraction} and {@code offsetDistance}.
+   */
+  public static @Nullable Geometry ST_LocateAlong(Geometry geom, BigDecimal segmentLengthFraction,
+      BigDecimal offsetDistance) {
+    List<Coordinate> coordinates = new ArrayList<>();
+    for (int i = 0; i < geom.getNumGeometries(); i++) {
+      Geometry geometry = geom.getGeometryN(i);
+      Coordinate[] geometryCoordinates = geometry.getCoordinates();
+      for (int j = 0; j < geometryCoordinates.length - 1; j++) {
+        Coordinate c1 = geometryCoordinates[j];
+        Coordinate c2 = geometryCoordinates[j + 1];
+        LineSegment lineSegment = new LineSegment(c1, c2);
+        coordinates.add(
+            lineSegment.pointAlongOffset(
+                segmentLengthFraction.doubleValue(),
+                offsetDistance.doubleValue()));
+      }
+    }
+    Coordinate[] coordinateArray = coordinates.toArray(new Coordinate[0]);
+    return GEOMETRY_FACTORY.createMultiPointFromCoords(coordinateArray);
+  }
+
+  /**
+   * Returns the 2-dimensional longest line-string between the points
+   * of {@code geom1} and {@code geom2}.
+   */
+  public static @Nullable Geometry ST_LongestLine(Geometry geom1, Geometry geom2) {
+    double maxDistance = Double.MIN_VALUE;
+    Coordinate c1 = null;
+    Coordinate c2 = null;
+    for (Coordinate coordinate1 : geom1.getCoordinates()) {
+      for (Coordinate coordinate2 : geom2.getCoordinates()) {
+        double distance = coordinate1.distance(coordinate2);
+        if (distance > maxDistance) {
+          maxDistance = distance;
+          c1 = coordinate1;
+          c2 = coordinate2;
+        }
+      }
+    }
+    if (c1 == null || c2 == null) {
+      return null;
+    }
+    return GEOMETRY_FACTORY.createLineString(new Coordinate[]{c1, c2});
+  }
+
+  /**
+   * Computes the maximum distance between {@code geom1} and {@code geom2}.
+   */
+  public static @Nullable Double ST_MaxDistance(Geometry geom1, Geometry geom2) {
+    double maxDistance = Double.MIN_VALUE;
+    for (Coordinate coordinate1 : geom1.getCoordinates()) {
+      for (Coordinate coordinate2 : geom2.getCoordinates()) {
+        double distance = coordinate1.distance(coordinate2);
+        if (distance > maxDistance) {
+          maxDistance = distance;
+        }
+      }
+    }
+    return maxDistance;
+  }
+
+  /**
+   * Returns the length of the perimeter of *polygon* (which may be a MULTIPOLYGON).
+   */
+  public static @Nullable Double ST_Perimeter(Geometry geom) {
+    double perimeter = 0;
+    for (int i = 0; i < geom.getNumGeometries(); i++) {
+      Geometry geometry = geom.getGeometryN(i);
+      if (geometry instanceof Polygon) {
+        perimeter += geometry.getLength();
+      }
+    }
+    return perimeter;
+  }
+
+  /**
+   * Projects {@code point} onto a {@code lineString} (which may be a MULTILINESTRING).
+   */
+  public static @Nullable Geometry ST_ProjectPoint(Geometry point, Geometry lineString) {
+    if (lineString.getDimension() > 1) {
+      return null;
+    }
+    LengthIndexedLine lengthIndexedLine = new LengthIndexedLine(lineString);
+    double index = lengthIndexedLine.project(point.getCoordinate());
+    Coordinate projectedCoordinate = lengthIndexedLine.extractPoint(index);
+    return GEOMETRY_FACTORY.createPoint(projectedCoordinate);
+  }
+
+  // Triangulation functions
+
+  /**
+   * Computes a constrained Delaunay triangulation based on points in {@code geom}.
+   */
+  public static Geometry ST_ConstrainedDelaunay(Geometry geom) {
+    return ST_ConstrainedDelaunay(geom, 0);
+  }
+
+  /**
+   * Computes a constrained Delaunay triangulation based on points in {@code geom}.
+   */
+  public static Geometry ST_ConstrainedDelaunay(Geometry geom, int flag) {
+    GeometryFactory factory = geom.getFactory();
+    ConstrainedDelaunayTriangulator cdt = new ConstrainedDelaunayTriangulator(geom);
+    List<Tri> tris = cdt.getTriangles();
+    Polygon[] polygons = new Polygon[tris.size()];
+    int i = 0;
+    for (Tri tri : tris) {
+      polygons[i++] = tri.toPolygon(factory);
+    }
+    MultiPolygon multiPolygon = factory.createMultiPolygon(polygons);
+    if (flag == 0) {
+      return multiPolygon;
+    } else {
+      return asTriangleEdges(multiPolygon);
+    }
+  }
+
+  /**
+   * Computes a Delaunay triangulation based on points in {@code geom}.
+   */
+  public static Geometry ST_Delaunay(Geometry geom) {
+    return ST_Delaunay(geom, 0);
+  }
+
+  /**
+   * Computes a Delaunay triangulation based on points in {@code geom}.
+   */
+  public static Geometry ST_Delaunay(Geometry geom, int flag) {
+    GeometryFactory factory = geom.getFactory();
+    DelaunayTriangulationBuilder builder = new DelaunayTriangulationBuilder();
+    builder.setSites(geom);
+    QuadEdgeSubdivision subdivision = builder.getSubdivision();
+    List triPtsList = subdivision.getTriangleCoordinates(false);
+    Polygon[] tris = new Polygon[triPtsList.size()];
+    int i = 0;
+    for (Iterator it = triPtsList.iterator(); it.hasNext();) {
+      Coordinate[] triPt = (Coordinate[]) it.next();
+      tris[i++] = factory.createPolygon(factory.createLinearRing(triPt));
+    }
+    MultiPolygon multiPolygon = factory.createMultiPolygon(tris);
+    if (flag == 0) {
+      return multiPolygon;
+    } else {
+      return asTriangleEdges(multiPolygon);
+    }
+  }
+
+  private static Geometry asTriangleEdges(MultiPolygon multiPolygon) {
+    GeometryFactory factory = multiPolygon.getFactory();
+    List<LineString> edges = new ArrayList<>();
+    for (int i = 0; i < multiPolygon.getNumGeometries(); i++) {
+      Polygon polygon = (Polygon) multiPolygon.getGeometryN(i);
+      Coordinate[] coordinates = polygon.getCoordinates();
+      for (int j = 1; j < coordinates.length; j++) {
+        Coordinate c1 = coordinates[j - 1].copy();
+        Coordinate c2 = coordinates[j].copy();
+        LineString line = factory.createLineString(new Coordinate[]{c1, c2});
+        edges.add(line);
+      }
+    }
+    Geometry geometry = factory.createMultiLineString(edges.toArray(new LineString[0]));
+    return geometry.union().norm();
+  }
+
+  // Space-filling curves
+
+  /**
+   * Returns the position of a point on the Hilbert curve, or null if it is not a 2-dimensional
+   * point.
+   */
+  @Hints({"SqlKind:HILBERT"})
+  public static @Nullable Long hilbert(Geometry geom) {
+    if (geom instanceof Point) {
+      final double x = ((Point) geom).getX();
+      final double y = ((Point) geom).getY();
+      return new HilbertCurve2D(8).toIndex(x, y);
+    }
+    return null;
+  }
+
+  /**
+   * Returns the position of a point on the Hilbert curve.
+   */
+  @Hints({"SqlKind:HILBERT"})
+  public static long hilbert(BigDecimal x, BigDecimal y) {
+    return new HilbertCurve2D(8).toIndex(x.doubleValue(), y.doubleValue());
+  }
+
+
+  // Inner classes ============================================================
+
+
+  /**
+   * Used at run time by the {@link #ST_MakeGrid} and {@link #ST_MakeGridPoints} functions.
+   */
+  public static class GridEnumerable extends AbstractEnumerable<Object[]> {
+    private final Envelope envelope;
+    private final boolean point;
+    private final double deltaX;
+    private final double deltaY;
+    private final double minX;
+    private final double minY;
+    private final int baseX;
+    private final int baseY;
+    private final int spanX;
+    private final int spanY;
+    private final int area;
+
+    public GridEnumerable(Envelope envelope, BigDecimal deltaX,
+        BigDecimal deltaY, boolean point) {
+      this.envelope = envelope;
+      this.deltaX = deltaX.doubleValue();
+      this.deltaY = deltaY.doubleValue();
+      this.point = point;
+      this.spanX = (int) Math.floor((envelope.getMaxX() - envelope.getMinX())
+          / this.deltaX) + 1;
+      this.baseX = (int) Math.floor(envelope.getMinX() / this.deltaX);
+      this.minX = this.deltaX * baseX;
+      this.spanY = (int) Math.floor((envelope.getMaxY() - envelope.getMinY())
+          / this.deltaY) + 1;
+      this.baseY = (int) Math.floor(envelope.getMinY() / this.deltaY);
+      this.minY = this.deltaY * baseY;
+      this.area = this.spanX * this.spanY;
+    }
+
+    @Override public Enumerator<Object[]> enumerator() {
+      return new Enumerator<Object[]>() {
+        int id = -1;
+
+        @Override public Object[] current() {
+          final Geometry geom;
+          final int x = id % spanX;
+          final int y = id / spanX;
+          if (point) {
+            final double xCurrent = minX + (x + 0.5D) * deltaX;
+            final double yCurrent = minY + (y + 0.5D) * deltaY;
+            geom =
+                ST_MakePoint(BigDecimal.valueOf(xCurrent),
+                    BigDecimal.valueOf(yCurrent));
+          } else {
+            final double left = minX + x * deltaX;
+            final double right = left + deltaX;
+            final double bottom = minY + y * deltaY;
+            final double top = bottom + deltaY;
+
+            Coordinate[] coordinates = new Coordinate[]{
+                new Coordinate(left, bottom),
+                new Coordinate(left, top),
+                new Coordinate(right, top),
+                new Coordinate(right, bottom),
+                new Coordinate(left, bottom)
+            };
+
+            LinearRing linearRing = GEOMETRY_FACTORY.createLinearRing(coordinates);
+            Polygon polygon = GEOMETRY_FACTORY.createPolygon(linearRing);
+
+            geom = polygon;
+          }
+          return new Object[]{geom, id, x + 1, y + 1, baseX + x, baseY + y};
+        }
+
+        @Override public boolean moveNext() {
+          return ++id < area;
+        }
+
+        @Override public void reset() {
+          id = -1;
+        }
+
+        @Override public void close() {
+        }
+      };
+    }
+  }
+}
diff --git a/core/src/main/java/org/apache/calcite/runtime/SpatialTypeUtils.java b/core/src/main/java/org/apache/calcite/runtime/SpatialTypeUtils.java
new file mode 100644
index 00000000000..49320220c59
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/runtime/SpatialTypeUtils.java
@@ -0,0 +1,261 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.runtime;
+
+import org.apache.calcite.avatica.util.ByteString;
+import org.apache.calcite.linq4j.function.Deterministic;
+import org.apache.calcite.linq4j.function.Experimental;
+import org.apache.calcite.linq4j.function.Strict;
+
+import org.locationtech.jts.geom.Coordinate;
+import org.locationtech.jts.geom.Geometry;
+import org.locationtech.jts.geom.GeometryFactory;
+import org.locationtech.jts.io.ParseException;
+import org.locationtech.jts.io.WKBReader;
+import org.locationtech.jts.io.WKBWriter;
+import org.locationtech.jts.io.WKTReader;
+import org.locationtech.jts.io.WKTWriter;
+import org.locationtech.jts.io.geojson.GeoJsonReader;
+import org.locationtech.jts.io.geojson.GeoJsonWriter;
+import org.locationtech.jts.io.gml2.GMLReader;
+import org.locationtech.jts.io.gml2.GMLWriter;
+import org.xml.sax.SAXException;
+
+import java.io.IOException;
+import java.util.Locale;
+import java.util.regex.Pattern;
+import javax.xml.parsers.ParserConfigurationException;
+
+/**
+ * Utilities for spatial types.
+ */
+@Deterministic
+@Strict
+@Experimental
+public class SpatialTypeUtils {
+  static final int NO_SRID = 0;
+
+  public static final GeometryFactory GEOMETRY_FACTORY = new GeometryFactory();
+
+  private SpatialTypeUtils() {}
+
+  /** Geometry types, with the names and codes assigned by OGC. */
+  public enum SpatialType {
+    GEOMETRY(0),
+    POINT(1),
+    LINESTRING(2),
+    POLYGON(3),
+    MULTIPOINT(4),
+    MULTILINESTRING(5),
+    MULTIPOLYGON(6),
+    GEOMETRYCOLLECTION(7);
+
+    private final int code;
+
+    SpatialType(int code) {
+      this.code = code;
+    }
+
+    public int code() {
+      return code;
+    }
+
+    /** Returns the OGC type of a geometry. */
+    public static SpatialType fromGeometry(Geometry g) {
+      switch (g.getGeometryType()) {
+      case "Geometry":
+        return SpatialType.GEOMETRY;
+      case "Point":
+        return SpatialType.POINT;
+      case "LineString":
+        return SpatialType.LINESTRING;
+      case "Polygon":
+        return SpatialType.POLYGON;
+      case "MultiPoint":
+        return SpatialType.MULTIPOINT;
+      case "MultiLineString":
+        return SpatialType.MULTILINESTRING;
+      case "MultiPolygon":
+        return SpatialType.MULTIPOLYGON;
+      case "GeometryCollection":
+        return SpatialType.GEOMETRYCOLLECTION;
+      default:
+        throw new AssertionError(g);
+      }
+    }
+  }
+
+  private static int dimension(Geometry geometry) {
+    int dimension = 3;
+    for (Coordinate coordinate : geometry.getCoordinates()) {
+      if (Double.isNaN(coordinate.getZ())) {
+        dimension = 2;
+        break;
+      }
+    }
+    return dimension;
+  }
+
+  /**
+   * Constructs a geometry from a GeoJson representation.
+   *
+   * @param geoJson a GeoJson
+   * @return a geometry
+   */
+  public static Geometry fromGeoJson(String geoJson) {
+    try {
+      GeoJsonReader reader = new GeoJsonReader();
+      return reader.read(geoJson);
+    } catch (ParseException e) {
+      throw new RuntimeException("Unable to parse GeoJSON");
+    }
+  }
+
+  /**
+   * Constructs a geometry from a GML representation.
+   *
+   * @param gml a GML
+   * @return a geometry
+   */
+  public static Geometry fromGml(String gml) {
+    try {
+      GMLReader reader = new GMLReader();
+      return reader.read(gml, GEOMETRY_FACTORY);
+    } catch (SAXException | IOException | ParserConfigurationException e) {
+      throw new RuntimeException("Unable to parse GML");
+    }
+  }
+
+  /**
+   * Constructs a geometry from a Well-Known binary (WKB) representation.
+   *
+   * @param wkb a WKB
+   * @return a geometry
+   */
+  public static Geometry fromWkb(ByteString wkb) {
+    try {
+      WKBReader reader = new WKBReader();
+      return reader.read(wkb.getBytes());
+    } catch (ParseException e) {
+      throw new RuntimeException("Unable to parse WKB");
+    }
+  }
+
+  /**
+   * Constructs a geometry from an Extended Well-Known text (EWKT) representation.
+   * EWKT representations are prefixed with the SRID.
+   *
+   * @param ewkt an EWKT
+   * @return a geometry
+   */
+  public static Geometry fromEwkt(String ewkt) {
+    Pattern pattern = Pattern.compile("^(?:srid:(\\d*);)?(.*)$", Pattern.DOTALL);
+    java.util.regex.Matcher matcher = pattern.matcher(ewkt);
+    if (!matcher.matches()) {
+      throw new RuntimeException("Unable to parse EWKT");
+    }
+
+    String wkt = matcher.group(2);
+    if (wkt == null) {
+      throw new RuntimeException("Unable to parse EWKT");
+    }
+
+    Geometry geometry = fromWkt(wkt);
+    String srid = matcher.group(1);
+    if (srid != null) {
+      geometry.setSRID(Integer.parseInt(srid));
+    }
+
+    return geometry;
+  }
+
+  /**
+   * Constructs a geometry from a Well-Known text (WKT) representation.
+   *
+   * @param wkt a WKT
+   * @return a geometry
+   */
+  public static Geometry fromWkt(String wkt) {
+    try {
+      WKTReader reader = new WKTReader();
+      return reader.read(wkt);
+    } catch (ParseException e) {
+      throw new RuntimeException("Unable to parse WKT");
+    }
+  }
+
+  /**
+   * Returns the GeoJson representation of the geometry.
+   *
+   * @param geometry a geometry
+   * @return a GeoJson
+   */
+  public static String asGeoJson(Geometry geometry) {
+    GeoJsonWriter geoJsonWriter = new GeoJsonWriter();
+    return geoJsonWriter.write(geometry);
+  }
+
+  /**
+   * Returns the GML representation of the geometry.
+   *
+   * @param geometry a geometry
+   * @return a GML
+   */
+  public static String asGml(Geometry geometry) {
+    GMLWriter gmlWriter = new GMLWriter();
+    // remove line breaks and indentation
+    String minified = gmlWriter.write(geometry)
+        .replace("\n", "")
+        .replace("  ", "");
+    return minified;
+  }
+
+  /**
+   * Returns the Extended Well-Known binary (WKB) representation of the geometry.
+   *
+   * @param geometry a geometry
+   * @return an WKB
+   */
+  public static ByteString asWkb(Geometry geometry) {
+    int outputDimension = dimension(geometry);
+    WKBWriter wkbWriter = new WKBWriter(outputDimension);
+    return new ByteString(wkbWriter.write(geometry));
+  }
+
+  /**
+   * Returns the Extended Well-Known text (EWKT) representation of the geometry.
+   * EWKT representations are prefixed with the SRID.
+   *
+   * @param geometry a geometry
+   * @return an EWKT
+   */
+  public static String asEwkt(Geometry geometry) {
+    return String.format(Locale.ROOT, "srid:%s;%s", geometry.getSRID(), asWkt(geometry));
+  }
+
+  /**
+   * Returns the Well-Known text (WKT) representation of the geometry.
+   *
+   * @param geometry a geometry
+   * @return a WKT
+   */
+  public static String asWkt(Geometry geometry) {
+    int outputDimension = dimension(geometry);
+    WKTWriter wktWriter = new WKTWriter(outputDimension);
+    return wktWriter.write(geometry);
+  }
+}
diff --git a/core/src/main/java/org/apache/calcite/runtime/SplitOperation.java b/core/src/main/java/org/apache/calcite/runtime/SplitOperation.java
new file mode 100644
index 00000000000..ffd6660bd81
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/runtime/SplitOperation.java
@@ -0,0 +1,172 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.runtime;
+
+import org.locationtech.jts.algorithm.LineIntersector;
+import org.locationtech.jts.algorithm.RobustLineIntersector;
+import org.locationtech.jts.geom.Coordinate;
+import org.locationtech.jts.geom.Geometry;
+import org.locationtech.jts.geom.GeometryCollection;
+import org.locationtech.jts.geom.GeometryFactory;
+import org.locationtech.jts.geom.LineString;
+import org.locationtech.jts.geom.MultiLineString;
+import org.locationtech.jts.geom.MultiPolygon;
+import org.locationtech.jts.geom.Point;
+import org.locationtech.jts.geom.Polygon;
+import org.locationtech.jts.geom.util.LineStringExtracter;
+import org.locationtech.jts.operation.polygonize.Polygonizer;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Splits {@code geom} by {@code blade}.
+ */
+public class SplitOperation {
+
+  private final Geometry geom;
+
+  private final Geometry blade;
+
+  public SplitOperation(Geometry geom, Geometry blade) {
+    this.geom = geom;
+    this.blade = blade;
+  }
+
+  public Geometry split() {
+    if (geom instanceof LineString && blade instanceof Point) {
+      return split((LineString) geom, (Point) blade);
+
+    } else if (geom instanceof LineString && blade instanceof LineString) {
+      return split((LineString) geom, (LineString) blade);
+
+    } else if (geom instanceof MultiLineString && blade instanceof Point) {
+      return split((MultiLineString) geom, (Point) blade);
+
+    } else if (geom instanceof MultiLineString && blade instanceof LineString) {
+      return split((MultiLineString) geom, (LineString) blade);
+
+    } else if (geom instanceof Polygon && blade instanceof LineString) {
+      return split((Polygon) geom, (LineString) blade);
+
+    } else if (geom instanceof MultiPolygon && blade instanceof LineString) {
+      return split((MultiPolygon) geom, (LineString) blade);
+
+    } else {
+      throw new UnsupportedOperationException(
+          "Split operation not supported for "
+              + geom.getGeometryType() + " and "
+              + blade.getGeometryType());
+    }
+  }
+
+  private static Geometry split(LineString geometry, Point blade) {
+    GeometryFactory factory = geometry.getFactory();
+
+    Coordinate[] coordinates = geometry.getCoordinates();
+    LineIntersector intersector = new RobustLineIntersector();
+    Coordinate p = blade.getCoordinate();
+
+    List<Coordinate> accumulator = new ArrayList<>();
+    List<LineString> lines = new ArrayList<>();
+
+    for (int i = 1; i < coordinates.length; i++) {
+      Coordinate p1 = coordinates[i - 1];
+      Coordinate p2 = coordinates[i];
+
+      accumulator.add(p1.copy());
+
+      intersector.computeIntersection(p, p1, p2);
+      if (intersector.hasIntersection()) {
+        accumulator.add(p.copy());
+        LineString line =
+            factory.createLineString(accumulator.toArray(new Coordinate[0]));
+        lines.add(line);
+
+        accumulator.clear();
+        accumulator.add(p.copy());
+      }
+    }
+
+    accumulator.add(coordinates[coordinates.length - 1].copy());
+    LineString line =
+        factory.createLineString(accumulator.toArray(new Coordinate[0]));
+    lines.add(line);
+
+    if (lines.size() == 1) {
+      return lines.get(0);
+    } else {
+      return factory.buildGeometry(lines);
+    }
+  }
+
+  private static Geometry split(MultiLineString geometry, Point blade) {
+    GeometryFactory factory = geometry.getFactory();
+    List<Geometry> geometries = new ArrayList<>();
+    for (int i = 0; i < geometry.getNumGeometries(); i++) {
+      Geometry split = split((LineString) geometry.getGeometryN(i), blade);
+      if (split instanceof GeometryCollection) {
+        for (int j = 0; j < split.getNumGeometries(); j++) {
+          geometries.add(split.getGeometryN(j));
+        }
+      } else {
+        geometries.add(split);
+      }
+    }
+    return factory.buildGeometry(geometries);
+  }
+
+  private static Geometry split(LineString geometry, LineString blade) {
+    return geometry.difference(blade);
+  }
+
+  private static Geometry split(MultiLineString geometry, LineString blade) {
+    return geometry.difference(blade);
+  }
+
+  private static Geometry split(Polygon geometry, LineString blade) {
+    GeometryFactory factory = geometry.getFactory();
+    List<Polygon> polygons = new ArrayList<>();
+    Geometry union = geometry.getBoundary().union(blade);
+    Polygonizer polygonizer = new Polygonizer();
+    polygonizer.add(LineStringExtracter.getLines(union));
+    for (Polygon p : GeometryFactory.toPolygonArray(polygonizer.getPolygons())) {
+      if (geometry.contains(geometry.getInteriorPoint())) {
+        p.normalize();
+        polygons.add(p);
+      }
+    }
+    return factory.buildGeometry(polygons);
+  }
+
+  private Geometry split(MultiPolygon geometry, LineString blade) {
+    GeometryFactory factory = geometry.getFactory();
+    List<Geometry> geometries = new ArrayList<>();
+    for (int i = 0; i < geometry.getNumGeometries(); i++) {
+      Geometry split = split((Polygon) geometry.getGeometryN(i), blade);
+      if (split instanceof GeometryCollection) {
+        for (int j = 0; j < split.getNumGeometries(); j++) {
+          geometries.add(split.getGeometryN(j));
+        }
+      } else {
+        geometries.add(split);
+      }
+    }
+    return factory.buildGeometry(geometries);
+  }
+
+}
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 17eeb00fe11..d2939dc3144 100644
--- a/core/src/main/java/org/apache/calcite/runtime/SqlFunctions.java
+++ b/core/src/main/java/org/apache/calcite/runtime/SqlFunctions.java
@@ -32,6 +32,8 @@
 import org.apache.calcite.linq4j.function.Function1;
 import org.apache.calcite.linq4j.function.NonDeterministic;
 import org.apache.calcite.linq4j.tree.Primitive;
+import org.apache.calcite.rel.type.TimeFrame;
+import org.apache.calcite.rel.type.TimeFrameSet;
 import org.apache.calcite.runtime.FlatLists.ComparableList;
 import org.apache.calcite.sql.fun.SqlLibraryOperators;
 import org.apache.calcite.util.NumberUtil;
@@ -39,12 +41,15 @@
 import org.apache.calcite.util.TimestampWithTimeZoneString;
 import org.apache.calcite.util.Unsafe;
 import org.apache.calcite.util.Util;
+import org.apache.calcite.util.format.FormatElement;
+import org.apache.calcite.util.format.FormatModels;
 
 import org.apache.commons.codec.digest.DigestUtils;
 import org.apache.commons.codec.language.Soundex;
 
 import com.google.common.base.Splitter;
 import com.google.common.base.Strings;
+import com.google.common.collect.ImmutableList;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.checkerframework.checker.nullness.qual.PolyNull;
@@ -57,15 +62,24 @@
 import java.sql.SQLException;
 import java.sql.Timestamp;
 import java.text.DecimalFormat;
+import java.time.Instant;
 import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.OffsetDateTime;
+import java.time.ZoneId;
+import java.time.ZoneOffset;
 import java.time.format.DateTimeFormatter;
+import java.time.format.DateTimeFormatterBuilder;
+import java.time.format.DateTimeParseException;
+import java.time.format.SignStyle;
+import java.time.temporal.ChronoField;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Base64;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
-import java.util.Date;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedList;
@@ -77,6 +91,7 @@
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.BinaryOperator;
 import java.util.regex.Pattern;
+import java.util.stream.Collectors;
 
 import static org.apache.calcite.linq4j.Nullness.castNonNull;
 import static org.apache.calcite.util.Static.RESOURCE;
@@ -89,11 +104,11 @@
  *
  * <p>Not present: and, or, not (builtin operators are better, because they
  * use lazy evaluation. Implementations do not check for null values; the
- * calling code must do that.</p>
+ * calling code must do that.
  *
  * <p>Many of the functions do not check for null values. This is intentional.
  * If null arguments are possible, the code-generation framework checks for
- * nulls before calling the functions.</p>
+ * nulls before calling the functions.
  */
 @SuppressWarnings("UnnecessaryUnboxing")
 @Deterministic
@@ -117,7 +132,7 @@ public class SqlFunctions {
   private static final Pattern FROM_BASE64_REGEXP = Pattern.compile("[\\t\\n\\r\\s]");
 
   private static final Function1<List<Object>, Enumerable<Object>> LIST_AS_ENUMERABLE =
-      Linq4j::asEnumerable;
+      a0 -> a0 == null ? Linq4j.emptyEnumerable() : Linq4j.asEnumerable(a0);
 
   @SuppressWarnings("unused")
   private static final Function1<Object[], Enumerable<@Nullable Object[]>> ARRAY_CARTESIAN_PRODUCT =
@@ -145,6 +160,49 @@ public class SqlFunctions {
 
   private static final Pattern PATTERN_0_STAR_E = Pattern.compile("0*E");
 
+  /** A byte string consisting of a single byte that is the ASCII space
+   * character (0x20). */
+  private static final ByteString SINGLE_SPACE_BYTE_STRING =
+      ByteString.of("20", 16);
+
+  // Date formatter for BigQuery's timestamp literals:
+  // https://cloud.google.com/bigquery/docs/reference/standard-sql/lexical#timestamp_literals
+  private static final DateTimeFormatter BIG_QUERY_TIMESTAMP_LITERAL_FORMATTER =
+      new DateTimeFormatterBuilder()
+          // Unlike ISO 8601, BQ only supports years between 1 - 9999,
+          // but can support single-digit month and day parts.
+          .appendValue(ChronoField.YEAR, 4)
+          .appendLiteral('-')
+          .appendValue(ChronoField.MONTH_OF_YEAR, 1, 2, SignStyle.NOT_NEGATIVE)
+          .appendLiteral('-')
+          .appendValue(ChronoField.DAY_OF_MONTH, 1, 2, SignStyle.NOT_NEGATIVE)
+          // Everything after the date is optional. Optional sections can be nested.
+          .optionalStart()
+          // BQ accepts either a literal 'T' or a space to separate the date from the time,
+          // so make the 'T' optional but pad with 1 space if it's omitted.
+          .padNext(1, ' ')
+          .optionalStart()
+          .appendLiteral('T')
+          .optionalEnd()
+          // Unlike ISO 8601, BQ can support single-digit hour, minute, and second parts.
+          .appendValue(ChronoField.HOUR_OF_DAY, 1, 2, SignStyle.NOT_NEGATIVE)
+          .appendLiteral(':')
+          .appendValue(ChronoField.MINUTE_OF_HOUR, 1, 2, SignStyle.NOT_NEGATIVE)
+          .appendLiteral(':')
+          .appendValue(ChronoField.SECOND_OF_MINUTE, 1, 2, SignStyle.NOT_NEGATIVE)
+          // ISO 8601 supports up to nanosecond precision, but BQ only up to microsecond.
+          .optionalStart()
+          .appendFraction(ChronoField.MICRO_OF_SECOND, 0, 6, true)
+          .optionalEnd()
+          .optionalStart()
+          .parseLenient()
+          .appendOffsetId()
+          .toFormatter(Locale.ROOT);
+
+  /** Whether the current Java version is 8 (1.8). */
+  private static final boolean IS_JDK_8 =
+      System.getProperty("java.version").startsWith("1.8");
+
   private SqlFunctions() {
   }
 
@@ -266,6 +324,191 @@ private static int makeRegexpFlags(@Nullable String stringFlags) {
     return flags;
   }
 
+  /** SQL {@code LPAD(string, integer, string)} function. */
+  public static String lpad(String originalValue, int returnLength,
+      String pattern) {
+    if (returnLength < 0) {
+      throw RESOURCE.illegalNegativePadLength().ex();
+    }
+    if (pattern.isEmpty()) {
+      throw RESOURCE.illegalEmptyPadPattern().ex();
+    }
+    if (returnLength <= originalValue.length()) {
+      return originalValue.substring(0, returnLength);
+    }
+    int paddingLengthRequired = returnLength - originalValue.length();
+    int patternLength = pattern.length();
+    final StringBuilder paddedS = new StringBuilder();
+    for (int i = 0; i < paddingLengthRequired; i++) {
+      char curChar = pattern.charAt(i % patternLength);
+      paddedS.append(curChar);
+    }
+    paddedS.append(originalValue);
+    return paddedS.toString();
+  }
+
+  /** SQL {@code LPAD(string, integer)} function. */
+  public static String lpad(String originalValue, int returnLength) {
+    return lpad(originalValue, returnLength, " ");
+  }
+
+  /** SQL {@code LPAD(binary, integer, binary)} function. */
+  public static ByteString lpad(ByteString originalValue, int returnLength,
+      ByteString pattern) {
+    if (returnLength < 0) {
+      throw RESOURCE.illegalNegativePadLength().ex();
+    }
+    if (pattern.length() == 0) {
+      throw RESOURCE.illegalEmptyPadPattern().ex();
+    }
+    if (returnLength <= originalValue.length()) {
+      return originalValue.substring(0, returnLength);
+    }
+    int paddingLengthRequired = returnLength - originalValue.length();
+    int patternLength = pattern.length();
+    byte[] bytes = new byte[returnLength];
+    for (int i = 0; i < paddingLengthRequired; i++) {
+      byte curByte = pattern.byteAt(i % patternLength);
+      bytes[i] = curByte;
+    }
+    for (int i = paddingLengthRequired; i < returnLength; i++) {
+      bytes[i] = originalValue.byteAt(i - paddingLengthRequired);
+    }
+
+    return new ByteString(bytes);
+  }
+
+  /** SQL {@code LPAD(binary, integer, binary)} function. */
+  public static ByteString lpad(ByteString originalValue, int returnLength) {
+    // 0x20 is the hexadecimal character for space ' '
+    return lpad(originalValue, returnLength, SINGLE_SPACE_BYTE_STRING);
+  }
+
+  /** SQL {@code RPAD(string, integer, string)} function. */
+  public static String rpad(String originalValue, int returnLength,
+      String pattern) {
+    if (returnLength < 0) {
+      throw RESOURCE.illegalNegativePadLength().ex();
+    }
+    if (pattern.isEmpty()) {
+      throw RESOURCE.illegalEmptyPadPattern().ex();
+    }
+    if (returnLength <= originalValue.length()) {
+      return originalValue.substring(0, returnLength);
+    }
+    int paddingLengthRequired = returnLength - originalValue.length();
+    int patternLength = pattern.length();
+    final StringBuilder paddedS = new StringBuilder();
+    paddedS.append(originalValue);
+    for (int i = 0; i < paddingLengthRequired; i++) {
+      char curChar = pattern.charAt(i % patternLength);
+      paddedS.append(curChar);
+    }
+    return paddedS.toString();
+  }
+
+  /** SQL {@code RPAD(string, integer)} function. */
+  public static String rpad(String originalValue, int returnLength) {
+    return rpad(originalValue, returnLength, " ");
+  }
+
+  /** SQL {@code RPAD(binary, integer, binary)} function. */
+  public static ByteString rpad(ByteString originalValue, int returnLength,
+      ByteString pattern) {
+    if (returnLength < 0) {
+      throw RESOURCE.illegalNegativePadLength().ex();
+    }
+    if (pattern.length() == 0) {
+      throw RESOURCE.illegalEmptyPadPattern().ex();
+    }
+    int originalLength = originalValue.length();
+    if (returnLength <= originalLength) {
+      return originalValue.substring(0, returnLength);
+    }
+
+    int paddingLengthRequired = returnLength - originalLength;
+    int patternLength = pattern.length();
+    byte[] bytes = new byte[returnLength];
+    for (int i = 0; i < originalLength; i++) {
+      bytes[i] = originalValue.byteAt(i);
+    }
+    for (int i = returnLength - paddingLengthRequired; i < returnLength; i++) {
+      byte curByte = pattern.byteAt(i % patternLength);
+      bytes[i] = curByte;
+    }
+    return new ByteString(bytes);
+  }
+
+  /** SQL {@code RPAD(binary, integer)} function. */
+  public static ByteString rpad(ByteString originalValue, int returnLength) {
+    return rpad(originalValue, returnLength, SINGLE_SPACE_BYTE_STRING);
+  }
+
+  /** SQL {@code ENDS_WITH(string, string)} function. */
+  public static boolean endsWith(String s0, String s1) {
+    return s0.endsWith(s1);
+  }
+
+  /** SQL {@code ENDS_WITH(binary, binary)} function. */
+  public static boolean endsWith(ByteString s0, ByteString s1) {
+    return s0.endsWith(s1);
+  }
+
+  /** SQL {@code STARTS_WITH(string, string)} function. */
+  public static boolean startsWith(String s0, String s1) {
+    return s0.startsWith(s1);
+  }
+
+  /** SQL {@code STARTS_WITH(binary, binary)} function. */
+  public static boolean startsWith(ByteString s0, ByteString s1) {
+    return s0.startsWith(s1);
+  }
+
+  /** SQL {@code SPLIT(string, string)} function. */
+  public static List<String> split(String s, String delimiter) {
+    if (s.isEmpty()) {
+      return ImmutableList.of();
+    }
+    if (delimiter.isEmpty()) {
+      return ImmutableList.of(s); // prevent mischief
+    }
+    final ImmutableList.Builder<String> list = ImmutableList.builder();
+    for (int i = 0;;) {
+      int j = s.indexOf(delimiter, i);
+      if (j < 0) {
+        list.add(s.substring(i));
+        return list.build();
+      }
+      list.add(s.substring(i, j));
+      i = j + delimiter.length();
+    }
+  }
+
+  /** SQL {@code SPLIT(string)} function. */
+  public static List<String> split(String s) {
+    return split(s, ",");
+  }
+
+  /** SQL {@code SPLIT(binary, binary)} function. */
+  public static List<ByteString> split(ByteString s, ByteString delimiter) {
+    if (s.length() == 0) {
+      return ImmutableList.of();
+    }
+    if (delimiter.length() == 0) {
+      return ImmutableList.of(s); // prevent mischief
+    }
+    final ImmutableList.Builder<ByteString> list = ImmutableList.builder();
+    for (int i = 0;;) {
+      int j = s.indexOf(delimiter, i);
+      if (j < 0) {
+        list.add(s.substring(i));
+        return list.build();
+      }
+      list.add(s.substring(i, j));
+      i = j + delimiter.length();
+    }
+  }
+
   /** SQL SUBSTRING(string FROM ...) function. */
   public static String substring(String c, int s) {
     final int s0 = s - 1;
@@ -462,9 +705,22 @@ public static ByteString right(ByteString s, int n) {
     return s.substring(len - n);
   }
 
-  /** SQL CHR(long) function. */
-  public static String chr(long n) {
-    return String.valueOf(Character.toChars((int) n));
+  /** SQL CHAR(integer) function, as in MySQL and Spark.
+   *
+   * <p>Returns the ASCII character of {@code n} modulo 256,
+   * or null if {@code n} &lt; 0. */
+  public static @Nullable String charFromAscii(int n) {
+    if (n < 0) {
+      return null;
+    }
+    return String.valueOf(Character.toChars(n % 256));
+  }
+
+  /** SQL CHR(integer) function, as in Oracle and Postgres.
+   *
+   * <p>Returns the UTF-8 character whose code is {@code n}. */
+  public static String charFromUtf8(int n) {
+    return String.valueOf(Character.toChars(n));
   }
 
   /** SQL OCTET_LENGTH(binary) function. */
@@ -733,7 +989,7 @@ public static boolean neAny(Object b0, Object b1) {
 
   /** SQL <code>&lt;</code> operator applied to boolean values. */
   public static boolean lt(boolean b0, boolean b1) {
-    return compare(b0, b1) < 0;
+    return Boolean.compare(b0, b1) < 0;
   }
 
   /** SQL <code>&lt;</code> operator applied to String values. */
@@ -756,6 +1012,40 @@ public static boolean lt(BigDecimal b0, BigDecimal b1) {
     return b0.compareTo(b1) < 0;
   }
 
+  /** Returns whether {@code b0} is less than {@code b1}
+   * (or {@code b1} is null). Helper for {@code ARG_MIN}. */
+  public static <T extends Comparable<T>> boolean ltNullable(T b0, T b1) {
+    return b1 == null || b0 != null && b0.compareTo(b1) < 0;
+  }
+
+  public static boolean lt(byte b0, byte b1) {
+    return b0 < b1;
+  }
+
+  public static boolean lt(char b0, char b1) {
+    return b0 < b1;
+  }
+
+  public static boolean lt(short b0, short b1) {
+    return b0 < b1;
+  }
+
+  public static boolean lt(int b0, int b1) {
+    return b0 < b1;
+  }
+
+  public static boolean lt(long b0, long b1) {
+    return b0 < b1;
+  }
+
+  public static boolean lt(float b0, float b1) {
+    return b0 < b1;
+  }
+
+  public static boolean lt(double b0, double b1) {
+    return b0 < b1;
+  }
+
   /** SQL <code>&lt;</code> operator applied to Object values. */
   public static boolean ltAny(Object b0, Object b1) {
     if (b0.getClass().equals(b1.getClass())
@@ -773,7 +1063,7 @@ public static boolean ltAny(Object b0, Object b1) {
 
   /** SQL <code>&le;</code> operator applied to boolean values. */
   public static boolean le(boolean b0, boolean b1) {
-    return compare(b0, b1) <= 0;
+    return Boolean.compare(b0, b1) <= 0;
   }
 
   /** SQL <code>&le;</code> operator applied to String values. */
@@ -814,7 +1104,7 @@ public static boolean leAny(Object b0, Object b1) {
 
   /** SQL <code>&gt;</code> operator applied to boolean values. */
   public static boolean gt(boolean b0, boolean b1) {
-    return compare(b0, b1) > 0;
+    return Boolean.compare(b0, b1) > 0;
   }
 
   /** SQL <code>&gt;</code> operator applied to String values. */
@@ -837,6 +1127,40 @@ public static boolean gt(BigDecimal b0, BigDecimal b1) {
     return b0.compareTo(b1) > 0;
   }
 
+  /** Returns whether {@code b0} is greater than {@code b1}
+   * (or {@code b1} is null). Helper for {@code ARG_MAX}. */
+  public static <T extends Comparable<T>> boolean gtNullable(T b0, T b1) {
+    return b1 == null || b0 != null && b0.compareTo(b1) > 0;
+  }
+
+  public static boolean gt(byte b0, byte b1) {
+    return b0 > b1;
+  }
+
+  public static boolean gt(char b0, char b1) {
+    return b0 > b1;
+  }
+
+  public static boolean gt(short b0, short b1) {
+    return b0 > b1;
+  }
+
+  public static boolean gt(int b0, int b1) {
+    return b0 > b1;
+  }
+
+  public static boolean gt(long b0, long b1) {
+    return b0 > b1;
+  }
+
+  public static boolean gt(float b0, float b1) {
+    return b0 > b1;
+  }
+
+  public static boolean gt(double b0, double b1) {
+    return b0 > b1;
+  }
+
   /** SQL <code>&gt;</code> operator applied to Object values (at least one
    * operand has ANY type; neither may be null). */
   public static boolean gtAny(Object b0, Object b1) {
@@ -855,7 +1179,7 @@ public static boolean gtAny(Object b0, Object b1) {
 
   /** SQL <code>&ge;</code> operator applied to boolean values. */
   public static boolean ge(boolean b0, boolean b1) {
-    return compare(b0, b1) >= 0;
+    return Boolean.compare(b0, b1) >= 0;
   }
 
   /** SQL <code>&ge;</code> operator applied to String values. */
@@ -1243,28 +1567,29 @@ public static double power(BigDecimal b0, BigDecimal b1) {
     return Math.pow(b0.doubleValue(), b1.doubleValue());
   }
 
-  // LN
 
-  /** SQL {@code LN(number)} function applied to double values. */
-  public static double ln(double d) {
-    return Math.log(d);
-  }
+  // LN, LOG, LOG10
 
-  /** SQL {@code LN(number)} function applied to BigDecimal values. */
-  public static double ln(BigDecimal d) {
-    return Math.log(d.doubleValue());
+  /** SQL {@code LOG(number, number2)} function applied to double values. */
+  public static double log(double d0, double d1) {
+    return Math.log(d0) / Math.log(d1);
   }
 
-  // LOG10
+  /** SQL {@code LOG(number, number2)} function applied to
+   * double and BigDecimal values. */
+  public static double log(double d0, BigDecimal d1) {
+    return Math.log(d0) / Math.log(d1.doubleValue());
+  }
 
-  /** SQL <code>LOG10(numeric)</code> operator applied to double values. */
-  public static double log10(double b0) {
-    return Math.log10(b0);
+  /** SQL {@code LOG(number, number2)} function applied to
+   * BigDecimal and double values. */
+  public static double log(BigDecimal d0, double d1) {
+    return Math.log(d0.doubleValue()) / Math.log(d1);
   }
 
-  /** SQL {@code LOG10(number)} function applied to BigDecimal values. */
-  public static double log10(BigDecimal d) {
-    return Math.log10(d.doubleValue());
+  /** SQL {@code LOG(number, number2)} function applied to double values. */
+  public static double log(BigDecimal d0, BigDecimal d1) {
+    return Math.log(d0.doubleValue()) / Math.log(d1.doubleValue());
   }
 
   // MOD
@@ -1810,11 +2135,6 @@ public static <T extends Comparable<T>> T greatest(T b0, T b1) {
     return b0 == null || b1 != null && b0.compareTo(b1) < 0 ? b1 : b0;
   }
 
-  /** Boolean comparison. */
-  public static int compare(boolean x, boolean y) {
-    return x == y ? 0 : x ? 1 : -1;
-  }
-
   /** CAST(FLOAT AS VARCHAR). */
   public static String toString(float x) {
     if (x == 0) {
@@ -1922,41 +2242,96 @@ public static short toShort(Object o) {
         : (Short) cannotConvert(o, short.class);
   }
 
-  /** Converts the Java type used for UDF parameters of SQL DATE type
-   * ({@link java.sql.Date}) to internal representation (int).
+  /**
+   * Converts a SQL DATE value from the Java type
+   * ({@link java.sql.Date}) to the internal representation type
+   * (number of days since January 1st, 1970 as {@code int})
+   * in the local time zone.
    *
-   * <p>Converse of {@link #internalToDate(int)}. */
-  public static int toInt(java.util.Date v) {
+   * <p>Since a time zone is not available, the date is converted to represent
+   * the same date as a Unix date in UTC as the {@link java.sql.Date} value in
+   * the local time zone.
+   *
+   * @see #toInt(java.sql.Date, TimeZone)
+   * @see #internalToDate(int) converse method
+   */
+  public static int toInt(java.sql.Date v) {
     return toInt(v, LOCAL_TZ);
   }
 
-  public static int toInt(java.util.Date v, TimeZone timeZone) {
-    return (int) (toLong(v, timeZone)  / DateTimeUtils.MILLIS_PER_DAY);
+  /**
+   * Converts a SQL DATE value from the Java type
+   * ({@link java.sql.Date}) to the internal representation type
+   * (number of days since January 1st, 1970 as {@code int}).
+   *
+   * <p>The {@link java.sql.Date} class uses the standard Gregorian calendar
+   * which switches from the Julian calendar to the Gregorian calendar in
+   * October 1582. For compatibility with ISO-8601, the internal representation
+   * is converted to use the proleptic Gregorian calendar.
+   *
+   * <p>If the date contains a partial day, it will be rounded to a full day
+   * depending on the milliseconds value. If the milliseconds value is positive,
+   * it will be rounded down to the closest full day. If the milliseconds value
+   * is negative, it will be rounded up to the closest full day.
+   */
+  public static int toInt(java.sql.Date v, TimeZone timeZone) {
+    return DateTimeUtils.sqlDateToUnixDate(v, timeZone);
   }
 
-  public static @PolyNull Integer toIntOptional(java.util.@PolyNull Date v) {
-    return v == null ? castNonNull(null) : toInt(v);
+  /**
+   * Converts a nullable SQL DATE value from the Java type
+   * ({@link java.sql.Date}) to the internal representation type
+   * (number of days since January 1st, 1970 as {@link Integer})
+   * in the local time zone.
+   *
+   * <p>Since a time zone is not available, the date is converted to represent
+   * the same date as a Unix date in UTC as the {@link java.sql.Date} value in
+   * the local time zone.
+   *
+   * @see #toInt(java.sql.Date, TimeZone)
+   * @see #internalToDate(Integer) converse method
+   */
+  public static @PolyNull Integer toIntOptional(java.sql.@PolyNull Date v) {
+    return v == null
+        ? castNonNull(null)
+        : toInt(v);
   }
 
-  public static @PolyNull Integer toIntOptional(java.util.@PolyNull Date v,
+  /**
+   * Converts a nullable SQL DATE value from the Java type
+   * ({@link java.sql.Date}) to the internal representation type
+   * (number of days since January 1st, 1970 as {@link Integer}).
+   *
+   * @see #toInt(java.sql.Date, TimeZone)
+   */
+  public static @PolyNull Integer toIntOptional(java.sql.@PolyNull Date v,
       TimeZone timeZone) {
     return v == null
         ? castNonNull(null)
         : toInt(v, timeZone);
   }
 
-  public static long toLong(Date v) {
-    return toLong(v, LOCAL_TZ);
-  }
-
-  /** Converts the Java type used for UDF parameters of SQL TIME type
-   * ({@link java.sql.Time}) to internal representation (int).
+  /**
+   * Converts a SQL TIME value from the Java type
+   * ({@link java.sql.Time}) to the internal representation type
+   * (number of milliseconds since January 1st, 1970 as {@code int})
+   * in the local time zone.
    *
-   * <p>Converse of {@link #internalToTime(int)}. */
+   * @see #toIntOptional(java.sql.Time)
+   * @see #internalToTime(int) converse method
+   */
   public static int toInt(java.sql.Time v) {
-    return (int) (toLong(v) % DateTimeUtils.MILLIS_PER_DAY);
+    return DateTimeUtils.sqlTimeToUnixTime(v, LOCAL_TZ);
   }
 
+  /**
+   * Converts a nullable SQL TIME value from the Java type
+   * ({@link java.sql.Time}) to the internal representation type
+   * (number of milliseconds since January 1st, 1970 as {@link Integer}).
+   *
+   * @see #toInt(java.sql.Time)
+   * @see #internalToTime(Integer) converse method
+   */
   public static @PolyNull Integer toIntOptional(java.sql.@PolyNull Time v) {
     return v == null ? castNonNull(null) : toInt(v);
   }
@@ -1973,7 +2348,8 @@ public static int toInt(Object o) {
     return o instanceof Integer ? (Integer) o
         : o instanceof Number ? toInt((Number) o)
         : o instanceof String ? toInt((String) o)
-        : o instanceof java.util.Date ? toInt((java.util.Date) o)
+        : o instanceof java.sql.Date ? toInt((java.sql.Date) o)
+        : o instanceof java.sql.Time ? toInt((java.sql.Time) o)
         : (Integer) cannotConvert(o, int.class);
   }
 
@@ -1981,27 +2357,80 @@ public static int toInt(Object o) {
     return o == null ? castNonNull(null) : toInt(o);
   }
 
-  /** Converts the Java type used for UDF parameters of SQL TIMESTAMP type
-   * ({@link java.sql.Timestamp}) to internal representation (long).
+  /**
+   * Converts a SQL TIMESTAMP value from the Java type
+   * ({@link java.util.Date}) to the internal representation type
+   * (number of milliseconds since January 1st, 1970 as {@code long}).
+   *
+   * <p>Since a time zone is not available, converts the timestamp to represent
+   * the same date and time as a Unix timestamp in UTC as the
+   * {@link java.util.Date} value in the local time zone.
    *
-   * <p>Converse of {@link #internalToTimestamp(long)}. */
+   * <p>The {@link java.util.Date} class uses the standard Gregorian calendar
+   * which switches from the Julian calendar to the Gregorian calendar in
+   * October 1582. For compatibility with ISO-8601, converts the internal
+   * representation to use the proleptic Gregorian calendar.
+   */
+  public static long toLong(java.util.Date v) {
+    return DateTimeUtils.utilDateToUnixTimestamp(v, LOCAL_TZ);
+  }
+
+  /**
+   * Converts a SQL TIMESTAMP value from the Java type
+   * ({@link Timestamp}) to the internal representation type
+   * (number of milliseconds since January 1st, 1970 as {@code long}).
+   *
+   * <p>Since a time zone is not available, converts the timestamp to represent
+   * the same date and time as a Unix timestamp in UTC as the
+   * {@link Timestamp} value in the local time zone.
+   *
+   * @see #toLong(Timestamp, TimeZone)
+   * @see #internalToTimestamp(Long) converse method
+   */
   public static long toLong(Timestamp v) {
     return toLong(v, LOCAL_TZ);
   }
 
-  // mainly intended for java.sql.Timestamp but works for other dates also
-  @SuppressWarnings("JavaUtilDate")
-  public static long toLong(java.util.Date v, TimeZone timeZone) {
-    final long time = v.getTime();
-    return time + timeZone.getOffset(time);
+  /**
+   * Converts a SQL TIMESTAMP value from the Java type
+   * ({@link Timestamp}) to the internal representation type
+   * (number of milliseconds since January 1st, 1970 as {@code long}).
+   *
+   * <p>For backwards compatibility, time zone offsets are calculated in
+   * relation to the local time zone instead of UTC. Providing the default time
+   * zone or {@code null} will return the timestamp unmodified.
+   *
+   * <p>The {@link Timestamp} class uses the standard Gregorian calendar which
+   * switches from the Julian calendar to the Gregorian calendar in
+   * October 1582. For compatibility with ISO-8601, the internal representation
+   * is converted to use the proleptic Gregorian calendar.
+   */
+  public static long toLong(Timestamp v, TimeZone timeZone) {
+    return DateTimeUtils.sqlTimestampToUnixTimestamp(v, timeZone);
   }
 
-  // mainly intended for java.sql.Timestamp but works for other dates also
-  public static @PolyNull Long toLongOptional(java.util.@PolyNull Date v) {
+  /**
+   * Converts a nullable SQL TIMESTAMP value from the Java type
+   * ({@link Timestamp}) to the internal representation type
+   * (number of milliseconds since January 1st, 1970 as {@link Long})
+   * in the local time zone.
+   *
+   * @see #toLong(Timestamp, TimeZone)
+   * @see #internalToTimestamp(Long) converse method
+   */
+  public static @PolyNull Long toLongOptional(@PolyNull Timestamp v) {
     return v == null ? castNonNull(null) : toLong(v, LOCAL_TZ);
   }
 
-  public static @PolyNull Long toLongOptional(@PolyNull Timestamp v, TimeZone timeZone) {
+  /**
+   * Converts a nullable SQL TIMESTAMP value from the Java type
+   * ({@link Timestamp}) to the internal representation type
+   * (number of milliseconds since January 1st, 1970 as {@link Long}).
+   *
+   * @see #toLong(Timestamp, TimeZone)
+   */
+  public static @PolyNull Long toLongOptional(@PolyNull Timestamp v,
+      TimeZone timeZone) {
     if (v == null) {
       return castNonNull(null);
     }
@@ -2023,6 +2452,9 @@ public static long toLong(Object o) {
     return o instanceof Long ? (Long) o
         : o instanceof Number ? toLong((Number) o)
         : o instanceof String ? toLong((String) o)
+        : o instanceof java.sql.Date ? toInt((java.sql.Date) o)
+        : o instanceof java.sql.Time ? toInt((java.sql.Time) o)
+        : o instanceof java.sql.Timestamp ? toLong((java.sql.Timestamp) o)
         : o instanceof java.util.Date ? toLong((java.util.Date) o)
         : (Long) cannotConvert(o, long.class);
   }
@@ -2079,24 +2511,61 @@ public static BigDecimal toBigDecimal(Object o) {
         : toBigDecimal(o.toString());
   }
 
-  /** Converts the internal representation of a SQL DATE (int) to the Java
-   * type used for UDF parameters ({@link java.sql.Date}). */
+  /**
+   * Converts a SQL DATE value from the internal representation type
+   * (number of days since January 1st, 1970) to the Java type
+   * ({@link java.sql.Date}).
+   *
+   * <p>Since a time zone is not available, converts the date to represent the
+   * same date as a {@link java.sql.Date} in the local time zone as the Unix
+   * date in UTC.
+   *
+   * <p>The Unix date should be the number of days since January 1st, 1970
+   * using the proleptic Gregorian calendar as defined by ISO-8601. The
+   * returned {@link java.sql.Date} object will use the standard Gregorian
+   * calendar which switches from the Julian calendar to the Gregorian calendar
+   * in October 1582.
+   *
+   * @see #internalToDate(Integer)
+   * @see #toInt(java.sql.Date) converse method
+   */
   public static java.sql.Date internalToDate(int v) {
-    final long t = v * DateTimeUtils.MILLIS_PER_DAY;
-    return new java.sql.Date(t - LOCAL_TZ.getOffset(t));
+    final LocalDate date = LocalDate.ofEpochDay(v);
+    return java.sql.Date.valueOf(date);
   }
 
-  /** As {@link #internalToDate(int)} but allows nulls. */
+  /**
+   * Converts a nullable SQL DATE value from the internal representation type
+   * (number of days since January 1st, 1970) to the Java type
+   * ({@link java.sql.Date}).
+   *
+   * @see #internalToDate(int)
+   * @see #toIntOptional(java.sql.Date) converse method
+   */
   public static java.sql.@PolyNull Date internalToDate(@PolyNull Integer v) {
     return v == null ? castNonNull(null) : internalToDate(v.intValue());
   }
 
-  /** Converts the internal representation of a SQL TIME (int) to the Java
-   * type used for UDF parameters ({@link java.sql.Time}). */
+  /**
+   * Converts a SQL TIME value from the internal representation type
+   * (number of milliseconds since January 1st, 1970) to the Java type
+   * ({@link java.sql.Time}).
+   *
+   * @see #internalToTime(Integer)
+   * @see #toInt(java.sql.Time) converse method
+   */
   public static java.sql.Time internalToTime(int v) {
     return new java.sql.Time(v - LOCAL_TZ.getOffset(v));
   }
 
+  /**
+   * Converts a nullable SQL TIME value from the internal representation type
+   * (number of milliseconds since January 1st, 1970) to the Java type
+   * ({@link java.sql.Time}).
+   *
+   * @see #internalToTime(Integer)
+   * @see #toIntOptional(java.sql.Time) converse method
+   */
   public static java.sql.@PolyNull Time internalToTime(@PolyNull Integer v) {
     return v == null ? castNonNull(null) : internalToTime(v.intValue());
   }
@@ -2152,12 +2621,70 @@ public static String timeWithLocalTimeZoneToString(int v, TimeZone timeZone) {
         .toString();
   }
 
-  /** Converts the internal representation of a SQL TIMESTAMP (long) to the Java
-   * type used for UDF parameters ({@link java.sql.Timestamp}). */
+  private static String internalFormatDatetime(String fmtString, java.util.Date date) {
+    List<FormatElement> elements =
+        FormatModels.BIG_QUERY.parse(fmtString);
+    return elements.stream()
+        .map(ele -> ele.format(date))
+        .collect(Collectors.joining());
+  }
+
+  public static String formatTimestamp(DataContext ctx, String fmtString, long timestamp) {
+    return internalFormatDatetime(fmtString, internalToTimestamp(timestamp));
+  }
+
+  public static String formatDate(DataContext ctx, String fmtString, int date) {
+    return internalFormatDatetime(fmtString, internalToDate(date));
+  }
+
+  public static String formatTime(DataContext ctx, String fmtString, int time) {
+    return internalFormatDatetime(fmtString, internalToTime(time));
+  }
+
+  /**
+   * Converts a SQL TIMESTAMP value from the internal representation type
+   * (number of milliseconds since January 1st, 1970) to the Java Type
+   * ({@link Timestamp})
+   * in the local time zone.
+   *
+   * <p>Since a time zone is not available, the timestamp is converted to
+   * represent the same timestamp as a {@link Timestamp} in the local time zone
+   * as the Unix timestamp in UTC.
+   *
+   * <p>The Unix timestamp should be the number of milliseconds since
+   * January 1st, 1970 using the proleptic Gregorian calendar as defined by
+   * ISO-8601. The returned {@link Timestamp} object will use the standard
+   * Gregorian calendar which switches from the Julian calendar to the
+   * Gregorian calendar in October 1582.
+   *
+   * @see #internalToTimestamp(Long)
+   * @see #toLong(Timestamp, TimeZone)
+   * @see #toLongOptional(Timestamp)
+   * @see #toLongOptional(Timestamp, TimeZone)
+   * @see #toLong(Timestamp) converse method
+   */
   public static java.sql.Timestamp internalToTimestamp(long v) {
-    return new java.sql.Timestamp(v - LOCAL_TZ.getOffset(v));
+    final LocalDateTime dateTime =
+        LocalDateTime.ofEpochSecond(
+            Math.floorDiv(v, DateTimeUtils.MILLIS_PER_SECOND),
+            (int) (Math.floorMod(v, DateTimeUtils.MILLIS_PER_SECOND)
+                * DateTimeUtils.NANOS_PER_MILLI),
+            ZoneOffset.UTC);
+    return java.sql.Timestamp.valueOf(dateTime);
   }
 
+  /**
+   * Converts a nullable SQL TIMESTAMP value from the internal representation
+   * type (number of milliseconds since January 1st, 1970) to the Java Type
+   * ({@link Timestamp})
+   * in the local time zone.
+   *
+   * @see #internalToTimestamp(long)
+   * @see #toLong(Timestamp)
+   * @see #toLong(Timestamp, TimeZone)
+   * @see #toLongOptional(Timestamp, TimeZone)
+   * @see #toLongOptional(Timestamp) converse method
+   */
   public static java.sql.@PolyNull Timestamp internalToTimestamp(@PolyNull Long v) {
     return v == null ? castNonNull(null) : internalToTimestamp(v.longValue());
   }
@@ -2241,6 +2768,206 @@ public static int unixDate(int v) {
     return v;
   }
 
+  /** SQL {@code DATE(year, month, day)} function. */
+  public static int date(int year, int month, int day) {
+    // Calcite represents dates as Unix integers (days since epoch).
+    return (int) LocalDate.of(year, month, day).toEpochDay();
+  }
+
+  /** SQL {@code DATE(TIMESTAMP)} and
+   * {@code DATE(TIMESTAMP WITH LOCAL TIME ZONE)} functions. */
+  public static int date(long timestampMillis) {
+    // Calcite represents dates as Unix integers (days since epoch).
+    // Unix time ignores leap seconds; every day has the exact same number of
+    // milliseconds. BigQuery TIMESTAMP and DATETIME values (Calcite TIMESTAMP
+    // WITH LOCAL TIME ZONE and TIMESTAMP, respectively) are represented
+    // internally as milliseconds since epoch (or epoch UTC).
+    return (int) (timestampMillis / DateTimeUtils.MILLIS_PER_DAY);
+  }
+
+  /** SQL {@code DATE(TIMESTAMP WITH LOCAL TIME, timeZone)} function. */
+  public static int date(long timestampMillis, String timeZone) {
+    // Calcite represents dates as Unix integers (days since epoch).
+    return (int) OffsetDateTime.ofInstant(Instant.ofEpochMilli(timestampMillis),
+            ZoneId.of(timeZone))
+        .toLocalDate()
+        .toEpochDay();
+  }
+
+  /** SQL {@code DATETIME(<year>, <month>, <day>, <hour>, <minute>, <second>)}
+   * function. */
+  public static long datetime(int year, int month, int day, int hour,
+      int minute, int second) {
+    // BigQuery's DATETIME function returns a Calcite TIMESTAMP,
+    // represented internally as milliseconds since epoch UTC.
+    return LocalDateTime.of(year, month, day, hour, minute, second)
+        .toEpochSecond(ZoneOffset.UTC)
+        * DateTimeUtils.MILLIS_PER_SECOND;
+  }
+
+  /** SQL {@code DATETIME(DATE)} function; returns a Calcite TIMESTAMP. */
+  public static long datetime(int daysSinceEpoch) {
+    // BigQuery's DATETIME function returns a Calcite TIMESTAMP,
+    // represented internally as milliseconds since epoch.
+    return daysSinceEpoch * DateTimeUtils.MILLIS_PER_DAY;
+  }
+
+  /** SQL {@code DATETIME(DATE, TIME)} function; returns a Calcite TIMESTAMP. */
+  public static long datetime(int daysSinceEpoch, int millisSinceMidnight) {
+    // BigQuery's DATETIME function returns a Calcite TIMESTAMP,
+    // represented internally as milliseconds since epoch UTC.
+    return daysSinceEpoch * DateTimeUtils.MILLIS_PER_DAY + millisSinceMidnight;
+  }
+
+  /** SQL {@code DATETIME(TIMESTAMP WITH LOCAL TIME ZONE)} function;
+   * returns a Calcite TIMESTAMP. */
+  public static long datetime(long millisSinceEpoch) {
+    // BigQuery TIMESTAMP and DATETIME values (Calcite TIMESTAMP WITH LOCAL TIME
+    // ZONE and TIMESTAMP, respectively) are represented internally as
+    // milliseconds since epoch (or epoch UTC).
+    return millisSinceEpoch;
+  }
+
+  /** SQL {@code DATETIME(TIMESTAMP, timeZone)} function;
+   * returns a Calcite TIMESTAMP. */
+  public static long datetime(long millisSinceEpoch, String timeZone) {
+    // BigQuery TIMESTAMP and DATETIME values (Calcite TIMESTAMP WITH LOCAL TIME
+    // ZONE and TIMESTAMP, respectively) are represented internally as
+    // milliseconds since epoch (or epoch UTC).
+    return OffsetDateTime.ofInstant(Instant.ofEpochMilli(millisSinceEpoch),
+            ZoneId.of(timeZone))
+        .atZoneSimilarLocal(ZoneId.of("UTC"))
+        .toInstant()
+        .toEpochMilli();
+  }
+
+  /** SQL {@code TIMESTAMP(<string>)} function. */
+  public static long timestamp(String expression) {
+    // Calcite represents TIMESTAMP WITH LOCAL TIME ZONE as Unix integers
+    // (milliseconds since epoch).
+    return parseBigQueryTimestampLiteral(expression).toInstant().toEpochMilli();
+  }
+
+  /** SQL {@code TIMESTAMP(<string>, <timeZone>)} function. */
+  public static long timestamp(String expression, String timeZone) {
+    // Calcite represents TIMESTAMP WITH LOCAL TIME ZONE as Unix integers
+    // (milliseconds since epoch).
+    return parseBigQueryTimestampLiteral(expression)
+        .atZoneSimilarLocal(ZoneId.of(timeZone))
+        .toInstant()
+        .toEpochMilli();
+  }
+
+  private static OffsetDateTime parseBigQueryTimestampLiteral(String expression) {
+    // First try to parse with an offset, otherwise parse as a local and assume
+    // UTC ("no offset").
+    try {
+      return OffsetDateTime.parse(expression,
+          BIG_QUERY_TIMESTAMP_LITERAL_FORMATTER);
+    } catch (DateTimeParseException e) {
+      // ignore
+    }
+    if (IS_JDK_8
+        && expression.matches(".*[+-][0-9][0-9]$")) {
+      // JDK 8 has a bug that prevents matching offsets like "+00" but can
+      // match "+00:00".
+      try {
+        expression += ":00";
+        return OffsetDateTime.parse(expression,
+            BIG_QUERY_TIMESTAMP_LITERAL_FORMATTER);
+      } catch (DateTimeParseException e) {
+        // ignore
+      }
+    }
+    try {
+      return LocalDateTime
+          .parse(expression, BIG_QUERY_TIMESTAMP_LITERAL_FORMATTER)
+          .atOffset(ZoneOffset.UTC);
+    } catch (DateTimeParseException e2) {
+      throw new IllegalArgumentException(
+          String.format(Locale.ROOT,
+              "Could not parse BigQuery timestamp literal: %s", expression),
+          e2);
+    }
+  }
+
+  /** SQL {@code TIMESTAMP(<date>)} function. */
+  public static long timestamp(int days) {
+    // Calcite represents TIMESTAMP WITH LOCAL TIME ZONE as Unix integers
+    // (milliseconds since epoch). Unix time ignores leap seconds; every day
+    // has the same number of milliseconds.
+    return ((long) days) * DateTimeUtils.MILLIS_PER_DAY;
+  }
+
+  /** SQL {@code TIMESTAMP(<date>, <timeZone>)} function. */
+  public static long timestamp(int days, String timeZone) {
+    // Calcite represents TIMESTAMP WITH LOCAL TIME ZONE as Unix integers
+    // (milliseconds since epoch).
+    final LocalDateTime localDateTime =
+        LocalDateTime.of(LocalDate.ofEpochDay(days), LocalTime.MIDNIGHT);
+    final ZoneOffset zoneOffset =
+        ZoneId.of(timeZone).getRules().getOffset(localDateTime);
+    return OffsetDateTime.of(localDateTime, zoneOffset)
+        .toInstant()
+        .toEpochMilli();
+  }
+
+  /** SQL {@code TIMESTAMP(<timestamp>)} function; returns a TIMESTAMP WITH
+   * LOCAL TIME ZONE. */
+  public static long timestamp(long millisSinceEpoch) {
+    // BigQuery TIMESTAMP and DATETIME values (Calcite TIMESTAMP WITH LOCAL
+    // TIME ZONE and TIMESTAMP, respectively) are represented internally as
+    // milliseconds since epoch UTC and epoch.
+    return millisSinceEpoch;
+  }
+
+  /** SQL {@code TIMESTAMP(<timestamp>, <timeZone>)} function; returns a
+   * TIMESTAMP WITH LOCAL TIME ZONE. */
+  public static long timestamp(long millisSinceEpoch, String timeZone) {
+    // BigQuery TIMESTAMP and DATETIME values (Calcite TIMESTAMP WITH LOCAL
+    // TIME ZONE and TIMESTAMP, respectively) are represented internally as
+    // milliseconds since epoch UTC and epoch.
+    final Instant instant = Instant.ofEpochMilli(millisSinceEpoch);
+    final ZoneId utcZone = ZoneId.of("UTC");
+    return OffsetDateTime.ofInstant(instant, utcZone)
+        .atZoneSimilarLocal(ZoneId.of(timeZone))
+        .toInstant()
+        .toEpochMilli();
+  }
+
+  /** SQL {@code TIME(<hour>, <minute>, <second>)} function. */
+  public static int time(int hour, int minute, int second) {
+    // Calcite represents time as Unix integers (milliseconds since midnight).
+    return (int) (LocalTime.of(hour, minute, second).toSecondOfDay()
+        * DateTimeUtils.MILLIS_PER_SECOND);
+  }
+
+  /** SQL {@code TIME(<timestamp>)} and {@code TIME(<timestampLtz>)}
+   * functions. */
+  public static int time(long timestampMillis) {
+    // Calcite represents time as Unix integers (milliseconds since midnight).
+    // Unix time ignores leap seconds; every day has the same number of
+    // milliseconds.
+    //
+    // BigQuery TIMESTAMP and DATETIME values (Calcite TIMESTAMP WITH LOCAL
+    // TIME ZONE and TIMESTAMP, respectively) are represented internally as
+    // milliseconds since epoch UTC and epoch.
+    return (int) (timestampMillis % DateTimeUtils.MILLIS_PER_DAY);
+  }
+
+  /** SQL {@code TIME(<timestampLtz>, <timeZone>)} function. */
+  public static int time(long timestampMillis, String timeZone) {
+    // Calcite represents time as Unix integers (milliseconds since midnight).
+    // Unix time ignores leap seconds; every day has the same number of
+    // milliseconds.
+    final Instant instant = Instant.ofEpochMilli(timestampMillis);
+    final ZoneId zoneId = ZoneId.of(timeZone);
+    return (int) (OffsetDateTime.ofInstant(instant, zoneId)
+        .toLocalTime()
+        .toNanoOfDay()
+        / (1000L * 1000L)); // milli > micro > nano
+  }
+
   public static @PolyNull Long toTimestampWithLocalTimeZone(@PolyNull String v) {
     if (v == null) {
       return castNonNull(null);
@@ -2375,33 +3102,6 @@ public static int truncate(int v, int x) {
     return v - remainder;
   }
 
-  /**
-   * SQL {@code LAST_DAY} function.
-   *
-   * @param date days since epoch
-   * @return days of the last day of the month since epoch
-   */
-  public static int lastDay(int date) {
-    int y0 = (int) DateTimeUtils.unixDateExtract(TimeUnitRange.YEAR, date);
-    int m0 = (int) DateTimeUtils.unixDateExtract(TimeUnitRange.MONTH, date);
-    int last = lastDay(y0, m0);
-    return DateTimeUtils.ymdToUnixDate(y0, m0, last);
-  }
-
-  /**
-   * SQL {@code LAST_DAY} function.
-   *
-   * @param timestamp milliseconds from epoch
-   * @return milliseconds of the last day of the month since epoch
-   */
-  public static int lastDay(long timestamp) {
-    int date = (int) (timestamp / DateTimeUtils.MILLIS_PER_DAY);
-    int y0 = (int) DateTimeUtils.unixDateExtract(TimeUnitRange.YEAR, date);
-    int m0 = (int) DateTimeUtils.unixDateExtract(TimeUnitRange.MONTH, date);
-    int last = lastDay(y0, m0);
-    return DateTimeUtils.ymdToUnixDate(y0, m0, last);
-  }
-
   /**
    * SQL {@code DAYNAME} function, applied to a TIMESTAMP argument.
    *
@@ -2470,21 +3170,32 @@ private static LocalDate dateToLocalDate(int date) {
    * @return localDate
    */
   private static LocalDate timeStampToLocalDate(long timestamp) {
-    int date = (int) (timestamp / DateTimeUtils.MILLIS_PER_DAY);
+    int date = timestampToDate(timestamp);
     return dateToLocalDate(date);
   }
 
+  /** Converts a timestamp (milliseconds since epoch)
+   * to a date (days since epoch). */
+  public static int timestampToDate(long timestamp) {
+    return (int) (timestamp / DateTimeUtils.MILLIS_PER_DAY);
+  }
+
+  /** Converts a timestamp (milliseconds since epoch)
+   * to a time (milliseconds since midnight). */
+  public static int timestampToTime(long timestamp) {
+    return (int) (timestamp % DateTimeUtils.MILLIS_PER_DAY);
+  }
+
   /** SQL {@code CURRENT_TIMESTAMP} function. */
   @NonDeterministic
   public static long currentTimestamp(DataContext root) {
-    // Cast required for JDK 1.6.
-    return (Long) DataContext.Variable.CURRENT_TIMESTAMP.get(root);
+    return DataContext.Variable.CURRENT_TIMESTAMP.get(root);
   }
 
   /** SQL {@code CURRENT_TIME} function. */
   @NonDeterministic
   public static int currentTime(DataContext root) {
-    int time = (int) (currentTimestamp(root) % DateTimeUtils.MILLIS_PER_DAY);
+    int time = timestampToTime(currentTimestamp(root));
     if (time < 0) {
       time = (int) (time + DateTimeUtils.MILLIS_PER_DAY);
     }
@@ -2495,8 +3206,8 @@ public static int currentTime(DataContext root) {
   @NonDeterministic
   public static int currentDate(DataContext root) {
     final long timestamp = currentTimestamp(root);
-    int date = (int) (timestamp / DateTimeUtils.MILLIS_PER_DAY);
-    final int time = (int) (timestamp % DateTimeUtils.MILLIS_PER_DAY);
+    int date = timestampToDate(timestamp);
+    final int time = timestampToTime(timestamp);
     if (time < 0) {
       --date;
     }
@@ -2506,19 +3217,18 @@ public static int currentDate(DataContext root) {
   /** SQL {@code LOCAL_TIMESTAMP} function. */
   @NonDeterministic
   public static long localTimestamp(DataContext root) {
-    // Cast required for JDK 1.6.
-    return (Long) DataContext.Variable.LOCAL_TIMESTAMP.get(root);
+    return DataContext.Variable.LOCAL_TIMESTAMP.get(root);
   }
 
   /** SQL {@code LOCAL_TIME} function. */
   @NonDeterministic
   public static int localTime(DataContext root) {
-    return (int) (localTimestamp(root) % DateTimeUtils.MILLIS_PER_DAY);
+    return timestampToTime(localTimestamp(root));
   }
 
   @NonDeterministic
   public static TimeZone timeZone(DataContext root) {
-    return (TimeZone) DataContext.Variable.TIME_ZONE.get(root);
+    return DataContext.Variable.TIME_ZONE.get(root);
   }
 
   /** SQL {@code USER} function. */
@@ -2535,7 +3245,109 @@ public static String systemUser(DataContext root) {
 
   @NonDeterministic
   public static Locale locale(DataContext root) {
-    return (Locale) DataContext.Variable.LOCALE.get(root);
+    return DataContext.Variable.LOCALE.get(root);
+  }
+
+  /** SQL {@code DATEADD} function applied to a custom time frame.
+   *
+   * <p>Custom time frames are created as part of a {@link TimeFrameSet}.
+   * This method retrieves the session's time frame set from the
+   * {@link DataContext.Variable#TIME_FRAME_SET} variable, then looks up the
+   * time frame by name. */
+  public static int customDateAdd(DataContext root,
+      String timeFrameName, int interval, int date) {
+    final TimeFrameSet timeFrameSet =
+        requireNonNull(DataContext.Variable.TIME_FRAME_SET.get(root));
+    final TimeFrame timeFrame = timeFrameSet.get(timeFrameName);
+    return timeFrameSet.addDate(date, interval, timeFrame);
+  }
+
+  /** SQL {@code TIMESTAMPADD} function applied to a custom time frame.
+   *
+   * <p>Custom time frames are created and accessed as described in
+   * {@link #customDateAdd}. */
+  public static long customTimestampAdd(DataContext root,
+      String timeFrameName, long interval, long timestamp) {
+    final TimeFrameSet timeFrameSet =
+        requireNonNull(DataContext.Variable.TIME_FRAME_SET.get(root));
+    final TimeFrame timeFrame = timeFrameSet.get(timeFrameName);
+    return timeFrameSet.addTimestamp(timestamp, interval, timeFrame);
+  }
+
+  /** SQL {@code DATEDIFF} function applied to a custom time frame.
+   *
+   * <p>Custom time frames are created and accessed as described in
+   * {@link #customDateAdd}. */
+  public static int customDateDiff(DataContext root,
+      String timeFrameName, int date, int date2) {
+    final TimeFrameSet timeFrameSet =
+        requireNonNull(DataContext.Variable.TIME_FRAME_SET.get(root));
+    final TimeFrame timeFrame = timeFrameSet.get(timeFrameName);
+    return timeFrameSet.diffDate(date, date2, timeFrame);
+  }
+
+  /** SQL {@code TIMESTAMPDIFF} function applied to a custom time frame.
+   *
+   * <p>Custom time frames are created and accessed as described in
+   * {@link #customDateAdd}. */
+  public static long customTimestampDiff(DataContext root,
+      String timeFrameName, long timestamp, long timestamp2) {
+    final TimeFrameSet timeFrameSet =
+        requireNonNull(DataContext.Variable.TIME_FRAME_SET.get(root));
+    final TimeFrame timeFrame = timeFrameSet.get(timeFrameName);
+    return timeFrameSet.diffTimestamp(timestamp, timestamp2, timeFrame);
+  }
+
+  /** SQL {@code FLOOR} function applied to a {@code DATE} value
+   * and a custom time frame.
+   *
+   * <p>Custom time frames are created and accessed as described in
+   * {@link #customDateAdd}. */
+  public static int customDateFloor(DataContext root,
+      String timeFrameName, int date) {
+    final TimeFrameSet timeFrameSet =
+        requireNonNull(DataContext.Variable.TIME_FRAME_SET.get(root));
+    final TimeFrame timeFrame = timeFrameSet.get(timeFrameName);
+    return timeFrameSet.floorDate(date, timeFrame);
+  }
+
+  /** SQL {@code CEIL} function applied to a {@code DATE} value
+   * and a custom time frame.
+   *
+   * <p>Custom time frames are created and accessed as described in
+   * {@link #customDateAdd}. */
+  public static int customDateCeil(DataContext root,
+      String timeFrameName, int date) {
+    final TimeFrameSet timeFrameSet =
+        requireNonNull(DataContext.Variable.TIME_FRAME_SET.get(root));
+    final TimeFrame timeFrame = timeFrameSet.get(timeFrameName);
+    return timeFrameSet.ceilDate(date, timeFrame);
+  }
+
+  /** SQL {@code FLOOR} function applied to a {@code TIMESTAMP} value
+   * and a custom time frame.
+   *
+   * <p>Custom time frames are created and accessed as described in
+   * {@link #customDateAdd}. */
+  public static long customTimestampFloor(DataContext root,
+      String timeFrameName, long timestamp) {
+    final TimeFrameSet timeFrameSet =
+        requireNonNull(DataContext.Variable.TIME_FRAME_SET.get(root));
+    final TimeFrame timeFrame = timeFrameSet.get(timeFrameName);
+    return timeFrameSet.floorTimestamp(timestamp, timeFrame);
+  }
+
+  /** SQL {@code CEIL} function applied to a {@code TIMESTAMP} value
+   * and a custom time frame.
+   *
+   * <p>Custom time frames are created and accessed as described in
+   * {@link #customDateAdd}. */
+  public static long customTimestampCeil(DataContext root,
+      String timeFrameName, long timestamp) {
+    final TimeFrameSet timeFrameSet =
+        requireNonNull(DataContext.Variable.TIME_FRAME_SET.get(root));
+    final TimeFrame timeFrame = timeFrameSet.get(timeFrameName);
+    return timeFrameSet.ceilTimestamp(timestamp, timeFrame);
   }
 
   /** SQL {@code TRANSLATE(string, search_chars, replacement_chars)}
@@ -2659,8 +3471,8 @@ public static long sequenceNextValue(String key) {
   }
 
   private static AtomicLong getAtomicLong(String key) {
-    final Map<String, AtomicLong> map = requireNonNull(THREAD_SEQUENCES.get(),
-        "THREAD_SEQUENCES.get()");
+    final Map<String, AtomicLong> map =
+        requireNonNull(THREAD_SEQUENCES.get(), "THREAD_SEQUENCES.get()");
     AtomicLong atomic = map.get(key);
     if (atomic == null) {
       atomic = new AtomicLong();
@@ -2847,8 +3659,9 @@ private static Enumerable<FlatLists.ComparableList<Comparable>> p2(
         Enumerator<Map.Entry<Comparable, Comparable>> enumerator =
             Linq4j.enumerator(map.entrySet());
 
-        Enumerator<List<Comparable>> transformed = Linq4j.transform(enumerator,
-            e -> FlatLists.of(e.getKey(), e.getValue()));
+        Enumerator<List<Comparable>> transformed =
+            Linq4j.transform(enumerator,
+                e -> FlatLists.of(e.getKey(), e.getValue()));
         enumerators.add(transformed);
         break;
       default:
@@ -2870,6 +3683,46 @@ public static Object[] array(Object... args) {
     return args;
   }
 
+  /**
+   * Returns whether there is an element in {@code list} for which {@code predicate} is true.
+   * Also, if {@code predicate} returns null for any element of {@code list}
+   * and does not return {@code true} for any element of {@code list},
+   * the result will be {@code null}, not {@code false}.
+   */
+  public static @Nullable <E> Boolean nullableExists(List<? extends E> list,
+      Function1<E, Boolean> predicate) {
+    boolean nullExists = false;
+    for (E e : list) {
+      Boolean res = predicate.apply(e);
+      if (res == null) {
+        nullExists = true;
+      } else if (res) {
+        return true;
+      }
+    }
+    return nullExists ? null : false;
+  }
+
+  /**
+   * Returns whether {@code predicate} is true for all elements of {@code list}.
+   * Also, if {@code predicate} returns null for any element of {@code list}
+   * and does not return {@code false} for any element,
+   * the result will be {@code null}, not {@code true}.
+   */
+  public static @Nullable <E> Boolean nullableAll(List<? extends E> list,
+      Function1<E, Boolean> predicate) {
+    boolean nullExists = false;
+    for (E e : list) {
+      Boolean res = predicate.apply(e);
+      if (res == null) {
+        nullExists = true;
+      } else if (!res) {
+        return false;
+      }
+    }
+    return nullExists ? null : true;
+  }
+
   /** Similar to {@link Linq4j#product(Iterable)} but each resulting list
    * implements {@link FlatLists.ComparableList}. */
   public static <E extends Comparable> Enumerable<FlatLists.ComparableList<E>> product(
@@ -2883,95 +3736,6 @@ public static <E extends Comparable> Enumerable<FlatLists.ComparableList<E>> pro
     };
   }
 
-  /** Adds a given number of months to a timestamp, represented as the number
-   * of milliseconds since the epoch. */
-  public static long addMonths(long timestamp, int m) {
-    final long millis =
-        DateTimeUtils.floorMod(timestamp, DateTimeUtils.MILLIS_PER_DAY);
-    timestamp -= millis;
-    final long x =
-        addMonths((int) (timestamp / DateTimeUtils.MILLIS_PER_DAY), m);
-    return x * DateTimeUtils.MILLIS_PER_DAY + millis;
-  }
-
-  /** Adds a given number of months to a date, represented as the number of
-   * days since the epoch. */
-  public static int addMonths(int date, int m) {
-    int y0 = (int) DateTimeUtils.unixDateExtract(TimeUnitRange.YEAR, date);
-    int m0 = (int) DateTimeUtils.unixDateExtract(TimeUnitRange.MONTH, date);
-    int d0 = (int) DateTimeUtils.unixDateExtract(TimeUnitRange.DAY, date);
-    m0 += m;
-    int deltaYear = (int) DateTimeUtils.floorDiv(m0, 12);
-    y0 += deltaYear;
-    m0 = (int) DateTimeUtils.floorMod(m0, 12);
-    if (m0 == 0) {
-      y0 -= 1;
-      m0 += 12;
-    }
-
-    int last = lastDay(y0, m0);
-    if (d0 > last) {
-      d0 = last;
-    }
-    return DateTimeUtils.ymdToUnixDate(y0, m0, d0);
-  }
-
-  private static int lastDay(int y, int m) {
-    switch (m) {
-    case 2:
-      return y % 4 == 0
-          && (y % 100 != 0
-          || y % 400 == 0)
-          ? 29 : 28;
-    case 4:
-    case 6:
-    case 9:
-    case 11:
-      return 30;
-    default:
-      return 31;
-    }
-  }
-
-  /** Finds the number of months between two dates, each represented as the
-   * number of days since the epoch. */
-  public static int subtractMonths(int date0, int date1) {
-    if (date0 < date1) {
-      return -subtractMonths(date1, date0);
-    }
-    // Start with an estimate.
-    // Since no month has more than 31 days, the estimate is <= the true value.
-    int m = (date0 - date1) / 31;
-    for (;;) {
-      int date2 = addMonths(date1, m);
-      if (date2 >= date0) {
-        return m;
-      }
-      int date3 = addMonths(date1, m + 1);
-      if (date3 > date0) {
-        return m;
-      }
-      ++m;
-    }
-  }
-
-  public static int subtractMonths(long t0, long t1) {
-    final long millis0 =
-        DateTimeUtils.floorMod(t0, DateTimeUtils.MILLIS_PER_DAY);
-    final int d0 = (int) DateTimeUtils.floorDiv(t0 - millis0,
-        DateTimeUtils.MILLIS_PER_DAY);
-    final long millis1 =
-        DateTimeUtils.floorMod(t1, DateTimeUtils.MILLIS_PER_DAY);
-    final int d1 = (int) DateTimeUtils.floorDiv(t1 - millis1,
-        DateTimeUtils.MILLIS_PER_DAY);
-    int x = subtractMonths(d0, d1);
-    final long d2 = addMonths(d1, x);
-    if (d2 == d0 && millis0 < millis1) {
-      --x;
-    }
-    return x;
-  }
-
   /**
    * Implements the {@code .} (field access) operator on an object
    * whose type is not known until runtime.
diff --git a/core/src/main/java/org/apache/calcite/runtime/UnionOperation.java b/core/src/main/java/org/apache/calcite/runtime/UnionOperation.java
new file mode 100644
index 00000000000..6585771ced2
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/runtime/UnionOperation.java
@@ -0,0 +1,42 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.runtime;
+
+import org.locationtech.jts.geom.Geometry;
+import org.locationtech.jts.operation.union.UnaryUnionOp;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Used at run time by the ST_Union function.
+ */
+public class UnionOperation {
+
+  public List<Geometry> init() {
+    return new ArrayList<>();
+  }
+
+  public List<Geometry> add(List<Geometry> accumulator, Geometry geometry) {
+    accumulator.add(geometry);
+    return accumulator;
+  }
+
+  public Geometry result(List<Geometry> accumulator) {
+    return new UnaryUnionOp(accumulator).union();
+  }
+}
diff --git a/core/src/main/java/org/apache/calcite/runtime/XmlFunctions.java b/core/src/main/java/org/apache/calcite/runtime/XmlFunctions.java
index 8c816475252..4773b7ecc9e 100644
--- a/core/src/main/java/org/apache/calcite/runtime/XmlFunctions.java
+++ b/core/src/main/java/org/apache/calcite/runtime/XmlFunctions.java
@@ -24,7 +24,9 @@
 import org.w3c.dom.Node;
 import org.w3c.dom.NodeList;
 import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
 
+import java.io.IOException;
 import java.io.StringReader;
 import java.io.StringWriter;
 import java.util.ArrayList;
@@ -33,6 +35,10 @@
 import java.util.Map;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import javax.xml.XMLConstants;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
 import javax.xml.transform.ErrorListener;
 import javax.xml.transform.OutputKeys;
 import javax.xml.transform.Source;
@@ -48,6 +54,7 @@
 import javax.xml.xpath.XPathExpression;
 import javax.xml.xpath.XPathExpressionException;
 import javax.xml.xpath.XPathFactory;
+import javax.xml.xpath.XPathFactoryConfigurationException;
 
 import static org.apache.calcite.linq4j.Nullness.castNonNull;
 import static org.apache.calcite.util.Static.RESOURCE;
@@ -60,13 +67,41 @@
 public class XmlFunctions {
 
   private static final ThreadLocal<@Nullable XPathFactory> XPATH_FACTORY =
-      ThreadLocal.withInitial(XPathFactory::newInstance);
+      ThreadLocal.withInitial(() -> {
+        final XPathFactory xPathFactory = XPathFactory.newInstance();
+        try {
+          xPathFactory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
+        } catch (XPathFactoryConfigurationException e) {
+          throw new IllegalStateException("XPath Factory configuration failed", e);
+        }
+        return xPathFactory;
+      });
   private static final ThreadLocal<@Nullable TransformerFactory> TRANSFORMER_FACTORY =
       ThreadLocal.withInitial(() -> {
-        TransformerFactory transformerFactory = TransformerFactory.newInstance();
+        final TransformerFactory transformerFactory = TransformerFactory.newInstance();
         transformerFactory.setErrorListener(new InternalErrorListener());
+        try {
+          transformerFactory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
+        } catch (TransformerConfigurationException e) {
+          throw new IllegalStateException("Transformer Factory configuration failed", e);
+        }
         return transformerFactory;
       });
+  private static final ThreadLocal<@Nullable DocumentBuilderFactory> DOCUMENT_BUILDER_FACTORY =
+      ThreadLocal.withInitial(() -> {
+        final DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
+        documentBuilderFactory.setXIncludeAware(false);
+        documentBuilderFactory.setExpandEntityReferences(false);
+        documentBuilderFactory.setNamespaceAware(true);
+        try {
+          documentBuilderFactory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
+          documentBuilderFactory
+              .setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+        } catch (final ParserConfigurationException e) {
+          throw new IllegalStateException("Document Builder configuration failed", e);
+        }
+        return documentBuilderFactory;
+      });
 
   private static final Pattern VALID_NAMESPACE_PATTERN = Pattern
       .compile("^(([0-9a-zA-Z:_-]+=\"[^\"]*\")( [0-9a-zA-Z:_-]+=\"[^\"]*\")*)$");
@@ -81,22 +116,24 @@ private XmlFunctions() {
       return null;
     }
     try {
+      final Node documentNode = getDocumentNode(input);
       XPathExpression xpathExpression = castNonNull(XPATH_FACTORY.get()).newXPath().compile(xpath);
       try {
         NodeList nodes = (NodeList) xpathExpression
-            .evaluate(new InputSource(new StringReader(input)), XPathConstants.NODESET);
+            .evaluate(documentNode, XPathConstants.NODESET);
         List<@Nullable String> result = new ArrayList<>();
         for (int i = 0; i < nodes.getLength(); i++) {
           Node item = castNonNull(nodes.item(i));
-          Node firstChild = requireNonNull(item.getFirstChild(),
-              () -> "firstChild of node " + item);
+          Node firstChild =
+              requireNonNull(item.getFirstChild(),
+                  () -> "firstChild of node " + item);
           result.add(firstChild.getTextContent());
         }
         return StringUtils.join(result, " ");
       } catch (XPathExpressionException e) {
-        return xpathExpression.evaluate(new InputSource(new StringReader(input)));
+        return xpathExpression.evaluate(documentNode);
       }
-    } catch (XPathExpressionException ex) {
+    } catch (IllegalArgumentException | XPathExpressionException ex) {
       throw RESOURCE.invalidInputForExtractValue(input, xpath).ex();
     }
   }
@@ -140,17 +177,18 @@ private XmlFunctions() {
 
       XPathExpression xpathExpression = xPath.compile(xpath);
 
+      final Node documentNode = getDocumentNode(xml);
       try {
         List<String> result = new ArrayList<>();
         NodeList nodes = (NodeList) xpathExpression
-            .evaluate(new InputSource(new StringReader(xml)), XPathConstants.NODESET);
+            .evaluate(documentNode, XPathConstants.NODESET);
         for (int i = 0; i < nodes.getLength(); i++) {
           result.add(convertNodeToString(castNonNull(nodes.item(i))));
         }
         return StringUtils.join(result, "");
       } catch (XPathExpressionException e) {
         Node node = (Node) xpathExpression
-            .evaluate(new InputSource(new StringReader(xml)), XPathConstants.NODE);
+            .evaluate(documentNode, XPathConstants.NODE);
         return convertNodeToString(node);
       }
     } catch (IllegalArgumentException | XPathExpressionException | TransformerException ex) {
@@ -174,16 +212,17 @@ private XmlFunctions() {
       }
 
       XPathExpression xpathExpression = xPath.compile(xpath);
+      final Node documentNode = getDocumentNode(xml);
       try {
         NodeList nodes = (NodeList) xpathExpression
-            .evaluate(new InputSource(new StringReader(xml)), XPathConstants.NODESET);
+            .evaluate(documentNode, XPathConstants.NODESET);
         if (nodes != null && nodes.getLength() > 0) {
           return 1;
         }
         return 0;
       } catch (XPathExpressionException e) {
         Node node = (Node) xpathExpression
-            .evaluate(new InputSource(new StringReader(xml)), XPathConstants.NODE);
+            .evaluate(documentNode, XPathConstants.NODE);
         if (node != null) {
           return 1;
         }
@@ -215,6 +254,17 @@ private static String convertNodeToString(Node node) throws TransformerException
     return writer.toString();
   }
 
+  private static Node getDocumentNode(final String xml) {
+    try {
+      final DocumentBuilder documentBuilder =
+          castNonNull(DOCUMENT_BUILDER_FACTORY.get()).newDocumentBuilder();
+      final InputSource inputSource = new InputSource(new StringReader(xml));
+      return documentBuilder.parse(inputSource);
+    } catch (final ParserConfigurationException | SAXException | IOException e) {
+      throw new IllegalArgumentException("XML parsing failed", e);
+    }
+  }
+
   /** The internal default ErrorListener for Transformer. Just rethrows errors to
    * discontinue the XML transformation. */
   private static class InternalErrorListener implements ErrorListener {
diff --git a/core/src/main/java/org/apache/calcite/schema/Schemas.java b/core/src/main/java/org/apache/calcite/schema/Schemas.java
index 54a82f1b870..c007701bd25 100644
--- a/core/src/main/java/org/apache/calcite/schema/Schemas.java
+++ b/core/src/main/java/org/apache/calcite/schema/Schemas.java
@@ -151,10 +151,10 @@ public static Expression tableExpression(SchemaPlus schema, Type elementType,
       String tableName, Class clazz) {
     final MethodCallExpression expression;
     if (Table.class.isAssignableFrom(clazz)) {
-      expression = Expressions.call(
-          expression(schema),
-          BuiltInMethod.SCHEMA_GET_TABLE.method,
-          Expressions.constant(tableName));
+      expression =
+          Expressions.call(expression(schema),
+              BuiltInMethod.SCHEMA_GET_TABLE.method,
+              Expressions.constant(tableName));
       if (ScannableTable.class.isAssignableFrom(clazz)) {
         return Expressions.call(
             BuiltInMethod.SCHEMAS_ENUMERABLE_SCANNABLE.method,
@@ -174,16 +174,45 @@ public static Expression tableExpression(SchemaPlus schema, Type elementType,
             DataContext.ROOT);
       }
     } else {
-      expression = Expressions.call(
-          BuiltInMethod.SCHEMAS_QUERYABLE.method,
-          DataContext.ROOT,
-          expression(schema),
-          Expressions.constant(elementType),
-          Expressions.constant(tableName));
+      expression =
+          Expressions.call(BuiltInMethod.SCHEMAS_QUERYABLE.method,
+              DataContext.ROOT,
+              expression(schema),
+              Expressions.constant(elementType),
+              Expressions.constant(tableName));
     }
     return EnumUtils.convert(expression, clazz);
   }
 
+  /**
+   * Generates an expression with which table can be referenced in
+   * generated code.
+   *
+   * @param schema    Schema
+   * @param tableName Table name (unique within schema)
+   * @param table     Table to be referenced
+   * @param clazz     Class that provides specific methods for accessing table data.
+   *                  It may differ from the {@code table} class; for example {@code clazz} may be
+   *                  {@code MongoTable.MongoQueryable}, though {@code table} is {@code MongoTable}
+   */
+  public static Expression getTableExpression(SchemaPlus schema, String tableName,
+      Table table, Class<?> clazz) {
+    if (table instanceof QueryableTable) {
+      QueryableTable queryableTable = (QueryableTable) table;
+      return queryableTable.getExpression(schema, tableName, clazz);
+    } else if (table instanceof ScannableTable
+        || table instanceof FilterableTable
+        || table instanceof ProjectableFilterableTable) {
+      return tableExpression(schema, Object[].class, tableName,
+          table.getClass());
+    } else if (table instanceof StreamableTable) {
+      return getTableExpression(schema, tableName,
+          ((StreamableTable) table).stream(), clazz);
+    } else {
+      throw new UnsupportedOperationException();
+    }
+  }
+
   public static DataContext createDataContext(
       Connection connection, @Nullable SchemaPlus rootSchema) {
     return DataContexts.of((CalciteConnection) connection, rootSchema);
@@ -218,9 +247,9 @@ public static <E> Queryable<E> queryable(DataContext root, Class<E> clazz,
   /** Returns a {@link Queryable}, given a schema and table name. */
   public static <E> Queryable<E> queryable(DataContext root, SchemaPlus schema,
       Class<E> clazz, String tableName) {
-    QueryableTable table = (QueryableTable) requireNonNull(
-        schema.getTable(tableName),
-        () -> "table " + tableName + " is not found in " + schema);
+    QueryableTable table =
+        (QueryableTable) requireNonNull(schema.getTable(tableName),
+            () -> "table " + tableName + " is not found in " + schema);
     QueryProvider queryProvider = root.getQueryProvider();
     return table.asQueryable(queryProvider, schema, tableName);
   }
diff --git a/core/src/main/java/org/apache/calcite/schema/impl/AggregateFunctionImpl.java b/core/src/main/java/org/apache/calcite/schema/impl/AggregateFunctionImpl.java
index 72626fa0aff..b03f94daf6b 100644
--- a/core/src/main/java/org/apache/calcite/schema/impl/AggregateFunctionImpl.java
+++ b/core/src/main/java/org/apache/calcite/schema/impl/AggregateFunctionImpl.java
@@ -86,8 +86,8 @@ private AggregateFunctionImpl(Class<?> declaringClass,
     final Method initMethod = ReflectiveFunctionBase.findMethod(clazz, "init");
     final Method addMethod = ReflectiveFunctionBase.findMethod(clazz, "add");
     final Method mergeMethod = null; // TODO:
-    final Method resultMethod = ReflectiveFunctionBase.findMethod(
-        clazz, "result");
+    final Method resultMethod =
+        ReflectiveFunctionBase.findMethod(clazz, "result");
     if (initMethod != null && addMethod != null) {
       // A is return type of init by definition
       final Class<?> accumulatorType = initMethod.getReturnType();
diff --git a/core/src/main/java/org/apache/calcite/schema/impl/MaterializedViewTable.java b/core/src/main/java/org/apache/calcite/schema/impl/MaterializedViewTable.java
index 5205963b118..f878bc9fd8d 100644
--- a/core/src/main/java/org/apache/calcite/schema/impl/MaterializedViewTable.java
+++ b/core/src/main/java/org/apache/calcite/schema/impl/MaterializedViewTable.java
@@ -36,7 +36,8 @@
 import java.sql.DriverManager;
 import java.sql.SQLException;
 import java.util.List;
-import java.util.Objects;
+
+import static java.util.Objects.requireNonNull;
 
 /**
  * Table that is a materialized view.
@@ -109,10 +110,11 @@ private MaterializedViewTableMacro(CalciteSchema schema, String viewSql,
       super(schema, viewSql,
           viewSchemaPath != null ? viewSchemaPath : schema.path(null), viewPath,
           Boolean.TRUE);
-      this.key = Objects.requireNonNull(
-          MaterializationService.instance().defineMaterialization(
-              schema, null, viewSql, schemaPath, suggestedTableName, true,
-              existing));
+      this.key =
+          requireNonNull(
+              MaterializationService.instance()
+                  .defineMaterialization(schema, null, viewSql, schemaPath,
+                      suggestedTableName, true, existing));
     }
 
     @Override public TranslatableTable apply(List<? extends @Nullable Object> arguments) {
diff --git a/core/src/main/java/org/apache/calcite/schema/impl/ModifiableViewTable.java b/core/src/main/java/org/apache/calcite/schema/impl/ModifiableViewTable.java
index 7ed7026aac1..99f81d4d268 100644
--- a/core/src/main/java/org/apache/calcite/schema/impl/ModifiableViewTable.java
+++ b/core/src/main/java/org/apache/calcite/schema/impl/ModifiableViewTable.java
@@ -200,9 +200,9 @@ private ModifiableViewTableInitializerExpressionFactory() {
 
     @Override public ColumnStrategy generationStrategy(RelOptTable table,
         int iColumn) {
-      final ModifiableViewTable viewTable = requireNonNull(
-          table.unwrap(ModifiableViewTable.class),
-          () -> "unable to unwrap ModifiableViewTable from " + table);
+      final ModifiableViewTable viewTable =
+          requireNonNull(table.unwrap(ModifiableViewTable.class),
+              () -> "unable to unwrap ModifiableViewTable from " + table);
       assert iColumn < viewTable.columnMapping.size();
 
       // Use the view constraint to generate the default value if the column is
@@ -228,9 +228,9 @@ private ModifiableViewTableInitializerExpressionFactory() {
 
     @Override public RexNode newColumnDefaultValue(RelOptTable table,
         int iColumn, InitializerContext context) {
-      final ModifiableViewTable viewTable = requireNonNull(
-          table.unwrap(ModifiableViewTable.class),
-          () -> "unable to unwrap ModifiableViewTable from " + table);
+      final ModifiableViewTable viewTable =
+          requireNonNull(table.unwrap(ModifiableViewTable.class),
+              () -> "unable to unwrap ModifiableViewTable from " + table);
       assert iColumn < viewTable.columnMapping.size();
       final RexBuilder rexBuilder = context.getRexBuilder();
       final RelDataTypeFactory typeFactory = rexBuilder.getTypeFactory();
diff --git a/core/src/main/java/org/apache/calcite/schema/impl/ReflectiveFunctionBase.java b/core/src/main/java/org/apache/calcite/schema/impl/ReflectiveFunctionBase.java
index 71573e0cf55..c3a0211342c 100644
--- a/core/src/main/java/org/apache/calcite/schema/impl/ReflectiveFunctionBase.java
+++ b/core/src/main/java/org/apache/calcite/schema/impl/ReflectiveFunctionBase.java
@@ -71,7 +71,7 @@ protected ReflectiveFunctionBase(Method method) {
    */
   static boolean classHasPublicZeroArgsConstructor(Class<?> clazz) {
     for (Constructor<?> constructor : clazz.getConstructors()) {
-      if (constructor.getParameterTypes().length == 0
+      if (constructor.getParameterCount() == 0
           && Modifier.isPublic(constructor.getModifiers())) {
         return true;
       }
@@ -89,7 +89,7 @@ static boolean classHasPublicZeroArgsConstructor(Class<?> clazz) {
    */
   static boolean classHasPublicFunctionContextConstructor(Class<?> clazz) {
     for (Constructor<?> constructor : clazz.getConstructors()) {
-      if (constructor.getParameterTypes().length == 1
+      if (constructor.getParameterCount() == 1
           && constructor.getParameterTypes()[0] == FunctionContext.class
           && Modifier.isPublic(constructor.getModifiers())) {
         return true;
diff --git a/core/src/main/java/org/apache/calcite/schema/impl/TableFunctionImpl.java b/core/src/main/java/org/apache/calcite/schema/impl/TableFunctionImpl.java
index fa4d699e9dc..7a9a1c2da04 100644
--- a/core/src/main/java/org/apache/calcite/schema/impl/TableFunctionImpl.java
+++ b/core/src/main/java/org/apache/calcite/schema/impl/TableFunctionImpl.java
@@ -121,23 +121,27 @@ private static CallImplementor createImplementor(final Method method) {
         new ReflectiveCallNotNullImplementor(method) {
           @Override public Expression implement(RexToLixTranslator translator,
               RexCall call, List<Expression> translatedOperands) {
-            Expression expr = super.implement(translator, call,
-                translatedOperands);
+            Expression expr =
+                super.implement(translator, call, translatedOperands);
             final Class<?> returnType = method.getReturnType();
             if (QueryableTable.class.isAssignableFrom(returnType)) {
-              Expression queryable = Expressions.call(
-                  Expressions.convert_(expr, QueryableTable.class),
-                  BuiltInMethod.QUERYABLE_TABLE_AS_QUERYABLE.method,
-                  Expressions.call(translator.getRoot(),
-                      BuiltInMethod.DATA_CONTEXT_GET_QUERY_PROVIDER.method),
-                  Expressions.constant(null, SchemaPlus.class),
-                  Expressions.constant(call.getOperator().getName(), String.class));
-              expr = Expressions.call(queryable,
-                  BuiltInMethod.QUERYABLE_AS_ENUMERABLE.method);
+              Expression queryable =
+                  Expressions.call(
+                      Expressions.convert_(expr, QueryableTable.class),
+                      BuiltInMethod.QUERYABLE_TABLE_AS_QUERYABLE.method,
+                      Expressions.call(translator.getRoot(),
+                          BuiltInMethod.DATA_CONTEXT_GET_QUERY_PROVIDER.method),
+                      Expressions.constant(null, SchemaPlus.class),
+                      Expressions.constant(call.getOperator().getName(),
+                          String.class));
+              expr =
+                  Expressions.call(queryable,
+                      BuiltInMethod.QUERYABLE_AS_ENUMERABLE.method);
             } else {
-              expr = Expressions.call(expr,
-                  BuiltInMethod.SCANNABLE_TABLE_SCAN.method,
-                  translator.getRoot());
+              expr =
+                  Expressions.call(expr,
+                      BuiltInMethod.SCANNABLE_TABLE_SCAN.method,
+                      translator.getRoot());
             }
             return expr;
           }
diff --git a/core/src/main/java/org/apache/calcite/schema/impl/ViewTable.java b/core/src/main/java/org/apache/calcite/schema/impl/ViewTable.java
index 55ecd9b1212..c055ab1dbe6 100644
--- a/core/src/main/java/org/apache/calcite/schema/impl/ViewTable.java
+++ b/core/src/main/java/org/apache/calcite/schema/impl/ViewTable.java
@@ -93,12 +93,12 @@ public String getViewSql() {
     return viewSql;
   }
 
-  /** Returns the the schema path of the view. */
+  /** Returns the schema path of the view. */
   public List<String> getSchemaPath() {
     return schemaPath;
   }
 
-  /** Returns the the path of the view. */
+  /** Returns the path of the view. */
   public @Nullable List<String> getViewPath() {
     return viewPath;
   }
@@ -130,8 +130,8 @@ private RelRoot expandView(RelOptTable.ToRelContext context,
           context.expandView(rowType, queryString, schemaPath, viewPath);
       final RelNode rel = RelOptUtil.createCastRel(root.rel, rowType, true);
       // Expand any views
-      final RelNode rel2 = rel.accept(
-          new RelShuttleImpl() {
+      final RelNode rel2 =
+          rel.accept(new RelShuttleImpl() {
             @Override public RelNode visit(TableScan scan) {
               final RelOptTable table = scan.getTable();
               final TranslatableTable translatableTable =
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlBasicFunction.java b/core/src/main/java/org/apache/calcite/sql/SqlBasicFunction.java
new file mode 100644
index 00000000000..a811228beab
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/sql/SqlBasicFunction.java
@@ -0,0 +1,227 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.sql;
+
+import org.apache.calcite.sql.type.OperandHandlers;
+import org.apache.calcite.sql.type.SqlOperandHandler;
+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 org.checkerframework.checker.nullness.qual.Nullable;
+
+import java.util.function.Function;
+
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Concrete implementation of {@link SqlFunction}.
+ *
+ * <p>The class is final, and instances are immutable.
+ *
+ * <p>Instances are created only by {@link SqlBasicFunction#create} and are
+ * "modified" by "wither" methods such as {@link #withName} to create a new
+ * instance with one property changed. Since the class is final, you can modify
+ * behavior only by providing strategy objects, not by overriding methods in a
+ * subclass.
+ */
+public class SqlBasicFunction extends SqlFunction {
+  private final SqlSyntax syntax;
+  private final boolean deterministic;
+  private final SqlOperandHandler operandHandler;
+  private final int callValidator;
+  private final Function<SqlOperatorBinding, SqlMonotonicity> monotonicityInference;
+
+  //~ Constructors -----------------------------------------------------------
+
+  /**
+   * Creates a new SqlFunction for a call to a built-in function.
+   *
+   * @param name Name of built-in function
+   * @param kind Kind of operator implemented by function
+   * @param syntax Syntax
+   * @param deterministic Whether the function is deterministic
+   * @param returnTypeInference Strategy to use for return type inference
+   * @param operandTypeInference Strategy to use for parameter type inference
+   * @param operandHandler Strategy to use for handling operands
+   * @param operandTypeChecker Strategy to use for parameter type checking
+   * @param callValidator Strategy to validate calls
+   * @param category Categorization for function
+   * @param monotonicityInference Strategy to infer monotonicity of a call
+   */
+  private SqlBasicFunction(String name, SqlKind kind, SqlSyntax syntax,
+      boolean deterministic, SqlReturnTypeInference returnTypeInference,
+      @Nullable SqlOperandTypeInference operandTypeInference,
+      SqlOperandHandler operandHandler,
+      SqlOperandTypeChecker operandTypeChecker,
+      Integer callValidator,
+      SqlFunctionCategory category,
+      Function<SqlOperatorBinding, SqlMonotonicity> monotonicityInference) {
+    super(name, kind,
+        requireNonNull(returnTypeInference, "returnTypeInference"),
+        operandTypeInference,
+        requireNonNull(operandTypeChecker, "operandTypeChecker"), category);
+    this.syntax = requireNonNull(syntax, "syntax");
+    this.deterministic = deterministic;
+    this.operandHandler = requireNonNull(operandHandler, "operandHandler");
+    this.callValidator = requireNonNull(callValidator, "callValidator");
+    this.monotonicityInference =
+        requireNonNull(monotonicityInference, "monotonicityInference");
+  }
+
+  /** Creates a {@code SqlBasicFunction} whose name is the same as its kind
+   * and whose category {@link SqlFunctionCategory#SYSTEM}. */
+  public static SqlBasicFunction create(SqlKind kind,
+      SqlReturnTypeInference returnTypeInference,
+      SqlOperandTypeChecker operandTypeChecker) {
+    return new SqlBasicFunction(kind.name(), kind,
+        SqlSyntax.FUNCTION, true, returnTypeInference, null,
+        OperandHandlers.DEFAULT, operandTypeChecker, 0,
+        SqlFunctionCategory.SYSTEM, call -> SqlMonotonicity.NOT_MONOTONIC);
+  }
+
+  /** Creates a {@code SqlBasicFunction}
+   *  with kind {@link SqlKind#OTHER_FUNCTION}
+   *  and category {@link SqlFunctionCategory#NUMERIC}. */
+  public static SqlBasicFunction create(String name,
+      SqlReturnTypeInference returnTypeInference,
+      SqlOperandTypeChecker operandTypeChecker) {
+    return new SqlBasicFunction(name, SqlKind.OTHER_FUNCTION,
+        SqlSyntax.FUNCTION, true, returnTypeInference, null,
+        OperandHandlers.DEFAULT, operandTypeChecker, 0,
+        SqlFunctionCategory.NUMERIC, call -> SqlMonotonicity.NOT_MONOTONIC);
+  }
+
+  /** Creates a {@code SqlBasicFunction}
+   *  with kind {@link SqlKind#OTHER_FUNCTION}. */
+  public static SqlBasicFunction create(String name,
+      SqlReturnTypeInference returnTypeInference,
+      SqlOperandTypeChecker operandTypeChecker, SqlFunctionCategory category) {
+    return new SqlBasicFunction(name, SqlKind.OTHER_FUNCTION,
+        SqlSyntax.FUNCTION, true, returnTypeInference, null,
+        OperandHandlers.DEFAULT, operandTypeChecker, 0,
+        category, call -> SqlMonotonicity.NOT_MONOTONIC);
+  }
+
+  //~ Methods ----------------------------------------------------------------
+
+  @Override public SqlReturnTypeInference getReturnTypeInference() {
+    return requireNonNull(super.getReturnTypeInference(), "returnTypeInference");
+  }
+
+  @Override public SqlOperandTypeChecker getOperandTypeChecker() {
+    return requireNonNull(super.getOperandTypeChecker(), "operandTypeChecker");
+  }
+
+  @Override public SqlSyntax getSyntax() {
+    return syntax;
+  }
+
+  @Override public boolean isDeterministic() {
+    return deterministic;
+  }
+
+  @Override public SqlMonotonicity getMonotonicity(SqlOperatorBinding call) {
+    return monotonicityInference.apply(call);
+  }
+
+  @Override public SqlNode rewriteCall(SqlValidator validator, SqlCall call) {
+    return operandHandler.rewriteCall(validator, call);
+  }
+
+  @Override public void validateCall(SqlCall call, SqlValidator validator,
+      SqlValidatorScope scope, SqlValidatorScope operandScope) {
+    super.validateCall(call, validator, scope, operandScope);
+  }
+
+  /** Returns a copy of this function with a given name. */
+  public SqlBasicFunction withName(String name) {
+    return new SqlBasicFunction(name, kind, syntax, deterministic,
+        getReturnTypeInference(), getOperandTypeInference(), operandHandler,
+        getOperandTypeChecker(), callValidator,
+        getFunctionType(), monotonicityInference);
+  }
+
+  /** Returns a copy of this function with a given kind. */
+  public SqlBasicFunction withKind(SqlKind kind) {
+    return new SqlBasicFunction(getName(), kind, syntax, deterministic,
+        getReturnTypeInference(), getOperandTypeInference(), operandHandler,
+        getOperandTypeChecker(), callValidator,
+        getFunctionType(), monotonicityInference);
+  }
+
+  /** Returns a copy of this function with a given category. */
+  public SqlBasicFunction withFunctionType(SqlFunctionCategory category) {
+    return new SqlBasicFunction(getName(), kind, syntax, deterministic,
+        getReturnTypeInference(), getOperandTypeInference(), operandHandler,
+        getOperandTypeChecker(), callValidator, category, monotonicityInference);
+  }
+
+  /** Returns a copy of this function with a given syntax. */
+  public SqlBasicFunction withSyntax(SqlSyntax syntax) {
+    return new SqlBasicFunction(getName(), kind, syntax, deterministic,
+        getReturnTypeInference(), getOperandTypeInference(), operandHandler,
+        getOperandTypeChecker(), callValidator,
+        getFunctionType(), monotonicityInference);
+  }
+
+  /** Returns a copy of this function with a given strategy for inferring
+   * the types of its operands. */
+  public SqlBasicFunction withOperandTypeInference(
+      SqlOperandTypeInference operandTypeInference) {
+    return new SqlBasicFunction(getName(), kind, syntax, deterministic,
+        getReturnTypeInference(), operandTypeInference, operandHandler,
+        getOperandTypeChecker(), callValidator,
+        getFunctionType(), monotonicityInference);
+  }
+
+  /** Returns a copy of this function with a given strategy for handling
+   * operands. */
+  public SqlBasicFunction withOperandHandler(SqlOperandHandler operandHandler) {
+    return new SqlBasicFunction(getName(), kind, syntax, deterministic,
+        getReturnTypeInference(), getOperandTypeInference(), operandHandler,
+        getOperandTypeChecker(), callValidator,
+        getFunctionType(), monotonicityInference);
+  }
+  /** Returns a copy of this function with a given determinism. */
+  public SqlBasicFunction withDeterministic(boolean deterministic) {
+    return new SqlBasicFunction(getName(), kind, syntax, deterministic,
+        getReturnTypeInference(), getOperandTypeInference(), operandHandler,
+        getOperandTypeChecker(), callValidator,
+        getFunctionType(), monotonicityInference);
+  }
+
+  /** Returns a copy of this function with a given strategy for inferring
+   * whether a call is monotonic. */
+  public SqlBasicFunction withMonotonicityInference(
+      Function<SqlOperatorBinding, SqlMonotonicity> monotonicityInference) {
+    return new SqlBasicFunction(getName(), kind, syntax, deterministic,
+        getReturnTypeInference(), getOperandTypeInference(), operandHandler,
+        getOperandTypeChecker(), callValidator,
+        getFunctionType(), monotonicityInference);
+  }
+
+  public SqlFunction withValidation(int callValidator) {
+    return new SqlBasicFunction(getName(), kind, syntax, deterministic,
+        getReturnTypeInference(), getOperandTypeInference(), operandHandler,
+        getOperandTypeChecker(), callValidator,
+        getFunctionType(), monotonicityInference);
+  }
+}
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlCall.java b/core/src/main/java/org/apache/calcite/sql/SqlCall.java
index c98cf363a49..7cc66e7ec7d 100755
--- a/core/src/main/java/org/apache/calcite/sql/SqlCall.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlCall.java
@@ -191,9 +191,9 @@ protected String getCallSignature(
       @Nullable SqlValidatorScope scope) {
     List<String> signatureList = new ArrayList<>();
     for (final SqlNode operand : getOperandList()) {
-      final RelDataType argType = validator.deriveType(
-          Objects.requireNonNull(scope, "scope"),
-          operand);
+      final RelDataType argType =
+          validator.deriveType(Objects.requireNonNull(scope, "scope"),
+              operand);
       if (null == argType) {
         continue;
       }
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlCallBinding.java b/core/src/main/java/org/apache/calcite/sql/SqlCallBinding.java
index 8852a0df02b..1ab7005fcb5 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlCallBinding.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlCallBinding.java
@@ -16,7 +16,10 @@
  */
 package org.apache.calcite.sql;
 
+import org.apache.calcite.avatica.util.TimeUnit;
 import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.rel.type.TimeFrame;
+import org.apache.calcite.rel.type.TimeFrameSet;
 import org.apache.calcite.runtime.CalciteException;
 import org.apache.calcite.runtime.Resources;
 import org.apache.calcite.sql.fun.SqlLiteralChainOperator;
@@ -177,9 +180,11 @@ private boolean hasAssignment() {
   /** Returns the operands to a call permuted into the same order as the
    * formal parameters of the function. */
   private List<SqlNode> permutedOperands(final SqlCall call) {
-    final SqlOperandMetadata operandMetadata = requireNonNull(
-        (SqlOperandMetadata) call.getOperator().getOperandTypeChecker(),
-        () -> "operandTypeChecker is null for " + call + ", operator " + call.getOperator());
+    final SqlOperator operator = call.getOperator();
+    final SqlOperandMetadata operandMetadata =
+        requireNonNull((SqlOperandMetadata) operator.getOperandTypeChecker(),
+            () -> "operandTypeChecker is null for " + call
+                + ", operator " + operator);
     final List<String> paramNames = operandMetadata.paramNames();
     final List<SqlNode> permuted = new ArrayList<>();
     final SqlNameMatcher nameMatcher =
@@ -204,7 +209,7 @@ private List<SqlNode> permutedOperands(final SqlCall call) {
           if (args != null) {
             throw SqlUtil.newContextException(args.right.getParserPosition(),
                 RESOURCE.paramNotFoundInFunctionDidYouMean(args.right.getSimple(),
-                    call.getOperator().getName(), args.left));
+                    operator.getName(), args.left));
           }
           if (operandMetadata.isFixedParameters()) {
             // Not like user defined functions, we do not patch up the operands
@@ -270,7 +275,7 @@ public SqlCall permutedCall() {
     return valueAs(node, clazz);
   }
 
-  private static <T extends Object> @Nullable T valueAs(SqlNode node, Class<T> clazz) {
+  private <T extends Object> @Nullable T valueAs(SqlNode node, Class<T> clazz) {
     final SqlLiteral literal;
     switch (node.getKind()) {
     case ARRAY_VALUE_CONSTRUCTOR:
@@ -308,6 +313,21 @@ public SqlCall permutedCall() {
 
     case INTERVAL_QUALIFIER:
       final SqlIntervalQualifier q = (SqlIntervalQualifier) node;
+      if (q.timeFrameName != null) {
+        // Custom time frames can only be cast to String. You can do more with
+        // them when validator has resolved to a TimeFrame.
+        final TimeFrameSet timeFrameSet = validator.getTimeFrameSet();
+        final TimeFrame timeFrame = timeFrameSet.getOpt(q.timeFrameName);
+        if (clazz == String.class) {
+          return clazz.cast(q.timeFrameName);
+        }
+        if (clazz == TimeUnit.class
+            && timeFrame != null) {
+          TimeUnit timeUnit = timeFrameSet.getUnit(timeFrame);
+          return clazz.cast(timeUnit);
+        }
+        return null;
+      }
       final SqlIntervalLiteral.IntervalValue intervalValue =
           new SqlIntervalLiteral.IntervalValue(q, 1, q.toString());
       literal = new SqlLiteral(intervalValue, q.typeName(), q.pos);
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlDialect.java b/core/src/main/java/org/apache/calcite/sql/SqlDialect.java
index 5172831e42c..ffb12c3629d 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlDialect.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlDialect.java
@@ -38,6 +38,8 @@
 import org.apache.calcite.sql.type.SqlTypeUtil;
 import org.apache.calcite.sql.validate.SqlConformance;
 import org.apache.calcite.sql.validate.SqlConformanceEnum;
+import org.apache.calcite.util.format.FormatModel;
+import org.apache.calcite.util.format.FormatModels;
 
 import com.google.common.base.Preconditions;
 import com.google.common.base.Suppliers;
@@ -289,6 +291,7 @@ public static DatabaseProduct getProduct(
     case "PHOENIX":
       return DatabaseProduct.PHOENIX;
     case "PRESTO":
+    case "AWS.ATHENA":
       return DatabaseProduct.PRESTO;
     case "MYSQL (INFOBRIGHT)":
       return DatabaseProduct.INFOBRIGHT;
@@ -488,6 +491,10 @@ public void unparseSqlDatetimeArithmetic(SqlWriter writer,
    * <code>INTERVAL '1 2:3:4' DAY(4) TO SECOND(4)</code>. */
   public void unparseSqlIntervalQualifier(SqlWriter writer,
       SqlIntervalQualifier qualifier, RelDataTypeSystem typeSystem) {
+    if (qualifier.timeFrameName != null) {
+      SqlIntervalQualifier.asIdentifier(qualifier).unparse(writer, 0, 0);
+      return;
+    }
     final String start = qualifier.timeUnitRange.startUnit.name();
     final int fractionalSecondPrecision =
         qualifier.getFractionalSecondPrecision(typeSystem);
@@ -997,6 +1004,18 @@ protected static void unparseOffset(SqlWriter writer, @Nullable SqlNode offset)
     }
   }
 
+  /**
+   * Returns a description of the format string used by functions in this
+   * dialect.
+   *
+   * <p>Dialects may need to override this element mapping if they differ from
+   * <a href="https://docs.oracle.com/en/database/oracle/oracle-database/19/sqlrf/Format-Models.html">
+   * Oracle's format elements</a>. By default, this returns {@link FormatModels#DEFAULT}.
+   */
+  public FormatModel getFormatModel() {
+    return FormatModels.DEFAULT;
+  }
+
   /**
    * Returns whether the dialect supports nested aggregations, for instance
    * {@code SELECT SUM(SUM(1)) }.
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlDialectFactoryImpl.java b/core/src/main/java/org/apache/calcite/sql/SqlDialectFactoryImpl.java
index 1454620bb5d..e44b6f0435e 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlDialectFactoryImpl.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlDialectFactoryImpl.java
@@ -107,6 +107,9 @@ public class SqlDialectFactoryImpl implements SqlDialectFactory {
       return new OracleSqlDialect(c);
     case "PHOENIX":
       return new PhoenixSqlDialect(c);
+    case "PRESTO":
+    case "AWS.ATHENA":
+      return new PrestoSqlDialect(c);
     case "MYSQL (INFOBRIGHT)":
       return new InfobrightSqlDialect(c);
     case "MYSQL":
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlFunction.java b/core/src/main/java/org/apache/calcite/sql/SqlFunction.java
index c16d22d8e2e..df48b7c9168 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlFunction.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlFunction.java
@@ -246,14 +246,26 @@ private RelDataType deriveType(
 
     final List<SqlNode> args = constructOperandList(validator, call, argNames);
 
-    final List<RelDataType> argTypes = constructArgTypeList(validator, scope,
-        call, args, convertRowArgToColumnList);
+    final List<RelDataType> argTypes =
+        constructArgTypeList(validator, scope,
+            call, args, convertRowArgToColumnList);
 
     SqlFunction function =
         (SqlFunction) SqlUtil.lookupRoutine(validator.getOperatorTable(),
             validator.getTypeFactory(), getNameAsId(), argTypes, argNames,
             getFunctionType(), SqlSyntax.FUNCTION, getKind(),
             validator.getCatalogReader().nameMatcher(), false);
+
+    // If the call already has an operator and its syntax is SPECIAL, it must
+    // have been created intentionally by the parser.
+    if (function == null
+        && call.getOperator().getSyntax() == SqlSyntax.SPECIAL
+        && call.getOperator() instanceof SqlFunction
+        && validator.getOperatorTable().getOperatorList().contains(
+            call.getOperator())) {
+      function = (SqlFunction) call.getOperator();
+    }
+
     try {
       // if we have a match on function name and parameter count, but
       // couldn't find a function with  a COLUMN_LIST type, retry, but
@@ -308,8 +320,9 @@ argTypes, argNames, getFunctionType(), SqlSyntax.FUNCTION,
 
         // check if the identifier represents type
         final SqlFunction x = (SqlFunction) call.getOperator();
-        final SqlIdentifier identifier = Util.first(x.getSqlIdentifier(),
-            new SqlIdentifier(x.getName(), SqlParserPos.ZERO));
+        final SqlIdentifier identifier =
+            Util.first(x.getSqlIdentifier(),
+                new SqlIdentifier(x.getName(), SqlParserPos.ZERO));
         RelDataType type = validator.getCatalogReader().getNamedType(identifier);
         if (type != null) {
           function = new SqlTypeConstructorFunction(identifier, type);
@@ -319,8 +332,9 @@ argTypes, argNames, getFunctionType(), SqlSyntax.FUNCTION,
         // if function doesn't exist within operator table and known function
         // handling is turned off then create a more permissive function
         if (function == null && validator.config().lenientOperatorLookup()) {
-          function = new SqlUnresolvedFunction(identifier, null,
-              null, OperandTypes.VARIADIC, null, x.getFunctionType());
+          function =
+              new SqlUnresolvedFunction(identifier, null,
+                  null, OperandTypes.VARIADIC, null, x.getFunctionType());
           break validCoercionType;
         }
         throw validator.handleUnresolvedFunction(call, this, argTypes,
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlIntervalQualifier.java b/core/src/main/java/org/apache/calcite/sql/SqlIntervalQualifier.java
index 4c468f3bb61..0dce371574d 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlIntervalQualifier.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlIntervalQualifier.java
@@ -20,6 +20,7 @@
 import org.apache.calcite.avatica.util.TimeUnitRange;
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeSystem;
+import org.apache.calcite.rel.type.TimeFrames;
 import org.apache.calcite.runtime.CalciteContextException;
 import org.apache.calcite.sql.parser.SqlParserPos;
 import org.apache.calcite.sql.type.SqlTypeName;
@@ -29,16 +30,20 @@
 import org.apache.calcite.util.Litmus;
 import org.apache.calcite.util.Util;
 
+import com.google.common.collect.ImmutableSet;
+
 import org.checkerframework.checker.nullness.qual.Nullable;
 
 import java.math.BigDecimal;
-import java.util.Objects;
+import java.util.Set;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 import static org.apache.calcite.linq4j.Nullness.castNonNull;
 import static org.apache.calcite.util.Static.RESOURCE;
 
+import static java.util.Objects.requireNonNull;
+
 /**
  * Represents an INTERVAL qualifier.
  *
@@ -92,28 +97,81 @@ public class SqlIntervalQualifier extends SqlNode {
   private static final BigDecimal INT_MAX_VALUE_PLUS_ONE =
       BigDecimal.valueOf(Integer.MAX_VALUE).add(BigDecimal.ONE);
 
+  private static final Set<TimeUnitRange> TIME_UNITS =
+      ImmutableSet.of(TimeUnitRange.HOUR,
+          TimeUnitRange.MINUTE,
+          TimeUnitRange.SECOND);
+
+  private static final Set<TimeUnitRange> MONTH_UNITS =
+      ImmutableSet.of(TimeUnitRange.MILLENNIUM,
+          TimeUnitRange.CENTURY,
+          TimeUnitRange.DECADE,
+          TimeUnitRange.YEAR,
+          TimeUnitRange.ISOYEAR,
+          TimeUnitRange.QUARTER,
+          TimeUnitRange.MONTH);
+
+  private static final Set<TimeUnitRange> DAY_UNITS =
+      ImmutableSet.of(TimeUnitRange.WEEK,
+          TimeUnitRange.DAY);
+
+  private static final Set<TimeUnitRange> DATE_UNITS =
+      ImmutableSet.<TimeUnitRange>builder()
+          .addAll(MONTH_UNITS).addAll(DAY_UNITS).build();
+
+  private static final Set<String> WEEK_FRAMES =
+      ImmutableSet.<String>builder()
+          .addAll(TimeFrames.WEEK_FRAME_NAMES)
+          .add("ISOWEEK")
+          .add("WEEK")
+          .add("SQL_TSI_WEEK")
+          .build();
+
+  private static final Set<String> TSI_TIME_FRAMES =
+      ImmutableSet.of(
+          "SQL_TSI_FRAC_SECOND",
+          "SQL_TSI_MICROSECOND",
+          "SQL_TSI_SECOND",
+          "SQL_TSI_MINUTE",
+          "SQL_TSI_HOUR");
+
+  private static final Set<String> TSI_DATE_FRAMES =
+      ImmutableSet.of(
+          "SQL_TSI_DAY",
+          "SQL_TSI_WEEK",
+          "SQL_TSI_MONTH",
+          "SQL_TSI_QUARTER",
+          "SQL_TSI_YEAR");
+
   //~ Instance fields --------------------------------------------------------
 
   private final int startPrecision;
+  public final @Nullable String timeFrameName;
   public final TimeUnitRange timeUnitRange;
   private final int fractionalSecondPrecision;
 
   //~ Constructors -----------------------------------------------------------
 
+  private SqlIntervalQualifier(SqlParserPos pos, @Nullable String timeFrameName,
+      TimeUnitRange timeUnitRange, int startPrecision,
+      int fractionalSecondPrecision) {
+    super(pos);
+    this.timeFrameName = timeFrameName;
+    this.timeUnitRange = requireNonNull(timeUnitRange, "timeUnitRange");
+    this.startPrecision = startPrecision;
+    this.fractionalSecondPrecision = fractionalSecondPrecision;
+  }
+
   public SqlIntervalQualifier(
       TimeUnit startUnit,
       int startPrecision,
       @Nullable TimeUnit endUnit,
       int fractionalSecondPrecision,
       SqlParserPos pos) {
-    super(pos);
-    if (endUnit == startUnit) {
-      endUnit = null;
-    }
-    this.timeUnitRange =
-        TimeUnitRange.of(Objects.requireNonNull(startUnit, "startUnit"), endUnit);
-    this.startPrecision = startPrecision;
-    this.fractionalSecondPrecision = fractionalSecondPrecision;
+    this(pos, null,
+        TimeUnitRange.of(requireNonNull(startUnit, "startUnit"),
+            endUnit == startUnit ? null : endUnit),
+        startPrecision, fractionalSecondPrecision);
   }
 
   public SqlIntervalQualifier(
@@ -128,6 +186,15 @@ public SqlIntervalQualifier(
         pos);
   }
 
+  /** Creates a qualifier based on a time frame name. */
+  public SqlIntervalQualifier(String timeFrameName,
+      SqlParserPos pos) {
+    this(pos, requireNonNull(timeFrameName, "timeFrameName"),
+        // EPOCH is a placeholder because code expects a non-null TimeUnitRange.
+        TimeUnitRange.EPOCH, RelDataType.PRECISION_NOT_SPECIFIED,
+        RelDataType.PRECISION_NOT_SPECIFIED);
+  }
+
   //~ Methods ----------------------------------------------------------------
 
   @Override public SqlKind getKind() {
@@ -180,6 +247,32 @@ public SqlTypeName typeName() {
     }
   }
 
+  /** Whether this is a DATE interval (including all week intervals). */
+  public boolean isDate() {
+    return DATE_UNITS.contains(timeUnitRange)
+        || timeFrameName != null && TSI_DATE_FRAMES.contains(timeFrameName)
+        || isWeek();
+  }
+
+  /** Whether this is a TIME interval. */
+  public boolean isTime() {
+    return TIME_UNITS.contains(timeUnitRange)
+        || timeFrameName != null && TSI_TIME_FRAMES.contains(timeFrameName);
+  }
+
+  /** Whether this is a TIMESTAMP interval (including all week intervals). */
+  public boolean isTimestamp() {
+    return isDate() || isTime();
+  }
+
+  /** Whether this qualifier represents {@code WEEK}, {@code ISOWEEK},
+   *  or {@code WEEK(}<i>weekday</i>{@code )}
+   * (for <i>weekday</i> in {@code SUNDAY} .. {@code SATURDAY}). */
+  public boolean isWeek() {
+    return timeUnitRange == TimeUnitRange.WEEK
+        || timeFrameName != null && WEEK_FRAMES.contains(timeFrameName);
+  }
+
   @Override public void validate(
       SqlValidator validator,
       SqlValidatorScope scope) {
@@ -577,6 +670,76 @@ private int[] evaluateIntervalLiteralAsMonth(
     }
   }
 
+  /**
+   * Validates an INTERVAL literal against a QUARTER interval qualifier.
+   *
+   * @throws org.apache.calcite.runtime.CalciteContextException if the interval
+   * value is illegal
+   */
+  private int[] evaluateIntervalLiteralAsQuarter(
+      RelDataTypeSystem typeSystem, int sign,
+      String value,
+      String originalValue,
+      SqlParserPos pos) {
+    BigDecimal quarter;
+
+    // validate as QUARTER(startPrecision), e.g. 'MM'
+    String intervalPattern = "(\\d+)";
+
+    Matcher m = Pattern.compile(intervalPattern).matcher(value);
+    if (m.matches()) {
+      // Break out  field values
+      try {
+        quarter = parseField(m, 1);
+      } catch (NumberFormatException e) {
+        throw invalidValueException(pos, originalValue);
+      }
+
+      // Validate individual fields
+      checkLeadFieldInRange(typeSystem, sign, quarter, TimeUnit.QUARTER, pos);
+
+      // package values up for return
+      return fillIntervalValueArray(sign, ZERO, quarter);
+    } else {
+      throw invalidValueException(pos, originalValue);
+    }
+  }
+
+  /**
+   * Validates an INTERVAL literal against a WEEK interval qualifier.
+   *
+   * @throws org.apache.calcite.runtime.CalciteContextException if the interval
+   * value is illegal
+   */
+  private int[] evaluateIntervalLiteralAsWeek(
+      RelDataTypeSystem typeSystem, int sign,
+      String value,
+      String originalValue,
+      SqlParserPos pos) {
+    BigDecimal week;
+
+    // validate as WEEK(startPrecision), e.g. 'MM'
+    String intervalPattern = "(\\d+)";
+
+    Matcher m = Pattern.compile(intervalPattern).matcher(value);
+    if (m.matches()) {
+      // Break out  field values
+      try {
+        week = parseField(m, 1);
+      } catch (NumberFormatException e) {
+        throw invalidValueException(pos, originalValue);
+      }
+
+      // Validate individual fields
+      checkLeadFieldInRange(typeSystem, sign, week, TimeUnit.WEEK, pos);
+
+      // package values up for return
+      return fillIntervalValueArray(sign, ZERO, week);
+    } else {
+      throw invalidValueException(pos, originalValue);
+    }
+  }
+
   /**
    * Validates an INTERVAL literal against a DAY interval qualifier.
    *
@@ -1132,6 +1295,12 @@ public int[] evaluateIntervalLiteral(String value, SqlParserPos pos,
     case MONTH:
       return evaluateIntervalLiteralAsMonth(typeSystem, sign, value, value0,
           pos);
+    case QUARTER:
+      return evaluateIntervalLiteralAsQuarter(typeSystem, sign, value, value0,
+          pos);
+    case WEEK:
+      return evaluateIntervalLiteralAsWeek(typeSystem, sign, value, value0,
+          pos);
     case DAY:
       return evaluateIntervalLiteralAsDay(typeSystem, sign, value, value0, pos);
     case DAY_TO_HOUR:
@@ -1187,4 +1356,20 @@ private static CalciteContextException fieldExceedsPrecisionException(
         RESOURCE.intervalFieldExceedsPrecision(
             value, type.name() + "(" + precision + ")"));
   }
+
+  /** Converts a {@link SqlIntervalQualifier} to a
+   * {@link org.apache.calcite.sql.SqlIdentifier} if it is a time frame
+   * reference.
+   *
+   * <p>Helps with unparsing of EXTRACT, FLOOR, CEIL functions. */
+  public static SqlNode asIdentifier(SqlNode node) {
+    if (node instanceof SqlIntervalQualifier) {
+      SqlIntervalQualifier intervalQualifier = (SqlIntervalQualifier) node;
+      if (intervalQualifier.timeFrameName != null) {
+        return new SqlIdentifier(intervalQualifier.timeFrameName,
+            node.getParserPosition());
+      }
+    }
+    return node;
+  }
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlJdbcFunctionCall.java b/core/src/main/java/org/apache/calcite/sql/SqlJdbcFunctionCall.java
index ccb804912db..c07e8b5c1ee 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlJdbcFunctionCall.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlJdbcFunctionCall.java
@@ -371,31 +371,31 @@ public class SqlJdbcFunctionCall extends SqlFunction {
   //~ Static fields/initializers ---------------------------------------------
 
   /** List of all numeric function names defined by JDBC. */
-  private static final String NUMERIC_FUNCTIONS = constructFuncList(
-      "ABS", "ACOS", "ASIN", "ATAN", "ATAN2", "CBRT", "CEILING", "COS", "COT",
-      "DEGREES", "EXP", "FLOOR", "LOG", "LOG10", "MOD", "PI",
-      "POWER", "RADIANS", "RAND", "ROUND", "SIGN", "SIN", "SQRT",
-      "TAN", "TRUNCATE");
+  private static final String NUMERIC_FUNCTIONS =
+      constructFuncList("ABS", "ACOS", "ASIN", "ATAN", "ATAN2",
+          "CBRT", "CEILING", "COS", "COT",
+          "DEGREES", "EXP", "FLOOR", "LOG", "LOG10", "MOD", "PI",
+          "POWER", "RADIANS", "RAND", "ROUND", "SIGN", "SIN", "SQRT",
+          "TAN", "TRUNCATE");
 
   /** List of all string function names defined by JDBC. */
-  private static final String STRING_FUNCTIONS = constructFuncList(
-      "ASCII", "CHAR", "CONCAT", "DIFFERENCE", "INSERT", "LCASE",
-      "LEFT", "LENGTH", "LOCATE", "LTRIM", "REPEAT", "REPLACE",
-      "RIGHT", "RTRIM", "SOUNDEX", "SPACE", "SUBSTRING", "UCASE");
-      // "ASCII", "CHAR", "DIFFERENCE", "LOWER",
-      // "LEFT", "TRIM", "REPEAT", "REPLACE",
-      // "RIGHT", "SPACE", "SUBSTRING", "UPPER", "INITCAP", "OVERLAY"
+  private static final String STRING_FUNCTIONS =
+      constructFuncList("ASCII", "CHAR", "CONCAT",
+          "DIFFERENCE", "INSERT", "LCASE",
+          "LEFT", "LENGTH", "LOCATE", "LTRIM", "REPEAT", "REPLACE",
+          "RIGHT", "RTRIM", "SOUNDEX", "SPACE", "SUBSTRING", "UCASE");
 
   /** List of all time/date function names defined by JDBC. */
-  private static final String TIME_DATE_FUNCTIONS = constructFuncList(
-      "CONVERT_TIMEZONE", "CURDATE", "CURTIME", "DAYNAME", "DAYOFMONTH", "DAYOFWEEK",
-      "DAYOFYEAR", "HOUR", "MINUTE", "MONTH", "MONTHNAME", "NOW",
-      "QUARTER", "SECOND", "TIMESTAMPADD", "TIMESTAMPDIFF", "TO_DATE", "TO_TIMESTAMP",
-      "WEEK", "YEAR");
+  private static final String TIME_DATE_FUNCTIONS =
+      constructFuncList("CONVERT_TIMEZONE", "CURDATE", "CURTIME",
+          "DAYNAME", "DAYOFMONTH", "DAYOFWEEK",
+          "DAYOFYEAR", "HOUR", "MINUTE", "MONTH", "MONTHNAME", "NOW",
+          "QUARTER", "SECOND", "TIMESTAMPADD", "TIMESTAMPDIFF",
+          "TO_DATE", "TO_TIMESTAMP", "WEEK", "YEAR");
 
   /** List of all system function names defined by JDBC. */
-  private static final String SYSTEM_FUNCTIONS = constructFuncList(
-      "CONVERT", "DATABASE", "IFNULL", "USER");
+  private static final String SYSTEM_FUNCTIONS =
+      constructFuncList("CONVERT", "DATABASE", "IFNULL", "USER");
 
   //~ Instance fields --------------------------------------------------------
 
@@ -708,6 +708,7 @@ private JdbcToInternalLookupTable() {
       map.put("TRUNCATE", simple(SqlStdOperatorTable.TRUNCATE));
 
       map.put("ASCII", simple(SqlStdOperatorTable.ASCII));
+      map.put("CHAR", simple(SqlLibraryOperators.CHAR));
       map.put("CONCAT", simple(SqlStdOperatorTable.CONCAT));
       map.put("DIFFERENCE", simple(SqlLibraryOperators.DIFFERENCE));
       map.put("INSERT",
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlJoin.java b/core/src/main/java/org/apache/calcite/sql/SqlJoin.java
index a609cb9d438..94887f23f2b 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlJoin.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlJoin.java
@@ -35,7 +35,10 @@
  * Parse tree node representing a {@code JOIN} clause.
  */
 public class SqlJoin extends SqlCall {
-  public static final SqlJoinOperator OPERATOR = new SqlJoinOperator();
+  static final SqlJoinOperator COMMA_OPERATOR =
+      new SqlJoinOperator("COMMA-JOIN", 16);
+  public static final SqlJoinOperator OPERATOR =
+      new SqlJoinOperator("JOIN", 18);
 
   SqlNode left;
 
@@ -80,7 +83,13 @@ public SqlJoin(SqlParserPos pos, SqlNode left, SqlLiteral natural,
   //~ Methods ----------------------------------------------------------------
 
   @Override public SqlOperator getOperator() {
-    return OPERATOR;
+    //noinspection SwitchStatementWithTooFewBranches
+    switch (getJoinType()) {
+    case COMMA:
+      return COMMA_OPERATOR;
+    default:
+      return OPERATOR;
+    }
   }
 
   @Override public SqlKind getKind() {
@@ -165,10 +174,9 @@ public void setRight(SqlNode right) {
     this.right = right;
   }
 
-  /**
-   * <code>SqlJoinOperator</code> describes the syntax of the SQL <code>
-   * JOIN</code> operator. Since there is only one such operator, this class is
-   * almost certainly a singleton.
+  /** Describes the syntax of the SQL {@code JOIN} operator.
+   *
+   * <p>A variant describes the comma operator, which has lower precedence.
    */
   public static class SqlJoinOperator extends SqlOperator {
     private static final SqlWriter.FrameType FRAME_TYPE =
@@ -176,8 +184,8 @@ public static class SqlJoinOperator extends SqlOperator {
 
     //~ Constructors -----------------------------------------------------------
 
-    private SqlJoinOperator() {
-      super("JOIN", SqlKind.JOIN, 16, true, null, null, null);
+    private SqlJoinOperator(String name, int prec) {
+      super(name, SqlKind.JOIN, prec, true, null, null, null);
     }
 
     //~ Methods ----------------------------------------------------------------
@@ -266,7 +274,7 @@ private SqlJoinOperator() {
     SqlNode selectWrapper =
         new SqlSelect(SqlParserPos.ZERO, SqlNodeList.EMPTY,
             SqlNodeList.SINGLETON_STAR, this, null, null, null,
-            SqlNodeList.EMPTY, null, null, null, SqlNodeList.EMPTY);
+            SqlNodeList.EMPTY, null, null, null, null, SqlNodeList.EMPTY);
     return selectWrapper.toSqlString(transform);
   }
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlKind.java b/core/src/main/java/org/apache/calcite/sql/SqlKind.java
index e73214bce0f..4fc34072f2d 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlKind.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlKind.java
@@ -130,6 +130,20 @@ public enum SqlKind {
    */
   OTHER_FUNCTION,
 
+  /**
+   * Input tables have either row semantics or set semantics.
+   * <ul>
+   * <li>Row semantics means that the result of the table function is
+   * decided on a row-by-row basis.
+   * <li>Set semantics means that the outcome of the function depends on how
+   * the data is partitioned.
+   * When the table function is called from a query, the table parameter can
+   * optionally be extended with either a PARTITION BY clause or
+   * an ORDER BY clause or both.
+   * </ul>
+   */
+  SET_SEMANTICS_TABLE,
+
   /** POSITION function. */
   POSITION,
 
@@ -157,6 +171,9 @@ public enum SqlKind {
   /** A dynamic parameter. */
   DYNAMIC_PARAM,
 
+  /** The DISTINCT keyword of the GROUP BY clause. */
+  GROUP_BY_DISTINCT,
+
   /**
    * ORDER BY clause.
    *
@@ -407,12 +424,27 @@ public enum SqlKind {
   /** {@code LEAST} function (Oracle). */
   LEAST,
 
+  /** {@code DATE_DIFF} function (BigQuery Semantics). */
+  DATE_ADD,
+
+  /** {@code DATE_SUB} function (BigQuery). */
+  DATE_SUB,
+
+  /** {@code TIME_ADD} function (BigQuery). */
+  TIME_ADD,
+
+  /** {@code TIME_SUB} function (BigQuery). */
+  TIME_SUB,
+
   /** {@code TIMESTAMP_ADD} function (ODBC, SQL Server, MySQL). */
   TIMESTAMP_ADD,
 
   /** {@code TIMESTAMP_DIFF} function (ODBC, SQL Server, MySQL). */
   TIMESTAMP_DIFF,
 
+  /** {@code TIMESTAMP_SUB} function (BigQuery). */
+  TIMESTAMP_SUB,
+
   // prefix operators
 
   /** Logical {@code NOT} operator. */
@@ -607,6 +639,10 @@ public enum SqlKind {
    */
   CAST,
 
+  /** The {@code SAFE_CAST} function, which is similar to {@link #CAST} but
+   * returns NULL rather than throwing an error if the conversion fails. */
+  SAFE_CAST,
+
   /**
    * The "NEXT VALUE OF sequence" operator.
    */
@@ -859,6 +895,12 @@ public enum SqlKind {
   /** The {@code MODE} aggregate function. */
   MODE,
 
+  /** The {@code ARG_MAX} aggregate function. */
+  ARG_MAX,
+
+  /** The {@code ARG_MIN} aggregate function. */
+  ARG_MIN,
+
   /** The {@code PERCENTILE_CONT} aggregate function. */
   PERCENTILE_CONT,
 
@@ -874,6 +916,9 @@ public enum SqlKind {
   /** The {@code SINGLE_VALUE} aggregate function. */
   SINGLE_VALUE,
 
+  /** The {@code AGGREGATE} aggregate function. */
+  AGGREGATE_FN,
+
   /** The {@code BIT_AND} aggregate function. */
   BIT_AND,
 
@@ -1177,12 +1222,14 @@ public enum SqlKind {
                   FILTER, WITHIN_GROUP, IGNORE_NULLS, RESPECT_NULLS, SEPARATOR,
                   DESCENDING, CUBE, ROLLUP, GROUPING_SETS, EXTEND, LATERAL,
                   SELECT, JOIN, OTHER_FUNCTION, POSITION, CAST, TRIM, FLOOR, CEIL,
-                  TIMESTAMP_ADD, TIMESTAMP_DIFF, EXTRACT, INTERVAL,
+                  DATE_ADD, DATE_SUB, TIME_ADD, TIME_SUB,
+                  TIMESTAMP_ADD, TIMESTAMP_DIFF, TIMESTAMP_SUB,
+                  EXTRACT, INTERVAL,
                   LITERAL_CHAIN, JDBC_FN, PRECEDING, FOLLOWING, ORDER_BY,
                   NULLS_FIRST, NULLS_LAST, COLLECTION_TABLE, TABLESAMPLE,
                   VALUES, WITH, WITH_ITEM, ITEM, SKIP_TO_FIRST, SKIP_TO_LAST,
                   JSON_VALUE_EXPRESSION, UNNEST),
-              AGGREGATE, DML, DDL));
+              SET_QUERY, AGGREGATE, DML, DDL));
 
   /**
    * Category of all SQL statement types.
@@ -1358,7 +1405,7 @@ public SqlKind reverse() {
    * <p>For {@link #IS_TRUE}, {@link #IS_FALSE}, {@link #IS_NOT_TRUE},
    * {@link #IS_NOT_FALSE}, nullable inputs need to be treated carefully.
    *
-   * <p>{@code NOT(IS_TRUE(null))} = {@code NOT(false)} = {@code true},
+   * <p>{@code NOT(IS_TRUE(null))} = {@code NOT false} = {@code true},
    * while {@code IS_FALSE(null)} = {@code false},
    * so {@code NOT(IS_TRUE(X))} should be {@code IS_NOT_TRUE(X)}.
    * On the other hand,
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlLateralOperator.java b/core/src/main/java/org/apache/calcite/sql/SqlLateralOperator.java
index 52e9325b424..f515e5d335b 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlLateralOperator.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlLateralOperator.java
@@ -38,10 +38,8 @@ public SqlLateralOperator(SqlKind kind) {
 
   @Override public void unparse(SqlWriter writer, SqlCall call, int leftPrec,
       int rightPrec) {
-    final Set<SqlKind> specialOperandKinds = ImmutableSet.of(
-        SqlKind.COLLECTION_TABLE,
-        SqlKind.SELECT,
-        SqlKind.AS);
+    final Set<SqlKind> specialOperandKinds =
+        ImmutableSet.of(SqlKind.COLLECTION_TABLE, SqlKind.SELECT, SqlKind.AS);
     if (call.operandCount() == 1
         && specialOperandKinds.contains(call.operand(0).getKind())) {
       // Do not create ( ) around the following TABLE clause.
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlLiteral.java b/core/src/main/java/org/apache/calcite/sql/SqlLiteral.java
index 97d14ff9323..4c9884ea2e9 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlLiteral.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlLiteral.java
@@ -16,6 +16,7 @@
  */
 package org.apache.calcite.sql;
 
+import org.apache.calcite.avatica.util.TimeUnit;
 import org.apache.calcite.avatica.util.TimeUnitRange;
 import org.apache.calcite.rel.metadata.NullSentinel;
 import org.apache.calcite.rel.type.RelDataType;
@@ -72,7 +73,7 @@
  * <caption>Allowable types for SqlLiteral</caption>
  * <tr>
  * <th>TypeName</th>
- * <th>Meaing</th>
+ * <th>Meaning</th>
  * <th>Value type</th>
  * </tr>
  * <tr>
@@ -204,6 +205,7 @@ public static boolean valueMatchesType(
     case TIME:
       return value instanceof TimeString;
     case TIMESTAMP:
+    case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
       return value instanceof TimestampString;
     case INTERVAL_YEAR:
     case INTERVAL_YEAR_MONTH:
@@ -228,6 +230,8 @@ public static boolean valueMatchesType(
           || (value instanceof SqlSampleSpec);
     case MULTISET:
       return true;
+    case UNKNOWN:
+      return value instanceof String;
     case INTEGER: // not allowed -- use Decimal
     case VARCHAR: // not allowed -- use Char
     case VARBINARY: // not allowed -- use Binary
@@ -288,6 +292,7 @@ public <T extends Object> T getValueAs(Class<T> clazz) {
       return clazz.cast(NullSentinel.INSTANCE);
     }
     requireNonNull(value, "value");
+    final SqlIntervalQualifier qualifier;
     switch (typeName) {
     case CHAR:
       if (clazz == String.class) {
@@ -345,15 +350,18 @@ public <T extends Object> T getValueAs(Class<T> clazz) {
     case INTERVAL_MONTH:
       final SqlIntervalLiteral.IntervalValue valMonth =
           (SqlIntervalLiteral.IntervalValue) value;
+      qualifier = valMonth.getIntervalQualifier();
       if (clazz == Long.class) {
         return clazz.cast(valMonth.getSign()
             * SqlParserUtil.intervalToMonths(valMonth));
       } else if (clazz == BigDecimal.class) {
         return clazz.cast(BigDecimal.valueOf(getValueAs(Long.class)));
       } else if (clazz == TimeUnitRange.class) {
-        return clazz.cast(valMonth.getIntervalQualifier().timeUnitRange);
+        return clazz.cast(qualifier.timeUnitRange);
+      } else if (clazz == TimeUnit.class) {
+        return clazz.cast(qualifier.timeUnitRange.startUnit);
       } else if (clazz == SqlIntervalQualifier.class) {
-        return clazz.cast(valMonth.getIntervalQualifier());
+        return clazz.cast(qualifier);
       }
       break;
     case INTERVAL_DAY:
@@ -368,15 +376,18 @@ public <T extends Object> T getValueAs(Class<T> clazz) {
     case INTERVAL_SECOND:
       final SqlIntervalLiteral.IntervalValue valTime =
           (SqlIntervalLiteral.IntervalValue) value;
+      qualifier = valTime.getIntervalQualifier();
       if (clazz == Long.class) {
         return clazz.cast(valTime.getSign()
             * SqlParserUtil.intervalToMillis(valTime));
       } else if (clazz == BigDecimal.class) {
         return clazz.cast(BigDecimal.valueOf(getValueAs(Long.class)));
       } else if (clazz == TimeUnitRange.class) {
-        return clazz.cast(valTime.getIntervalQualifier().timeUnitRange);
+        return clazz.cast(qualifier.timeUnitRange);
+      } else if (clazz == TimeUnit.class) {
+        return clazz.cast(qualifier.timeUnitRange.startUnit);
       } else if (clazz == SqlIntervalQualifier.class) {
-        return clazz.cast(valTime.getIntervalQualifier());
+        return clazz.cast(qualifier);
       }
       break;
     default:
@@ -818,6 +829,28 @@ public RelDataType createSqlType(RelDataTypeFactory typeFactory) {
     }
   }
 
+  /** Creates a literal whose type is unknown until validation time.
+   * The literal has a tag that looks like a type name, but the tag cannot be
+   * resolved until validation time, when we have the mapping from type aliases
+   * to types.
+   *
+   * <p>For example,
+   * <blockquote>{@code
+   * TIMESTAMP '1969-07-20 22:56:00'
+   * }</blockquote>
+   * calls {@code createUnknown("TIMESTAMP", "1969-07-20 22:56:00")}; at
+   * validate time, we may discover that "TIMESTAMP" maps to the type
+   * "TIMESTAMP WITH LOCAL TIME ZONE".
+   *
+   * @param tag Type name, e.g. "TIMESTAMP", "TIMESTAMP WITH LOCAL TIME ZONE"
+   * @param value String encoding of the value
+   * @param pos Parser position
+   */
+  public static SqlLiteral createUnknown(String tag, String value,
+      SqlParserPos pos) {
+    return new SqlUnknownLiteral(tag, value, pos);
+  }
+
   @Deprecated // to be removed before 2.0
   public static SqlDateLiteral createDate(
       Calendar calendar,
@@ -836,15 +869,25 @@ public static SqlTimestampLiteral createTimestamp(
       Calendar calendar,
       int precision,
       SqlParserPos pos) {
-    return createTimestamp(TimestampString.fromCalendarFields(calendar),
-        precision, pos);
+    return createTimestamp(SqlTypeName.TIMESTAMP,
+        TimestampString.fromCalendarFields(calendar), precision, pos);
   }
 
+  @Deprecated // to be removed before 2.0
   public static SqlTimestampLiteral createTimestamp(
       TimestampString ts,
       int precision,
       SqlParserPos pos) {
-    return new SqlTimestampLiteral(ts, precision, false, pos);
+    return createTimestamp(SqlTypeName.TIMESTAMP, ts, precision, pos);
+  }
+
+  /** Creates a TIMESTAMP or TIMESTAMP WITH LOCAL TIME ZONE literal. */
+  public static SqlTimestampLiteral createTimestamp(
+      SqlTypeName typeName,
+      TimestampString ts,
+      int precision,
+      SqlParserPos pos) {
+    return new SqlTimestampLiteral(ts, precision, typeName, pos);
   }
 
   @Deprecated // to be removed before 2.0
@@ -1043,10 +1086,7 @@ public SqlLiteral unescapeUnicode(char unicodeEscapeChar) {
         sb.append(c);
       }
     }
-    ns = new NlsString(
-        sb.toString(),
-        ns.getCharsetName(),
-        ns.getCollation());
+    ns = new NlsString(sb.toString(), ns.getCharsetName(), ns.getCollation());
     return new SqlCharStringLiteral(ns, getParserPosition());
   }
 
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlMerge.java b/core/src/main/java/org/apache/calcite/sql/SqlMerge.java
index 7f77650c6b4..ba70a9e52ed 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlMerge.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlMerge.java
@@ -211,7 +211,7 @@ public void setSourceSelect(SqlSelect sourceSelect) {
       if (targetColumnList != null) {
         targetColumnList.unparse(writer, opLeft, opRight);
       }
-      insertCall.getSource().unparse(writer, opLeft, opRight);
+      insertCall.getSource().unparse(writer, 0, 0);
 
       writer.endList(frame);
     }
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlNode.java b/core/src/main/java/org/apache/calcite/sql/SqlNode.java
index 56266081abb..9baa97ea2c0 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlNode.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlNode.java
@@ -41,8 +41,8 @@
 /**
  * A <code>SqlNode</code> is a SQL parse tree.
  *
- * <p>It may be an
- * {@link SqlOperator operator}, {@link SqlLiteral literal},
+ * <p>It may be a
+ * {@link SqlCall call}, {@link SqlLiteral literal},
  * {@link SqlIdentifier identifier}, and so forth.
  */
 public abstract class SqlNode implements Cloneable {
@@ -341,9 +341,10 @@ public SqlMonotonicity getMonotonicity(@Nullable SqlValidatorScope scope) {
     return SqlMonotonicity.NOT_MONOTONIC;
   }
 
-  /** Returns whether two lists of operands are equal. */
-  public static boolean equalDeep(List<SqlNode> operands0,
-      List<SqlNode> operands1, Litmus litmus) {
+  /** Returns whether two lists of operands are equal, comparing using
+   * {@link SqlNode#equalsDeep(SqlNode, Litmus)}. */
+  public static boolean equalDeep(List<? extends @Nullable SqlNode> operands0,
+      List<? extends @Nullable SqlNode> operands1, Litmus litmus) {
     if (operands0.size() != operands1.size()) {
       return litmus.fail(null);
     }
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlNodeList.java b/core/src/main/java/org/apache/calcite/sql/SqlNodeList.java
index 98ef092d474..dfa0486e304 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlNodeList.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlNodeList.java
@@ -34,6 +34,7 @@
 import java.util.ListIterator;
 import java.util.Objects;
 import java.util.RandomAccess;
+import java.util.function.Consumer;
 
 import static org.apache.calcite.linq4j.Nullness.castNonNull;
 
@@ -129,6 +130,11 @@ public static SqlNodeList of(SqlParserPos pos, List<@Nullable SqlNode> list) {
     return list.size();
   }
 
+  @Override public void forEach(Consumer<? super SqlNode> action) {
+    //noinspection RedundantCast
+    ((List<SqlNode>) list).forEach(action);
+  }
+
   @SuppressWarnings("return.type.incompatible")
   @Override public Iterator</*Nullable*/ SqlNode> iterator() {
     return list.iterator();
@@ -271,24 +277,8 @@ void andOrList(SqlWriter writer, SqlBinaryOperator sepOp) {
       return litmus.fail("{} != {}", this, node);
     }
     SqlNodeList that = (SqlNodeList) node;
-    if (this.size() != that.size()) {
-      return litmus.fail("{} != {}", this, node);
-    }
-    for (int i = 0; i < list.size(); i++) {
-      SqlNode thisChild = list.get(i);
-      final SqlNode thatChild = that.list.get(i);
-      if (thisChild == null) {
-        if (thatChild == null) {
-          continue;
-        } else {
-          return litmus.fail(null);
-        }
-      }
-      if (!thisChild.equalsDeep(thatChild, litmus)) {
-        return litmus.fail(null);
-      }
-    }
-    return litmus.succeed();
+    return SqlNode.equalDeep(list, that.list,
+        litmus.withMessageArgs("{} != {}", this, node));
   }
 
   public static boolean isEmptyList(final SqlNode node) {
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlOperator.java b/core/src/main/java/org/apache/calcite/sql/SqlOperator.java
index 466c1e74b86..43a23795ffa 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlOperator.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlOperator.java
@@ -586,8 +586,8 @@ public RelDataType deriveType(
 
     final List<SqlNode> args = constructOperandList(validator, call, null);
 
-    final List<RelDataType> argTypes = constructArgTypeList(validator, scope,
-        call, args, false);
+    final List<RelDataType> argTypes =
+        constructArgTypeList(validator, scope, call, args, false);
 
     // Always disable type coercion for builtin operator operands,
     // they are handled by the TypeCoercion specifically.
@@ -665,8 +665,9 @@ protected List<RelDataType> constructArgTypeList(
     final SqlValidatorScope operandScope = scope.getOperandScope(call);
 
     final ImmutableList.Builder<RelDataType> argTypeBuilder =
-            ImmutableList.builder();
-    for (SqlNode operand : args) {
+        ImmutableList.builder();
+    for (int i = 0; i < args.size(); i++) {
+      SqlNode operand = args.get(i);
       RelDataType nodeType;
       // for row arguments that should be converted to ColumnList
       // types, set the nodeType to a ColumnList type but defer
@@ -677,7 +678,7 @@ protected List<RelDataType> constructArgTypeList(
         nodeType = typeFactory.createSqlType(SqlTypeName.COLUMN_LIST);
         validator.setValidatedNodeType(operand, nodeType);
       } else {
-        nodeType = validator.deriveType(operandScope, operand);
+        nodeType = deriveOperandType(validator, operandScope, i, operand);
       }
       argTypeBuilder.add(nodeType);
     }
@@ -685,6 +686,11 @@ protected List<RelDataType> constructArgTypeList(
     return argTypeBuilder.build();
   }
 
+  protected RelDataType deriveOperandType(SqlValidator validator,
+      SqlValidatorScope scope, int i, SqlNode operand) {
+    return validator.deriveType(scope, operand);
+  }
+
   /**
    * Returns whether this operator should be surrounded by space when
    * unparsed.
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlOperatorBinding.java b/core/src/main/java/org/apache/calcite/sql/SqlOperatorBinding.java
index 9711385f6ff..04e64cfeca2 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlOperatorBinding.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlOperatorBinding.java
@@ -22,6 +22,7 @@
 import org.apache.calcite.rel.type.RelDataTypeFactoryImpl;
 import org.apache.calcite.runtime.CalciteException;
 import org.apache.calcite.runtime.Resources;
+import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.sql.validate.SqlMonotonicity;
 import org.apache.calcite.sql.validate.SqlValidatorException;
 import org.apache.calcite.util.NlsString;
@@ -195,6 +196,18 @@ public boolean isOperandLiteral(int ordinal, boolean allowCast) {
     throw new UnsupportedOperationException();
   }
 
+  /**
+   * Returns whether an operand is a time frame.
+   *
+   * @param ordinal   zero-based ordinal of operand of interest
+   * @return whether operand is a time frame
+   */
+  public boolean isOperandTimeFrame(int ordinal) {
+    return getOperandCount() > 0
+        && SqlTypeName.TIME_FRAME_TYPES.contains(
+            getOperandType(ordinal).getSqlTypeName());
+  }
+
   /** Returns the number of bound operands. */
   public abstract int getOperandCount();
 
@@ -216,6 +229,14 @@ public SqlMonotonicity getOperandMonotonicity(int ordinal) {
     return SqlMonotonicity.NOT_MONOTONIC;
   }
 
+
+  /**
+   * Returns the collation type.
+   */
+  public RelDataType getCollationType() {
+    throw new UnsupportedOperationException();
+  }
+
   /**
    * Collects the types of the bound operands into a list.
    *
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlOperatorTable.java b/core/src/main/java/org/apache/calcite/sql/SqlOperatorTable.java
index 9027bbfadc0..7bd58045f71 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlOperatorTable.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlOperatorTable.java
@@ -49,7 +49,7 @@ void lookupOperatorOverloads(SqlIdentifier opName,
 
   /**
    * Retrieves a list of all functions and operators in this table. Used for
-   * automated testing.
+   * automated testing. Depending on the table type, may or may not be mutable.
    *
    * @return list of SqlOperator objects
    */
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlPivot.java b/core/src/main/java/org/apache/calcite/sql/SqlPivot.java
index cbe16c8744d..6a082b14330 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlPivot.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlPivot.java
@@ -35,6 +35,8 @@
 import java.util.function.BiConsumer;
 import java.util.stream.Collectors;
 
+import static java.util.Objects.requireNonNull;
+
 /**
  * Parse tree node that represents a PIVOT applied to a table reference
  * (or sub-query).
@@ -132,7 +134,7 @@ private static SqlNode strip(SqlNode e) {
   public void forEachAgg(BiConsumer<@Nullable String, SqlNode> consumer) {
     for (SqlNode agg : aggList) {
       final SqlNode call = SqlUtil.stripAs(agg);
-      final String alias = SqlValidatorUtil.getAlias(agg, -1);
+      final @Nullable String alias = SqlValidatorUtil.alias(agg);
       consumer.accept(alias, call);
     }
   }
@@ -195,5 +197,16 @@ static class Operator extends SqlSpecialOperator {
     Operator(SqlKind kind) {
       super(kind.name(), kind);
     }
+
+    @Override public SqlCall createCall(
+        @Nullable SqlLiteral functionQualifier,
+        SqlParserPos pos,
+        @Nullable SqlNode... operands) {
+      assert operands.length == 4;
+      return new SqlPivot(pos, requireNonNull(operands[0], "query"),
+          requireNonNull((SqlNodeList) operands[1], "aggList"),
+          requireNonNull((SqlNodeList) operands[2], "axisList"),
+          requireNonNull((SqlNodeList) operands[3], "inList"));
+    }
   }
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlProcedureCallOperator.java b/core/src/main/java/org/apache/calcite/sql/SqlProcedureCallOperator.java
index d6575389224..4fc22700fab 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlProcedureCallOperator.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlProcedureCallOperator.java
@@ -57,6 +57,7 @@ public SqlProcedureCallOperator() {
         null,
         null,
         null,
+        null,
         null);
   }
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlRowTypeNameSpec.java b/core/src/main/java/org/apache/calcite/sql/SqlRowTypeNameSpec.java
index 909b761b10a..2e0d8ef02fd 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlRowTypeNameSpec.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlRowTypeNameSpec.java
@@ -106,22 +106,13 @@ public int getArity() {
       return litmus.fail("{} != {}", this, node);
     }
     SqlRowTypeNameSpec that = (SqlRowTypeNameSpec) node;
-    if (this.fieldNames.size() != that.fieldNames.size()) {
+    if (!SqlNode.equalDeep(this.fieldNames, that.fieldNames,
+        litmus.withMessageArgs("{} != {}", this, node))) {
       return litmus.fail("{} != {}", this, node);
     }
-    for (int i = 0; i < fieldNames.size(); i++) {
-      if (!this.fieldNames.get(i).equalsDeep(that.fieldNames.get(i), litmus)) {
-        return litmus.fail("{} != {}", this, node);
-      }
-    }
-    if (this.fieldTypes.size() != that.fieldTypes.size()) {
+    if (!this.fieldTypes.equals(that.fieldTypes)) {
       return litmus.fail("{} != {}", this, node);
     }
-    for (int i = 0; i < fieldTypes.size(); i++) {
-      if (!this.fieldTypes.get(i).equals(that.fieldTypes.get(i))) {
-        return litmus.fail("{} != {}", this, node);
-      }
-    }
     return litmus.succeed();
   }
 
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlSelect.java b/core/src/main/java/org/apache/calcite/sql/SqlSelect.java
index 4ce27f0668b..1d81fa7dbf6 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlSelect.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlSelect.java
@@ -16,6 +16,7 @@
  */
 package org.apache.calcite.sql;
 
+import org.apache.calcite.sql.fun.SqlInternalOperators;
 import org.apache.calcite.sql.parser.SqlParserPos;
 import org.apache.calcite.sql.validate.SqlValidator;
 import org.apache.calcite.sql.validate.SqlValidatorScope;
@@ -41,6 +42,7 @@ public class SqlSelect extends SqlCall {
   public static final int FROM_OPERAND = 2;
   public static final int WHERE_OPERAND = 3;
   public static final int HAVING_OPERAND = 5;
+  public static final int QUALIFY_OPERAND = 7;
 
   SqlNodeList keywordList;
   SqlNodeList selectList;
@@ -49,6 +51,7 @@ public class SqlSelect extends SqlCall {
   @Nullable SqlNodeList groupBy;
   @Nullable SqlNode having;
   SqlNodeList windowDecls;
+  @Nullable SqlNode qualify;
   @Nullable SqlNodeList orderBy;
   @Nullable SqlNode offset;
   @Nullable SqlNode fetch;
@@ -64,6 +67,7 @@ public SqlSelect(SqlParserPos pos,
       @Nullable SqlNodeList groupBy,
       @Nullable SqlNode having,
       @Nullable SqlNodeList windowDecls,
+      @Nullable SqlNode qualify,
       @Nullable SqlNodeList orderBy,
       @Nullable SqlNode offset,
       @Nullable SqlNode fetch,
@@ -78,12 +82,31 @@ public SqlSelect(SqlParserPos pos,
     this.having = having;
     this.windowDecls = requireNonNull(windowDecls != null
         ? windowDecls : new SqlNodeList(pos));
+    this.qualify = qualify;
     this.orderBy = orderBy;
     this.offset = offset;
     this.fetch = fetch;
     this.hints = hints;
   }
 
+  /** deprecated, without {@code qualify}. */
+  @Deprecated // to be removed before 2.0
+  public SqlSelect(SqlParserPos pos,
+      @Nullable SqlNodeList keywordList,
+      SqlNodeList selectList,
+      @Nullable SqlNode from,
+      @Nullable SqlNode where,
+      @Nullable SqlNodeList groupBy,
+      @Nullable SqlNode having,
+      @Nullable SqlNodeList windowDecls,
+      @Nullable SqlNodeList orderBy,
+      @Nullable SqlNode offset,
+      @Nullable SqlNode fetch,
+      @Nullable SqlNodeList hints) {
+    this(pos, keywordList, selectList, from, where, groupBy, having,
+        windowDecls, null, orderBy, offset, fetch, hints);
+  }
+
   //~ Methods ----------------------------------------------------------------
 
   @Override public SqlOperator getOperator() {
@@ -97,7 +120,7 @@ public SqlSelect(SqlParserPos pos,
   @SuppressWarnings("nullness")
   @Override public List<SqlNode> getOperandList() {
     return ImmutableNullableList.of(keywordList, selectList, from, where,
-        groupBy, having, windowDecls, orderBy, offset, fetch, hints);
+        groupBy, having, windowDecls, qualify, orderBy, offset, fetch, hints);
   }
 
   @Override public void setOperand(int i, @Nullable SqlNode operand) {
@@ -124,12 +147,15 @@ public SqlSelect(SqlParserPos pos,
       windowDecls = requireNonNull((SqlNodeList) operand);
       break;
     case 7:
-      orderBy = (SqlNodeList) operand;
+      qualify = operand;
       break;
     case 8:
-      offset = operand;
+      orderBy = (SqlNodeList) operand;
       break;
     case 9:
+      offset = operand;
+      break;
+    case 10:
       fetch = operand;
       break;
     default:
@@ -201,6 +227,15 @@ public final SqlNodeList getWindowList() {
     return windowDecls;
   }
 
+  @Pure
+  public final @Nullable SqlNode getQualify() {
+    return qualify;
+  }
+
+  public void setQualify(@Nullable SqlNode qualify) {
+    this.qualify = qualify;
+  }
+
   @Pure
   public final @Nullable SqlNodeList getOrderList() {
     return orderBy;
@@ -249,7 +284,16 @@ public boolean hasHints() {
 
   // Override SqlCall, to introduce a sub-query frame.
   @Override public void unparse(SqlWriter writer, int leftPrec, int rightPrec) {
-    if (!writer.inQuery()) {
+    if (!writer.inQuery()
+        || getFetch() != null
+            && (leftPrec > SqlInternalOperators.FETCH.getLeftPrec()
+                || rightPrec > SqlInternalOperators.FETCH.getLeftPrec())
+        || getOffset() != null
+            && (leftPrec > SqlInternalOperators.OFFSET.getLeftPrec()
+                || rightPrec > SqlInternalOperators.OFFSET.getLeftPrec())
+        || getOrderList() != null
+            && (leftPrec > SqlOrderBy.OPERATOR.getLeftPrec()
+                || rightPrec > SqlOrderBy.OPERATOR.getRightPrec())) {
       // If this SELECT is the topmost item in a sub-query, introduce a new
       // frame. (The topmost item in the sub-query might be a UNION or
       // ORDER. In this case, we don't need a wrapper frame.)
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlSelectOperator.java b/core/src/main/java/org/apache/calcite/sql/SqlSelectOperator.java
index 59025647cbf..d6bd88dc40d 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlSelectOperator.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlSelectOperator.java
@@ -76,10 +76,11 @@ private SqlSelectOperator() {
         (SqlNodeList) operands[4],
         operands[5],
         (SqlNodeList) operands[6],
-        (SqlNodeList) operands[7],
-        operands[8],
+        operands[7],
+        (SqlNodeList) operands[8],
         operands[9],
-        (SqlNodeList) operands[10]);
+        operands[10],
+        (SqlNodeList) operands[11]);
   }
 
   /**
@@ -96,6 +97,7 @@ public SqlSelect createCall(
       SqlNodeList groupBy,
       SqlNode having,
       SqlNodeList windowDecls,
+      SqlNode qualify,
       SqlNodeList orderBy,
       SqlNode offset,
       SqlNode fetch,
@@ -110,6 +112,7 @@ public SqlSelect createCall(
         groupBy,
         having,
         windowDecls,
+        qualify,
         orderBy,
         offset,
         fetch,
@@ -165,8 +168,8 @@ public SqlSelect createCall(
           writer.startList(SqlWriter.FrameTypeEnum.FROM_LIST);
       select.from.unparse(
           writer,
-          SqlJoin.OPERATOR.getLeftPrec() - 1,
-          SqlJoin.OPERATOR.getRightPrec() - 1);
+          SqlJoin.COMMA_OPERATOR.getLeftPrec() - 1,
+          SqlJoin.COMMA_OPERATOR.getRightPrec() - 1);
       writer.endList(fromFrame);
     }
 
@@ -202,10 +205,18 @@ public SqlSelect createCall(
       }
     }
     if (select.groupBy != null) {
-      writer.sep("GROUP BY");
-      final SqlNodeList groupBy =
+      SqlNodeList groupBy =
           select.groupBy.size() == 0 ? SqlNodeList.SINGLETON_EMPTY
               : select.groupBy;
+      // if the DISTINCT keyword of GROUP BY is present it can be the only item
+      if (groupBy.size() == 1 && groupBy.get(0) != null
+          && groupBy.get(0).getKind() == SqlKind.GROUP_BY_DISTINCT) {
+        writer.sep("GROUP BY DISTINCT");
+        List<SqlNode> operandList = ((SqlCall) groupBy.get(0)).getOperandList();
+        groupBy = new SqlNodeList(operandList, groupBy.getParserPosition());
+      } else {
+        writer.sep("GROUP BY");
+      }
       writer.list(SqlWriter.FrameTypeEnum.GROUP_BY_LIST, SqlWriter.COMMA,
           groupBy);
     }
@@ -218,6 +229,10 @@ public SqlSelect createCall(
       writer.list(SqlWriter.FrameTypeEnum.WINDOW_DECL_LIST, SqlWriter.COMMA,
           select.windowDecls);
     }
+    if (select.qualify != null) {
+      writer.sep("QUALIFY");
+      select.qualify.unparse(writer, 0, 0);
+    }
     if (select.orderBy != null && select.orderBy.size() > 0) {
       writer.sep("ORDER BY");
       writer.list(SqlWriter.FrameTypeEnum.ORDER_BY_LIST, SqlWriter.COMMA,
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlSetSemanticsTableOperator.java b/core/src/main/java/org/apache/calcite/sql/SqlSetSemanticsTableOperator.java
new file mode 100644
index 00000000000..310af7c880d
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/sql/SqlSetSemanticsTableOperator.java
@@ -0,0 +1,94 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.sql;
+
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.sql.parser.SqlParserPos;
+import org.apache.calcite.sql.validate.SqlValidator;
+import org.apache.calcite.sql.validate.SqlValidatorScope;
+
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+import java.util.List;
+
+/**
+ * SetSemanticsTable appears as an parameter in a table function.
+ * It represents as an input table with set semantics.
+ * Set semantics means that the outcome of the function depends on how
+ * the data is partitioned.
+ * When the table function is called from a query, the table parameter can
+ * optionally be extended with either a PARTITION BY clause or
+ * an ORDER BY clause or both.
+ *
+ */
+public class SqlSetSemanticsTableOperator extends SqlInternalOperator {
+
+  //~ Constructors -----------------------------------------------------------
+
+  public SqlSetSemanticsTableOperator() {
+    super("SET_SEMANTICS_TABLE", SqlKind.SET_SEMANTICS_TABLE);
+  }
+
+  @Override public SqlCall createCall(
+      @Nullable SqlLiteral functionQualifier,
+      SqlParserPos pos,
+      @Nullable SqlNode... operands) {
+    assert operands.length == 3;
+    SqlNode partitionList = operands[1];
+    SqlNode orderList = operands[2];
+    assert (partitionList != null && !SqlNodeList.isEmptyList(partitionList))
+        || (orderList != null && !SqlNodeList.isEmptyList(orderList));
+    return super.createCall(functionQualifier, pos, operands);
+  }
+
+  @Override public void unparse(
+      SqlWriter writer,
+      SqlCall call,
+      int leftPrec,
+      int rightPrec) {
+    call.operand(0).unparse(writer, 0, 0);
+
+    SqlNodeList partitionList = call.operand(1);
+    if (partitionList.size() > 0) {
+      writer.sep("PARTITION BY");
+      final SqlWriter.Frame partitionFrame = writer.startList("", "");
+      partitionList.unparse(writer, 0, 0);
+      writer.endList(partitionFrame);
+    }
+    SqlNodeList orderList = call.operand(2);
+    if (orderList.size() > 0) {
+      writer.sep("ORDER BY");
+      writer.list(
+          SqlWriter.FrameTypeEnum.ORDER_BY_LIST,
+          SqlWriter.COMMA,
+          orderList);
+    }
+  }
+
+  @Override public RelDataType deriveType(
+      SqlValidator validator,
+      SqlValidatorScope scope, SqlCall call) {
+    final List<SqlNode> operands = call.getOperandList();
+    RelDataType tableType = validator.deriveType(scope, operands.get(0));
+    assert tableType != null;
+    return tableType;
+  }
+
+  @Override public boolean argumentMustBeScalar(int ordinal) {
+    return false;
+  }
+}
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlSpatialTypeOperatorTable.java b/core/src/main/java/org/apache/calcite/sql/SqlSpatialTypeOperatorTable.java
new file mode 100644
index 00000000000..8ab7dc7d88a
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/sql/SqlSpatialTypeOperatorTable.java
@@ -0,0 +1,92 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.sql;
+
+import org.apache.calcite.config.CalciteConnectionConfigImpl;
+import org.apache.calcite.jdbc.CalciteSchema;
+import org.apache.calcite.jdbc.JavaTypeFactoryImpl;
+import org.apache.calcite.model.ModelHandler;
+import org.apache.calcite.prepare.CalciteCatalogReader;
+import org.apache.calcite.runtime.AccumOperation;
+import org.apache.calcite.runtime.CollectOperation;
+import org.apache.calcite.runtime.SpatialTypeFunctions;
+import org.apache.calcite.runtime.UnionOperation;
+import org.apache.calcite.schema.SchemaPlus;
+import org.apache.calcite.schema.impl.AggregateFunctionImpl;
+import org.apache.calcite.sql.fun.SqlSpatialTypeFunctions;
+import org.apache.calcite.sql.util.SqlOperatorTables;
+import org.apache.calcite.sql.validate.SqlNameMatcher;
+
+import com.google.common.collect.ImmutableList;
+
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * Implementation of {@link org.apache.calcite.sql.SqlSpatialTypeOperatorTable} containing
+ * the spatial operators and functions.
+ */
+public class SqlSpatialTypeOperatorTable implements SqlOperatorTable {
+
+  private final SqlOperatorTable operatorTable;
+
+  public SqlSpatialTypeOperatorTable() {
+    // Create a root schema to hold the spatial functions.
+    CalciteSchema rootSchema = CalciteSchema.createRootSchema(false, false);
+    SchemaPlus schema = rootSchema.plus();
+
+    // Register the spatial functions.
+    ModelHandler.addFunctions(schema, null, ImmutableList.of(),
+        SpatialTypeFunctions.class.getName(), "*", true);
+
+    // Register the sql spatial functions.
+    ModelHandler.addFunctions(schema, null, ImmutableList.of(),
+        SqlSpatialTypeFunctions.class.getName(), "*", true);
+
+    // Register the spatial aggregate functions.
+    schema.add(
+        "ST_UNION", Objects.requireNonNull(
+        AggregateFunctionImpl.create(UnionOperation.class)));
+    schema.add(
+        "ST_ACCUM", Objects.requireNonNull(
+        AggregateFunctionImpl.create(AccumOperation.class)));
+    schema.add(
+        "ST_COLLECT", Objects.requireNonNull(
+        AggregateFunctionImpl.create(CollectOperation.class)));
+
+    // Create a catalog reader to retrieve the operators.
+    CalciteCatalogReader catalogReader =
+        new CalciteCatalogReader(rootSchema,
+            ImmutableList.of(),
+            new JavaTypeFactoryImpl(),
+            CalciteConnectionConfigImpl.DEFAULT);
+
+    operatorTable = SqlOperatorTables.of(catalogReader.getOperatorList());
+  }
+
+  @Override public void lookupOperatorOverloads(SqlIdentifier opName,
+      @Nullable SqlFunctionCategory category, SqlSyntax syntax,
+      List<SqlOperator> operatorList, SqlNameMatcher nameMatcher) {
+    operatorTable.lookupOperatorOverloads(opName, category, syntax, operatorList, nameMatcher);
+  }
+
+  @Override public List<SqlOperator> getOperatorList() {
+    return operatorTable.getOperatorList();
+  }
+}
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlSplittableAggFunction.java b/core/src/main/java/org/apache/calcite/sql/SqlSplittableAggFunction.java
index c4e0d152aed..7bd55d7b229 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlSplittableAggFunction.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlSplittableAggFunction.java
@@ -189,8 +189,8 @@ class CountSplitter implements SqlSplittableAggFunction {
       }
       final RexNode predicate =
           RexUtil.composeConjunction(rexBuilder, predicates, true);
-      final RexNode rexOne = rexBuilder.makeExactLiteral(
-          BigDecimal.ONE, aggregateCall.getType());
+      final RexNode rexOne =
+          rexBuilder.makeExactLiteral(BigDecimal.ONE, aggregateCall.getType());
       if (predicate == null) {
         return rexOne;
       } else {
@@ -302,7 +302,7 @@ abstract class AbstractSumSplitter implements SqlSplittableAggFunction {
         break;
       case 2:
         node = rexBuilder.makeCall(SqlStdOperatorTable.MULTIPLY, merges);
-        node = rexBuilder.makeAbstractCast(aggregateCall.type, node);
+        node = rexBuilder.makeAbstractCast(aggregateCall.type, node, false);
         break;
       default:
         throw new AssertionError("unexpected count " + merges);
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlTableFunction.java b/core/src/main/java/org/apache/calcite/sql/SqlTableFunction.java
index af79dd5b672..bef0b7d1270 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlTableFunction.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlTableFunction.java
@@ -18,6 +18,8 @@
 
 import org.apache.calcite.sql.type.SqlReturnTypeInference;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+
 /**
  * A function that returns a table.
  */
@@ -30,4 +32,17 @@ public interface SqlTableFunction {
    * @return strategy to infer the row type of a call to this function
    */
   SqlReturnTypeInference getRowTypeInference();
+
+  /**
+   * Returns the table parameter characteristics for <code>ordinal</code>th
+   * parameter to this table function.
+   *
+   * <p>Returns <code>null</code> if the <code>ordinal</code>th argument is
+   * not table parameter or the <code>ordinal</code> is smaller than 0 or
+   * the <code>ordinal</code> is greater than or equals to the number of
+   * parameters.
+   */
+  default @Nullable TableCharacteristic tableCharacteristic(int ordinal) {
+    return null;
+  }
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlTimestampLiteral.java b/core/src/main/java/org/apache/calcite/sql/SqlTimestampLiteral.java
index 62869df8399..ac169cad300 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlTimestampLiteral.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlTimestampLiteral.java
@@ -34,9 +34,11 @@ public class SqlTimestampLiteral extends SqlAbstractDateTimeLiteral {
   //~ Constructors -----------------------------------------------------------
 
   SqlTimestampLiteral(TimestampString ts, int precision,
-      boolean hasTimeZone, SqlParserPos pos) {
-    super(ts, hasTimeZone, SqlTypeName.TIMESTAMP, precision, pos);
+      SqlTypeName typeName, SqlParserPos pos) {
+    super(ts, false, typeName, precision, pos);
     Preconditions.checkArgument(this.precision >= 0);
+    Preconditions.checkArgument(typeName == SqlTypeName.TIMESTAMP
+        || typeName == SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE);
   }
 
   //~ Methods ----------------------------------------------------------------
@@ -45,11 +47,11 @@ public class SqlTimestampLiteral extends SqlAbstractDateTimeLiteral {
     return new SqlTimestampLiteral(
         (TimestampString) Objects.requireNonNull(value, "value"),
         precision,
-        hasTimeZone, pos);
+        getTypeName(), pos);
   }
 
   @Override public String toString() {
-    return "TIMESTAMP '" + toFormattedString() + "'";
+    return getTypeName() + " '" + toFormattedString() + "'";
   }
 
   /**
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlUnknownLiteral.java b/core/src/main/java/org/apache/calcite/sql/SqlUnknownLiteral.java
new file mode 100644
index 00000000000..a6cbbbbf48d
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/sql/SqlUnknownLiteral.java
@@ -0,0 +1,68 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.sql;
+
+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.util.NlsString;
+import org.apache.calcite.util.Util;
+
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Literal whose type is not yet known.
+ */
+public class SqlUnknownLiteral extends SqlLiteral {
+  public final String tag;
+
+  SqlUnknownLiteral(String tag, String value, SqlParserPos pos) {
+    super(requireNonNull(value, "value"), SqlTypeName.UNKNOWN, pos);
+    this.tag = requireNonNull(tag, "tag");
+  }
+
+  @Override public String getValue() {
+    return (String) requireNonNull(super.getValue(), "value");
+  }
+
+  @Override public SqlLiteral clone(SqlParserPos pos) {
+    return new SqlUnknownLiteral(tag, getValue(), pos);
+  }
+
+  @Override public void unparse(SqlWriter writer, int leftPrec, int rightPrec) {
+    final NlsString nlsString = new NlsString(getValue(), null, null);
+    writer.keyword(tag);
+    writer.literal(nlsString.asSql(true, true, writer.getDialect()));
+  }
+
+
+  /** Converts this unknown literal to a literal of known type. */
+  public SqlLiteral resolve(SqlTypeName typeName) {
+    switch (typeName) {
+    case DATE:
+      return SqlParserUtil.parseDateLiteral(getValue(), pos);
+    case TIME:
+      return SqlParserUtil.parseTimeLiteral(getValue(), pos);
+    case TIMESTAMP:
+      return SqlParserUtil.parseTimestampLiteral(getValue(), pos);
+    case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
+      return SqlParserUtil.parseTimestampWithLocalTimeZoneLiteral(getValue(), pos);
+    default:
+      throw Util.unexpected(typeName);
+    }
+  }
+}
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlUtil.java b/core/src/main/java/org/apache/calcite/sql/SqlUtil.java
index ad7aae2dcf9..37c5afbe158 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlUtil.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlUtil.java
@@ -42,6 +42,7 @@
 import org.apache.calcite.util.BarfingInvocationHandler;
 import org.apache.calcite.util.ConversionUtil;
 import org.apache.calcite.util.Glossary;
+import org.apache.calcite.util.Litmus;
 import org.apache.calcite.util.NlsString;
 import org.apache.calcite.util.Pair;
 import org.apache.calcite.util.Util;
@@ -161,6 +162,18 @@ public static SqlNodeList toNodeList(SqlNode[] operands) {
     return ret;
   }
 
+  /** Finds the index of an expression in a list, comparing using
+   * {@link SqlNode#equalsDeep(SqlNode, Litmus)}. */
+  public static int indexOfDeep(List<? extends SqlNode> list, SqlNode e,
+      Litmus litmus) {
+    for (int i = 0; i < list.size(); i++) {
+      if (e.equalsDeep(list.get(i), litmus)) {
+        return i;
+      }
+    }
+    return -1;
+  }
+
   /**
    * Returns whether a node represents the NULL value.
    *
@@ -946,7 +959,7 @@ public static boolean isCallTo(SqlNode node, SqlOperator operator) {
   /**
    * Creates the type of an {@link org.apache.calcite.util.NlsString}.
    *
-   * <p>The type inherits the The NlsString's {@link Charset} and
+   * <p>The type inherits the NlsString's {@link Charset} and
    * {@link SqlCollation}, if they are set, otherwise it gets the system
    * defaults.
    *
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlWindowTableFunction.java b/core/src/main/java/org/apache/calcite/sql/SqlWindowTableFunction.java
index 3647dad6ab7..a17a1eb181e 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlWindowTableFunction.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlWindowTableFunction.java
@@ -142,10 +142,6 @@ protected abstract static class AbstractOperandMetadata
       return paramNames;
     }
 
-    @Override public Consistency getConsistency() {
-      return Consistency.NONE;
-    }
-
     @Override public boolean isOptional(int i) {
       return i > getOperandCountRange().getMin()
           && i <= getOperandCountRange().getMax();
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlWith.java b/core/src/main/java/org/apache/calcite/sql/SqlWith.java
index 06171be8c2c..091b65d8ff2 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlWith.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlWith.java
@@ -103,8 +103,9 @@ private SqlWithOperator() {
       }
       writer.endList(frame1);
       final SqlWriter.Frame frame2 =
-          writer.startList(SqlWriter.FrameTypeEnum.SIMPLE);
-      with.body.unparse(writer, 100, 100);
+          writer.startList(SqlWriter.FrameTypeEnum.WITH_BODY);
+      with.body.unparse(writer,
+          SqlWithOperator.INSTANCE.getLeftPrec(), SqlWithOperator.INSTANCE.getRightPrec());
       writer.endList(frame2);
       writer.endList(frame);
     }
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlWithItem.java b/core/src/main/java/org/apache/calcite/sql/SqlWithItem.java
index fe9de4f0b11..e68cc328f23 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlWithItem.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlWithItem.java
@@ -97,7 +97,7 @@ private static class SqlWithItemOperator extends SqlSpecialOperator {
         withItem.columnList.unparse(writer, getLeftPrec(), getRightPrec());
       }
       writer.keyword("AS");
-      withItem.query.unparse(writer, 10, 10);
+      withItem.query.unparse(writer, MDX_PRECEDENCE, MDX_PRECEDENCE);
     }
 
     @SuppressWarnings("argument.type.incompatible")
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlWithinGroupOperator.java b/core/src/main/java/org/apache/calcite/sql/SqlWithinGroupOperator.java
index 596d9518edd..d3359483228 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlWithinGroupOperator.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlWithinGroupOperator.java
@@ -19,10 +19,14 @@
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.sql.type.OperandTypes;
 import org.apache.calcite.sql.type.ReturnTypes;
+import org.apache.calcite.sql.type.SqlTypeUtil;
 import org.apache.calcite.sql.validate.SqlValidator;
+import org.apache.calcite.sql.validate.SqlValidatorNamespace;
 import org.apache.calcite.sql.validate.SqlValidatorScope;
 import org.apache.calcite.sql.validate.SqlValidatorUtil;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+
 import java.util.Objects;
 
 import static org.apache.calcite.util.Static.RESOURCE;
@@ -62,12 +66,13 @@ public SqlWithinGroupOperator() {
       SqlValidatorScope operandScope) {
     assert call.getOperator() == this;
     assert call.operandCount() == 2;
+
     final SqlValidatorUtil.FlatAggregate flat = SqlValidatorUtil.flatten(call);
-    if (!flat.aggregateCall.getOperator().isAggregator()) {
-      throw validator.newValidationError(call,
-          RESOURCE.withinGroupNotAllowed(
-              flat.aggregateCall.getOperator().getName()));
+    final SqlOperator operator = flat.aggregateCall.getOperator();
+    if (!operator.isAggregator()) {
+      throw validator.newValidationError(call, RESOURCE.withinGroupNotAllowed(operator.getName()));
     }
+
     for (SqlNode order : Objects.requireNonNull(flat.orderList)) {
       Objects.requireNonNull(validator.deriveType(scope, order));
     }
@@ -79,7 +84,50 @@ public SqlWithinGroupOperator() {
       SqlValidator validator,
       SqlValidatorScope scope,
       SqlCall call) {
-    // Validate type of the inner aggregate call
-    return validateOperands(validator, scope, call);
+
+    SqlCall inner = call.operand(0);
+    final SqlOperator operator = inner.getOperator();
+    if (!operator.isAggregator()) {
+      throw validator.newValidationError(call, RESOURCE.withinGroupNotAllowed(operator.getName()));
+    }
+
+    if (inner.getOperator().getKind() == SqlKind.PERCENTILE_DISC
+        || inner.getOperator().getKind() == SqlKind.PERCENTILE_CONT) {
+      // We first check the percentile call operands, and then derive the correct type using
+      // PercentileDiscCallBinding (See CALCITE-5230).
+      SqlCallBinding opBinding =
+          new PercentileDiscCallBinding(validator, scope, inner, getCollationColumn(call));
+      inner.getOperator().checkOperandTypes(opBinding, true);
+      RelDataType ret = inner.getOperator().inferReturnType(opBinding);
+      validator.setValidatedNodeType(inner, ret);
+      return ret;
+    } else {
+      return validateOperands(validator, scope, call);
+    }
+  }
+
+  private static SqlNode getCollationColumn(SqlCall call) {
+    return ((SqlNodeList) call.operand(1)).get(0);
+  }
+
+  /**
+   * Used for PERCENTILE_DISC return type inference.
+   */
+  public static class PercentileDiscCallBinding extends SqlCallBinding {
+    private final SqlNode collationColumn;
+
+    private PercentileDiscCallBinding(SqlValidator validator,
+        @Nullable SqlValidatorScope scope,
+        SqlCall call,
+        SqlNode collation) {
+      super(validator, scope, call);
+      this.collationColumn = collation;
+    }
+
+    @Override public RelDataType getCollationType() {
+      final RelDataType type = SqlTypeUtil.deriveType(this, collationColumn);
+      final SqlValidatorNamespace namespace = super.getValidator().getNamespace(collationColumn);
+      return namespace != null ? namespace.getType() : type;
+    }
   }
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlWriter.java b/core/src/main/java/org/apache/calcite/sql/SqlWriter.java
index 4eae8a165c2..9f846323026 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlWriter.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlWriter.java
@@ -149,6 +149,11 @@ enum FrameTypeEnum implements FrameType {
      */
     WITH,
 
+    /**
+     * The body query of WITH.
+     */
+    WITH_BODY,
+
     /**
      * OFFSET clause.
      *
diff --git a/core/src/main/java/org/apache/calcite/sql/TableCharacteristic.java b/core/src/main/java/org/apache/calcite/sql/TableCharacteristic.java
new file mode 100644
index 00000000000..c4afe538435
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/sql/TableCharacteristic.java
@@ -0,0 +1,357 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.sql;
+
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+import java.util.Objects;
+
+/**
+ * A table-valued input parameter of a table function is classified by three
+ * characteristics.
+
+ * <p>The first characteristic is semantics. The table has either
+ * row semantics or set semantics.
+ *
+ * <p>Row semantics means that the result of the table function is decided
+ * on a row-by-row basis.
+ *
+ * <p>Example of a table function with row semantics input table parameter:
+ * We often need to read a CSV file, generally, the first line of the file
+ * contains a list of column names, and subsequent lines of the file contain
+ * data. The data in general can be treated as a large VARCHAR.
+ * However, some of the fields may be numeric or datetime.
+ *
+ * <p>A table function named CSVReader is designed to read a file of
+ * comma-separated values and interpret this file as a table.
+ * The function has three parameters:
+ * <ul>
+ * <li>The first parameter, File, is the name of a file on the query author's
+ * system. This file must contain the comma-separated values that are to be
+ * converted to a table. The first line of the file contains the names of
+ * the resulting columns. Succeeding lines contain the data. Each line after
+ * the first will result in one row of output, with column names as determined
+ * by the first line of the input.
+ * <li>Floats is a descriptor area, which should provide a list of the
+ * column names that are to be interpreted numerically.
+ * These columns will be output with the data type FLOAT.
+ * <li>Dates is a descriptor area, which provides a list of the column
+ * names that are to be interpreted as datetimes.
+ * These columns will be output with the data type DATE.
+ * </ul>
+ *
+ * <p>How to use this table function in query?
+ *
+ * <p>For a csv file which contents are:
+ * <blockquote><pre>
+ * docno,name,due_date,principle,interest
+ * 123,Mary,01/01/2014,234.56,345.67
+ * 234,Edgar,01/01/2014,654.32,543.21
+ * </pre></blockquote>
+ *
+ * <p>The query author may write a query such as the following:
+ * <blockquote><pre>{@code
+ * SELECT *
+ * FROM TABLE (
+ *   CSVreader (
+ *   'abc.csv',
+ *   DESCRIPTOR ("principle", "interest")
+ *   DESCRIPTOR ("due_date")))
+ * }</pre></blockquote>
+ *
+ * <table>
+ * <caption>Results of the query</caption>
+ * <tr>
+ * <th>docno</th>
+ * <th>name</th>
+ * <th>due_date</th>
+ * <th>principle</th>
+ * <th>interest</th>
+ * </tr>
+ * <tr>
+ * <th>123</th>
+ * <th>Mary</th>
+ * <th>01/01/2014</th>
+ * <th>234.56</th>
+ * <th>345.67</th>
+ * </tr>
+ * <tr>
+ * <th>234</th>
+ * <th>Edgar</th>
+ * <th>01/01/2014</th>
+ * <th>654.32</th>
+ * <th>543.21</th>
+ * </tr>
+ * </table>
+ *
+ * <p>Set semantics means that the outcome of the function depends on how
+ * the data is partitioned. Set semantics is useful to implement user-defined
+ * analytics like aggregation or window functions.
+ * They operate on an entire table or a logical partition of it.
+ *
+ * <p>Example of a table function with set semantics input table parameter:
+ * TopN takes an input table that has been sorted on a numeric column.
+ * It copies the first n rows through to the output table. Any additional
+ * rows are summarized in a single output row in which the sort column has
+ * been summed and all other columns are null.
+ * TopN function has two parameters:
+ * <ul>
+ * <li>The first parameter, Input, is the input table. This table has set
+ * semantics, meaning that the result depends on the set of data (since the
+ * last row is a summary row). In addition, the table is marked as PRUNE WHEN
+ * EMPTY, meaning that the result is necessarily empty if the input is empty.
+ * The query author must order this input table on a single numeric column
+ * (syntax below).
+ * <li>The second parameter, Howmany, specifies how many input rows that the
+ * user wants to be copied into the output table; all rows after this will
+ * contribute to the final summary row in the output.
+ * </ul>
+ *
+ * <p>How to use this table function in query?
+ * <table>
+ * <caption>Original records of table orders</caption>
+ * <tr>
+ * <th>region</th>
+ * <th>product</th>
+ * <th>sales</th>
+ * </tr>
+ * <tr>
+ * <th>East</th>
+ * <th>A</th>
+ * <th>1234.56</th>
+ * </tr>
+ * <tr>
+ * <th>East</th>
+ * <th>B</th>
+ * <th>987.65</th>
+ * </tr>
+ * <tr>
+ * <th>East</th>
+ * <th>C</th>
+ * <th>876.54</th>
+ * </tr>
+ * <tr>
+ * <th>East</th>
+ * <th>D</th>
+ * <th>765.43</th>
+ * </tr>
+ * <tr>
+ * <th>East</th>
+ * <th>E</th>
+ * <th>654.32</th>
+ * </tr>
+ * <tr>
+ * <th>West</th>
+ * <th>E</th>
+ * <th>2345.67</th>
+ * </tr>
+ * <tr>
+ * <th>West</th>
+ * <th>D</th>
+ * <th>2001.33</th>
+ * </tr>
+ * <tr>
+ * <th>West</th>
+ * <th>C</th>
+ * <th>1357.99</th>
+ * </tr>
+ * <tr>
+ * <th>West</th>
+ * <th>B</th>
+ * <th>975.35</th>
+ * </tr>
+ * <tr>
+ * <th>West</th>
+ * <th>A</th>
+ * <th>864,22</th>
+ * </tr>
+ * </table>
+ *
+ * <p>The query author may write a query such as the following:
+ * <blockquote><pre>{@code
+ * SELECT *
+ * FROM TABLE(
+ *   Topn(
+ *     TABLE orders PARTITION BY region ORDER BY sales desc,
+ *     3))
+ * }</pre></blockquote>
+ *
+ * <p>The result will be:
+ * <table>
+ * <caption>Original records of table orders</caption>
+ * <tr>
+ * <th>region</th>
+ * <th>product</th>
+ * <th>sales</th>
+ * </tr>
+ * <tr>
+ * <th>East</th>
+ * <th>A</th>
+ * <th>1234.56</th>
+ * </tr>
+ * <tr>
+ * <th>East</th>
+ * <th>B</th>
+ * <th>987.65</th>
+ * </tr>
+ * <tr>
+ * <th>East</th>
+ * <th>C</th>
+ * <th>876.54</th>
+ * </tr>
+ * <tr>
+ * <th>West</th>
+ * <th>E</th>
+ * <th>2345.67</th>
+ * </tr>
+ * <tr>
+ * <th>West</th>
+ * <th>D</th>
+ * <th>2001.33</th>
+ * </tr>
+ * <tr>
+ * <th>West</th>
+ * <th>C</th>
+ * <th>1357.99</th>
+ * </tr>
+ * </table>
+ *
+ * <p>The second characteristic of input table parameter only applies to input
+ * table with set semantics. It specifies whether the table function can
+ * generate a result row even if the input table is empty.
+ *
+ * <p>The third characteristic is whether the input table supports
+ * pass-through columns or not.
+ */
+public class TableCharacteristic {
+
+  /**
+   * Input table has either row semantics or set semantics.
+   */
+  public final Semantics semantics;
+
+  /**
+   * If the value is true, meaning that the DBMS can prune virtual processors
+   * from the query plan if the input table is empty.
+   * If the value is false, meaning that the DBMS must actually instantiate
+   * a virtual processor (or more than one virtual processor in the presence
+   * of other input tables).
+   */
+  public final boolean pruneIfEmpty;
+
+  /**
+   * If the value is true, for each input row, the table function makes the
+   * entire input row available in the output, qualified by a range variable
+   * associated with the input table. Otherwise the value is false.
+   */
+  public final boolean passColumnsThrough;
+
+  private TableCharacteristic(
+      Semantics semantics,
+      boolean pruneIfEmpty,
+      boolean passColumnsThrough) {
+    this.semantics = semantics;
+    this.pruneIfEmpty = pruneIfEmpty;
+    this.passColumnsThrough = passColumnsThrough;
+  }
+
+  /** Creates a builder. */
+  public static TableCharacteristic.Builder builder(Semantics semantics) {
+    return new Builder(semantics);
+  }
+
+  @Override public boolean equals(@Nullable Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    TableCharacteristic that = (TableCharacteristic) o;
+    return pruneIfEmpty == that.pruneIfEmpty
+        && passColumnsThrough == that.passColumnsThrough
+        && semantics == that.semantics;
+  }
+
+  @Override public int hashCode() {
+    return Objects.hash(semantics, pruneIfEmpty, passColumnsThrough);
+  }
+
+  @Override public String toString() {
+    return "TableCharacteristic{"
+        + "semantics=" + semantics
+        + ", pruneIfEmpty=" + pruneIfEmpty
+        + ", passColumnsThrough=" + passColumnsThrough
+        + '}';
+  }
+
+  /**
+   * Input table has either row semantics or set semantics.
+   */
+  public enum Semantics {
+    /**
+     * Row semantics means that the result of the Window TableFunction
+     * is decided on a row-by-row basis.
+     * As an extreme example, the DBMS could atomize the input table into
+     * individual rows, and send each single row to a different virtual
+     * processor.
+     */
+    ROW,
+
+    /**
+     * Set semantics means that the outcome of the Window TableFunction
+     * depends on how the data is partitioned.
+     * A partition may not be split across virtual processors, nor may a
+     * virtual processor handle more than one partition.
+     */
+    SET
+  }
+
+  /**
+   * Builder for {@link TableCharacteristic}.
+   */
+  public static class Builder {
+    private final Semantics semantics;
+    private boolean pruneIfEmpty = false;
+    private boolean passColumnsThrough = false;
+
+    /** Creates the semantics. */
+    private Builder(Semantics semantics) {
+      if (semantics == Semantics.ROW) {
+        // Tables with row semantics are always effectively prune when empty.
+        this.pruneIfEmpty = true;
+      }
+      this.semantics = semantics;
+    }
+
+    /** DBMS could prune virtual processors if the input table is empty. */
+    public Builder pruneIfEmpty() {
+      this.pruneIfEmpty = true;
+      return this;
+    }
+
+    /** Input table supports pass-through columns. */
+    public Builder passColumnsThrough() {
+      this.passColumnsThrough = true;
+      return this;
+    }
+
+    public TableCharacteristic build() {
+      return new TableCharacteristic(semantics, pruneIfEmpty, passColumnsThrough);
+    }
+  }
+}
diff --git a/core/src/main/java/org/apache/calcite/sql/advise/SqlAdvisor.java b/core/src/main/java/org/apache/calcite/sql/advise/SqlAdvisor.java
index fad6f19a11e..b81170988db 100644
--- a/core/src/main/java/org/apache/calcite/sql/advise/SqlAdvisor.java
+++ b/core/src/main/java/org/apache/calcite/sql/advise/SqlAdvisor.java
@@ -48,12 +48,13 @@
 import java.util.Collections;
 import java.util.List;
 import java.util.Locale;
-import java.util.Objects;
 import java.util.Set;
 import java.util.TreeSet;
 
 import static org.apache.calcite.linq4j.Nullness.castNonNull;
 
+import static java.util.Objects.requireNonNull;
+
 /**
  * An assistant which offers hints and corrections to a partially-formed SQL
  * statement. It is used in the SQL editor user-interface.
@@ -369,11 +370,12 @@ public List<SqlMoniker> getCompletionHints(String sql, SqlParserPos pos) {
 
   private static boolean isSelectListItem(SqlNode root,
       final SqlParserPos pos, String hintToken) {
-    List<SqlNode> nodes = SqlUtil.getAncestry(root,
-        input -> input instanceof SqlIdentifier
-            && ((SqlIdentifier) input).names.contains(hintToken),
-        input -> Objects.requireNonNull(input, "input").getParserPosition()
-            .startsAt(pos));
+    List<SqlNode> nodes =
+        SqlUtil.getAncestry(root,
+            input -> input instanceof SqlIdentifier
+                && ((SqlIdentifier) input).names.contains(hintToken),
+            input -> requireNonNull(input, "input")
+                .getParserPosition().startsAt(pos));
     assert nodes.get(0) == root;
     nodes = Lists.reverse(nodes);
     return nodes.size() > 2
diff --git a/core/src/main/java/org/apache/calcite/sql/advise/SqlAdvisorGetHintsFunction.java b/core/src/main/java/org/apache/calcite/sql/advise/SqlAdvisorGetHintsFunction.java
index 3d0369f2219..d49478ad6bc 100644
--- a/core/src/main/java/org/apache/calcite/sql/advise/SqlAdvisorGetHintsFunction.java
+++ b/core/src/main/java/org/apache/calcite/sql/advise/SqlAdvisorGetHintsFunction.java
@@ -104,8 +104,8 @@ public class SqlAdvisorGetHintsFunction
   public static Enumerable<SqlAdvisorHint> getCompletionHints(
       final SqlAdvisor advisor, final String sql, final int pos) {
     final String[] replaced = new String[1];
-    final List<SqlMoniker> hints = advisor.getCompletionHints(sql,
-        pos, replaced);
+    final List<SqlMoniker> hints =
+        advisor.getCompletionHints(sql, pos, replaced);
     final List<SqlAdvisorHint> res = new ArrayList<>(hints.size() + 1);
     res.add(new SqlAdvisorHint(replaced[0], null, "MATCH"));
     for (SqlMoniker hint : hints) {
diff --git a/core/src/main/java/org/apache/calcite/sql/advise/SqlAdvisorGetHintsFunction2.java b/core/src/main/java/org/apache/calcite/sql/advise/SqlAdvisorGetHintsFunction2.java
index 4f593ab632f..1f5fe1a3607 100644
--- a/core/src/main/java/org/apache/calcite/sql/advise/SqlAdvisorGetHintsFunction2.java
+++ b/core/src/main/java/org/apache/calcite/sql/advise/SqlAdvisorGetHintsFunction2.java
@@ -106,8 +106,8 @@ public class SqlAdvisorGetHintsFunction2
   public static Enumerable<SqlAdvisorHint2> getCompletionHints(
       final SqlAdvisor advisor, final String sql, final int pos) {
     final String[] replaced = new String[1];
-    final List<SqlMoniker> hints = advisor.getCompletionHints(sql,
-        pos, replaced);
+    final List<SqlMoniker> hints =
+        advisor.getCompletionHints(sql, pos, replaced);
     final List<SqlAdvisorHint2> res = new ArrayList<>(hints.size() + 1);
     res.add(new SqlAdvisorHint2(replaced[0], null, "MATCH", null));
 
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 df38d9c3a9e..f5d963a4c13 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
@@ -43,6 +43,8 @@
 import org.apache.calcite.sql.type.BasicSqlType;
 import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.sql.type.SqlTypeUtil;
+import org.apache.calcite.util.format.FormatModel;
+import org.apache.calcite.util.format.FormatModels;
 
 import com.google.common.collect.ImmutableList;
 
@@ -271,6 +273,15 @@ private static TimeUnit validate(TimeUnit timeUnit) {
     }
   }
 
+  /**
+   * {@inheritDoc}
+   *
+   * @see FormatModels#BIG_QUERY
+   */
+  @Override public FormatModel getFormatModel() {
+    return FormatModels.BIG_QUERY;
+  }
+
   /** {@inheritDoc}
    *
    * <p>BigQuery data type reference:
@@ -316,16 +327,16 @@ private static TimeUnit validate(TimeUnit timeUnit) {
 
   private static SqlDataTypeSpec createSqlDataTypeSpecByName(String typeAlias,
       SqlTypeName typeName) {
-    SqlAlienSystemTypeNameSpec typeNameSpec = new SqlAlienSystemTypeNameSpec(
-        typeAlias, typeName, SqlParserPos.ZERO);
+    SqlAlienSystemTypeNameSpec typeNameSpec =
+        new SqlAlienSystemTypeNameSpec(typeAlias, typeName, SqlParserPos.ZERO);
     return new SqlDataTypeSpec(typeNameSpec, SqlParserPos.ZERO);
   }
 
   /**
    * List of BigQuery Specific Operators needed to form Syntactically Correct SQL.
    */
-  private static final SqlOperator UNION_DISTINCT = new SqlSetOperator(
-      "UNION DISTINCT", SqlKind.UNION, 14, false);
+  private static final SqlOperator UNION_DISTINCT =
+      new SqlSetOperator("UNION DISTINCT", SqlKind.UNION, 14, false);
 
   private static final SqlSetOperator EXCEPT_DISTINCT =
       new SqlSetOperator("EXCEPT DISTINCT", SqlKind.EXCEPT, 14, false);
diff --git a/core/src/main/java/org/apache/calcite/sql/dialect/FireboltSqlDialect.java b/core/src/main/java/org/apache/calcite/sql/dialect/FireboltSqlDialect.java
index 71ca1318753..4c5e4aad207 100644
--- a/core/src/main/java/org/apache/calcite/sql/dialect/FireboltSqlDialect.java
+++ b/core/src/main/java/org/apache/calcite/sql/dialect/FireboltSqlDialect.java
@@ -16,13 +16,17 @@
  */
 package org.apache.calcite.sql.dialect;
 
+import org.apache.calcite.avatica.util.TimeUnit;
 import org.apache.calcite.avatica.util.TimeUnitRange;
 import org.apache.calcite.config.NullCollation;
 import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.rel.type.RelDataTypeSystem;
 import org.apache.calcite.sql.SqlAlienSystemTypeNameSpec;
 import org.apache.calcite.sql.SqlCall;
 import org.apache.calcite.sql.SqlDataTypeSpec;
 import org.apache.calcite.sql.SqlDialect;
+import org.apache.calcite.sql.SqlIntervalLiteral;
+import org.apache.calcite.sql.SqlIntervalQualifier;
 import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.SqlLiteral;
 import org.apache.calcite.sql.SqlNode;
@@ -158,6 +162,10 @@ public FireboltSqlDialect(Context context) {
         SqlParserPos.ZERO);
   }
 
+  @Override public boolean supportsAggregateFunctionFilter() {
+    return false;
+  }
+
   @Override public boolean supportsFunction(SqlOperator operator,
       RelDataType type, final List<RelDataType> paramTypes) {
     switch (operator.kind) {
@@ -186,8 +194,9 @@ public FireboltSqlDialect(Context context) {
         final SqlLiteral timeUnitNode = call.operand(1);
         final TimeUnitRange timeUnit = timeUnitNode.getValueAs(TimeUnitRange.class);
 
-        SqlCall call2 = SqlFloorFunction.replaceTimeUnitOperand(call, timeUnit.name(),
-            timeUnitNode.getParserPosition());
+        SqlCall call2 =
+            SqlFloorFunction.replaceTimeUnitOperand(call, timeUnit.name(),
+                timeUnitNode.getParserPosition());
         SqlFloorFunction.unparseDatetimeFunction(writer, call2, "DATE_TRUNC", false);
         break;
 
@@ -196,4 +205,53 @@ public FireboltSqlDialect(Context context) {
       }
     }
   }
+
+  /** Firebolt interval syntax: sign INTERVAL int64 time_unit. */
+  @Override public void unparseSqlIntervalLiteral(SqlWriter writer,
+      SqlIntervalLiteral literal, int leftPrec, int rightPrec) {
+    SqlIntervalLiteral.IntervalValue interval =
+        literal.getValueAs(SqlIntervalLiteral.IntervalValue.class);
+    writer.keyword("INTERVAL");
+    writer.print("'");
+    try {
+      Long.parseLong(interval.getIntervalLiteral());
+    } catch (NumberFormatException e) {
+      throw new RuntimeException("Only INT64 is supported as the interval value for Firebolt.");
+    }
+    writer.literal(interval.getIntervalLiteral());
+    unparseSqlIntervalQualifier(writer, interval.getIntervalQualifier(),
+        RelDataTypeSystem.DEFAULT);
+    writer.print("'");
+  }
+
+  @Override public void unparseSqlIntervalQualifier(
+      SqlWriter writer, SqlIntervalQualifier qualifier, RelDataTypeSystem typeSystem) {
+    final String start = validate(qualifier.timeUnitRange.startUnit).name();
+    if (qualifier.timeUnitRange.endUnit == null) {
+      writer.keyword(start);
+    } else {
+      throw new RuntimeException("Range time unit is not supported for Firebolt.");
+    }
+  }
+
+  private static TimeUnit validate(TimeUnit timeUnit) {
+    switch (timeUnit) {
+    case MICROSECOND:
+    case MILLISECOND:
+    case SECOND:
+    case MINUTE:
+    case HOUR:
+    case DAY:
+    case WEEK:
+    case MONTH:
+    case YEAR:
+    case DECADE:
+    case CENTURY:
+    case MILLENNIUM:
+      return timeUnit;
+    default:
+      throw new RuntimeException("Time unit " + timeUnit + " is not supported for Firebolt.");
+    }
+  }
+
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/dialect/HiveSqlDialect.java b/core/src/main/java/org/apache/calcite/sql/dialect/HiveSqlDialect.java
index 21fcbdf3ad7..3762972cf60 100644
--- a/core/src/main/java/org/apache/calcite/sql/dialect/HiveSqlDialect.java
+++ b/core/src/main/java/org/apache/calcite/sql/dialect/HiveSqlDialect.java
@@ -143,8 +143,9 @@ public HiveSqlDialect(Context context) {
     if (type instanceof BasicSqlType) {
       switch (type.getSqlTypeName()) {
       case INTEGER:
-        SqlAlienSystemTypeNameSpec typeNameSpec = new SqlAlienSystemTypeNameSpec(
-            "INT", type.getSqlTypeName(), SqlParserPos.ZERO);
+        SqlAlienSystemTypeNameSpec typeNameSpec =
+            new SqlAlienSystemTypeNameSpec("INT", type.getSqlTypeName(),
+                SqlParserPos.ZERO);
         return new SqlDataTypeSpec(typeNameSpec, SqlParserPos.ZERO);
       default:
         break;
diff --git a/core/src/main/java/org/apache/calcite/sql/dialect/HsqldbSqlDialect.java b/core/src/main/java/org/apache/calcite/sql/dialect/HsqldbSqlDialect.java
index b509ea5d38f..b1c8fc5be63 100644
--- a/core/src/main/java/org/apache/calcite/sql/dialect/HsqldbSqlDialect.java
+++ b/core/src/main/java/org/apache/calcite/sql/dialect/HsqldbSqlDialect.java
@@ -70,8 +70,9 @@ public HsqldbSqlDialect(Context context) {
       final TimeUnitRange timeUnit = timeUnitNode.getValueAs(TimeUnitRange.class);
 
       final String translatedLit = convertTimeUnit(timeUnit);
-      SqlCall call2 = SqlFloorFunction.replaceTimeUnitOperand(call, translatedLit,
-          timeUnitNode.getParserPosition());
+      SqlCall call2 =
+          SqlFloorFunction.replaceTimeUnitOperand(call, translatedLit,
+              timeUnitNode.getParserPosition());
       SqlFloorFunction.unparseDatetimeFunction(writer, call2, "TRUNC", true);
       break;
 
@@ -88,8 +89,9 @@ public HsqldbSqlDialect(Context context) {
   @Override public SqlNode rewriteSingleValueExpr(SqlNode aggCall) {
     final SqlNode operand = ((SqlBasicCall) aggCall).operand(0);
     final SqlLiteral nullLiteral = SqlLiteral.createNull(SqlParserPos.ZERO);
-    final SqlNode unionOperand = SqlStdOperatorTable.VALUES.createCall(SqlParserPos.ZERO,
-        SqlLiteral.createApproxNumeric("0", SqlParserPos.ZERO));
+    final SqlNode unionOperand =
+        SqlStdOperatorTable.VALUES.createCall(SqlParserPos.ZERO,
+            SqlLiteral.createApproxNumeric("0", SqlParserPos.ZERO));
     // For hsqldb, generate
     //   CASE COUNT(*)
     //   WHEN 0 THEN NULL
diff --git a/core/src/main/java/org/apache/calcite/sql/dialect/JethroDataSqlDialect.java b/core/src/main/java/org/apache/calcite/sql/dialect/JethroDataSqlDialect.java
index e2489c993b2..40790acb57b 100644
--- a/core/src/main/java/org/apache/calcite/sql/dialect/JethroDataSqlDialect.java
+++ b/core/src/main/java/org/apache/calcite/sql/dialect/JethroDataSqlDialect.java
@@ -38,9 +38,10 @@
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
-import java.util.Objects;
 import java.util.Set;
 
+import static java.util.Objects.requireNonNull;
+
 /**
  * A <code>SqlDialect</code> implementation for the JethroData database.
  */
@@ -128,7 +129,7 @@ static class JethroSupportedFunction {
     private final List<SqlTypeName> operandTypes;
 
     JethroSupportedFunction(String name, String operands) {
-      Objects.requireNonNull(name, "name"); // not currently used
+      requireNonNull(name, "name"); // not currently used
       final ImmutableList.Builder<SqlTypeName> b = ImmutableList.builder();
       for (String strType : operands.split(":")) {
         b.add(parse(strType));
@@ -205,12 +206,11 @@ private static JethroInfo makeInfo(Connection jethroConnection) {
         final Multimap<String, JethroSupportedFunction> supportedFunctions =
             LinkedHashMultimap.create();
         while (functionsTupleSet.next()) {
-          String functionName = Objects.requireNonNull(
-              functionsTupleSet.getString(1),
-              "functionName");
-          String operandsType = Objects.requireNonNull(
-              functionsTupleSet.getString(3),
-              () -> "operands for " + functionName);
+          String functionName =
+              requireNonNull(functionsTupleSet.getString(1), "functionName");
+          String operandsType =
+              requireNonNull(functionsTupleSet.getString(3),
+                  () -> "operands for " + functionName);
           supportedFunctions.put(functionName,
               new JethroSupportedFunction(functionName, operandsType));
         }
@@ -227,8 +227,8 @@ private static JethroInfo makeInfo(Connection jethroConnection) {
 
   /** Information about the capabilities of a Jethro database. */
   public static class JethroInfo {
-    public static final JethroInfo EMPTY = new JethroInfo(
-        ImmutableSetMultimap.of());
+    public static final JethroInfo EMPTY =
+        new JethroInfo(ImmutableSetMultimap.of());
 
     private final ImmutableSetMultimap<String, JethroSupportedFunction> supportedFunctions;
 
diff --git a/core/src/main/java/org/apache/calcite/sql/dialect/MssqlSqlDialect.java b/core/src/main/java/org/apache/calcite/sql/dialect/MssqlSqlDialect.java
index b59bb29289e..0a168a10506 100644
--- a/core/src/main/java/org/apache/calcite/sql/dialect/MssqlSqlDialect.java
+++ b/core/src/main/java/org/apache/calcite/sql/dialect/MssqlSqlDialect.java
@@ -20,6 +20,7 @@
 import org.apache.calcite.config.NullCollation;
 import org.apache.calcite.rel.type.RelDataTypeSystem;
 import org.apache.calcite.sql.SqlAbstractDateTimeLiteral;
+import org.apache.calcite.sql.SqlBasicFunction;
 import org.apache.calcite.sql.SqlCall;
 import org.apache.calcite.sql.SqlDialect;
 import org.apache.calcite.sql.SqlFunction;
@@ -34,6 +35,7 @@
 import org.apache.calcite.sql.SqlWriter;
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
 import org.apache.calcite.sql.parser.SqlParserPos;
+import org.apache.calcite.sql.type.OperandTypes;
 import org.apache.calcite.sql.type.ReturnTypes;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
@@ -54,9 +56,8 @@ public class MssqlSqlDialect extends SqlDialect {
   public static final SqlDialect DEFAULT = new MssqlSqlDialect(DEFAULT_CONTEXT);
 
   private static final SqlFunction MSSQL_SUBSTRING =
-      new SqlFunction("SUBSTRING", SqlKind.OTHER_FUNCTION,
-          ReturnTypes.ARG0_NULLABLE_VARYING, null, null,
-          SqlFunctionCategory.STRING);
+      SqlBasicFunction.create("SUBSTRING", ReturnTypes.ARG0_NULLABLE_VARYING,
+          OperandTypes.VARIADIC, SqlFunctionCategory.STRING);
 
   /** Whether to generate "SELECT TOP(fetch)" rather than
    * "SELECT ... FETCH NEXT fetch ROWS ONLY". */
diff --git a/core/src/main/java/org/apache/calcite/sql/dialect/MysqlSqlDialect.java b/core/src/main/java/org/apache/calcite/sql/dialect/MysqlSqlDialect.java
index be1c8ef5012..fb3cf64c255 100644
--- a/core/src/main/java/org/apache/calcite/sql/dialect/MysqlSqlDialect.java
+++ b/core/src/main/java/org/apache/calcite/sql/dialect/MysqlSqlDialect.java
@@ -26,12 +26,12 @@
 import org.apache.calcite.rel.type.RelDataTypeSystemImpl;
 import org.apache.calcite.sql.SqlAlienSystemTypeNameSpec;
 import org.apache.calcite.sql.SqlBasicCall;
+import org.apache.calcite.sql.SqlBasicFunction;
 import org.apache.calcite.sql.SqlBasicTypeNameSpec;
 import org.apache.calcite.sql.SqlCall;
 import org.apache.calcite.sql.SqlDataTypeSpec;
 import org.apache.calcite.sql.SqlDialect;
 import org.apache.calcite.sql.SqlFunction;
-import org.apache.calcite.sql.SqlFunctionCategory;
 import org.apache.calcite.sql.SqlIntervalQualifier;
 import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.SqlLiteral;
@@ -40,15 +40,20 @@
 import org.apache.calcite.sql.SqlSelect;
 import org.apache.calcite.sql.SqlWriter;
 import org.apache.calcite.sql.fun.SqlCase;
+import org.apache.calcite.sql.fun.SqlInternalOperators;
+import org.apache.calcite.sql.fun.SqlLibraryOperators;
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
 import org.apache.calcite.sql.parser.SqlParserPos;
-import org.apache.calcite.sql.type.InferTypes;
 import org.apache.calcite.sql.type.OperandTypes;
 import org.apache.calcite.sql.type.ReturnTypes;
 import org.apache.calcite.sql.type.SqlTypeName;
 
+import com.google.common.collect.ImmutableList;
+
 import org.checkerframework.checker.nullness.qual.Nullable;
 
+import java.util.List;
+
 /**
  * A <code>SqlDialect</code> implementation for the MySQL database.
  */
@@ -82,9 +87,7 @@ public class MysqlSqlDialect extends SqlDialect {
 
   /** MySQL specific function. */
   public static final SqlFunction ISNULL_FUNCTION =
-      new SqlFunction("ISNULL", SqlKind.OTHER_FUNCTION,
-          ReturnTypes.BOOLEAN, InferTypes.FIRST_KNOWN,
-          OperandTypes.ANY, SqlFunctionCategory.SYSTEM);
+      SqlBasicFunction.create("ISNULL", ReturnTypes.BOOLEAN, OperandTypes.ANY);
 
   private final int majorVersion;
 
@@ -184,9 +187,10 @@ public MysqlSqlDialect(Context context) {
   @Override public SqlNode rewriteSingleValueExpr(SqlNode aggCall) {
     final SqlNode operand = ((SqlBasicCall) aggCall).operand(0);
     final SqlLiteral nullLiteral = SqlLiteral.createNull(SqlParserPos.ZERO);
-    final SqlNode unionOperand = new SqlSelect(SqlParserPos.ZERO, SqlNodeList.EMPTY,
-        SqlNodeList.of(nullLiteral), null, null, null, null,
-        SqlNodeList.EMPTY, null, null, null, SqlNodeList.EMPTY);
+    final SqlNode unionOperand =
+        new SqlSelect(SqlParserPos.ZERO, SqlNodeList.EMPTY,
+            SqlNodeList.of(nullLiteral), null, null, null, null,
+            SqlNodeList.EMPTY, null, null, null, null, SqlNodeList.EMPTY);
     // For MySQL, generate
     //   CASE COUNT(*)
     //   WHEN 0 THEN NULL
@@ -223,11 +227,66 @@ public MysqlSqlDialect(Context context) {
       unparseFloor(writer, call);
       break;
 
+    case WITHIN_GROUP:
+      final List<SqlNode> operands = call.getOperandList();
+      if (operands.size() <= 0 || operands.get(0).getKind() != SqlKind.LISTAGG) {
+        super.unparseCall(writer, call, leftPrec, rightPrec);
+        return;
+      }
+      unparseListAggCall(writer, (SqlCall) operands.get(0),
+          operands.size() == 2 ? operands.get(1) : null, leftPrec, rightPrec);
+      break;
+
+    case LISTAGG:
+      unparseListAggCall(writer, call, null, leftPrec, rightPrec);
+      break;
+
     default:
       super.unparseCall(writer, call, leftPrec, rightPrec);
     }
   }
 
+  /**
+   * Unparses LISTAGG for MySQL. This call is translated to GROUP_CONCAT.
+   *
+   * <p>For example:
+   * <ul>
+   * <li>source:
+   *   <code>LISTAGG(DISTINCT c1, ',') WITHIN GROUP (ORDER BY c2, c3)</code>
+   * <li>target:
+   *   <code>GROUP_CONCAT(DISTINCT c1 ORDER BY c2, c3 SEPARATOR ',')</code>
+   * </ul>
+   *
+   * @param writer Writer
+   * @param call Call to LISTAGG
+   * @param orderItemNode Elements of WITHIN_GROUP; null means no elements in
+   *                     the WITHIN_GROUP
+   * @param leftPrec Left precedence
+   * @param rightPrec Right precedence
+   */
+  private static void unparseListAggCall(SqlWriter writer, SqlCall call,
+      @Nullable SqlNode orderItemNode, int leftPrec, int rightPrec) {
+    final List<SqlNode> listAggCallOperands = call.getOperandList();
+    final boolean separatorExist = listAggCallOperands.size() == 2;
+
+    final ImmutableList.Builder<SqlNode> newOperandListBuilder =
+        ImmutableList.builder();
+    newOperandListBuilder.add(listAggCallOperands.get(0));
+    if (orderItemNode != null) {
+      newOperandListBuilder.add(orderItemNode);
+    }
+    if (separatorExist) {
+      newOperandListBuilder.add(
+          SqlInternalOperators.SEPARATOR.createCall(SqlParserPos.ZERO,
+              listAggCallOperands.get(1)));
+    }
+    final SqlCall call2 =
+        SqlLibraryOperators.GROUP_CONCAT.createCall(
+            call.getFunctionQuantifier(), call.getParserPosition(),
+            newOperandListBuilder.build());
+    call2.unparse(writer, leftPrec, rightPrec);
+  }
+
   /**
    * Unparses datetime floor for MySQL. There is no TRUNC function, so simulate
    * this using calls to DATE_FORMAT.
diff --git a/core/src/main/java/org/apache/calcite/sql/dialect/OracleSqlDialect.java b/core/src/main/java/org/apache/calcite/sql/dialect/OracleSqlDialect.java
index 1865d51d4ea..790028ea914 100644
--- a/core/src/main/java/org/apache/calcite/sql/dialect/OracleSqlDialect.java
+++ b/core/src/main/java/org/apache/calcite/sql/dialect/OracleSqlDialect.java
@@ -159,8 +159,9 @@ public OracleSqlDialect(Context context) {
         final SqlLiteral timeUnitNode = call.operand(1);
         final TimeUnitRange timeUnit = timeUnitNode.getValueAs(TimeUnitRange.class);
 
-        SqlCall call2 = SqlFloorFunction.replaceTimeUnitOperand(call, timeUnit.name(),
-            timeUnitNode.getParserPosition());
+        SqlCall call2 =
+            SqlFloorFunction.replaceTimeUnitOperand(call, timeUnit.name(),
+                timeUnitNode.getParserPosition());
         SqlFloorFunction.unparseDatetimeFunction(writer, call2, "TRUNC", true);
         break;
 
diff --git a/core/src/main/java/org/apache/calcite/sql/dialect/PostgresqlSqlDialect.java b/core/src/main/java/org/apache/calcite/sql/dialect/PostgresqlSqlDialect.java
index db225546217..ac2307a0145 100644
--- a/core/src/main/java/org/apache/calcite/sql/dialect/PostgresqlSqlDialect.java
+++ b/core/src/main/java/org/apache/calcite/sql/dialect/PostgresqlSqlDialect.java
@@ -128,8 +128,9 @@ public PostgresqlSqlDialect(Context context) {
       final SqlLiteral timeUnitNode = call.operand(1);
       final TimeUnitRange timeUnit = timeUnitNode.getValueAs(TimeUnitRange.class);
 
-      SqlCall call2 = SqlFloorFunction.replaceTimeUnitOperand(call, timeUnit.name(),
-          timeUnitNode.getParserPosition());
+      SqlCall call2 =
+          SqlFloorFunction.replaceTimeUnitOperand(call, timeUnit.name(),
+              timeUnitNode.getParserPosition());
       SqlFloorFunction.unparseDatetimeFunction(writer, call2, "DATE_TRUNC", false);
       break;
 
diff --git a/core/src/main/java/org/apache/calcite/sql/dialect/SparkSqlDialect.java b/core/src/main/java/org/apache/calcite/sql/dialect/SparkSqlDialect.java
index 2bee3125e67..4c3aa6abd5e 100644
--- a/core/src/main/java/org/apache/calcite/sql/dialect/SparkSqlDialect.java
+++ b/core/src/main/java/org/apache/calcite/sql/dialect/SparkSqlDialect.java
@@ -19,6 +19,7 @@
 import org.apache.calcite.avatica.util.TimeUnitRange;
 import org.apache.calcite.config.NullCollation;
 import org.apache.calcite.sql.JoinType;
+import org.apache.calcite.sql.SqlBasicFunction;
 import org.apache.calcite.sql.SqlCall;
 import org.apache.calcite.sql.SqlDialect;
 import org.apache.calcite.sql.SqlFunction;
@@ -30,6 +31,7 @@
 import org.apache.calcite.sql.SqlWriter;
 import org.apache.calcite.sql.fun.SqlFloorFunction;
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
+import org.apache.calcite.sql.type.OperandTypes;
 import org.apache.calcite.sql.type.ReturnTypes;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
@@ -47,9 +49,8 @@ public class SparkSqlDialect extends SqlDialect {
   public static final SqlDialect DEFAULT = new SparkSqlDialect(DEFAULT_CONTEXT);
 
   private static final SqlFunction SPARKSQL_SUBSTRING =
-      new SqlFunction("SUBSTRING", SqlKind.OTHER_FUNCTION,
-          ReturnTypes.ARG0_NULLABLE_VARYING, null, null,
-          SqlFunctionCategory.STRING);
+      SqlBasicFunction.create("SUBSTRING", ReturnTypes.ARG0_NULLABLE_VARYING,
+          OperandTypes.VARIADIC, SqlFunctionCategory.STRING);
 
   /**
    * Creates a SparkSqlDialect.
@@ -78,6 +79,23 @@ public SparkSqlDialect(SqlDialect.Context context) {
     return false;
   }
 
+  @Override public boolean supportsAggregateFunction(SqlKind kind) {
+    switch (kind) {
+    case AVG:
+    case COUNT:
+    case CUBE:
+    case SUM:
+    case SUM0:
+    case MIN:
+    case MAX:
+    case ROLLUP:
+      return true;
+    default:
+      break;
+    }
+    return false;
+  }
+
   @Override public boolean supportsApproxCountDistinct() {
     return true;
   }
@@ -97,6 +115,21 @@ public SparkSqlDialect(SqlDialect.Context context) {
       SqlUtil.unparseFunctionSyntax(SPARKSQL_SUBSTRING, writer, call, false);
     } else {
       switch (call.getKind()) {
+      case ARRAY_VALUE_CONSTRUCTOR:
+      case MAP_VALUE_CONSTRUCTOR:
+        final String keyword =
+            call.getKind() == SqlKind.ARRAY_VALUE_CONSTRUCTOR ? "array" : "map";
+
+        writer.keyword(keyword);
+
+        final SqlWriter.Frame frame = writer.startList("(", ")");
+        for (SqlNode operand : call.getOperandList()) {
+          writer.sep(",");
+          operand.unparse(writer, leftPrec, rightPrec);
+        }
+        writer.endList(frame);
+        break;
+
       case FLOOR:
         if (call.operandCount() != 2) {
           super.unparseCall(writer, call, leftPrec, rightPrec);
@@ -106,8 +139,9 @@ public SparkSqlDialect(SqlDialect.Context context) {
         final SqlLiteral timeUnitNode = call.operand(1);
         final TimeUnitRange timeUnit = timeUnitNode.getValueAs(TimeUnitRange.class);
 
-        SqlCall call2 = SqlFloorFunction.replaceTimeUnitOperand(call, timeUnit.name(),
-            timeUnitNode.getParserPosition());
+        SqlCall call2 =
+            SqlFloorFunction.replaceTimeUnitOperand(call, timeUnit.name(),
+                timeUnitNode.getParserPosition());
         SqlFloorFunction.unparseDatetimeFunction(writer, call2, "DATE_TRUNC", false);
         break;
       case TRIM:
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlAbstractTimeFunction.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlAbstractTimeFunction.java
index 4b445565361..80e77b8d0c6 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlAbstractTimeFunction.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlAbstractTimeFunction.java
@@ -38,8 +38,7 @@ public class SqlAbstractTimeFunction extends SqlFunction {
   //~ Static fields/initializers ---------------------------------------------
 
   private static final SqlOperandTypeChecker OTC_CUSTOM =
-      OperandTypes.or(
-          OperandTypes.POSITIVE_INTEGER_LITERAL, OperandTypes.NILADIC);
+      OperandTypes.POSITIVE_INTEGER_LITERAL.or(OperandTypes.NILADIC);
 
   //~ Instance fields --------------------------------------------------------
 
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlArrayQueryConstructor.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlArrayQueryConstructor.java
index 810df293b91..273f6642bdd 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlArrayQueryConstructor.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlArrayQueryConstructor.java
@@ -27,6 +27,6 @@ public class SqlArrayQueryConstructor extends SqlMultisetQueryConstructor {
   //~ Constructors -----------------------------------------------------------
 
   public SqlArrayQueryConstructor() {
-    super("ARRAY", SqlKind.ARRAY_QUERY_CONSTRUCTOR, SqlTypeTransforms.TO_ARRAY);
+    super("ARRAY", SqlKind.ARRAY_QUERY_CONSTRUCTOR, SqlTypeTransforms.TO_ARRAY_QUERY);
   }
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlBasicAggFunction.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlBasicAggFunction.java
index 54b07254fa2..95623dfc56a 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlBasicAggFunction.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlBasicAggFunction.java
@@ -128,6 +128,15 @@ public static SqlBasicAggFunction create(String name, SqlKind kind,
     return requireNonNull(super.getOperandTypeChecker(), "operandTypeChecker");
   }
 
+  /** Sets {@link #getName()}. */
+  public SqlAggFunction withName(String name) {
+    return new SqlBasicAggFunction(name, getSqlIdentifier(), kind,
+        getReturnTypeInference(), getOperandTypeInference(),
+        getOperandTypeChecker(), getFunctionType(), requiresOrder(),
+        requiresOver(), requiresGroupOrder(), distinctOptionality, syntax,
+        allowsNullTreatment, allowsSeparator, percentile);
+  }
+
   /** Sets {@link #getDistinctOptionality()}. */
   SqlBasicAggFunction withDistinct(Optionality distinctOptionality) {
     return new SqlBasicAggFunction(getName(), getSqlIdentifier(), kind,
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlBetweenOperator.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlBetweenOperator.java
index 1030eca7a48..b040b31d3e4 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlBetweenOperator.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlBetweenOperator.java
@@ -148,8 +148,8 @@ private static SqlBetweenOperator of(boolean negated, boolean symmetric) {
         new ExplicitOperatorBinding(
             opBinding,
             opBinding.collectOperandTypes());
-    RelDataType type = ReturnTypes.BOOLEAN_NULLABLE.inferReturnType(
-        newOpBinding);
+    RelDataType type =
+        ReturnTypes.BOOLEAN_NULLABLE.inferReturnType(newOpBinding);
     return requireNonNull(type, "inferred BETWEEN element type");
   }
 
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlBitOpAggFunction.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlBitOpAggFunction.java
index ad9629d84ad..30af5d457bc 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlBitOpAggFunction.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlBitOpAggFunction.java
@@ -46,7 +46,7 @@ public SqlBitOpAggFunction(SqlKind kind) {
         kind,
         ReturnTypes.ARG0_NULLABLE_IF_EMPTY,
         null,
-        OperandTypes.or(OperandTypes.INTEGER, OperandTypes.BINARY),
+        OperandTypes.INTEGER.or(OperandTypes.BINARY),
         SqlFunctionCategory.NUMERIC,
         false,
         false,
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlCaseOperator.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlCaseOperator.java
index 0adbd3d8c2f..ffb11eb0714 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlCaseOperator.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlCaseOperator.java
@@ -252,8 +252,9 @@ private static RelDataType inferTypeFromValidator(
       }
     }
 
-    SqlNode elseOp = requireNonNull(caseCall.getElseOperand(),
-        () -> "elseOperand for " + caseCall);
+    SqlNode elseOp =
+        requireNonNull(caseCall.getElseOperand(),
+            () -> "elseOperand for " + caseCall);
     argTypes.add(
         SqlTypeUtil.deriveType(callBinding, elseOp));
     if (SqlUtil.isNullLiteral(elseOp, false)) {
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlCastFunction.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlCastFunction.java
index ce45bf7e24f..a9bfd8cff87 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlCastFunction.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlCastFunction.java
@@ -17,6 +17,7 @@
 package org.apache.calcite.sql.fun;
 
 import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.rel.type.RelDataTypeFactory;
 import org.apache.calcite.rel.type.RelDataTypeFamily;
 import org.apache.calcite.sql.SqlCall;
 import org.apache.calcite.sql.SqlCallBinding;
@@ -33,10 +34,10 @@
 import org.apache.calcite.sql.SqlWriter;
 import org.apache.calcite.sql.type.InferTypes;
 import org.apache.calcite.sql.type.SqlOperandCountRanges;
+import org.apache.calcite.sql.type.SqlReturnTypeInference;
 import org.apache.calcite.sql.type.SqlTypeFamily;
 import org.apache.calcite.sql.type.SqlTypeUtil;
 import org.apache.calcite.sql.validate.SqlMonotonicity;
-import org.apache.calcite.sql.validate.SqlValidatorImpl;
 
 import com.google.common.collect.ImmutableSetMultimap;
 import com.google.common.collect.SetMultimap;
@@ -44,6 +45,8 @@
 import java.text.Collator;
 import java.util.Objects;
 
+import static com.google.common.base.Preconditions.checkArgument;
+
 import static org.apache.calcite.util.Static.RESOURCE;
 
 /**
@@ -83,39 +86,44 @@ public class SqlCastFunction extends SqlFunction {
   //~ Constructors -----------------------------------------------------------
 
   public SqlCastFunction() {
-    super("CAST",
-        SqlKind.CAST,
-        null,
-        InferTypes.FIRST_KNOWN,
-        null,
-        SqlFunctionCategory.SYSTEM);
+    this(SqlKind.CAST);
+  }
+
+  public SqlCastFunction(SqlKind kind) {
+    super(kind.toString(), kind, returnTypeInference(kind == SqlKind.SAFE_CAST),
+        InferTypes.FIRST_KNOWN, null, SqlFunctionCategory.SYSTEM);
+    checkArgument(kind == SqlKind.CAST || kind == SqlKind.SAFE_CAST, kind);
   }
 
   //~ Methods ----------------------------------------------------------------
 
-  @Override public RelDataType inferReturnType(
-      SqlOperatorBinding opBinding) {
-    assert opBinding.getOperandCount() == 2;
-    RelDataType ret = opBinding.getOperandType(1);
-    RelDataType firstType = opBinding.getOperandType(0);
-    ret =
-        opBinding.getTypeFactory().createTypeWithNullability(
-            ret,
-            firstType.isNullable());
-    if (opBinding instanceof SqlCallBinding) {
-      SqlCallBinding callBinding = (SqlCallBinding) opBinding;
-      SqlNode operand0 = callBinding.operand(0);
-
-      // dynamic parameters and null constants need their types assigned
-      // to them using the type they are casted to.
-      if (SqlUtil.isNullLiteral(operand0, false)
-          || (operand0 instanceof SqlDynamicParam)) {
-        final SqlValidatorImpl validator =
-            (SqlValidatorImpl) callBinding.getValidator();
-        validator.setValidatedNodeType(operand0, ret);
+  static SqlReturnTypeInference returnTypeInference(boolean safe) {
+    return opBinding -> {
+      assert opBinding.getOperandCount() == 2;
+      final RelDataType ret =
+          deriveType(opBinding.getTypeFactory(), opBinding.getOperandType(0),
+              opBinding.getOperandType(1), safe);
+
+      if (opBinding instanceof SqlCallBinding) {
+        final SqlCallBinding callBinding = (SqlCallBinding) opBinding;
+        SqlNode operand0 = callBinding.operand(0);
+
+        // dynamic parameters and null constants need their types assigned
+        // to them using the type they are casted to.
+        if (SqlUtil.isNullLiteral(operand0, false)
+            || operand0 instanceof SqlDynamicParam) {
+          callBinding.getValidator().setValidatedNodeType(operand0, ret);
+        }
       }
-    }
-    return ret;
+      return ret;
+    };
+  }
+
+  /** Derives the type of "CAST(expression AS targetType)". */
+  public static RelDataType deriveType(RelDataTypeFactory typeFactory,
+      RelDataType expressionType, RelDataType targetType, boolean safe) {
+    return typeFactory.createTypeWithNullability(targetType,
+        expressionType.isNullable() || safe);
   }
 
   @Override public String getSignatureTemplate(final int operandsCount) {
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlConvertFunction.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlConvertFunction.java
index 23fbb4b1755..f36621858f1 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlConvertFunction.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlConvertFunction.java
@@ -21,6 +21,8 @@
 import org.apache.calcite.sql.SqlFunctionCategory;
 import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.SqlWriter;
+import org.apache.calcite.sql.type.OperandTypes;
+import org.apache.calcite.sql.type.ReturnTypes;
 
 /**
  * Common base for the <code>CONVERT</code> and <code>TRANSLATE</code>
@@ -33,9 +35,9 @@ protected SqlConvertFunction(String name) {
     super(
         name,
         SqlKind.OTHER_FUNCTION,
+        ReturnTypes.ARG0,
         null,
-        null,
-        null,
+        OperandTypes.ANY_ANY,
         SqlFunctionCategory.STRING);
   }
 
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlDatePartFunction.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlDatePartFunction.java
index 31fbc284e0e..5f6b2e0cf5d 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlDatePartFunction.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlDatePartFunction.java
@@ -34,6 +34,8 @@
 
 import java.util.List;
 
+import static org.apache.calcite.util.Static.RESOURCE;
+
 /**
  * SqlDatePartFunction represents the SQL:1999 standard {@code YEAR},
  * {@code QUARTER}, {@code MONTH} and {@code DAY} functions.
@@ -56,6 +58,11 @@ public SqlDatePartFunction(String name, TimeUnit timeUnit) {
 
   @Override public SqlNode rewriteCall(SqlValidator validator, SqlCall call) {
     final List<SqlNode> operands = call.getOperandList();
+
+    if (operands.size() != 1) {
+      throw validator.newValidationError(call, RESOURCE.invalidArgCount(getName(), 1));
+    }
+
     final SqlParserPos pos = call.getParserPosition();
     return SqlStdOperatorTable.EXTRACT.createCall(pos,
         new SqlIntervalQualifier(timeUnit, null, SqlParserPos.ZERO),
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlDatetimePlusOperator.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlDatetimePlusOperator.java
index dd83c265518..0be4b0e99aa 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlDatetimePlusOperator.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlDatetimePlusOperator.java
@@ -16,9 +16,6 @@
  */
 package org.apache.calcite.sql.fun;
 
-import org.apache.calcite.avatica.util.TimeUnit;
-import org.apache.calcite.rel.type.RelDataType;
-import org.apache.calcite.rel.type.RelDataTypeFactory;
 import org.apache.calcite.sql.SqlCall;
 import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.SqlOperatorBinding;
@@ -27,32 +24,31 @@
 import org.apache.calcite.sql.type.InferTypes;
 import org.apache.calcite.sql.type.IntervalSqlType;
 import org.apache.calcite.sql.type.OperandTypes;
-import org.apache.calcite.sql.type.ReturnTypes;
+import org.apache.calcite.sql.type.SqlReturnTypeInference;
+import org.apache.calcite.sql.type.SqlTypeTransforms;
 import org.apache.calcite.sql.validate.SqlMonotonicity;
 
 /**
  * Operator that adds an INTERVAL to a DATETIME.
  */
 public class SqlDatetimePlusOperator extends SqlSpecialOperator {
+  private static final SqlReturnTypeInference RETURN_TYPE_INFERENCE =
+      opBinding ->
+          SqlTimestampAddFunction.deduceType(opBinding.getTypeFactory(),
+              ((IntervalSqlType) opBinding.getOperandType(1))
+                  .getIntervalQualifier().getStartUnit(),
+              opBinding.getOperandType(0));
+
   //~ Constructors -----------------------------------------------------------
 
   SqlDatetimePlusOperator() {
-    super("+", SqlKind.PLUS, 40, true, ReturnTypes.ARG2_NULLABLE,
+    super("+", SqlKind.PLUS, 40, true,
+        RETURN_TYPE_INFERENCE.andThen(SqlTypeTransforms.TO_NULLABLE),
         InferTypes.FIRST_KNOWN, OperandTypes.MINUS_DATE_OPERATOR);
   }
 
   //~ Methods ----------------------------------------------------------------
 
-  @Override public RelDataType inferReturnType(SqlOperatorBinding opBinding) {
-    final RelDataTypeFactory typeFactory = opBinding.getTypeFactory();
-    final RelDataType leftType = opBinding.getOperandType(0);
-    final IntervalSqlType unitType =
-        (IntervalSqlType) opBinding.getOperandType(1);
-    final TimeUnit timeUnit = unitType.getIntervalQualifier().getStartUnit();
-    return SqlTimestampAddFunction.deduceType(typeFactory, timeUnit,
-        unitType, leftType);
-  }
-
   @Override public void unparse(
       SqlWriter writer,
       SqlCall call,
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlDatetimeSubtractionOperator.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlDatetimeSubtractionOperator.java
index e63303e02d8..571428d972b 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlDatetimeSubtractionOperator.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlDatetimeSubtractionOperator.java
@@ -23,7 +23,7 @@
 import org.apache.calcite.sql.SqlWriter;
 import org.apache.calcite.sql.type.InferTypes;
 import org.apache.calcite.sql.type.OperandTypes;
-import org.apache.calcite.sql.type.ReturnTypes;
+import org.apache.calcite.sql.type.SqlReturnTypeInference;
 import org.apache.calcite.sql.validate.SqlMonotonicity;
 
 /**
@@ -37,17 +37,22 @@
  * additional interval qualifier specification, when in {@link SqlCall} form.
  * In {@link org.apache.calcite.rex.RexNode} form, it has only two parameters,
  * and the return type describes the desired type of interval.
+ *
+ * <p>When being used for BigQuery's {@code TIMESTAMP_SUB}, {@code TIME_SUB},
+ * and {@code DATE_SUB} operators, this operator subtracts an interval value
+ * from a timestamp value. The return type differs due to differing number of
+ * parameters and ordering. This is accounted for by passing in a
+ * {@link SqlReturnTypeInference} which is passed in by
+ * the standard {@link SqlStdOperatorTable#MINUS_DATE MINUS_DATE}
+ * and the library {@link SqlInternalOperators#MINUS_DATE2 MINUS_DATE2}
+ * operators at their respective initializations.
  */
 public class SqlDatetimeSubtractionOperator extends SqlSpecialOperator {
   //~ Constructors -----------------------------------------------------------
 
-  public SqlDatetimeSubtractionOperator() {
-    super(
-        "-",
-        SqlKind.MINUS,
-        40,
-        true,
-        ReturnTypes.ARG2_NULLABLE,
+  public SqlDatetimeSubtractionOperator(String name,
+      SqlReturnTypeInference returnTypeInference) {
+    super("-", SqlKind.MINUS, 40, true, returnTypeInference,
         InferTypes.FIRST_KNOWN, OperandTypes.MINUS_DATE_OPERATOR);
   }
 
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlDotOperator.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlDotOperator.java
index ea4fe05cf40..2bc78ae3804 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlDotOperator.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlDotOperator.java
@@ -179,11 +179,12 @@ private static SqlSingleOperandTypeChecker getChecker(RelDataType operandType) {
     final RelDataType recordType = opBinding.getOperandType(0);
     switch (recordType.getSqlTypeName()) {
     case ROW:
-      final String fieldName = getOperandLiteralValueOrThrow(opBinding, 1, String.class);
-      final RelDataType type = requireNonNull(
-          recordType.getField(fieldName, false, false),
-          () -> "field " + fieldName + " is not found in " + recordType)
-          .getType();
+      final String fieldName =
+          getOperandLiteralValueOrThrow(opBinding, 1, String.class);
+      final RelDataTypeField field =
+          requireNonNull(recordType.getField(fieldName, false, false),
+              () -> "field " + fieldName + " is not found in " + recordType);
+      final RelDataType type = field.getType();
       if (recordType.isNullable()) {
         return typeFactory.createTypeWithNullability(type, true);
       } else {
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 97e6e4951bc..07789aa7cca 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
@@ -20,12 +20,15 @@
 import org.apache.calcite.sql.SqlCall;
 import org.apache.calcite.sql.SqlFunction;
 import org.apache.calcite.sql.SqlFunctionCategory;
+import org.apache.calcite.sql.SqlIntervalQualifier;
 import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.SqlOperatorBinding;
 import org.apache.calcite.sql.SqlWriter;
 import org.apache.calcite.sql.type.OperandTypes;
 import org.apache.calcite.sql.type.ReturnTypes;
 import org.apache.calcite.sql.validate.SqlMonotonicity;
+import org.apache.calcite.sql.validate.SqlValidator;
+import org.apache.calcite.sql.validate.SqlValidatorScope;
 import org.apache.calcite.util.Util;
 
 import static org.apache.calcite.sql.validate.SqlNonNullableAccessors.getOperandLiteralValueOrThrow;
@@ -41,8 +44,8 @@ public class SqlExtractFunction extends SqlFunction {
 
   // SQL2003, Part 2, Section 4.4.3 - extract returns a exact numeric
   // TODO: Return type should be decimal for seconds
-  public SqlExtractFunction() {
-    super("EXTRACT", SqlKind.EXTRACT, ReturnTypes.BIGINT_NULLABLE, null,
+  public SqlExtractFunction(String name) {
+    super(name, SqlKind.EXTRACT, ReturnTypes.BIGINT_NULLABLE, null,
         OperandTypes.INTERVALINTERVAL_INTERVALDATETIME,
         SqlFunctionCategory.SYSTEM);
   }
@@ -60,12 +63,30 @@ public SqlExtractFunction() {
       int leftPrec,
       int rightPrec) {
     final SqlWriter.Frame frame = writer.startFunCall(getName());
-    call.operand(0).unparse(writer, 0, 0);
+    SqlIntervalQualifier.asIdentifier(call.operand(0))
+        .unparse(writer, 0, 0);
     writer.sep("FROM");
     call.operand(1).unparse(writer, 0, 0);
     writer.endFunCall(frame);
   }
 
+  @Override public void validateCall(SqlCall call, SqlValidator validator,
+      SqlValidatorScope scope, SqlValidatorScope operandScope) {
+    super.validateCall(call, validator, scope, operandScope);
+
+    // This is either a time unit or a time frame:
+    //
+    //  * In "EXTRACT(YEAR FROM x)" operand 0 is a SqlIntervalQualifier with
+    //    startUnit = YEAR and timeFrameName = null.
+    //
+    //  * In "EXTRACT(MINUTE15 FROM x)" operand 0 is a SqlIntervalQualifier with
+    //    startUnit = EPOCH and timeFrameName = 'MINUTE15'.
+    //
+    // If the latter, check that timeFrameName is valid.
+    validator.validateTimeFrame(
+        (SqlIntervalQualifier) call.getOperandList().get(0));
+  }
+
   @Override public SqlMonotonicity getMonotonicity(SqlOperatorBinding call) {
     TimeUnitRange value = getOperandLiteralValueOrThrow(call, 0, TimeUnitRange.class);
     switch (value) {
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 ed7921d3e63..9a089890d73 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
@@ -19,6 +19,7 @@
 import org.apache.calcite.sql.SqlCall;
 import org.apache.calcite.sql.SqlFunction;
 import org.apache.calcite.sql.SqlFunctionCategory;
+import org.apache.calcite.sql.SqlIntervalQualifier;
 import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.SqlLiteral;
 import org.apache.calcite.sql.SqlNode;
@@ -29,6 +30,8 @@
 import org.apache.calcite.sql.type.OperandTypes;
 import org.apache.calcite.sql.type.ReturnTypes;
 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;
 
@@ -40,11 +43,10 @@ public class SqlFloorFunction extends SqlMonotonicUnaryFunction {
 
   public SqlFloorFunction(SqlKind kind) {
     super(kind.name(), kind, ReturnTypes.ARG0_OR_EXACT_NO_SCALE, null,
-        OperandTypes.or(OperandTypes.NUMERIC_OR_INTERVAL,
-            OperandTypes.sequence(
-                "'" + kind + "(<DATE> TO <TIME_UNIT>)'\n"
-                + "'" + kind + "(<TIME> TO <TIME_UNIT>)'\n"
-                + "'" + kind + "(<TIMESTAMP> TO <TIME_UNIT>)'",
+        OperandTypes.NUMERIC_OR_INTERVAL.or(
+            OperandTypes.sequence("'" + kind + "(<DATE> TO <TIME_UNIT>)'\n"
+                    + "'" + kind + "(<TIME> TO <TIME_UNIT>)'\n"
+                    + "'" + kind + "(<TIMESTAMP> TO <TIME_UNIT>)'",
                 OperandTypes.DATETIME,
                 OperandTypes.ANY)),
         SqlFunctionCategory.NUMERIC);
@@ -64,13 +66,33 @@ public SqlFloorFunction(SqlKind kind) {
     if (call.operandCount() == 2) {
       call.operand(0).unparse(writer, 0, 100);
       writer.sep("TO");
-      call.operand(1).unparse(writer, 100, 0);
+      SqlIntervalQualifier.asIdentifier(call.operand(1))
+          .unparse(writer, 100, 0);
     } else {
       call.operand(0).unparse(writer, 0, 0);
     }
     writer.endFunCall(frame);
   }
 
+  @Override public void validateCall(SqlCall call, SqlValidator validator,
+      SqlValidatorScope scope, SqlValidatorScope operandScope) {
+    super.validateCall(call, validator, scope, operandScope);
+
+    if (call.operandCount() > 1) {
+      // This is either a time unit or a time frame:
+      //
+      //  * In "FLOOR(x TO YEAR)" operand 1 is a SqlIntervalQualifier with
+      //    startUnit = YEAR and timeFrameName = null.
+      //
+      //  * In "FLOOR(x TO MINUTE15)" operand 1 is a SqlIntervalQualifier with
+      //    startUnit = EPOCH and timeFrameName = 'MINUTE15'.
+      //
+      // If the latter, check that timeFrameName is valid.
+      validator.validateTimeFrame(
+          (SqlIntervalQualifier) call.getOperandList().get(1));
+    }
+  }
+
   /**
    * Copies a {@link SqlCall}, replacing the time unit operand with the given
    * literal.
@@ -98,9 +120,10 @@ public static SqlCall replaceTimeUnitOperand(SqlCall call, String literal, SqlPa
    */
   public static void unparseDatetimeFunction(SqlWriter writer, SqlCall call,
       String funName, Boolean datetimeFirst) {
-    SqlFunction func = new SqlFunction(funName, SqlKind.OTHER_FUNCTION,
-        ReturnTypes.ARG0_NULLABLE_VARYING, null, null,
-        SqlFunctionCategory.STRING);
+    SqlFunction func =
+        new SqlFunction(funName, SqlKind.OTHER_FUNCTION,
+            ReturnTypes.ARG0_NULLABLE_VARYING, null, null,
+            SqlFunctionCategory.STRING);
 
     SqlCall call1;
     if (datetimeFirst) {
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlInternalOperators.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlInternalOperators.java
index ceea8fbb1f2..492ac12b992 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlInternalOperators.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlInternalOperators.java
@@ -24,6 +24,7 @@
 import org.apache.calcite.sql.SqlNodeList;
 import org.apache.calcite.sql.SqlOperator;
 import org.apache.calcite.sql.SqlOperatorTable;
+import org.apache.calcite.sql.SqlSyntax;
 import org.apache.calcite.sql.SqlWriter;
 import org.apache.calcite.sql.type.InferTypes;
 import org.apache.calcite.sql.type.OperandTypes;
@@ -115,4 +116,46 @@ private SqlInternalOperators() {
       new SqlInternalOperator("SEPARATOR", SqlKind.SEPARATOR, 20, false,
           ReturnTypes.ARG0, InferTypes.RETURN_TYPE, OperandTypes.ANY);
 
+  /** {@code DISTINCT} operator, occurs within {@code GROUP BY} clause. */
+  public static final SqlInternalOperator GROUP_BY_DISTINCT =
+      new SqlRollupOperator("GROUP BY DISTINCT", SqlKind.GROUP_BY_DISTINCT);
+
+  /** Fetch operator is ONLY used for its precedence during unparsing. */
+  public static final SqlOperator FETCH =
+      SqlBasicOperator.create("FETCH")
+          .withPrecedence(SqlStdOperatorTable.UNION.getLeftPrec() - 2, true);
+
+  /** 2-argument form of the special minus-date operator
+   * to be used with BigQuery subtraction functions. It differs from
+   * the standard MINUS_DATE operator in that it has 2 arguments,
+   * and subtracts an interval from a datetime. */
+  public static final SqlDatetimeSubtractionOperator MINUS_DATE2 =
+      new SqlDatetimeSubtractionOperator("MINUS_DATE2", ReturnTypes.ARG0_NULLABLE);
+
+  /** Offset operator is ONLY used for its precedence during unparsing. */
+  public static final SqlOperator OFFSET =
+      SqlBasicOperator.create("OFFSET")
+          .withPrecedence(SqlStdOperatorTable.UNION.getLeftPrec() - 2, true);
+
+  /** Subject to change. */
+  private static class SqlBasicOperator extends SqlOperator {
+    @Override public SqlSyntax getSyntax() {
+      return SqlSyntax.SPECIAL;
+    }
+
+    /** Private constructor. Use {@link #create}. */
+    private SqlBasicOperator(String name, int leftPrecedence, int rightPrecedence) {
+      super(name, SqlKind.OTHER, leftPrecedence, rightPrecedence,
+          ReturnTypes.BOOLEAN, InferTypes.RETURN_TYPE, OperandTypes.ANY);
+    }
+
+    static SqlBasicOperator create(String name) {
+      return new SqlBasicOperator(name, 0, 0);
+    }
+
+    SqlBasicOperator withPrecedence(int prec, boolean leftAssoc) {
+      return new SqlBasicOperator(getName(), leftPrec(prec, leftAssoc),
+          rightPrec(prec, leftAssoc));
+    }
+  }
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlItemOperator.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlItemOperator.java
index 3e5858481db..928563e570e 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlItemOperator.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlItemOperator.java
@@ -50,10 +50,9 @@
 class SqlItemOperator extends SqlSpecialOperator {
 
   private static final SqlSingleOperandTypeChecker ARRAY_OR_MAP =
-      OperandTypes.or(
-          OperandTypes.family(SqlTypeFamily.ARRAY),
-          OperandTypes.family(SqlTypeFamily.MAP),
-          OperandTypes.family(SqlTypeFamily.ANY));
+      OperandTypes.family(SqlTypeFamily.ARRAY)
+          .or(OperandTypes.family(SqlTypeFamily.MAP))
+          .or(OperandTypes.family(SqlTypeFamily.ANY));
 
   SqlItemOperator() {
     super("ITEM", SqlKind.ITEM, 100, true, null, null, null);
@@ -106,8 +105,8 @@ private static SqlSingleOperandTypeChecker getChecker(SqlCallBinding callBinding
     case ARRAY:
       return OperandTypes.family(SqlTypeFamily.INTEGER);
     case MAP:
-      RelDataType keyType = requireNonNull(operandType.getKeyType(),
-          "operandType.getKeyType()");
+      RelDataType keyType =
+          requireNonNull(operandType.getKeyType(), "operandType.getKeyType()");
       SqlTypeName sqlTypeName = keyType.getSqlTypeName();
       return OperandTypes.family(
           requireNonNull(sqlTypeName.getFamily(),
@@ -115,9 +114,8 @@ private static SqlSingleOperandTypeChecker getChecker(SqlCallBinding callBinding
     case ROW:
     case ANY:
     case DYNAMIC_STAR:
-      return OperandTypes.or(
-          OperandTypes.family(SqlTypeFamily.INTEGER),
-          OperandTypes.family(SqlTypeFamily.CHARACTER));
+      return OperandTypes.family(SqlTypeFamily.INTEGER)
+          .or(OperandTypes.family(SqlTypeFamily.CHARACTER));
     default:
       throw callBinding.newValidationSignatureError();
     }
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlJsonExistsFunction.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlJsonExistsFunction.java
index f547b453919..3078c63041a 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlJsonExistsFunction.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlJsonExistsFunction.java
@@ -33,8 +33,7 @@ public class SqlJsonExistsFunction extends SqlFunction {
   public SqlJsonExistsFunction() {
     super("JSON_EXISTS", SqlKind.OTHER_FUNCTION,
         ReturnTypes.BOOLEAN.andThen(SqlTypeTransforms.FORCE_NULLABLE), null,
-        OperandTypes.or(
-            OperandTypes.family(SqlTypeFamily.ANY, SqlTypeFamily.CHARACTER),
+        OperandTypes.family(SqlTypeFamily.ANY, SqlTypeFamily.CHARACTER).or(
             OperandTypes.family(SqlTypeFamily.ANY, SqlTypeFamily.CHARACTER,
                 SqlTypeFamily.ANY)),
         SqlFunctionCategory.SYSTEM);
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlJsonKeysFunction.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlJsonKeysFunction.java
index f71ae0e449d..d3469ea70ce 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlJsonKeysFunction.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlJsonKeysFunction.java
@@ -32,7 +32,7 @@ public SqlJsonKeysFunction() {
     super("JSON_KEYS", SqlKind.OTHER_FUNCTION,
         ReturnTypes.VARCHAR_2000.andThen(SqlTypeTransforms.FORCE_NULLABLE),
         null,
-        OperandTypes.or(OperandTypes.ANY,
+        OperandTypes.ANY.or(
             OperandTypes.family(SqlTypeFamily.ANY, SqlTypeFamily.CHARACTER)),
         SqlFunctionCategory.SYSTEM);
   }
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlJsonLengthFunction.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlJsonLengthFunction.java
index 27f33edb029..30799f27b62 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlJsonLengthFunction.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlJsonLengthFunction.java
@@ -32,7 +32,7 @@ public SqlJsonLengthFunction() {
     super("JSON_LENGTH", SqlKind.OTHER_FUNCTION,
         ReturnTypes.INTEGER.andThen(SqlTypeTransforms.FORCE_NULLABLE),
         null,
-        OperandTypes.or(OperandTypes.ANY,
+        OperandTypes.ANY.or(
             OperandTypes.family(SqlTypeFamily.ANY, SqlTypeFamily.CHARACTER)),
         SqlFunctionCategory.SYSTEM);
   }
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlJsonModifyFunction.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlJsonModifyFunction.java
new file mode 100644
index 00000000000..ba8896bf7c7
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlJsonModifyFunction.java
@@ -0,0 +1,97 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.sql.fun;
+
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.sql.SqlCall;
+import org.apache.calcite.sql.SqlCallBinding;
+import org.apache.calcite.sql.SqlFunction;
+import org.apache.calcite.sql.SqlFunctionCategory;
+import org.apache.calcite.sql.SqlKind;
+import org.apache.calcite.sql.SqlOperandCountRange;
+import org.apache.calcite.sql.type.OperandTypes;
+import org.apache.calcite.sql.type.ReturnTypes;
+import org.apache.calcite.sql.type.SqlOperandCountRanges;
+import org.apache.calcite.sql.type.SqlOperandTypeChecker;
+import org.apache.calcite.sql.type.SqlTypeTransforms;
+import org.apache.calcite.sql.type.SqlTypeUtil;
+import org.apache.calcite.sql.validate.SqlValidator;
+
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+import java.util.Locale;
+
+import static org.apache.calcite.util.Static.RESOURCE;
+
+/**
+ * Definition of the <code>JSON_INSERT</code>, <code>JSON_REPLACE</code>
+ * and <code>JSON_SET</code> JSON Modify functions.
+ */
+public class SqlJsonModifyFunction extends SqlFunction {
+  public SqlJsonModifyFunction(String name) {
+    super(name,
+        SqlKind.OTHER_FUNCTION,
+        ReturnTypes.cascade(ReturnTypes.VARCHAR_2000,
+            SqlTypeTransforms.FORCE_NULLABLE),
+        null,
+        OperandTypes.ANY,
+        SqlFunctionCategory.SYSTEM);
+  }
+
+  @Override public SqlOperandCountRange getOperandCountRange() {
+    return SqlOperandCountRanges.from(3);
+  }
+
+  @Override protected void checkOperandCount(SqlValidator validator,
+      @Nullable SqlOperandTypeChecker argType, SqlCall call) {
+    assert (call.operandCount() >= 3) && (call.operandCount() % 2 == 1);
+  }
+
+  @Override public boolean checkOperandTypes(SqlCallBinding callBinding,
+      boolean throwOnFailure) {
+    final int count = callBinding.getOperandCount();
+    for (int i = 1; i < count; i += 2) {
+      RelDataType nameType = callBinding.getOperandType(i);
+      if (!SqlTypeUtil.isCharacter(nameType)) {
+        if (throwOnFailure) {
+          throw callBinding.newError(RESOURCE.expectedCharacter());
+        }
+        return false;
+      }
+      if (nameType.isNullable()) {
+        if (throwOnFailure) {
+          throw callBinding.newError(
+              RESOURCE.argumentMustNotBeNull(
+                  callBinding.operand(i).toString()));
+        }
+        return false;
+      }
+    }
+    return true;
+  }
+
+  @Override public String getSignatureTemplate(int operandsCount) {
+    assert operandsCount % 2 == 1;
+    StringBuilder sb = new StringBuilder();
+    sb.append("{0}(");
+    for (int i = 1; i < operandsCount; i++) {
+      sb.append(String.format(Locale.ROOT, "{%d} ", i + 1));
+    }
+    sb.append("{1})");
+    return sb.toString();
+  }
+}
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlJsonObjectAggAggFunction.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlJsonObjectAggAggFunction.java
index 88d1617c25f..aae4c7fdaa3 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlJsonObjectAggAggFunction.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlJsonObjectAggAggFunction.java
@@ -48,10 +48,11 @@ public SqlJsonObjectAggAggFunction(SqlKind kind,
         (callBinding, returnType, operandTypes) -> {
           RelDataTypeFactory typeFactory = callBinding.getTypeFactory();
           operandTypes[0] = typeFactory.createSqlType(SqlTypeName.VARCHAR);
-          operandTypes[1] = typeFactory.createTypeWithNullability(
-              typeFactory.createSqlType(SqlTypeName.ANY), true);
-        }, OperandTypes.family(SqlTypeFamily.CHARACTER,
-            SqlTypeFamily.ANY),
+          operandTypes[1] =
+              typeFactory.createTypeWithNullability(
+                  typeFactory.createSqlType(SqlTypeName.ANY), true);
+        },
+        OperandTypes.family(SqlTypeFamily.CHARACTER, SqlTypeFamily.ANY),
         SqlFunctionCategory.SYSTEM, false, false, Optionality.FORBIDDEN);
     this.nullClause = Objects.requireNonNull(nullClause, "nullClause");
   }
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlJsonObjectFunction.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlJsonObjectFunction.java
index b8854cf1537..61d8393b39b 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlJsonObjectFunction.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlJsonObjectFunction.java
@@ -99,8 +99,8 @@ public SqlJsonObjectFunction() {
   @Override public SqlCall createCall(@Nullable SqlLiteral functionQualifier,
       SqlParserPos pos, @Nullable SqlNode... operands) {
     if (operands[0] == null) {
-      operands[0] = SqlLiteral.createSymbol(
-          SqlJsonConstructorNullClause.NULL_ON_NULL, pos);
+      operands[0] =
+          SqlLiteral.createSymbol(SqlJsonConstructorNullClause.NULL_ON_NULL, pos);
     }
     return super.createCall(functionQualifier, pos, operands);
   }
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlJsonValueFunction.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlJsonValueFunction.java
index ce5b716bc9b..878aefd3f33 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlJsonValueFunction.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlJsonValueFunction.java
@@ -16,6 +16,7 @@
  */
 package org.apache.calcite.sql.fun;
 
+import org.apache.calcite.linq4j.Nullness;
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeFactory;
 import org.apache.calcite.sql.SqlCall;
@@ -39,6 +40,7 @@
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Objects;
@@ -72,12 +74,12 @@ private static RelDataType getDefaultType(SqlOperatorBinding opBinding) {
    * Returns new operand list with type specification removed.
    */
   public static List<SqlNode> removeTypeSpecOperands(SqlCall call) {
-    @Nullable SqlNode[] operands = call.getOperandList().toArray(new SqlNode[0]);
-    if (hasExplicitTypeSpec(operands)) {
-      operands[2] = null;
-      operands[3] = null;
+    List<@Nullable SqlNode> operands = new ArrayList<>(call.getOperandList());
+    if (hasExplicitTypeSpec(call.getOperandList())) {
+      operands.set(2, null);
+      operands.set(3, null);
     }
-    return Arrays.stream(operands)
+    return operands.stream()
         .filter(Objects::nonNull)
         .collect(Collectors.toList());
   }
@@ -98,9 +100,15 @@ private static Optional<RelDataType> explicitTypeSpec(SqlOperatorBinding opBindi
   }
 
   /** Returns whether there is an explicit return type specification. */
+  public static boolean hasExplicitTypeSpec(List<SqlNode> operands) {
+    return operands.size() > 2
+        && isReturningTypeSymbol(operands.get(2));
+  }
+
+  @Deprecated // to be removed before 2.0
   public static boolean hasExplicitTypeSpec(@Nullable SqlNode[] operands) {
-    return operands.length > 2
-        && isReturningTypeSymbol(operands[2]);
+    return hasExplicitTypeSpec(
+        Arrays.asList(Nullness.castNonNullArray(operands)));
   }
 
   private static boolean isReturningTypeSymbol(@Nullable SqlNode node) {
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlLeadLagAggFunction.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlLeadLagAggFunction.java
index 7d8f7f2e795..9a15d545454 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlLeadLagAggFunction.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlLeadLagAggFunction.java
@@ -23,18 +23,13 @@
 import org.apache.calcite.sql.SqlOperatorBinding;
 import org.apache.calcite.sql.type.OperandTypes;
 import org.apache.calcite.sql.type.ReturnTypes;
-import org.apache.calcite.sql.type.SameOperandTypeChecker;
 import org.apache.calcite.sql.type.SqlReturnTypeInference;
 import org.apache.calcite.sql.type.SqlSingleOperandTypeChecker;
-import org.apache.calcite.sql.type.SqlTypeFamily;
 import org.apache.calcite.sql.type.SqlTypeTransform;
 import org.apache.calcite.sql.type.SqlTypeTransforms;
 import org.apache.calcite.util.Optionality;
 
 import com.google.common.base.Preconditions;
-import com.google.common.collect.ImmutableList;
-
-import java.util.List;
 
 /**
  * <code>LEAD</code> and <code>LAG</code> aggregate functions
@@ -42,19 +37,10 @@
  */
 public class SqlLeadLagAggFunction extends SqlAggFunction {
   private static final SqlSingleOperandTypeChecker OPERAND_TYPES =
-      OperandTypes.or(
-          OperandTypes.ANY,
-          OperandTypes.family(SqlTypeFamily.ANY, SqlTypeFamily.NUMERIC),
-          OperandTypes.and(
-              OperandTypes.family(SqlTypeFamily.ANY, SqlTypeFamily.NUMERIC,
-                  SqlTypeFamily.ANY),
-              // Arguments 1 and 3 must have same type
-              new SameOperandTypeChecker(3) {
-                @Override protected List<Integer>
-                getOperandList(int operandCount) {
-                  return ImmutableList.of(0, 2);
-                }
-              }));
+      OperandTypes.ANY
+          .or(OperandTypes.ANY_NUMERIC)
+          .or(OperandTypes.ANY_NUMERIC_ANY
+              .and(OperandTypes.same(3, 0, 2)));
 
   private static final SqlReturnTypeInference RETURN_TYPE =
       ReturnTypes.ARG0.andThen(SqlLeadLagAggFunction::transformType);
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlLibrary.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlLibrary.java
index e9418745e7b..ee673c06d22 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlLibrary.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlLibrary.java
@@ -27,7 +27,8 @@
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
-import java.util.Objects;
+
+import static java.util.Objects.requireNonNull;
 
 /**
  * A library is a collection of SQL functions and operators.
@@ -50,11 +51,16 @@ public enum SqlLibrary {
   /** A collection of operators that are in Google BigQuery but not in standard
    * SQL. */
   BIG_QUERY("b", "bigquery"),
+  /** Calcite-specific extensions. */
+  CALCITE("c", "calcite"),
   /** A collection of operators that are in Apache Hive but not in standard
    * SQL. */
   HIVE("h", "hive"),
   /** A collection of operators that are in MySQL but not in standard SQL. */
   MYSQL("m", "mysql"),
+  /** A collection of operators that are in Microsoft SQL Server (MSSql) but not
+   * in standard SQL. */
+  MSSQL("q", "mssql"),
   /** A collection of operators that are in Oracle but not in standard SQL. */
   ORACLE("o", "oracle"),
   /** A collection of operators that are in PostgreSQL but not in standard
@@ -72,8 +78,8 @@ public enum SqlLibrary {
   public final String fun;
 
   SqlLibrary(String abbrev, String fun) {
-    this.abbrev = Objects.requireNonNull(abbrev, "abbrev");
-    this.fun = Objects.requireNonNull(fun, "fun");
+    this.abbrev = requireNonNull(abbrev, "abbrev");
+    this.fun = requireNonNull(fun, "fun");
     Preconditions.checkArgument(
         fun.equals(name().toLowerCase(Locale.ROOT).replace("_", "")));
   }
@@ -89,8 +95,9 @@ public enum SqlLibrary {
   public static List<SqlLibrary> parse(String libraryNameList) {
     final ImmutableList.Builder<SqlLibrary> list = ImmutableList.builder();
     for (String libraryName : libraryNameList.split(",")) {
-      SqlLibrary library = Objects.requireNonNull(
-          SqlLibrary.of(libraryName), () -> "library does not exist: " + libraryName);
+      SqlLibrary library =
+          requireNonNull(SqlLibrary.of(libraryName),
+              () -> "library does not exist: " + libraryName);
       list.add(library);
     }
     return list.build();
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlLibraryOperatorTableFactory.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlLibraryOperatorTableFactory.java
index 26adcdf4f5d..6367427e043 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlLibraryOperatorTableFactory.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlLibraryOperatorTableFactory.java
@@ -18,7 +18,6 @@
 
 import org.apache.calcite.sql.SqlOperator;
 import org.apache.calcite.sql.SqlOperatorTable;
-import org.apache.calcite.sql.util.ListSqlOperatorTable;
 import org.apache.calcite.sql.util.SqlOperatorTables;
 import org.apache.calcite.util.Util;
 
@@ -29,6 +28,8 @@
 import com.google.common.collect.ImmutableSet;
 
 import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Set;
 import java.util.concurrent.ExecutionException;
 
@@ -77,7 +78,7 @@ private SqlLibraryOperatorTableFactory(Class... classes) {
   /** Creates an operator table that contains operators in the given set of
    * libraries. */
   private SqlOperatorTable create(ImmutableSet<SqlLibrary> librarySet) {
-    final ImmutableList.Builder<SqlOperator> list = ImmutableList.builder();
+    final List<SqlOperator> list = new ArrayList<>();
     boolean custom = false;
     boolean standard = false;
     for (SqlLibrary library : librarySet) {
@@ -100,8 +101,9 @@ private SqlOperatorTable create(ImmutableSet<SqlLibrary> librarySet) {
         for (Field field : aClass.getFields()) {
           try {
             if (SqlOperator.class.isAssignableFrom(field.getType())) {
-              final SqlOperator op = (SqlOperator) requireNonNull(field.get(this),
-                  () -> "null value of " + field + " for " + this);
+              final SqlOperator op =
+                  (SqlOperator) requireNonNull(field.get(this),
+                      () -> "null value of " + field + " for " + this);
               if (operatorIsInLibrary(op.getName(), field, librarySet)) {
                 list.add(op);
               }
@@ -112,7 +114,7 @@ private SqlOperatorTable create(ImmutableSet<SqlLibrary> librarySet) {
         }
       }
     }
-    SqlOperatorTable operatorTable = new ListSqlOperatorTable(list.build());
+    SqlOperatorTable operatorTable = SqlOperatorTables.of(list);
     if (standard) {
       operatorTable =
           SqlOperatorTables.chain(SqlStdOperatorTable.instance(),
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 acec95ff1ed..ae45e899e74 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
@@ -19,7 +19,10 @@
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeFactory;
 import org.apache.calcite.sql.SqlAggFunction;
+import org.apache.calcite.sql.SqlBasicFunction;
 import org.apache.calcite.sql.SqlBinaryOperator;
+import org.apache.calcite.sql.SqlCall;
+import org.apache.calcite.sql.SqlCallBinding;
 import org.apache.calcite.sql.SqlFunction;
 import org.apache.calcite.sql.SqlFunctionCategory;
 import org.apache.calcite.sql.SqlKind;
@@ -28,19 +31,21 @@
 import org.apache.calcite.sql.SqlOperatorTable;
 import org.apache.calcite.sql.SqlSpecialOperator;
 import org.apache.calcite.sql.SqlSyntax;
+import org.apache.calcite.sql.SqlWriter;
 import org.apache.calcite.sql.type.InferTypes;
+import org.apache.calcite.sql.type.OperandHandlers;
 import org.apache.calcite.sql.type.OperandTypes;
 import org.apache.calcite.sql.type.ReturnTypes;
-import org.apache.calcite.sql.type.SameOperandTypeChecker;
 import org.apache.calcite.sql.type.SqlOperandCountRanges;
 import org.apache.calcite.sql.type.SqlReturnTypeInference;
 import org.apache.calcite.sql.type.SqlTypeFamily;
 import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.sql.type.SqlTypeTransforms;
+import org.apache.calcite.sql.type.SqlTypeUtil;
+import org.apache.calcite.sql.validate.SqlValidator;
 import org.apache.calcite.util.Litmus;
 import org.apache.calcite.util.Optionality;
-
-import com.google.common.collect.ImmutableList;
+import org.apache.calcite.util.Static;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 
@@ -48,7 +53,9 @@
 import java.util.List;
 
 import static org.apache.calcite.sql.fun.SqlLibrary.BIG_QUERY;
+import static org.apache.calcite.sql.fun.SqlLibrary.CALCITE;
 import static org.apache.calcite.sql.fun.SqlLibrary.HIVE;
+import static org.apache.calcite.sql.fun.SqlLibrary.MSSQL;
 import static org.apache.calcite.sql.fun.SqlLibrary.MYSQL;
 import static org.apache.calcite.sql.fun.SqlLibrary.ORACLE;
 import static org.apache.calcite.sql.fun.SqlLibrary.POSTGRESQL;
@@ -66,19 +73,134 @@ public abstract class SqlLibraryOperators {
   private SqlLibraryOperators() {
   }
 
+  /** The "AGGREGATE(m)" aggregate function;
+   * aggregates a measure column according to the measure's rollup strategy.
+   * This is a Calcite-specific extension.
+   *
+   * <p>This operator is for SQL (and AST); for internal use (RexNode and
+   * Aggregate) use {@code AGG_M2M}. */
+  @LibraryOperator(libraries = {CALCITE})
+  public static final SqlFunction AGGREGATE =
+      SqlBasicAggFunction.create("AGGREGATE", SqlKind.AGGREGATE_FN,
+          ReturnTypes.ARG0, OperandTypes.MEASURE);
+
   /** The "CONVERT_TIMEZONE(tz1, tz2, datetime)" function;
    * converts the timezone of {@code datetime} from {@code tz1} to {@code tz2}.
    * This function is only on Redshift, but we list it in PostgreSQL
    * because Redshift does not have its own library. */
   @LibraryOperator(libraries = {POSTGRESQL})
   public static final SqlFunction CONVERT_TIMEZONE =
-      new SqlFunction("CONVERT_TIMEZONE",
-          SqlKind.OTHER_FUNCTION,
-          ReturnTypes.DATE_NULLABLE,
-          null,
-          OperandTypes.CHARACTER_CHARACTER_DATETIME,
+      SqlBasicFunction.create("CONVERT_TIMEZONE",
+          ReturnTypes.DATE_NULLABLE, OperandTypes.CHARACTER_CHARACTER_DATETIME,
           SqlFunctionCategory.TIMEDATE);
 
+  /** THE "DATE_ADD(date, interval)" function
+   * (BigQuery) adds the interval to the date. */
+  @LibraryOperator(libraries = {BIG_QUERY})
+  public static final SqlFunction DATE_ADD =
+      SqlBasicFunction.create(SqlKind.DATE_ADD, ReturnTypes.ARG0_NULLABLE,
+              OperandTypes.DATE_INTERVAL)
+          .withFunctionType(SqlFunctionCategory.TIMEDATE);
+
+  /** THE "DATE_DIFF(date, date2, timeUnit)" function
+   * (BigQuery) returns the number of timeUnit in (date - date2). */
+  @LibraryOperator(libraries = {BIG_QUERY})
+  public static final SqlFunction DATE_DIFF =
+      new SqlTimestampDiffFunction("DATE_DIFF",
+          OperandTypes.family(SqlTypeFamily.DATE, SqlTypeFamily.DATE, SqlTypeFamily.ANY));
+
+  /** The "DATEADD(timeUnit, numeric, datetime)" function
+   * (Microsoft SQL Server, Redshift, Snowflake). */
+  @LibraryOperator(libraries = {MSSQL, POSTGRESQL})
+  public static final SqlFunction DATEADD =
+      new SqlTimestampAddFunction("DATEADD");
+
+  /** The "DATEDIFF(timeUnit, datetime, datetime2)" function
+   * (Microsoft SQL Server, Redshift, Snowflake).
+   *
+   * <p>MySQL has "DATEDIFF(date, date2)" and "TIMEDIFF(time, time2)" functions
+   * but Calcite does not implement these because they have no "timeUnit"
+   * argument. */
+  @LibraryOperator(libraries = {MSSQL, POSTGRESQL})
+  public static final SqlFunction DATEDIFF =
+      new SqlTimestampDiffFunction("DATEDIFF",
+          OperandTypes.family(SqlTypeFamily.ANY, SqlTypeFamily.DATE,
+              SqlTypeFamily.DATE));
+
+  /** The "CONVERT(type, expr [,style])" function (Microsoft SQL Server).
+   *
+   * <p>Syntax:
+   * <blockquote>{@code
+   * CONVERT( data_type [ ( length ) ], expression [, style ] )
+   * }</blockquote>
+   *
+   * <p>The optional "style" argument specifies how the value is going to be
+   * converted; this implementation ignores the {@code style} parameter.
+   *
+   * <p>{@code CONVERT(type, expr, style)} is equivalent to CAST(expr AS type),
+   * and the implementation delegates most of its logic to actual CAST operator.
+   *
+   * <p>Not to be confused with standard {@link SqlStdOperatorTable#CONVERT},
+   * which converts a string from one character set to another. */
+  @LibraryOperator(libraries = {MSSQL})
+  public static final SqlFunction MSSQL_CONVERT =
+      SqlBasicFunction.create(SqlKind.CAST,
+              ReturnTypes.andThen(SqlLibraryOperators::transformConvert,
+                  SqlCastFunction.returnTypeInference(false)),
+              OperandTypes.repeat(SqlOperandCountRanges.between(2, 3),
+                  OperandTypes.ANY))
+          .withName("CONVERT")
+          .withFunctionType(SqlFunctionCategory.SYSTEM)
+          .withOperandTypeInference(InferTypes.FIRST_KNOWN)
+          .withOperandHandler(
+              OperandHandlers.of(SqlLibraryOperators::transformConvert));
+
+  /** Transforms a call binding of {@code CONVERT} to an equivalent binding for
+   *  {@code CAST}. */
+  private static SqlCallBinding transformConvert(SqlOperatorBinding opBinding) {
+    // Guaranteed to be a SqlCallBinding, with 2 or 3 arguments
+    final SqlCallBinding binding = (SqlCallBinding) opBinding;
+    return new SqlCallBinding(binding.getValidator(), binding.getScope(),
+        transformConvert(binding.getValidator(), binding.getCall()));
+  }
+
+  /** Transforms a call to {@code CONVERT} to an equivalent call to
+   *  {@code CAST}. */
+  private static SqlCall transformConvert(SqlValidator validator, SqlCall call) {
+    return SqlStdOperatorTable.CAST.createCall(call.getParserPosition(),
+        call.operand(1), call.operand(0));
+  }
+
+  /** The "DATE_PART(timeUnit, datetime)" function
+   * (Databricks, Postgres, Redshift, Snowflake). */
+  @LibraryOperator(libraries = {POSTGRESQL})
+  public static final SqlFunction DATE_PART =
+      new SqlExtractFunction("DATE_PART") {
+        @Override public void unparse(SqlWriter writer, SqlCall call,
+            int leftPrec, int rightPrec) {
+          getSyntax().unparse(writer, this, call, leftPrec, rightPrec);
+        }
+      };
+
+  /** The "DATE_SUB(date, interval)" function (BigQuery);
+   * subtracts interval from the date, independent of any time zone. */
+  @LibraryOperator(libraries = {BIG_QUERY})
+  public static final SqlFunction DATE_SUB =
+      SqlBasicFunction.create(SqlKind.DATE_SUB, ReturnTypes.ARG0_NULLABLE,
+           OperandTypes.DATE_INTERVAL)
+          .withFunctionType(SqlFunctionCategory.TIMEDATE);
+
+  /** The "DATEPART(timeUnit, datetime)" function
+   * (Microsoft SQL Server). */
+  @LibraryOperator(libraries = {MSSQL})
+  public static final SqlFunction DATEPART =
+      new SqlExtractFunction("DATEPART") {
+        @Override public void unparse(SqlWriter writer, SqlCall call,
+            int leftPrec, int rightPrec) {
+          getSyntax().unparse(writer, this, call, leftPrec, rightPrec);
+        }
+      };
+
   /** Return type inference for {@code DECODE}. */
   private static final SqlReturnTypeInference DECODE_RETURN_TYPE =
       opBinding -> {
@@ -100,24 +222,19 @@ private SqlLibraryOperators() {
   /** The "DECODE(v, v1, result1, [v2, result2, ...], resultN)" function. */
   @LibraryOperator(libraries = {ORACLE})
   public static final SqlFunction DECODE =
-      new SqlFunction("DECODE", SqlKind.DECODE, DECODE_RETURN_TYPE, null,
-          OperandTypes.VARIADIC, SqlFunctionCategory.SYSTEM);
+      SqlBasicFunction.create(SqlKind.DECODE, DECODE_RETURN_TYPE,
+          OperandTypes.VARIADIC);
 
   /** The "IF(condition, thenValue, elseValue)" function. */
   @LibraryOperator(libraries = {BIG_QUERY, HIVE, SPARK})
   public static final SqlFunction IF =
       new SqlFunction("IF", SqlKind.IF, SqlLibraryOperators::inferIfReturnType,
           null,
-          OperandTypes.and(
-              OperandTypes.family(SqlTypeFamily.BOOLEAN, SqlTypeFamily.ANY,
-                  SqlTypeFamily.ANY),
-              // Arguments 1 and 2 must have same type
-              new SameOperandTypeChecker(3) {
-                @Override protected List<Integer>
-                getOperandList(int operandCount) {
-                  return ImmutableList.of(1, 2);
-                }
-              }),
+          OperandTypes.family(SqlTypeFamily.BOOLEAN, SqlTypeFamily.ANY,
+              SqlTypeFamily.ANY)
+              .and(
+                  // Arguments 1 and 2 must have same type
+                  OperandTypes.same(3, 1, 2)),
           SqlFunctionCategory.SYSTEM) {
         @Override public boolean validRexOperands(int count, Litmus litmus) {
           // IF is translated to RexNode by expanding to CASE.
@@ -135,43 +252,112 @@ private SqlLibraryOperators() {
 
   /** The "NVL(value, value)" function. */
   @LibraryOperator(libraries = {ORACLE})
-  public static final SqlFunction NVL =
-      new SqlFunction("NVL", SqlKind.NVL,
+  public static final SqlBasicFunction NVL =
+      SqlBasicFunction.create(SqlKind.NVL,
           ReturnTypes.LEAST_RESTRICTIVE
               .andThen(SqlTypeTransforms.TO_NULLABLE_ALL),
-          null, OperandTypes.SAME_SAME, SqlFunctionCategory.SYSTEM);
+          OperandTypes.SAME_SAME);
+
+  /** The "IFNULL(value, value)" function. */
+  @LibraryOperator(libraries = {BIG_QUERY})
+  public static final SqlFunction IFNULL = NVL.withName("IFNULL");
+
+  /** The "LENGTH(string)" function. */
+  @LibraryOperator(libraries = {BIG_QUERY})
+  public static final SqlFunction LENGTH =
+      SqlStdOperatorTable.CHAR_LENGTH.withName("LENGTH");
+
+  /** The "LPAD(original_value, return_length[, pattern])" function. */
+  @LibraryOperator(libraries = {BIG_QUERY, ORACLE})
+  public static final SqlFunction LPAD =
+      SqlBasicFunction.create(
+          "LPAD",
+          ReturnTypes.ARG0_NULLABLE_VARYING,
+          OperandTypes.STRING_NUMERIC_OPTIONAL_STRING,
+          SqlFunctionCategory.STRING);
+
+  /** The "RPAD(original_value, return_length[, pattern])" function. */
+  @LibraryOperator(libraries = {BIG_QUERY, ORACLE})
+  public static final SqlFunction RPAD =
+      SqlBasicFunction.create(
+          "RPAD",
+          ReturnTypes.ARG0_NULLABLE_VARYING,
+          OperandTypes.STRING_NUMERIC_OPTIONAL_STRING,
+          SqlFunctionCategory.STRING);
 
   /** The "LTRIM(string)" function. */
-  @LibraryOperator(libraries = {ORACLE})
+  @LibraryOperator(libraries = {BIG_QUERY, ORACLE})
   public static final SqlFunction LTRIM =
-      new SqlFunction("LTRIM", SqlKind.LTRIM,
+      SqlBasicFunction.create(SqlKind.LTRIM,
           ReturnTypes.ARG0.andThen(SqlTypeTransforms.TO_NULLABLE)
-              .andThen(SqlTypeTransforms.TO_VARYING), null,
-          OperandTypes.STRING, SqlFunctionCategory.STRING);
+              .andThen(SqlTypeTransforms.TO_VARYING),
+          OperandTypes.STRING)
+          .withFunctionType(SqlFunctionCategory.STRING);
 
   /** The "RTRIM(string)" function. */
-  @LibraryOperator(libraries = {ORACLE})
+  @LibraryOperator(libraries = {BIG_QUERY, ORACLE})
   public static final SqlFunction RTRIM =
-      new SqlFunction("RTRIM", SqlKind.RTRIM,
+      SqlBasicFunction.create(SqlKind.RTRIM,
           ReturnTypes.ARG0.andThen(SqlTypeTransforms.TO_NULLABLE)
-              .andThen(SqlTypeTransforms.TO_VARYING), null,
-          OperandTypes.STRING, SqlFunctionCategory.STRING);
+              .andThen(SqlTypeTransforms.TO_VARYING),
+          OperandTypes.STRING)
+          .withFunctionType(SqlFunctionCategory.STRING);
 
-  /** BigQuery's "SUBSTR(string, position [, substringLength ])" function. */
+  /** The "SPLIT(string [, delimiter])" function. */
   @LibraryOperator(libraries = {BIG_QUERY})
-  public static final SqlFunction SUBSTR_BIG_QUERY =
-      new SqlFunction("SUBSTR", SqlKind.SUBSTR_BIG_QUERY,
-          ReturnTypes.ARG0_NULLABLE_VARYING, null,
+  public static final SqlFunction SPLIT =
+      SqlBasicFunction.create("SPLIT",
+          ReturnTypes.ARG0
+              .andThen(SqlLibraryOperators::deriveTypeSplit)
+              .andThen(SqlTypeTransforms.TO_ARRAY),
+          OperandTypes.or(OperandTypes.CHARACTER_CHARACTER,
+              OperandTypes.CHARACTER,
+              OperandTypes.BINARY_BINARY,
+              OperandTypes.BINARY),
+          SqlFunctionCategory.STRING)
+          .withValidation(3);
+
+  static RelDataType deriveTypeSplit(SqlOperatorBinding operatorBinding,
+      RelDataType type) {
+    if (SqlTypeUtil.isBinary(type) && operatorBinding.getOperandCount() == 1) {
+      throw operatorBinding.newError(
+          Static.RESOURCE.delimiterIsRequired(
+              operatorBinding.getOperator().getName(), type.toString()));
+    }
+    return type;
+  }
+
+  /** The "STRPOS(string, substring)" function. */
+  @LibraryOperator(libraries = {BIG_QUERY, POSTGRESQL})
+  public static final SqlFunction STRPOS = new SqlPositionFunction("STRPOS");
+
+  /** Generic "SUBSTR(string, position [, substringLength ])" function. */
+  private static final SqlBasicFunction SUBSTR =
+      SqlBasicFunction.create("SUBSTR", ReturnTypes.ARG0_NULLABLE_VARYING,
           OperandTypes.STRING_INTEGER_OPTIONAL_INTEGER,
           SqlFunctionCategory.STRING);
 
+  /** The "ENDS_WITH(value1, value2)" function (BigQuery). */
+  @LibraryOperator(libraries = {BIG_QUERY})
+  public static final SqlFunction ENDS_WITH =
+      SqlBasicFunction.create("ENDS_WITH", ReturnTypes.BOOLEAN_NULLABLE,
+          OperandTypes.STRING_SAME_SAME, SqlFunctionCategory.STRING);
+
+  /** The "STARTS_WITH(value1, value2)" function (BigQuery). */
+  @LibraryOperator(libraries = {BIG_QUERY})
+  public static final SqlFunction STARTS_WITH =
+      SqlBasicFunction.create("STARTS_WITH", ReturnTypes.BOOLEAN_NULLABLE,
+          OperandTypes.STRING_SAME_SAME, SqlFunctionCategory.STRING);
+
+  /** BigQuery's "SUBSTR(string, position [, substringLength ])" function. */
+  @LibraryOperator(libraries = {BIG_QUERY})
+  public static final SqlFunction SUBSTR_BIG_QUERY =
+      SUBSTR.withKind(SqlKind.SUBSTR_BIG_QUERY);
+
   /** MySQL's "SUBSTR(string, position [, substringLength ])" function. */
   @LibraryOperator(libraries = {MYSQL})
   public static final SqlFunction SUBSTR_MYSQL =
-      new SqlFunction("SUBSTR", SqlKind.SUBSTR_MYSQL,
-          ReturnTypes.ARG0_NULLABLE_VARYING, null,
-          OperandTypes.STRING_INTEGER_OPTIONAL_INTEGER,
-          SqlFunctionCategory.STRING);
+      SUBSTR.withKind(SqlKind.SUBSTR_MYSQL);
 
   /** Oracle's "SUBSTR(string, position [, substringLength ])" function.
    *
@@ -189,32 +375,26 @@ private SqlLibraryOperators() {
    */
   @LibraryOperator(libraries = {ORACLE})
   public static final SqlFunction SUBSTR_ORACLE =
-      new SqlFunction("SUBSTR", SqlKind.SUBSTR_ORACLE,
-          ReturnTypes.ARG0_NULLABLE_VARYING, null,
-          OperandTypes.STRING_INTEGER_OPTIONAL_INTEGER,
-          SqlFunctionCategory.STRING);
+      SUBSTR.withKind(SqlKind.SUBSTR_ORACLE);
 
   /** PostgreSQL's "SUBSTR(string, position [, substringLength ])" function. */
   @LibraryOperator(libraries = {POSTGRESQL})
   public static final SqlFunction SUBSTR_POSTGRESQL =
-      new SqlFunction("SUBSTR", SqlKind.SUBSTR_POSTGRESQL,
-          ReturnTypes.ARG0_NULLABLE_VARYING, null,
-          OperandTypes.STRING_INTEGER_OPTIONAL_INTEGER,
-          SqlFunctionCategory.STRING);
+      SUBSTR.withKind(SqlKind.SUBSTR_POSTGRESQL);
 
   /** The "GREATEST(value, value)" function. */
-  @LibraryOperator(libraries = {ORACLE})
+  @LibraryOperator(libraries = {BIG_QUERY, ORACLE})
   public static final SqlFunction GREATEST =
-      new SqlFunction("GREATEST", SqlKind.GREATEST,
+      SqlBasicFunction.create(SqlKind.GREATEST,
           ReturnTypes.LEAST_RESTRICTIVE.andThen(SqlTypeTransforms.TO_NULLABLE),
-          null, OperandTypes.SAME_VARIADIC, SqlFunctionCategory.SYSTEM);
+          OperandTypes.SAME_VARIADIC);
 
   /** The "LEAST(value, value)" function. */
-  @LibraryOperator(libraries = {ORACLE})
+  @LibraryOperator(libraries = {BIG_QUERY, ORACLE})
   public static final SqlFunction LEAST =
-      new SqlFunction("LEAST", SqlKind.LEAST,
+      SqlBasicFunction.create(SqlKind.LEAST,
           ReturnTypes.LEAST_RESTRICTIVE.andThen(SqlTypeTransforms.TO_NULLABLE),
-          null, OperandTypes.SAME_VARIADIC, SqlFunctionCategory.SYSTEM);
+          OperandTypes.SAME_VARIADIC);
 
   /**
    * The <code>TRANSLATE(<i>string_expr</i>, <i>search_chars</i>,
@@ -225,7 +405,7 @@ private SqlLibraryOperators() {
    * <p>It is not defined in the SQL standard, but occurs in Oracle and
    * PostgreSQL.
    */
-  @LibraryOperator(libraries = {ORACLE, POSTGRESQL})
+  @LibraryOperator(libraries = {BIG_QUERY, ORACLE, POSTGRESQL})
   public static final SqlFunction TRANSLATE3 = new SqlTranslate3Function();
 
   @LibraryOperator(libraries = {MYSQL})
@@ -249,42 +429,49 @@ private SqlLibraryOperators() {
   @LibraryOperator(libraries = {MYSQL})
   public static final SqlFunction JSON_STORAGE_SIZE = new SqlJsonStorageSizeFunction();
 
+  @LibraryOperator(libraries = {MYSQL})
+  public static final SqlFunction JSON_INSERT = new SqlJsonModifyFunction("JSON_INSERT");
+
+  @LibraryOperator(libraries = {MYSQL})
+  public static final SqlFunction JSON_REPLACE = new SqlJsonModifyFunction("JSON_REPLACE");
+
+  @LibraryOperator(libraries = {MYSQL})
+  public static final SqlFunction JSON_SET = new SqlJsonModifyFunction("JSON_SET");
+
   @LibraryOperator(libraries = {MYSQL, ORACLE})
   public static final SqlFunction REGEXP_REPLACE = new SqlRegexpReplaceFunction();
 
   @LibraryOperator(libraries = {MYSQL})
   public static final SqlFunction COMPRESS =
-      new SqlFunction("COMPRESS", SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("COMPRESS",
           ReturnTypes.explicit(SqlTypeName.VARBINARY)
               .andThen(SqlTypeTransforms.TO_NULLABLE),
-          null, OperandTypes.STRING, SqlFunctionCategory.STRING);
-
+          OperandTypes.STRING, SqlFunctionCategory.STRING);
 
   @LibraryOperator(libraries = {MYSQL})
   public static final SqlFunction EXTRACT_VALUE =
-      new SqlFunction("EXTRACTVALUE", SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("EXTRACTVALUE",
           ReturnTypes.VARCHAR_2000.andThen(SqlTypeTransforms.FORCE_NULLABLE),
-          null, OperandTypes.STRING_STRING, SqlFunctionCategory.SYSTEM);
+          OperandTypes.STRING_STRING);
 
   @LibraryOperator(libraries = {ORACLE})
   public static final SqlFunction XML_TRANSFORM =
-      new SqlFunction("XMLTRANSFORM", SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("XMLTRANSFORM",
           ReturnTypes.VARCHAR_2000.andThen(SqlTypeTransforms.FORCE_NULLABLE),
-          null, OperandTypes.STRING_STRING, SqlFunctionCategory.SYSTEM);
+          OperandTypes.STRING_STRING);
 
   @LibraryOperator(libraries = {ORACLE})
   public static final SqlFunction EXTRACT_XML =
-      new SqlFunction("EXTRACT", SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("EXTRACT",
           ReturnTypes.VARCHAR_2000.andThen(SqlTypeTransforms.FORCE_NULLABLE),
-          null, OperandTypes.STRING_STRING_OPTIONAL_STRING,
-          SqlFunctionCategory.SYSTEM);
+          OperandTypes.STRING_STRING_OPTIONAL_STRING);
 
   @LibraryOperator(libraries = {ORACLE})
   public static final SqlFunction EXISTS_NODE =
-      new SqlFunction("EXISTSNODE", SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("EXISTSNODE",
           ReturnTypes.INTEGER_NULLABLE
-              .andThen(SqlTypeTransforms.FORCE_NULLABLE), null,
-          OperandTypes.STRING_STRING_OPTIONAL_STRING, SqlFunctionCategory.SYSTEM);
+              .andThen(SqlTypeTransforms.FORCE_NULLABLE),
+          OperandTypes.STRING_STRING_OPTIONAL_STRING);
 
   /** The "BOOL_AND(condition)" aggregate function, PostgreSQL and Redshift's
    * equivalent to {@link SqlStdOperatorTable#EVERY}. */
@@ -353,7 +540,7 @@ private SqlLibraryOperators() {
   public static final SqlAggFunction STRING_AGG =
       SqlBasicAggFunction
           .create(SqlKind.STRING_AGG, ReturnTypes.ARG0_NULLABLE,
-              OperandTypes.or(OperandTypes.STRING, OperandTypes.STRING_STRING))
+              OperandTypes.STRING.or(OperandTypes.STRING_STRING))
           .withFunctionType(SqlFunctionCategory.SYSTEM)
           .withSyntax(SqlSyntax.ORDERED_FUNCTION);
 
@@ -369,114 +556,222 @@ private SqlLibraryOperators() {
           .create(SqlKind.GROUP_CONCAT,
               ReturnTypes.andThen(ReturnTypes::stripOrderBy,
                   ReturnTypes.ARG0_NULLABLE),
-              OperandTypes.or(OperandTypes.STRING, OperandTypes.STRING_STRING))
+              OperandTypes.STRING.or(OperandTypes.STRING_STRING))
           .withFunctionType(SqlFunctionCategory.SYSTEM)
           .withAllowsNullTreatment(false)
           .withAllowsSeparator(true)
           .withSyntax(SqlSyntax.ORDERED_FUNCTION);
 
-  /** The "DATE(string)" function, equivalent to "CAST(string AS DATE). */
+  /** The "MAX_BY(value, comp)" aggregate function, Spark's
+   * equivalent to {@link SqlStdOperatorTable#ARG_MAX}. */
+  @LibraryOperator(libraries = {SPARK})
+  public static final SqlAggFunction MAX_BY =
+      SqlStdOperatorTable.ARG_MAX.withName("MAX_BY");
+
+  /** The "MIN_BY(condition)" aggregate function, Spark's
+   * equivalent to {@link SqlStdOperatorTable#ARG_MIN}. */
+  @LibraryOperator(libraries = {SPARK})
+  public static final SqlAggFunction MIN_BY =
+      SqlStdOperatorTable.ARG_MIN.withName("MIN_BY");
+
+  /** The "DATE" function. It has the following overloads:
+   *
+   * <ul>
+   *   <li>{@code DATE(string)} is syntactic sugar for
+   *       {@code CAST(string AS DATE)}
+   *   <li>{@code DATE(year, month, day)}
+   *   <li>{@code DATE(timestampLtz [, timeZone])}
+   *   <li>{@code DATE(timestamp)}
+   * </ul>
+   */
   @LibraryOperator(libraries = {BIG_QUERY})
   public static final SqlFunction DATE =
-      new SqlFunction("DATE", SqlKind.OTHER_FUNCTION,
-          ReturnTypes.DATE_NULLABLE, null, OperandTypes.STRING,
+      SqlBasicFunction.create("DATE", ReturnTypes.DATE_NULLABLE,
+          OperandTypes.or(
+              // DATE(string)
+              OperandTypes.STRING,
+              // DATE(year, month, day)
+              OperandTypes.family(SqlTypeFamily.INTEGER, SqlTypeFamily.INTEGER,
+                  SqlTypeFamily.INTEGER),
+              // DATE(timestamp)
+              OperandTypes.TIMESTAMP_NTZ,
+              // DATE(timestampLtz)
+              OperandTypes.TIMESTAMP_LTZ,
+              // DATE(timestampLtz, timeZone)
+              OperandTypes.sequence(
+                  "DATE(TIMESTAMP WITH LOCAL TIME ZONE, VARCHAR)",
+                  OperandTypes.TIMESTAMP_LTZ, OperandTypes.CHARACTER)),
+          SqlFunctionCategory.TIMEDATE);
+
+  /** The "DATETIME" function returns a Calcite
+   * {@code TIMESTAMP} (which BigQuery calls a {@code DATETIME}).
+   *
+   * <p>It has the following overloads:
+   *
+   * <ul>
+   *   <li>{@code DATETIME(year, month, day, hour, minute, second)}
+   *   <li>{@code DATETIME(date[, time])}
+   *   <li>{@code DATETIME(timestampLtz[, timeZone])}
+   * </ul>
+   */
+  @LibraryOperator(libraries = {BIG_QUERY})
+  public static final SqlFunction DATETIME =
+      SqlBasicFunction.create("DATETIME", ReturnTypes.TIMESTAMP_NULLABLE,
+          OperandTypes.or(
+              // DATETIME(year, month, day, hour, minute, second)
+              OperandTypes.family(SqlTypeFamily.INTEGER, SqlTypeFamily.INTEGER,
+                  SqlTypeFamily.INTEGER, SqlTypeFamily.INTEGER,
+                  SqlTypeFamily.INTEGER, SqlTypeFamily.INTEGER),
+              // DATETIME(date)
+              OperandTypes.DATE,
+              // DATETIME(date, time)
+              OperandTypes.DATE_TIME,
+              // DATETIME(timestampLtz)
+              OperandTypes.TIMESTAMP_LTZ,
+              // DATETIME(timestampLtz, timeZone)
+              OperandTypes.sequence(
+                  "DATETIME(TIMESTAMP WITH LOCAL TIME ZONE, VARCHAR)",
+                  OperandTypes.TIMESTAMP_LTZ, OperandTypes.CHARACTER)),
+          SqlFunctionCategory.TIMEDATE);
+
+  /** The "TIME" function. It has the following overloads:
+   *
+   * <ul>
+   *   <li>{@code TIME(hour, minute, second)}
+   *   <li>{@code TIME(timestampLtz [, timeZone])}
+   *   <li>{@code TIME(timestamp)}
+   * </ul>
+   */
+  @LibraryOperator(libraries = {BIG_QUERY})
+  public static final SqlFunction TIME =
+      SqlBasicFunction.create("TIME", ReturnTypes.TIME_NULLABLE,
+          OperandTypes.or(
+              // TIME(hour, minute, second)
+              OperandTypes.family(SqlTypeFamily.INTEGER, SqlTypeFamily.INTEGER,
+                  SqlTypeFamily.INTEGER),
+              // TIME(timestamp)
+              OperandTypes.TIMESTAMP_NTZ,
+              // TIME(timestampLtz)
+              OperandTypes.TIMESTAMP_LTZ,
+              // TIME(timestampLtz, timeZone)
+              OperandTypes.sequence(
+                  "TIME(TIMESTAMP WITH LOCAL TIME ZONE, VARCHAR)",
+                  OperandTypes.TIMESTAMP_LTZ, OperandTypes.CHARACTER)),
+          SqlFunctionCategory.TIMEDATE);
+
+  /** The "TIMESTAMP" function returns a Calcite
+   * {@code TIMESTAMP WITH LOCAL TIME ZONE}
+   * (which BigQuery calls a {@code TIMESTAMP}). It has the following overloads:
+   *
+   * <ul>
+   *   <li>{@code TIMESTAMP(string[, timeZone])}
+   *   <li>{@code TIMESTAMP(date[, timeZone])}
+   *   <li>{@code TIMESTAMP(timestamp[, timeZone])}
+   * </ul>
+   */
+  @LibraryOperator(libraries = {BIG_QUERY})
+  public static final SqlFunction TIMESTAMP =
+      SqlBasicFunction.create("TIMESTAMP",
+          ReturnTypes.TIMESTAMP_LTZ.andThen(SqlTypeTransforms.TO_NULLABLE),
+          OperandTypes.or(
+              // TIMESTAMP(string)
+              OperandTypes.CHARACTER,
+              // TIMESTAMP(string, timeZone)
+              OperandTypes.CHARACTER_CHARACTER,
+              // TIMESTAMP(date)
+              OperandTypes.DATE,
+              // TIMESTAMP(date, timeZone)
+              OperandTypes.DATE_CHARACTER,
+              // TIMESTAMP(timestamp)
+              OperandTypes.TIMESTAMP_NTZ,
+              // TIMESTAMP(timestamp, timeZone)
+              OperandTypes.sequence("TIMESTAMP(TIMESTAMP, VARCHAR)",
+                  OperandTypes.TIMESTAMP_NTZ, OperandTypes.CHARACTER)),
           SqlFunctionCategory.TIMEDATE);
 
   /** The "CURRENT_DATETIME([timezone])" function. */
   @LibraryOperator(libraries = {BIG_QUERY})
   public static final SqlFunction CURRENT_DATETIME =
-      new SqlFunction("CURRENT_DATETIME", SqlKind.OTHER_FUNCTION,
-          ReturnTypes.TIMESTAMP.andThen(SqlTypeTransforms.TO_NULLABLE), null,
-          OperandTypes.or(OperandTypes.NILADIC, OperandTypes.STRING),
+      SqlBasicFunction.create("CURRENT_DATETIME",
+          ReturnTypes.TIMESTAMP.andThen(SqlTypeTransforms.TO_NULLABLE),
+          OperandTypes.NILADIC.or(OperandTypes.STRING),
           SqlFunctionCategory.TIMEDATE);
 
   /** The "DATE_FROM_UNIX_DATE(integer)" function; returns a DATE value
    * a given number of seconds after 1970-01-01. */
   @LibraryOperator(libraries = {BIG_QUERY})
   public static final SqlFunction DATE_FROM_UNIX_DATE =
-      new SqlFunction("DATE_FROM_UNIX_DATE", SqlKind.OTHER_FUNCTION,
-          ReturnTypes.DATE_NULLABLE, null, OperandTypes.INTEGER,
+      SqlBasicFunction.create("DATE_FROM_UNIX_DATE",
+          ReturnTypes.DATE_NULLABLE, OperandTypes.INTEGER,
           SqlFunctionCategory.TIMEDATE);
 
   /** The "UNIX_DATE(date)" function; returns the number of days since
    * 1970-01-01. */
   @LibraryOperator(libraries = {BIG_QUERY})
   public static final SqlFunction UNIX_DATE =
-      new SqlFunction("UNIX_DATE", SqlKind.OTHER_FUNCTION,
-          ReturnTypes.INTEGER_NULLABLE, null, OperandTypes.DATE,
+      SqlBasicFunction.create("UNIX_DATE",
+          ReturnTypes.INTEGER_NULLABLE, OperandTypes.DATE,
           SqlFunctionCategory.TIMEDATE);
 
   /** The "MONTHNAME(datetime)" function; returns the name of the month,
    * in the current locale, of a TIMESTAMP or DATE argument. */
   @LibraryOperator(libraries = {MYSQL})
   public static final SqlFunction MONTHNAME =
-      new SqlFunction("MONTHNAME", SqlKind.OTHER_FUNCTION,
-          ReturnTypes.VARCHAR_2000, null, OperandTypes.DATETIME,
+      SqlBasicFunction.create("MONTHNAME",
+          ReturnTypes.VARCHAR_2000, OperandTypes.DATETIME,
           SqlFunctionCategory.TIMEDATE);
 
   /** The "DAYNAME(datetime)" function; returns the name of the day of the week,
    * in the current locale, of a TIMESTAMP or DATE argument. */
   @LibraryOperator(libraries = {MYSQL})
   public static final SqlFunction DAYNAME =
-      new SqlFunction("DAYNAME", SqlKind.OTHER_FUNCTION,
-          ReturnTypes.VARCHAR_2000, null, OperandTypes.DATETIME,
+      SqlBasicFunction.create("DAYNAME",
+          ReturnTypes.VARCHAR_2000, OperandTypes.DATETIME,
           SqlFunctionCategory.TIMEDATE);
 
-  @LibraryOperator(libraries = {MYSQL, POSTGRESQL})
+  @LibraryOperator(libraries = {BIG_QUERY, MYSQL, POSTGRESQL})
   public static final SqlFunction LEFT =
-      new SqlFunction("LEFT", SqlKind.OTHER_FUNCTION,
-          ReturnTypes.ARG0_NULLABLE_VARYING, null,
+      SqlBasicFunction.create("LEFT",
+          ReturnTypes.ARG0_NULLABLE_VARYING,
           OperandTypes.CBSTRING_INTEGER, SqlFunctionCategory.STRING);
 
-  @LibraryOperator(libraries = {MYSQL, POSTGRESQL})
+  @LibraryOperator(libraries = {BIG_QUERY, MYSQL, POSTGRESQL})
   public static final SqlFunction REPEAT =
-      new SqlFunction(
-          "REPEAT",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("REPEAT",
           ReturnTypes.ARG0_NULLABLE_VARYING,
-          null,
           OperandTypes.STRING_INTEGER,
           SqlFunctionCategory.STRING);
 
-  @LibraryOperator(libraries = {MYSQL, POSTGRESQL})
+  @LibraryOperator(libraries = {BIG_QUERY, MYSQL, POSTGRESQL})
   public static final SqlFunction RIGHT =
-      new SqlFunction("RIGHT", SqlKind.OTHER_FUNCTION,
-          ReturnTypes.ARG0_NULLABLE_VARYING, null,
+      SqlBasicFunction.create("RIGHT", ReturnTypes.ARG0_NULLABLE_VARYING,
           OperandTypes.CBSTRING_INTEGER, SqlFunctionCategory.STRING);
 
   @LibraryOperator(libraries = {MYSQL})
   public static final SqlFunction SPACE =
-      new SqlFunction("SPACE",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("SPACE",
           ReturnTypes.VARCHAR_2000_NULLABLE,
-          null,
           OperandTypes.INTEGER,
           SqlFunctionCategory.STRING);
 
   @LibraryOperator(libraries = {MYSQL})
   public static final SqlFunction STRCMP =
-      new SqlFunction("STRCMP",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("STRCMP",
           ReturnTypes.INTEGER_NULLABLE,
-          null,
           OperandTypes.STRING_STRING,
           SqlFunctionCategory.STRING);
 
-  @LibraryOperator(libraries = {MYSQL, POSTGRESQL, ORACLE})
+  @LibraryOperator(libraries = {BIG_QUERY, MYSQL, POSTGRESQL, ORACLE})
   public static final SqlFunction SOUNDEX =
-      new SqlFunction("SOUNDEX",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("SOUNDEX",
           ReturnTypes.VARCHAR_4_NULLABLE,
-          null,
           OperandTypes.CHARACTER,
           SqlFunctionCategory.STRING);
 
   @LibraryOperator(libraries = {POSTGRESQL})
   public static final SqlFunction DIFFERENCE =
-      new SqlFunction("DIFFERENCE",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("DIFFERENCE",
           ReturnTypes.INTEGER_NULLABLE,
-          null,
           OperandTypes.STRING_STRING,
           SqlFunctionCategory.STRING);
 
@@ -502,15 +797,14 @@ private SqlLibraryOperators() {
 
   /** The "CONCAT(arg, ...)" function that concatenates strings.
    * For example, "CONCAT('a', 'bc', 'd')" returns "abcd". */
-  @LibraryOperator(libraries = {MYSQL, POSTGRESQL})
+  @LibraryOperator(libraries = {MYSQL, POSTGRESQL, BIG_QUERY})
   public static final SqlFunction CONCAT_FUNCTION =
-      new SqlFunction("CONCAT",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("CONCAT",
           ReturnTypes.MULTIVALENT_STRING_SUM_PRECISION_NULLABLE,
-          InferTypes.RETURN_TYPE,
           OperandTypes.repeat(SqlOperandCountRanges.from(2),
               OperandTypes.STRING),
-          SqlFunctionCategory.STRING);
+          SqlFunctionCategory.STRING)
+          .withOperandTypeInference(InferTypes.RETURN_TYPE);
 
   /** The "CONCAT(arg0, arg1)" function that concatenates strings.
    * For example, "CONCAT('a', 'bc')" returns "abc".
@@ -519,75 +813,62 @@ private SqlLibraryOperators() {
    * {@link #CONCAT_FUNCTION}. */
   @LibraryOperator(libraries = {ORACLE})
   public static final SqlFunction CONCAT2 =
-      new SqlFunction("CONCAT",
-          SqlKind.CONCAT2,
+      SqlBasicFunction.create("CONCAT",
           ReturnTypes.MULTIVALENT_STRING_SUM_PRECISION_NULLABLE,
-          InferTypes.RETURN_TYPE,
           OperandTypes.STRING_SAME_SAME,
-          SqlFunctionCategory.STRING);
+          SqlFunctionCategory.STRING)
+          .withOperandTypeInference(InferTypes.RETURN_TYPE)
+          .withKind(SqlKind.CONCAT2);
 
   /** The "ARRAY_LENGTH(array)" function. */
   @LibraryOperator(libraries = {BIG_QUERY})
   public static final SqlFunction ARRAY_LENGTH =
-      new SqlFunction("ARRAY_LENGTH",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("ARRAY_LENGTH",
           ReturnTypes.INTEGER_NULLABLE,
-          null,
-          OperandTypes.ARRAY,
-          SqlFunctionCategory.SYSTEM);
+          OperandTypes.ARRAY);
 
   /** The "ARRAY_REVERSE(array)" function. */
   @LibraryOperator(libraries = {BIG_QUERY})
   public static final SqlFunction ARRAY_REVERSE =
-      new SqlFunction("ARRAY_REVERSE",
-          SqlKind.ARRAY_REVERSE,
+      SqlBasicFunction.create(SqlKind.ARRAY_REVERSE,
           ReturnTypes.ARG0_NULLABLE,
-          null,
-          OperandTypes.ARRAY,
-          SqlFunctionCategory.SYSTEM);
+          OperandTypes.ARRAY);
 
   /** The "ARRAY_CONCAT(array [, array]*)" function. */
   @LibraryOperator(libraries = {BIG_QUERY})
   public static final SqlFunction ARRAY_CONCAT =
-      new SqlFunction("ARRAY_CONCAT",
-          SqlKind.ARRAY_CONCAT,
+      SqlBasicFunction.create(SqlKind.ARRAY_CONCAT,
           ReturnTypes.LEAST_RESTRICTIVE,
-          null,
-          OperandTypes.AT_LEAST_ONE_SAME_VARIADIC,
-          SqlFunctionCategory.SYSTEM);
+          OperandTypes.AT_LEAST_ONE_SAME_VARIADIC);
 
-  @LibraryOperator(libraries = {MYSQL})
+  @LibraryOperator(libraries = {BIG_QUERY, MYSQL})
   public static final SqlFunction REVERSE =
-      new SqlFunction("REVERSE",
-          SqlKind.REVERSE,
+      SqlBasicFunction.create(SqlKind.REVERSE,
           ReturnTypes.ARG0_NULLABLE_VARYING,
-          null,
-          OperandTypes.CHARACTER,
-          SqlFunctionCategory.STRING);
+          OperandTypes.CHARACTER)
+          .withFunctionType(SqlFunctionCategory.STRING);
 
-  @LibraryOperator(libraries = {MYSQL})
+  @LibraryOperator(libraries = {BIG_QUERY, MYSQL})
   public static final SqlFunction FROM_BASE64 =
-      new SqlFunction("FROM_BASE64", SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("FROM_BASE64",
           ReturnTypes.explicit(SqlTypeName.VARBINARY)
               .andThen(SqlTypeTransforms.TO_NULLABLE),
-          null, OperandTypes.STRING, SqlFunctionCategory.STRING);
+          OperandTypes.STRING, SqlFunctionCategory.STRING);
 
   @LibraryOperator(libraries = {MYSQL})
   public static final SqlFunction TO_BASE64 =
-      new SqlFunction("TO_BASE64", SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("TO_BASE64",
           ReturnTypes.explicit(SqlTypeName.VARCHAR)
               .andThen(SqlTypeTransforms.TO_NULLABLE),
-          null, OperandTypes.or(OperandTypes.STRING, OperandTypes.BINARY),
+          OperandTypes.STRING.or(OperandTypes.BINARY),
           SqlFunctionCategory.STRING);
 
   /** The "TO_DATE(string1, string2)" function; casts string1
    * to a DATE using the format specified in string2. */
   @LibraryOperator(libraries = {POSTGRESQL, ORACLE})
   public static final SqlFunction TO_DATE =
-      new SqlFunction("TO_DATE",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("TO_DATE",
           ReturnTypes.DATE_NULLABLE,
-          null,
           OperandTypes.STRING_STRING,
           SqlFunctionCategory.TIMEDATE);
 
@@ -595,119 +876,340 @@ private SqlLibraryOperators() {
    * to a TIMESTAMP using the format specified in string2. */
   @LibraryOperator(libraries = {POSTGRESQL, ORACLE})
   public static final SqlFunction TO_TIMESTAMP =
-      new SqlFunction("TO_TIMESTAMP",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("TO_TIMESTAMP",
           ReturnTypes.DATE_NULLABLE,
-          null,
           OperandTypes.STRING_STRING,
           SqlFunctionCategory.TIMEDATE);
 
+  /** The "FORMAT_TIME(string, time)" function (BigQuery);
+   * Formats a time object according to the specified string. */
+  @LibraryOperator(libraries = {BIG_QUERY})
+  public static final SqlFunction FORMAT_TIME =
+      SqlBasicFunction.create("FORMAT_TIME", ReturnTypes.VARCHAR_2000_NULLABLE,
+          OperandTypes.CHARACTER_TIME, SqlFunctionCategory.STRING);
+
+  /** The "FORMAT_DATE(string, date)" function (BigQuery);
+   * Formats a date object according to the specified string. */
+  @LibraryOperator(libraries = {BIG_QUERY})
+  public static final SqlFunction FORMAT_DATE =
+      SqlBasicFunction.create("FORMAT_DATE", ReturnTypes.VARCHAR_2000_NULLABLE,
+          OperandTypes.CHARACTER_DATE, SqlFunctionCategory.STRING);
+
+  /** The "FORMAT_TIMESTAMP(string, timestamp)" function (BigQuery);
+   * Formats a timestamp object according to the specified string.
+   *
+   * <p>In BigQuery, the "TIMESTAMP" datatype maps to Calcite's
+   * TIMESTAMP_WITH_LOCAL_TIME_ZONE */
+  @LibraryOperator(libraries = {BIG_QUERY})
+  public static final SqlFunction FORMAT_TIMESTAMP =
+      SqlBasicFunction.create("FORMAT_TIMESTAMP",
+          ReturnTypes.VARCHAR_2000_NULLABLE,
+          OperandTypes.sequence("FORMAT_TIMESTAMP(<CHARACTER>, "
+                  + "<TIMESTAMP WITH LOCAL TIME ZONE>)",
+              OperandTypes.CHARACTER, OperandTypes.TIMESTAMP_LTZ)
+              .or(
+                  OperandTypes.sequence("FORMAT_TIMESTAMP(<CHARACTER>, "
+                          + "<TIMESTAMP WITH LOCAL TIME ZONE>, <CHARACTER>)",
+                      OperandTypes.CHARACTER, OperandTypes.TIMESTAMP_LTZ,
+                      OperandTypes.CHARACTER)),
+          SqlFunctionCategory.STRING);
+
+  /** The "FORMAT_DATETIME(string, timestamp)" function (BigQuery);
+   * formats a timestamp object according to the specified string.
+   *
+   * <p>Note that the {@code TIMESTAMP} type of Calcite and Standard SQL
+   * is called {@code DATETIME} in BigQuery. */
+  @LibraryOperator(libraries = {BIG_QUERY})
+  public static final SqlFunction FORMAT_DATETIME =
+      SqlBasicFunction.create("FORMAT_DATETIME",
+          ReturnTypes.VARCHAR_2000_NULLABLE,
+          OperandTypes.sequence("FORMAT_DATETIME(<CHARACTER>, <TIMESTAMP>)",
+                  OperandTypes.CHARACTER, OperandTypes.TIMESTAMP_NTZ)
+              .or(
+                  OperandTypes.sequence("FORMAT_DATETIME(<CHARACTER>, "
+                          + "<TIMESTAMP>, <CHARACTER>)",
+                      OperandTypes.CHARACTER, OperandTypes.TIMESTAMP_NTZ,
+                      OperandTypes.CHARACTER)),
+          SqlFunctionCategory.STRING);
+
+  /** The "TIMESTAMP_ADD(timestamp, interval)" function (BigQuery), the
+   * two-argument variant of the built-in
+   * {@link SqlStdOperatorTable#TIMESTAMP_ADD TIMESTAMPADD} function, which has
+   * three arguments.
+   *
+   * <p>In BigQuery, the syntax is "TIMESTAMP_ADD(timestamp, INTERVAL
+   * int64_expression date_part)" but in Calcite the second argument can be any
+   * interval expression, not just an interval literal. */
+  @LibraryOperator(libraries = {BIG_QUERY})
+  public static final SqlBasicFunction TIMESTAMP_ADD2 =
+      SqlBasicFunction.create(SqlKind.TIMESTAMP_ADD, ReturnTypes.ARG0_NULLABLE,
+          OperandTypes.TIMESTAMP_INTERVAL)
+          .withFunctionType(SqlFunctionCategory.TIMEDATE);
+
+  /** The "TIMESTAMP_DIFF(timestamp, timestamp, timeUnit)" function (BigQuery);
+   * returns the number of timeUnit between the two timestamp expressions.
+   *
+   * <p>{@code TIMESTAMP_DIFF(t1, t2, unit)} is equivalent to
+   * {@code TIMESTAMPDIFF(unit, t2, t1)} and {@code (t1 - t2) unit}. */
+  @LibraryOperator(libraries = {BIG_QUERY})
+  public static final SqlFunction TIMESTAMP_DIFF3 =
+      new SqlTimestampDiffFunction("TIMESTAMP_DIFF",
+          OperandTypes.family(SqlTypeFamily.TIMESTAMP, SqlTypeFamily.TIMESTAMP,
+              SqlTypeFamily.ANY));
+
+  /** The "TIME_ADD(time, interval)" function (BigQuery);
+   * adds interval expression to the specified time expression. */
+  @LibraryOperator(libraries = {BIG_QUERY})
+  public static final SqlFunction TIME_ADD =
+      SqlBasicFunction.create(SqlKind.TIME_ADD, ReturnTypes.ARG0_NULLABLE,
+              OperandTypes.TIME_INTERVAL)
+          .withFunctionType(SqlFunctionCategory.TIMEDATE);
+
+  /** The "TIME_DIFF(time, time, timeUnit)" function (BigQuery);
+   * returns the number of timeUnit between the two time expressions. */
+  @LibraryOperator(libraries = {BIG_QUERY})
+  public static final SqlFunction TIME_DIFF =
+      new SqlTimestampDiffFunction("TIME_DIFF",
+          OperandTypes.family(SqlTypeFamily.TIME, SqlTypeFamily.TIME,
+              SqlTypeFamily.ANY));
+
+  /** The "DATE_TRUNC(date, timeUnit)" function (BigQuery);
+   * truncates a DATE value to the beginning of a timeUnit. */
+  @LibraryOperator(libraries = {BIG_QUERY})
+  public static final SqlFunction DATE_TRUNC =
+      SqlBasicFunction.create("DATE_TRUNC",
+          ReturnTypes.DATE_NULLABLE,
+          OperandTypes.sequence("'DATE_TRUNC(<DATE>, <DATETIME_INTERVAL>)'",
+              OperandTypes.DATE, OperandTypes.dateInterval()),
+          SqlFunctionCategory.TIMEDATE)
+          .withOperandHandler(OperandHandlers.OPERAND_1_MIGHT_BE_TIME_FRAME);
+
+  /** The "TIME_SUB(time, interval)" function (BigQuery);
+   * subtracts an interval from a time, independent of any time zone.
+   *
+   * <p>In BigQuery, the syntax is "TIME_SUB(time, INTERVAL int64 date_part)"
+   * but in Calcite the second argument can be any interval expression, not just
+   * an interval literal. */
+  @LibraryOperator(libraries = {BIG_QUERY})
+  public static final SqlFunction TIME_SUB =
+      SqlBasicFunction.create(SqlKind.TIME_SUB, ReturnTypes.ARG0_NULLABLE,
+              OperandTypes.TIME_INTERVAL)
+          .withFunctionType(SqlFunctionCategory.TIMEDATE);
+
+  /** The "TIME_TRUNC(time, timeUnit)" function (BigQuery);
+   * truncates a TIME value to the beginning of a timeUnit. */
+  @LibraryOperator(libraries = {BIG_QUERY})
+  public static final SqlFunction TIME_TRUNC =
+      SqlBasicFunction.create("TIME_TRUNC",
+          ReturnTypes.TIME_NULLABLE,
+          OperandTypes.sequence("'TIME_TRUNC(<TIME>, <DATETIME_INTERVAL>)'",
+              OperandTypes.TIME, OperandTypes.timeInterval()),
+          SqlFunctionCategory.TIMEDATE);
+
+  /** The "TIMESTAMP_SUB(timestamp, interval)" function (BigQuery);
+   * subtracts an interval from a timestamp, independent of any time zone.
+   *
+   * <p>In BigQuery, the syntax is "TIMESTAMP_SUB(timestamp,
+   * INTERVAL int64 date_part)" but in Calcite the second argument can be any
+   * interval expression, not just an interval literal. */
+  @LibraryOperator(libraries = {BIG_QUERY})
+  public static final SqlBasicFunction TIMESTAMP_SUB =
+      SqlBasicFunction.create(SqlKind.TIMESTAMP_SUB, ReturnTypes.ARG0_NULLABLE,
+          OperandTypes.TIMESTAMP_INTERVAL)
+          .withFunctionType(SqlFunctionCategory.TIMEDATE);
+
+  /** The "DATETIME_SUB(timestamp, interval)" function (BigQuery).
+   *
+   * <p>Note that the {@code TIMESTAMP} type of Calcite and Standard SQL
+   * is called {@code DATETIME} in BigQuery.
+   *
+   * <p>A synonym for {@link #TIMESTAMP_SUB}, which supports both
+   * {@code TIMESTAMP} and {@code TIMESTAMP WITH LOCAL TIME ZONE} operands. */
+  @LibraryOperator(libraries = {BIG_QUERY})
+  public static final SqlFunction DATETIME_SUB =
+      TIMESTAMP_SUB.withName("DATETIME_SUB");
+
+  /** The "TIMESTAMP_TRUNC(timestamp, timeUnit[, timeZone])" function (BigQuery);
+   * truncates a {@code TIMESTAMP WITH LOCAL TIME ZONE} value to the beginning
+   * of a timeUnit.
+   *
+   * <p>Note that the {@code TIMESTAMP WITH LOCAL TIME ZONE} type of Calcite
+   * is called {@code TIMESTAMP} in BigQuery. */
+  @LibraryOperator(libraries = {BIG_QUERY})
+  public static final SqlFunction TIMESTAMP_TRUNC =
+      SqlBasicFunction.create("TIMESTAMP_TRUNC",
+          ReturnTypes.TIMESTAMP_NULLABLE,
+          OperandTypes.sequence(
+              "'TIMESTAMP_TRUNC(<TIMESTAMP>, <DATETIME_INTERVAL>)'",
+              OperandTypes.TIMESTAMP, OperandTypes.timestampInterval()),
+          SqlFunctionCategory.TIMEDATE);
+
+  /** The "DATETIME_TRUNC(timestamp, timeUnit)" function (BigQuery);
+   * truncates a TIMESTAMP value to the beginning of a timeUnit.
+   *
+   * <p>Note that the {@code TIMESTAMP} type of Calcite and Standard SQL
+   * is called {@code DATETIME} in BigQuery. */
+  @LibraryOperator(libraries = {BIG_QUERY})
+  public static final SqlFunction DATETIME_TRUNC =
+      SqlBasicFunction.create("DATETIME_TRUNC",
+          ReturnTypes.TIMESTAMP_NULLABLE,
+          OperandTypes.sequence(
+              "'DATETIME_TRUNC(<TIMESTAMP>, <DATETIME_INTERVAL>)'",
+              OperandTypes.TIMESTAMP, OperandTypes.timestampInterval()),
+          SqlFunctionCategory.TIMEDATE);
+
   /** The "TIMESTAMP_SECONDS(bigint)" function; returns a TIMESTAMP value
    * a given number of seconds after 1970-01-01 00:00:00. */
   @LibraryOperator(libraries = {BIG_QUERY})
   public static final SqlFunction TIMESTAMP_SECONDS =
-      new SqlFunction("TIMESTAMP_SECONDS", SqlKind.OTHER_FUNCTION,
-          ReturnTypes.TIMESTAMP_NULLABLE, null, OperandTypes.INTEGER,
+      SqlBasicFunction.create("TIMESTAMP_SECONDS",
+          ReturnTypes.TIMESTAMP_NULLABLE, OperandTypes.INTEGER,
           SqlFunctionCategory.TIMEDATE);
 
   /** The "TIMESTAMP_MILLIS(bigint)" function; returns a TIMESTAMP value
    * a given number of milliseconds after 1970-01-01 00:00:00. */
   @LibraryOperator(libraries = {BIG_QUERY})
   public static final SqlFunction TIMESTAMP_MILLIS =
-      new SqlFunction("TIMESTAMP_MILLIS", SqlKind.OTHER_FUNCTION,
-          ReturnTypes.TIMESTAMP_NULLABLE, null, OperandTypes.INTEGER,
+      SqlBasicFunction.create("TIMESTAMP_MILLIS",
+          ReturnTypes.TIMESTAMP_NULLABLE, OperandTypes.INTEGER,
           SqlFunctionCategory.TIMEDATE);
 
   /** The "TIMESTAMP_MICROS(bigint)" function; returns a TIMESTAMP value
    * a given number of micro-seconds after 1970-01-01 00:00:00. */
   @LibraryOperator(libraries = {BIG_QUERY})
   public static final SqlFunction TIMESTAMP_MICROS =
-      new SqlFunction("TIMESTAMP_MICROS", SqlKind.OTHER_FUNCTION,
-          ReturnTypes.TIMESTAMP_NULLABLE, null, OperandTypes.INTEGER,
+      SqlBasicFunction.create("TIMESTAMP_MICROS",
+          ReturnTypes.TIMESTAMP_NULLABLE, OperandTypes.INTEGER,
           SqlFunctionCategory.TIMEDATE);
 
   /** The "UNIX_SECONDS(bigint)" function; returns the number of seconds
    * since 1970-01-01 00:00:00. */
   @LibraryOperator(libraries = {BIG_QUERY})
   public static final SqlFunction UNIX_SECONDS =
-      new SqlFunction("UNIX_SECONDS", SqlKind.OTHER_FUNCTION,
-          ReturnTypes.BIGINT_NULLABLE, null, OperandTypes.TIMESTAMP,
-          SqlFunctionCategory.TIMEDATE);
+      SqlBasicFunction.create("UNIX_SECONDS", ReturnTypes.BIGINT_NULLABLE,
+          OperandTypes.TIMESTAMP, SqlFunctionCategory.TIMEDATE);
 
   /** The "UNIX_MILLIS(bigint)" function; returns the number of milliseconds
    * since 1970-01-01 00:00:00. */
   @LibraryOperator(libraries = {BIG_QUERY})
   public static final SqlFunction UNIX_MILLIS =
-      new SqlFunction("UNIX_MILLIS", SqlKind.OTHER_FUNCTION,
-          ReturnTypes.BIGINT_NULLABLE, null, OperandTypes.TIMESTAMP,
+      SqlBasicFunction.create("UNIX_MILLIS",
+          ReturnTypes.BIGINT_NULLABLE, OperandTypes.TIMESTAMP,
           SqlFunctionCategory.TIMEDATE);
 
   /** The "UNIX_MICROS(bigint)" function; returns the number of microseconds
    * since 1970-01-01 00:00:00. */
   @LibraryOperator(libraries = {BIG_QUERY})
   public static final SqlFunction UNIX_MICROS =
-      new SqlFunction("UNIX_MICROS", SqlKind.OTHER_FUNCTION,
-          ReturnTypes.BIGINT_NULLABLE, null, OperandTypes.TIMESTAMP,
+      SqlBasicFunction.create("UNIX_MICROS",
+          ReturnTypes.BIGINT_NULLABLE, OperandTypes.TIMESTAMP,
           SqlFunctionCategory.TIMEDATE);
 
-  @LibraryOperator(libraries = {ORACLE})
+  /** The "DATETIME_ADD(timestamp, interval)" function (BigQuery).
+   * As {@code TIMESTAMP_ADD}, returns a Calcite {@code TIMESTAMP}
+   * (which BigQuery calls a {@code DATETIME}). */
+  @LibraryOperator(libraries = {BIG_QUERY})
+  public static final SqlFunction DATETIME_ADD =
+      TIMESTAMP_ADD2.withName("DATETIME_ADD");
+
+  /** The "DATETIME_DIFF(timestamp, timestamp2, timeUnit)" function (BigQuery).
+   *
+   * <p>Note that the {@code TIMESTAMP} type of Calcite and Standard SQL
+   * is called {@code DATETIME} in BigQuery. */
+  @LibraryOperator(libraries = {BIG_QUERY})
+  public static final SqlFunction DATETIME_DIFF =
+      new SqlTimestampDiffFunction("DATETIME_DIFF",
+          OperandTypes.family(SqlTypeFamily.TIMESTAMP, SqlTypeFamily.TIMESTAMP,
+              SqlTypeFamily.ANY));
+
+  /** The "CHAR(n)" function; returns the character whose ASCII code is
+   * {@code n} % 256, or null if {@code n} &lt; 0. */
+  @LibraryOperator(libraries = {MYSQL, SPARK})
+  public static final SqlFunction CHAR =
+      SqlBasicFunction.create("CHAR",
+          ReturnTypes.CHAR_FORCE_NULLABLE,
+          OperandTypes.INTEGER,
+          SqlFunctionCategory.STRING);
+
+  /** The "CHR(n)" function; returns the character whose UTF-8 code is
+   * {@code n}. */
+  @LibraryOperator(libraries = {BIG_QUERY, ORACLE, POSTGRESQL})
   public static final SqlFunction CHR =
-      new SqlFunction("CHR",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("CHR",
           ReturnTypes.CHAR,
-          null,
           OperandTypes.INTEGER,
           SqlFunctionCategory.STRING);
 
-  @LibraryOperator(libraries = {ORACLE})
+  @LibraryOperator(libraries = {BIG_QUERY, ORACLE})
   public static final SqlFunction TANH =
-      new SqlFunction("TANH",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("TANH",
           ReturnTypes.DOUBLE_NULLABLE,
-          null,
           OperandTypes.NUMERIC,
           SqlFunctionCategory.NUMERIC);
 
-  @LibraryOperator(libraries = {ORACLE})
+  @LibraryOperator(libraries = {BIG_QUERY, ORACLE})
   public static final SqlFunction COSH =
-      new SqlFunction("COSH",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("COSH",
           ReturnTypes.DOUBLE_NULLABLE,
-          null,
           OperandTypes.NUMERIC,
           SqlFunctionCategory.NUMERIC);
 
-  @LibraryOperator(libraries = {ORACLE})
+  @LibraryOperator(libraries = {BIG_QUERY, ORACLE})
   public static final SqlFunction SINH =
-      new SqlFunction("SINH",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("SINH",
           ReturnTypes.DOUBLE_NULLABLE,
-          null,
           OperandTypes.NUMERIC,
           SqlFunctionCategory.NUMERIC);
 
-  @LibraryOperator(libraries = {MYSQL, POSTGRESQL})
+  @LibraryOperator(libraries = {BIG_QUERY, MYSQL, POSTGRESQL})
   public static final SqlFunction MD5 =
-      new SqlFunction("MD5", SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("MD5",
           ReturnTypes.explicit(SqlTypeName.VARCHAR)
               .andThen(SqlTypeTransforms.TO_NULLABLE),
-          null, OperandTypes.or(OperandTypes.STRING, OperandTypes.BINARY),
+          OperandTypes.STRING.or(OperandTypes.BINARY),
           SqlFunctionCategory.STRING);
 
-  @LibraryOperator(libraries = {MYSQL, POSTGRESQL})
+  @LibraryOperator(libraries = {BIG_QUERY, MYSQL, POSTGRESQL})
   public static final SqlFunction SHA1 =
-      new SqlFunction("SHA1", SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("SHA1",
           ReturnTypes.explicit(SqlTypeName.VARCHAR)
               .andThen(SqlTypeTransforms.TO_NULLABLE),
-          null, OperandTypes.or(OperandTypes.STRING, OperandTypes.BINARY),
+          OperandTypes.STRING.or(OperandTypes.BINARY),
           SqlFunctionCategory.STRING);
 
+  /** The "LOG(value [, value2])" function.
+   *
+   * @see SqlStdOperatorTable#LN
+   * @see SqlStdOperatorTable#LOG10
+   */
+  @LibraryOperator(libraries = {BIG_QUERY})
+  public static final SqlFunction LOG =
+      SqlBasicFunction.create("LOG",
+          ReturnTypes.DOUBLE_NULLABLE,
+          OperandTypes.NUMERIC_OPTIONAL_NUMERIC,
+          SqlFunctionCategory.NUMERIC);
+
+  @LibraryOperator(libraries = {BIG_QUERY})
+  public static final SqlFunction POW =
+      SqlStdOperatorTable.POWER.withName("POW");
+
+  @LibraryOperator(libraries = {BIG_QUERY})
+  public static final SqlFunction TRUNC =
+      SqlStdOperatorTable.TRUNCATE.withName("TRUNC");
+
   /** Infix "::" cast operator used by PostgreSQL, for example
    * {@code '100'::INTEGER}. */
   @LibraryOperator(libraries = { POSTGRESQL })
   public static final SqlOperator INFIX_CAST =
       new SqlCastOperator();
 
+  /** The "SAFE_CAST(expr AS type)" function; identical to CAST(),
+   * except that if conversion fails, it returns NULL instead of raising an
+   * error. */
+  @LibraryOperator(libraries = {BIG_QUERY})
+  public static final SqlFunction SAFE_CAST =
+      new SqlCastFunction(SqlKind.SAFE_CAST);
+
   /** NULL-safe "&lt;=&gt;" equal operator used by MySQL, for example
    * {@code 1<=>NULL}. */
   @LibraryOperator(libraries = { MYSQL })
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlListaggAggFunction.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlListaggAggFunction.java
index 9bda375a78d..f27722ab235 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlListaggAggFunction.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlListaggAggFunction.java
@@ -31,7 +31,7 @@ class SqlListaggAggFunction extends SqlAggFunction {
   SqlListaggAggFunction(SqlKind kind,
       SqlReturnTypeInference returnTypeInference) {
     super(kind.name(), null, kind, returnTypeInference,
-        null, OperandTypes.or(OperandTypes.STRING, OperandTypes.STRING_STRING),
+        null, OperandTypes.STRING.or(OperandTypes.STRING_STRING),
         SqlFunctionCategory.SYSTEM, false, false, Optionality.OPTIONAL);
   }
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlMultisetQueryConstructor.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlMultisetQueryConstructor.java
index 2391bba50be..05ed42ca842 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlMultisetQueryConstructor.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlMultisetQueryConstructor.java
@@ -52,7 +52,7 @@ public class SqlMultisetQueryConstructor extends SqlSpecialOperator {
 
   public SqlMultisetQueryConstructor() {
     this("MULTISET", SqlKind.MULTISET_QUERY_CONSTRUCTOR,
-        SqlTypeTransforms.TO_MULTISET);
+        SqlTypeTransforms.TO_MULTISET_QUERY);
   }
 
   protected SqlMultisetQueryConstructor(String name, SqlKind kind,
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlOverlayFunction.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlOverlayFunction.java
index 71192cfb661..293e153014f 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlOverlayFunction.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlOverlayFunction.java
@@ -32,9 +32,8 @@ public class SqlOverlayFunction extends SqlFunction {
   //~ Static fields/initializers ---------------------------------------------
 
   private static final SqlOperandTypeChecker OTC_CUSTOM =
-      OperandTypes.or(
-          OperandTypes.STRING_STRING_INTEGER,
-          OperandTypes.STRING_STRING_INTEGER_INTEGER);
+      OperandTypes.STRING_STRING_INTEGER
+          .or(OperandTypes.STRING_STRING_INTEGER_INTEGER);
 
   //~ Constructors -----------------------------------------------------------
 
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlPositionFunction.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlPositionFunction.java
index 349715a1767..753ba93f8c0 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlPositionFunction.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlPositionFunction.java
@@ -37,17 +37,12 @@ public class SqlPositionFunction extends SqlFunction {
   // as part of rtiDyadicStringSumPrecision
 
   private static final SqlOperandTypeChecker OTC_CUSTOM =
-      OperandTypes.or(OperandTypes.STRING_SAME_SAME,
-          OperandTypes.STRING_SAME_SAME_INTEGER);
+      OperandTypes.STRING_SAME_SAME
+          .or(OperandTypes.STRING_SAME_SAME_INTEGER);
 
-  public SqlPositionFunction() {
-    super(
-        "POSITION",
-        SqlKind.POSITION,
-        ReturnTypes.INTEGER_NULLABLE,
-        null,
-        OTC_CUSTOM,
-        SqlFunctionCategory.NUMERIC);
+  public SqlPositionFunction(String name) {
+    super(name, SqlKind.POSITION, ReturnTypes.INTEGER_NULLABLE, null,
+        OTC_CUSTOM, SqlFunctionCategory.NUMERIC);
   }
 
   //~ Methods ----------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlQuantifyOperator.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlQuantifyOperator.java
index 37250cd7cf6..f259627fe64 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlQuantifyOperator.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlQuantifyOperator.java
@@ -16,10 +16,21 @@
  */
 package org.apache.calcite.sql.fun;
 
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.sql.SqlCall;
 import org.apache.calcite.sql.SqlKind;
+import org.apache.calcite.sql.SqlNode;
+import org.apache.calcite.sql.SqlNodeList;
+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.sql.validate.SqlValidatorScope;
 
 import com.google.common.base.Preconditions;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+import java.util.List;
 import java.util.Objects;
 
 /**
@@ -59,4 +70,46 @@ public class SqlQuantifyOperator extends SqlInOperator {
     Preconditions.checkArgument(kind == SqlKind.SOME
         || kind == SqlKind.ALL);
   }
+
+
+  @Override public RelDataType deriveType(SqlValidator validator,
+      SqlValidatorScope scope, SqlCall call) {
+    final List<SqlNode> operands = call.getOperandList();
+    assert operands.size() == 2;
+
+    RelDataType typeForCollectionArgument = tryDeriveTypeForCollection(validator, scope, call);
+    if (typeForCollectionArgument != null) {
+      return typeForCollectionArgument;
+    }
+    return super.deriveType(validator, scope, call);
+  }
+
+  /**
+   * Derive type for SOME(collection expression), ANY (collection expression).
+   *
+   * @param validator Validator
+   * @param scope     Scope of validation
+   * @param call      Call to this operator
+   * @return If SOME or ALL is applied to a collection, then the function
+   * returns type of call, otherwise it returns null.
+   */
+  public @Nullable RelDataType tryDeriveTypeForCollection(SqlValidator validator,
+      SqlValidatorScope scope, SqlCall call) {
+    final SqlNode left = call.operand(0);
+    final SqlNode right = call.operand(1);
+    if (right instanceof SqlNodeList && ((SqlNodeList) right).size() == 1) {
+      final RelDataType rightType = validator.deriveType(scope, ((SqlNodeList) right).get(0));
+      if (SqlTypeUtil.isCollection(rightType)) {
+        final RelDataType componentRightType = Objects.requireNonNull(rightType.getComponentType());
+        final RelDataType leftType = validator.deriveType(scope, left);
+        if (SqlTypeUtil.sameNamedType(componentRightType, leftType)
+            || SqlTypeUtil.isNull(leftType) || SqlTypeUtil.isNull(componentRightType)) {
+          return validator.getTypeFactory().createTypeWithNullability(
+              validator.getTypeFactory().createSqlType(SqlTypeName.BOOLEAN),
+              rightType.isNullable() || componentRightType.isNullable() || leftType.isNullable());
+        }
+      }
+    }
+    return null;
+  }
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlRandFunction.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlRandFunction.java
index e8319e31a53..096d6f97378 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlRandFunction.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlRandFunction.java
@@ -19,7 +19,6 @@
 import org.apache.calcite.sql.SqlFunction;
 import org.apache.calcite.sql.SqlFunctionCategory;
 import org.apache.calcite.sql.SqlKind;
-import org.apache.calcite.sql.SqlSyntax;
 import org.apache.calcite.sql.type.OperandTypes;
 import org.apache.calcite.sql.type.ReturnTypes;
 
@@ -40,16 +39,12 @@ public SqlRandFunction() {
         SqlKind.OTHER_FUNCTION,
         ReturnTypes.DOUBLE,
         null,
-        OperandTypes.or(OperandTypes.NILADIC, OperandTypes.NUMERIC),
+        OperandTypes.NILADIC.or(OperandTypes.NUMERIC),
         SqlFunctionCategory.NUMERIC);
   }
 
   //~ Methods ----------------------------------------------------------------
 
-  @Override public SqlSyntax getSyntax() {
-    return SqlSyntax.FUNCTION;
-  }
-
   // Plans referencing context variables should never be cached
   @Override public boolean isDynamicFunction() {
     return true;
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlRandIntegerFunction.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlRandIntegerFunction.java
index 1b27a17999e..adf4d40d049 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlRandIntegerFunction.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlRandIntegerFunction.java
@@ -19,7 +19,6 @@
 import org.apache.calcite.sql.SqlFunction;
 import org.apache.calcite.sql.SqlFunctionCategory;
 import org.apache.calcite.sql.SqlKind;
-import org.apache.calcite.sql.SqlSyntax;
 import org.apache.calcite.sql.type.OperandTypes;
 import org.apache.calcite.sql.type.ReturnTypes;
 
@@ -40,16 +39,12 @@ public SqlRandIntegerFunction() {
         SqlKind.OTHER_FUNCTION,
         ReturnTypes.INTEGER,
         null,
-        OperandTypes.or(OperandTypes.NUMERIC, OperandTypes.NUMERIC_NUMERIC),
+        OperandTypes.NUMERIC.or(OperandTypes.NUMERIC_NUMERIC),
         SqlFunctionCategory.NUMERIC);
   }
 
   //~ Methods ----------------------------------------------------------------
 
-  @Override public SqlSyntax getSyntax() {
-    return SqlSyntax.FUNCTION;
-  }
-
   // Plans referencing context variables should never be cached
   @Override public boolean isDynamicFunction() {
     return true;
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlRollupOperator.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlRollupOperator.java
index 0b3f8b9d31c..ed0007bcd7b 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlRollupOperator.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlRollupOperator.java
@@ -53,6 +53,11 @@ class SqlRollupOperator extends SqlInternalOperator {
         return;
       }
       break;
+    case GROUP_BY_DISTINCT:
+      writer.keyword(call.getOperator().getName());
+      SqlNodeList groupBy = new SqlNodeList(call.getOperandList(), call.getParserPosition());
+      writer.list(SqlWriter.FrameTypeEnum.GROUP_BY_LIST, SqlWriter.COMMA, groupBy);
+      return;
     default:
       break;
     }
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlRowOperator.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlRowOperator.java
index b73ceb4decd..3e28ca84766 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlRowOperator.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlRowOperator.java
@@ -57,18 +57,18 @@ public SqlRowOperator(String name) {
     // {e1type,e2type}.  According to the standard, field names are
     // implementation-defined.
     final RelDataTypeFactory typeFactory = opBinding.getTypeFactory();
-    final RelDataType recordType = typeFactory.createStructType(
-        new AbstractList<Map.Entry<String, RelDataType>>() {
-          @Override public Map.Entry<String, RelDataType> get(int index) {
-            return Pair.of(
-                SqlUtil.deriveAliasFromOrdinal(index),
-                opBinding.getOperandType(index));
-          }
+    final RelDataType recordType =
+        typeFactory.createStructType(
+            new AbstractList<Map.Entry<String, RelDataType>>() {
+              @Override public Map.Entry<String, RelDataType> get(int index) {
+                return Pair.of(SqlUtil.deriveAliasFromOrdinal(index),
+                    opBinding.getOperandType(index));
+              }
 
-          @Override public int size() {
-            return opBinding.getOperandCount();
-          }
-        });
+              @Override public int size() {
+                return opBinding.getOperandCount();
+              }
+            });
 
     // The value of ROW(e1,e2) is considered null if and only all of its
     // fields (i.e., e1, e2) are null. Otherwise ROW can not be null.
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlGeoFunctions.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlSpatialTypeFunctions.java
similarity index 66%
rename from core/src/main/java/org/apache/calcite/sql/fun/SqlGeoFunctions.java
rename to core/src/main/java/org/apache/calcite/sql/fun/SqlSpatialTypeFunctions.java
index 08206aabeb5..7963948551a 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlGeoFunctions.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlSpatialTypeFunctions.java
@@ -20,10 +20,10 @@
 import org.apache.calcite.config.CalciteConnectionConfig;
 import org.apache.calcite.linq4j.Enumerable;
 import org.apache.calcite.linq4j.Linq4j;
+import org.apache.calcite.linq4j.function.Functions;
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeFactory;
-import org.apache.calcite.runtime.GeoFunctions;
-import org.apache.calcite.runtime.Geometries.Geom;
+import org.apache.calcite.runtime.SpatialTypeFunctions;
 import org.apache.calcite.schema.ScannableTable;
 import org.apache.calcite.schema.Schema;
 import org.apache.calcite.schema.Statistic;
@@ -33,52 +33,101 @@
 import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.util.ImmutableBitSet;
 
-import com.esri.core.geometry.Envelope;
-import com.esri.core.geometry.Geometry;
 import com.google.common.collect.ImmutableList;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
+import org.locationtech.jts.geom.Geometry;
 
 import java.math.BigDecimal;
 
 /**
- * Utilities for Geo/Spatial functions.
+ * Utilities for spatial type functions.
  *
  * <p>Includes some table functions, and may in future include other functions
  * that have dependencies beyond the {@code org.apache.calcite.runtime} package.
  */
-public class SqlGeoFunctions {
-  private SqlGeoFunctions() {}
+public class SqlSpatialTypeFunctions {
+  private SqlSpatialTypeFunctions() {}
 
   // Geometry table functions =================================================
 
+  /**
+   * Explodes the {@code geom} into multiple geometries.
+   *
+   * @see SpatialTypeFunctions ST_Explode */
+  @SuppressWarnings({"WeakerAccess", "unused"})
+  public static ScannableTable ST_Explode(Geometry geom) {
+    return new ExplodeTable(geom);
+  }
+
   /** Calculates a regular grid of polygons based on {@code geom}.
    *
-   * @see GeoFunctions ST_MakeGrid */
+   * @see SpatialTypeFunctions ST_MakeGrid */
   @SuppressWarnings({"WeakerAccess", "unused"})
-  public static ScannableTable ST_MakeGrid(final Geom geom,
+  public static ScannableTable ST_MakeGrid(final Geometry geom,
       final BigDecimal deltaX, final BigDecimal deltaY) {
     return new GridTable(geom, deltaX, deltaY, false);
   }
 
   /** Calculates a regular grid of points based on {@code geom}.
    *
-   * @see GeoFunctions ST_MakeGridPoints */
+   * @see SpatialTypeFunctions ST_MakeGridPoints */
   @SuppressWarnings({"WeakerAccess", "unused"})
-  public static ScannableTable ST_MakeGridPoints(final Geom geom,
+  public static ScannableTable ST_MakeGridPoints(final Geometry geom,
       final BigDecimal deltaX, final BigDecimal deltaY) {
     return new GridTable(geom, deltaX, deltaY, true);
   }
 
+  /** Returns the geometries of a geometry. */
+  public static class ExplodeTable implements ScannableTable {
+
+    private final Geometry geometry;
+
+    public ExplodeTable(Geometry geometry) {
+      this.geometry = geometry;
+    }
+
+    @Override public Enumerable<@Nullable Object[]> scan(DataContext root) {
+      return Linq4j.asEnumerable(
+          Functions.generate(
+            geometry.getNumGeometries(),
+            i -> new Object[] { geometry.getGeometryN(i), i }));
+    }
+
+    @Override public RelDataType getRowType(RelDataTypeFactory typeFactory) {
+      return typeFactory.builder()
+          .add("GEOM", SqlTypeName.GEOMETRY)
+          .add("INDEX", SqlTypeName.INTEGER)
+          .build();
+    }
+
+    @Override public Statistic getStatistic() {
+      return Statistics.UNKNOWN;
+    }
+
+    @Override public Schema.TableType getJdbcTableType() {
+      return Schema.TableType.TABLE;
+    }
+
+    @Override public boolean isRolledUp(String column) {
+      return false;
+    }
+
+    @Override public boolean rolledUpColumnValidInsideAgg(String column, SqlCall call,
+        @Nullable SqlNode parent, @Nullable CalciteConnectionConfig config) {
+      return true;
+    }
+  }
+
   /** Returns the points or rectangles in a grid that covers a given
    * geometry. */
   public static class GridTable implements ScannableTable {
-    private final Geom geom;
+    private final Geometry geom;
     private final BigDecimal deltaX;
     private final BigDecimal deltaY;
     private boolean point;
 
-    GridTable(Geom geom, BigDecimal deltaX, BigDecimal deltaY,
+    GridTable(Geometry geom, BigDecimal deltaX, BigDecimal deltaY,
         boolean point) {
       this.geom = geom;
       this.deltaX = deltaX;
@@ -105,12 +154,9 @@ public static class GridTable implements ScannableTable {
 
     @Override public Enumerable<@Nullable Object[]> scan(DataContext root) {
       if (geom != null && deltaX != null && deltaY != null) {
-        final Geometry geometry = geom.g();
-        final Envelope envelope = new Envelope();
-        geometry.queryEnvelope(envelope);
         if (deltaX.compareTo(BigDecimal.ZERO) > 0
             && deltaY.compareTo(BigDecimal.ZERO) > 0) {
-          return new GeoFunctions.GridEnumerable(envelope, deltaX, deltaY,
+          return new SpatialTypeFunctions.GridEnumerable(geom.getEnvelopeInternal(), deltaX, deltaY,
               point);
         }
       }
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 882202f91cb..e1427ab35b3 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
@@ -20,6 +20,7 @@
 import org.apache.calcite.sql.SqlAggFunction;
 import org.apache.calcite.sql.SqlAsOperator;
 import org.apache.calcite.sql.SqlBasicCall;
+import org.apache.calcite.sql.SqlBasicFunction;
 import org.apache.calcite.sql.SqlBinaryOperator;
 import org.apache.calcite.sql.SqlCall;
 import org.apache.calcite.sql.SqlDescriptorOperator;
@@ -47,6 +48,7 @@
 import org.apache.calcite.sql.SqlSampleSpec;
 import org.apache.calcite.sql.SqlSessionTableFunction;
 import org.apache.calcite.sql.SqlSetOperator;
+import org.apache.calcite.sql.SqlSetSemanticsTableOperator;
 import org.apache.calcite.sql.SqlSpecialOperator;
 import org.apache.calcite.sql.SqlSyntax;
 import org.apache.calcite.sql.SqlTumbleTableFunction;
@@ -270,8 +272,7 @@ public class SqlStdOperatorTable extends ReflectiveSqlOperatorTable {
                 "inferred CONCAT element type");
           }),
           null,
-          OperandTypes.STRING_SAME_SAME_OR_ARRAY_SAME_SAME
-      );
+          OperandTypes.STRING_SAME_SAME_OR_ARRAY_SAME_SAME);
 
 
   /**
@@ -299,7 +300,7 @@ public class SqlStdOperatorTable extends ReflectiveSqlOperatorTable {
           SqlKind.MOD,
           60,
           true,
-          ReturnTypes.ARG1_NULLABLE,
+          ReturnTypes.NULLABLE_MOD,
           null,
           OperandTypes.EXACT_NUMERIC_EXACT_NUMERIC);
 
@@ -477,6 +478,21 @@ public class SqlStdOperatorTable extends ReflectiveSqlOperatorTable {
   public static final SqlQuantifyOperator ALL_NE =
       new SqlQuantifyOperator(SqlKind.ALL, SqlKind.NOT_EQUALS);
 
+  public static final List<SqlQuantifyOperator> QUANTIFY_OPERATORS =
+      ImmutableList.of(SqlStdOperatorTable.SOME_EQ,
+          SqlStdOperatorTable.SOME_GT,
+          SqlStdOperatorTable.SOME_GE,
+          SqlStdOperatorTable.SOME_LE,
+          SqlStdOperatorTable.SOME_LT,
+          SqlStdOperatorTable.SOME_NE,
+
+          SqlStdOperatorTable.ALL_EQ,
+          SqlStdOperatorTable.ALL_GT,
+          SqlStdOperatorTable.ALL_GE,
+          SqlStdOperatorTable.ALL_LE,
+          SqlStdOperatorTable.ALL_LT,
+          SqlStdOperatorTable.ALL_NE);
+
   /**
    * Logical less-than operator, '<code>&lt;</code>'.
    */
@@ -1003,6 +1019,24 @@ public class SqlStdOperatorTable extends ReflectiveSqlOperatorTable {
   public static final SqlAggFunction APPROX_COUNT_DISTINCT =
       new SqlCountAggFunction("APPROX_COUNT_DISTINCT");
 
+  /**
+   * <code>ARG_MAX</code> aggregate function.
+   */
+  public static final SqlBasicAggFunction ARG_MAX =
+      SqlBasicAggFunction.create("ARG_MAX", SqlKind.ARG_MAX,
+          ReturnTypes.ARG0_NULLABLE_IF_EMPTY, OperandTypes.ANY_COMPARABLE)
+          .withGroupOrder(Optionality.FORBIDDEN)
+          .withFunctionType(SqlFunctionCategory.SYSTEM);
+
+  /**
+   * <code>ARG_MIN</code> aggregate function.
+   */
+  public static final SqlBasicAggFunction ARG_MIN =
+      SqlBasicAggFunction.create("ARG_MIN", SqlKind.ARG_MIN,
+              ReturnTypes.ARG0_NULLABLE_IF_EMPTY, OperandTypes.ANY_COMPARABLE)
+          .withGroupOrder(Optionality.FORBIDDEN)
+          .withFunctionType(SqlFunctionCategory.SYSTEM);
+
   /**
    * <code>MIN</code> aggregate function.
    */
@@ -1179,11 +1213,8 @@ public class SqlStdOperatorTable extends ReflectiveSqlOperatorTable {
    * <code>HISTOGRAM_MIN</code> window aggregate function.
    */
   public static final SqlFunction HISTOGRAM_MIN =
-      new SqlFunction(
-          "$HISTOGRAM_MIN",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("$HISTOGRAM_MIN",
           ReturnTypes.ARG0_NULLABLE,
-          null,
           OperandTypes.NUMERIC_OR_STRING,
           SqlFunctionCategory.NUMERIC);
 
@@ -1191,11 +1222,8 @@ public class SqlStdOperatorTable extends ReflectiveSqlOperatorTable {
    * <code>HISTOGRAM_MAX</code> window aggregate function.
    */
   public static final SqlFunction HISTOGRAM_MAX =
-      new SqlFunction(
-          "$HISTOGRAM_MAX",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("$HISTOGRAM_MAX",
           ReturnTypes.ARG0_NULLABLE,
-          null,
           OperandTypes.NUMERIC_OR_STRING,
           SqlFunctionCategory.NUMERIC);
 
@@ -1203,11 +1231,8 @@ public class SqlStdOperatorTable extends ReflectiveSqlOperatorTable {
    * <code>HISTOGRAM_FIRST_VALUE</code> window aggregate function.
    */
   public static final SqlFunction HISTOGRAM_FIRST_VALUE =
-      new SqlFunction(
-          "$HISTOGRAM_FIRST_VALUE",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("$HISTOGRAM_FIRST_VALUE",
           ReturnTypes.ARG0_NULLABLE,
-          null,
           OperandTypes.NUMERIC_OR_STRING,
           SqlFunctionCategory.NUMERIC);
 
@@ -1215,11 +1240,8 @@ public class SqlStdOperatorTable extends ReflectiveSqlOperatorTable {
    * <code>HISTOGRAM_LAST_VALUE</code> window aggregate function.
    */
   public static final SqlFunction HISTOGRAM_LAST_VALUE =
-      new SqlFunction(
-          "$HISTOGRAM_LAST_VALUE",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("$HISTOGRAM_LAST_VALUE",
           ReturnTypes.ARG0_NULLABLE,
-          null,
           OperandTypes.NUMERIC_OR_STRING,
           SqlFunctionCategory.NUMERIC);
 
@@ -1288,7 +1310,7 @@ public class SqlStdOperatorTable extends ReflectiveSqlOperatorTable {
    * additional interval qualifier specification.</p>
    */
   public static final SqlDatetimeSubtractionOperator MINUS_DATE =
-      new SqlDatetimeSubtractionOperator();
+      new SqlDatetimeSubtractionOperator("-", ReturnTypes.ARG2_NULLABLE);
 
   /**
    * The MULTISET Value Constructor. e.g. "<code>MULTISET[1,2,3]</code>".
@@ -1405,25 +1427,37 @@ public class SqlStdOperatorTable extends ReflectiveSqlOperatorTable {
   public static final SqlFunction JSON_ARRAY = new SqlJsonArrayFunction();
 
   @Deprecated // to be removed before 2.0
-  public static final SqlFunction JSON_TYPE = SqlLibraryOperators.JSON_TYPE;
+  public static final SqlFunction JSON_TYPE = new SqlJsonTypeFunction();
+
+  @Deprecated // to be removed before 2.0
+  public static final SqlFunction JSON_DEPTH = new SqlJsonDepthFunction();
+
+  @Deprecated // to be removed before 2.0
+  public static final SqlFunction JSON_LENGTH = new SqlJsonLengthFunction();
+
+  @Deprecated // to be removed before 2.0
+  public static final SqlFunction JSON_KEYS = new SqlJsonKeysFunction();
 
   @Deprecated // to be removed before 2.0
-  public static final SqlFunction JSON_DEPTH = SqlLibraryOperators.JSON_DEPTH;
+  public static final SqlFunction JSON_PRETTY = new SqlJsonPrettyFunction();
 
   @Deprecated // to be removed before 2.0
-  public static final SqlFunction JSON_LENGTH = SqlLibraryOperators.JSON_LENGTH;
+  public static final SqlFunction JSON_REMOVE = new SqlJsonRemoveFunction();
 
   @Deprecated // to be removed before 2.0
-  public static final SqlFunction JSON_KEYS = SqlLibraryOperators.JSON_KEYS;
+  public static final SqlFunction JSON_STORAGE_SIZE = new SqlJsonStorageSizeFunction();
 
   @Deprecated // to be removed before 2.0
-  public static final SqlFunction JSON_PRETTY = SqlLibraryOperators.JSON_PRETTY;
+  public static final SqlFunction JSON_INSERT =
+      new SqlJsonModifyFunction("JSON_INSERT");
 
   @Deprecated // to be removed before 2.0
-  public static final SqlFunction JSON_REMOVE = SqlLibraryOperators.JSON_REMOVE;
+  public static final SqlFunction JSON_REPLACE =
+      new SqlJsonModifyFunction("JSON_REPLACE");
 
   @Deprecated // to be removed before 2.0
-  public static final SqlFunction JSON_STORAGE_SIZE = SqlLibraryOperators.JSON_STORAGE_SIZE;
+  public static final SqlFunction JSON_SET =
+      new SqlJsonModifyFunction("JSON_SET");
 
   public static final SqlJsonArrayAggAggFunction JSON_ARRAYAGG =
       new SqlJsonArrayAggAggFunction(SqlKind.JSON_ARRAYAGG,
@@ -1538,8 +1572,7 @@ public class SqlStdOperatorTable extends ReflectiveSqlOperatorTable {
   /** The {@code REPLACE(string, search, replace)} function. Not standard SQL,
    * but in Oracle and Postgres. */
   public static final SqlFunction REPLACE =
-      new SqlFunction("REPLACE", SqlKind.OTHER_FUNCTION,
-          ReturnTypes.ARG0_NULLABLE_VARYING, null,
+      SqlBasicFunction.create("REPLACE", ReturnTypes.ARG0_NULLABLE_VARYING,
           OperandTypes.STRING_STRING_STRING, SqlFunctionCategory.STRING);
 
   public static final SqlFunction CONVERT =
@@ -1560,95 +1593,66 @@ public class SqlStdOperatorTable extends ReflectiveSqlOperatorTable {
   /** The "TRIM" function. */
   public static final SqlFunction TRIM = SqlTrimFunction.INSTANCE;
 
-  public static final SqlFunction POSITION = new SqlPositionFunction();
+  public static final SqlFunction POSITION = new SqlPositionFunction("POSITION");
 
-  public static final SqlFunction CHAR_LENGTH =
-      new SqlFunction(
-          "CHAR_LENGTH",
-          SqlKind.OTHER_FUNCTION,
+  public static final SqlBasicFunction CHAR_LENGTH =
+      SqlBasicFunction.create("CHAR_LENGTH",
           ReturnTypes.INTEGER_NULLABLE,
-          null,
           OperandTypes.CHARACTER,
           SqlFunctionCategory.NUMERIC);
 
   /** Alias for {@link #CHAR_LENGTH}. */
   public static final SqlFunction CHARACTER_LENGTH =
-      new SqlFunction(
-          "CHARACTER_LENGTH",
-          SqlKind.OTHER_FUNCTION,
-          ReturnTypes.INTEGER_NULLABLE,
-          null,
-          OperandTypes.CHARACTER,
-          SqlFunctionCategory.NUMERIC);
+      CHAR_LENGTH.withName("CHARACTER_LENGTH");
 
   public static final SqlFunction OCTET_LENGTH =
-      new SqlFunction(
-          "OCTET_LENGTH",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("OCTET_LENGTH",
           ReturnTypes.INTEGER_NULLABLE,
-          null,
           OperandTypes.BINARY,
           SqlFunctionCategory.NUMERIC);
 
   public static final SqlFunction UPPER =
-      new SqlFunction(
-          "UPPER",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("UPPER",
           ReturnTypes.ARG0_NULLABLE,
-          null,
           OperandTypes.CHARACTER,
           SqlFunctionCategory.STRING);
 
   public static final SqlFunction LOWER =
-      new SqlFunction(
-          "LOWER",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("LOWER",
           ReturnTypes.ARG0_NULLABLE,
-          null,
           OperandTypes.CHARACTER,
           SqlFunctionCategory.STRING);
 
   public static final SqlFunction INITCAP =
-      new SqlFunction(
-          "INITCAP",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("INITCAP",
           ReturnTypes.ARG0_NULLABLE,
-          null,
           OperandTypes.CHARACTER,
           SqlFunctionCategory.STRING);
 
   public static final SqlFunction ASCII =
-      new SqlFunction(
-          "ASCII",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("ASCII",
           ReturnTypes.INTEGER_NULLABLE,
-          null,
           OperandTypes.CHARACTER,
           SqlFunctionCategory.STRING);
 
-  /**
-   * Uses SqlOperatorTable.useDouble for its return type since we don't know
+  /** The {@code POWER(numeric, numeric)} function.
+   *
+   * <p>The return type is always {@code DOUBLE} since we don't know
    * what the result type will be by just looking at the operand types. For
-   * example POW(int, int) can return a non integer if the second operand is
-   * negative.
+   * example {@code POWER(INTEGER, INTEGER)} can return a non-INTEGER if the
+   * second operand is negative.
    */
-  public static final SqlFunction POWER =
-      new SqlFunction(
-          "POWER",
-          SqlKind.OTHER_FUNCTION,
+  public static final SqlBasicFunction POWER =
+      SqlBasicFunction.create("POWER",
           ReturnTypes.DOUBLE_NULLABLE,
-          null,
           OperandTypes.NUMERIC_NUMERIC,
           SqlFunctionCategory.NUMERIC);
 
+  /** The {@code SQRT(numeric)} function. */
   public static final SqlFunction SQRT =
-      new SqlFunction(
-          "SQRT",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("SQRT",
           ReturnTypes.DOUBLE_NULLABLE,
-          null,
-          OperandTypes.NUMERIC,
-          SqlFunctionCategory.NUMERIC);
+          OperandTypes.NUMERIC);
 
   /**
    * Arithmetic remainder function {@code MOD}.
@@ -1658,193 +1662,149 @@ public class SqlStdOperatorTable extends ReflectiveSqlOperatorTable {
   public static final SqlFunction MOD =
       // Return type is same as divisor (2nd operand)
       // SQL2003 Part2 Section 6.27, Syntax Rules 9
-      new SqlFunction(
-          "MOD",
-          SqlKind.MOD,
+      SqlBasicFunction.create(SqlKind.MOD,
           ReturnTypes.NULLABLE_MOD,
-          null,
-          OperandTypes.EXACT_NUMERIC_EXACT_NUMERIC,
-          SqlFunctionCategory.NUMERIC);
+          OperandTypes.EXACT_NUMERIC_EXACT_NUMERIC)
+          .withFunctionType(SqlFunctionCategory.NUMERIC);
 
+  /** The {@code LN(numeric)} function. */
   public static final SqlFunction LN =
-      new SqlFunction(
-          "LN",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("LN",
           ReturnTypes.DOUBLE_NULLABLE,
-          null,
           OperandTypes.NUMERIC,
           SqlFunctionCategory.NUMERIC);
 
+  /** The {@code LOG10(numeric)} function. */
   public static final SqlFunction LOG10 =
-      new SqlFunction(
-          "LOG10",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("LOG10",
           ReturnTypes.DOUBLE_NULLABLE,
-          null,
           OperandTypes.NUMERIC,
           SqlFunctionCategory.NUMERIC);
 
+  /** The {@code ABS(numeric)} function. */
   public static final SqlFunction ABS =
-      new SqlFunction(
-          "ABS",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("ABS",
           ReturnTypes.ARG0,
-          null,
           OperandTypes.NUMERIC_OR_INTERVAL,
           SqlFunctionCategory.NUMERIC);
 
+  /** The {@code ACOS(numeric)} function. */
   public static final SqlFunction ACOS =
-      new SqlFunction(
-          "ACOS",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("ACOS",
           ReturnTypes.DOUBLE_NULLABLE,
-          null,
           OperandTypes.NUMERIC,
           SqlFunctionCategory.NUMERIC);
 
+  /** The {@code ASIN(numeric)} function. */
   public static final SqlFunction ASIN =
-      new SqlFunction(
-          "ASIN",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("ASIN",
           ReturnTypes.DOUBLE_NULLABLE,
-          null,
           OperandTypes.NUMERIC,
           SqlFunctionCategory.NUMERIC);
 
+  /** The {@code ATAN(numeric)} function. */
   public static final SqlFunction ATAN =
-      new SqlFunction(
-          "ATAN",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("ATAN",
           ReturnTypes.DOUBLE_NULLABLE,
-          null,
           OperandTypes.NUMERIC,
           SqlFunctionCategory.NUMERIC);
 
+  /** The {@code ATAN2(numeric, numeric)} function. */
   public static final SqlFunction ATAN2 =
-      new SqlFunction(
-          "ATAN2",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("ATAN2",
           ReturnTypes.DOUBLE_NULLABLE,
-          null,
           OperandTypes.NUMERIC_NUMERIC,
           SqlFunctionCategory.NUMERIC);
 
+  /** The {@code CBRT(numeric)} function. */
   public static final SqlFunction CBRT =
-      new SqlFunction(
-          "CBRT",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("CBRT",
           ReturnTypes.DOUBLE_NULLABLE,
-          null,
           OperandTypes.NUMERIC,
           SqlFunctionCategory.NUMERIC);
 
+  /** The {@code COS(numeric)} function. */
   public static final SqlFunction COS =
-      new SqlFunction(
-          "COS",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("COS",
           ReturnTypes.DOUBLE_NULLABLE,
-          null,
           OperandTypes.NUMERIC,
           SqlFunctionCategory.NUMERIC);
 
+  /** The {@code COT(numeric)} function. */
   public static final SqlFunction COT =
-      new SqlFunction(
-          "COT",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("COT",
           ReturnTypes.DOUBLE_NULLABLE,
-          null,
           OperandTypes.NUMERIC,
           SqlFunctionCategory.NUMERIC);
 
+  /** The {@code DEGREES(numeric)} function. */
   public static final SqlFunction DEGREES =
-      new SqlFunction(
-          "DEGREES",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("DEGREES",
           ReturnTypes.DOUBLE_NULLABLE,
-          null,
           OperandTypes.NUMERIC,
           SqlFunctionCategory.NUMERIC);
 
+  /** The {@code EXP(numeric)} function. */
   public static final SqlFunction EXP =
-      new SqlFunction(
-          "EXP",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("EXP",
           ReturnTypes.DOUBLE_NULLABLE,
-          null,
           OperandTypes.NUMERIC,
           SqlFunctionCategory.NUMERIC);
 
+  /** The {@code RADIANS(numeric)} function. */
   public static final SqlFunction RADIANS =
-      new SqlFunction(
-          "RADIANS",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("RADIANS",
           ReturnTypes.DOUBLE_NULLABLE,
-          null,
           OperandTypes.NUMERIC,
           SqlFunctionCategory.NUMERIC);
 
+  /** The {@code ROUND(numeric [, numeric])} function. */
   public static final SqlFunction ROUND =
-      new SqlFunction(
-          "ROUND",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("ROUND",
           ReturnTypes.ARG0_NULLABLE,
-          null,
           OperandTypes.NUMERIC_OPTIONAL_INTEGER,
           SqlFunctionCategory.NUMERIC);
 
+  /** The {@code SIGN(numeric)} function. */
   public static final SqlFunction SIGN =
-      new SqlFunction(
-          "SIGN",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("SIGN",
           ReturnTypes.ARG0,
-          null,
           OperandTypes.NUMERIC,
           SqlFunctionCategory.NUMERIC);
 
+  /** The {@code SIN(numeric)} function. */
   public static final SqlFunction SIN =
-      new SqlFunction(
-          "SIN",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("SIN",
           ReturnTypes.DOUBLE_NULLABLE,
-          null,
           OperandTypes.NUMERIC,
           SqlFunctionCategory.NUMERIC);
 
+  /** The {@code TAN(numeric)} function. */
   public static final SqlFunction TAN =
-      new SqlFunction(
-          "TAN",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("TAN",
           ReturnTypes.DOUBLE_NULLABLE,
-          null,
           OperandTypes.NUMERIC,
           SqlFunctionCategory.NUMERIC);
 
-  public static final SqlFunction TRUNCATE =
-      new SqlFunction(
-          "TRUNCATE",
-          SqlKind.OTHER_FUNCTION,
+  /** The {@code TRUNCATE(numeric [, numeric])} function. */
+  public static final SqlBasicFunction TRUNCATE =
+      SqlBasicFunction.create("TRUNCATE",
           ReturnTypes.ARG0_NULLABLE,
-          null,
           OperandTypes.NUMERIC_OPTIONAL_INTEGER,
           SqlFunctionCategory.NUMERIC);
 
+  /** The {@code PI} function. */
   public static final SqlFunction PI =
-      new SqlFunction(
-          "PI",
-          SqlKind.OTHER_FUNCTION,
-          ReturnTypes.DOUBLE,
-          null,
-          OperandTypes.NILADIC,
-          SqlFunctionCategory.NUMERIC) {
-        @Override public SqlSyntax getSyntax() {
-          return SqlSyntax.FUNCTION_ID;
-        }
-      };
+      SqlBasicFunction.create("PI", ReturnTypes.DOUBLE, OperandTypes.NILADIC,
+          SqlFunctionCategory.NUMERIC)
+          .withSyntax(SqlSyntax.FUNCTION_ID);
 
   /** {@code FIRST} function to be used within {@code MATCH_RECOGNIZE}. */
   public static final SqlFunction FIRST =
-      new SqlFunction("FIRST", SqlKind.FIRST, ReturnTypes.ARG0_NULLABLE,
-          null, OperandTypes.ANY_NUMERIC, SqlFunctionCategory.MATCH_RECOGNIZE);
+      SqlBasicFunction.create(SqlKind.FIRST,
+          ReturnTypes.ARG0_NULLABLE,
+          OperandTypes.ANY_NUMERIC)
+          .withFunctionType(SqlFunctionCategory.MATCH_RECOGNIZE);
 
   /** {@code LAST} function to be used within {@code MATCH_RECOGNIZE}. */
   public static final SqlMatchFunction LAST =
@@ -1858,8 +1818,9 @@ public class SqlStdOperatorTable extends ReflectiveSqlOperatorTable {
 
   /** {@code NEXT} function to be used within {@code MATCH_RECOGNIZE}. */
   public static final SqlFunction NEXT =
-      new SqlFunction("NEXT", SqlKind.NEXT, ReturnTypes.ARG0_NULLABLE, null,
-          OperandTypes.ANY_NUMERIC, SqlFunctionCategory.MATCH_RECOGNIZE);
+      SqlBasicFunction.create(SqlKind.NEXT, ReturnTypes.ARG0_NULLABLE,
+          OperandTypes.ANY_NUMERIC)
+          .withFunctionType(SqlFunctionCategory.MATCH_RECOGNIZE);
 
   /** {@code CLASSIFIER} function to be used within {@code MATCH_RECOGNIZE}. */
   public static final SqlMatchFunction CLASSIFIER =
@@ -1868,8 +1829,9 @@ public class SqlStdOperatorTable extends ReflectiveSqlOperatorTable {
 
   /** {@code MATCH_NUMBER} function to be used within {@code MATCH_RECOGNIZE}. */
   public static final SqlFunction MATCH_NUMBER =
-      new SqlFunction("MATCH_NUMBER ", SqlKind.MATCH_NUMBER, ReturnTypes.BIGINT_NULLABLE,
-          null, OperandTypes.NILADIC, SqlFunctionCategory.MATCH_RECOGNIZE);
+      SqlBasicFunction.create(SqlKind.MATCH_NUMBER, ReturnTypes.BIGINT_NULLABLE,
+          OperandTypes.NILADIC)
+          .withFunctionType(SqlFunctionCategory.MATCH_RECOGNIZE);
 
   public static final SqlFunction NULLIF = new SqlNullifFunction();
 
@@ -1967,10 +1929,14 @@ public class SqlStdOperatorTable extends ReflectiveSqlOperatorTable {
       new SqlCurrentDateFunction();
 
   /** The <code>TIMESTAMPADD</code> function. */
-  public static final SqlFunction TIMESTAMP_ADD = new SqlTimestampAddFunction();
+  public static final SqlFunction TIMESTAMP_ADD =
+      new SqlTimestampAddFunction("TIMESTAMPADD");
 
   /** The <code>TIMESTAMPDIFF</code> function. */
-  public static final SqlFunction TIMESTAMP_DIFF = new SqlTimestampDiffFunction();
+  public static final SqlFunction TIMESTAMP_DIFF =
+      new SqlTimestampDiffFunction("TIMESTAMPDIFF",
+          OperandTypes.family(SqlTypeFamily.ANY, SqlTypeFamily.DATETIME,
+              SqlTypeFamily.DATETIME));
 
   /**
    * Use of the <code>IN_FENNEL</code> operator forces the argument to be
@@ -2016,7 +1982,7 @@ public class SqlStdOperatorTable extends ReflectiveSqlOperatorTable {
    * <code>EXTRACT(HOUR FROM INTERVAL '364 23:59:59')</code> returns <code>
    * 23</code>
    */
-  public static final SqlFunction EXTRACT = new SqlExtractFunction();
+  public static final SqlFunction EXTRACT = new SqlExtractFunction("EXTRACT");
 
   /**
    * The SQL <code>YEAR</code> operator. Returns the Year
@@ -2108,12 +2074,10 @@ public class SqlStdOperatorTable extends ReflectiveSqlOperatorTable {
   public static final SqlDatePartFunction SECOND =
       new SqlDatePartFunction("SECOND", TimeUnit.SECOND);
 
+  /** The {@code LAST_DAY(date)} function. */
   public static final SqlFunction LAST_DAY =
-      new SqlFunction(
-          "LAST_DAY",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("LAST_DAY",
           ReturnTypes.DATE_NULLABLE,
-          null,
           OperandTypes.DATETIME,
           SqlFunctionCategory.TIMEDATE);
 
@@ -2122,13 +2086,9 @@ public class SqlStdOperatorTable extends ReflectiveSqlOperatorTable {
    * "regular" type. Example ... log(ELEMENT(MULTISET[1])) ...
    */
   public static final SqlFunction ELEMENT =
-      new SqlFunction(
-          "ELEMENT",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("ELEMENT",
           ReturnTypes.MULTISET_ELEMENT_NULLABLE,
-          null,
-          OperandTypes.COLLECTION,
-          SqlFunctionCategory.SYSTEM);
+          OperandTypes.COLLECTION);
 
   /**
    * The item operator {@code [ ... ]}, used to access a given element of an
@@ -2261,13 +2221,9 @@ public class SqlStdOperatorTable extends ReflectiveSqlOperatorTable {
    * MULTISET, ARRAY or MAP.
    */
   public static final SqlFunction CARDINALITY =
-      new SqlFunction(
-          "CARDINALITY",
-          SqlKind.OTHER_FUNCTION,
+      SqlBasicFunction.create("CARDINALITY",
           ReturnTypes.INTEGER_NULLABLE,
-          null,
-          OperandTypes.COLLECTION_OR_MAP,
-          SqlFunctionCategory.SYSTEM);
+          OperandTypes.COLLECTION_OR_MAP);
 
   /**
    * The COLLECT operator. Multiset aggregator function.
@@ -2282,11 +2238,12 @@ public class SqlStdOperatorTable extends ReflectiveSqlOperatorTable {
    * {@code PERCENTILE_CONT} inverse distribution aggregate function.
    *
    * <p>The argument must be a numeric literal in the range 0 to 1 inclusive
-   * (representing a percentage), and the return type is {@code DOUBLE}.
+   * (representing a percentage), and the return type is the type of the
+   * {@code ORDER BY} expression.
    */
   public static final SqlAggFunction PERCENTILE_CONT =
       SqlBasicAggFunction
-          .create(SqlKind.PERCENTILE_CONT, ReturnTypes.DOUBLE,
+          .create(SqlKind.PERCENTILE_CONT, ReturnTypes.PERCENTILE_DISC_CONT,
               OperandTypes.UNIT_INTERVAL_NUMERIC_LITERAL)
           .withFunctionType(SqlFunctionCategory.SYSTEM)
           .withGroupOrder(Optionality.MANDATORY)
@@ -2296,13 +2253,12 @@ public class SqlStdOperatorTable extends ReflectiveSqlOperatorTable {
    * {@code PERCENTILE_DISC} inverse distribution aggregate function.
    *
    * <p>The argument must be a numeric literal in the range 0 to 1 inclusive
-   * (representing a percentage), and the return type is {@code DOUBLE}.
-   * (The return type should determined by the type of the {@code ORDER BY}
-   * expression, but this cannot be determined by the function itself.)
+   * (representing a percentage), and the return type is the type of the
+   * {@code ORDER BY} expression.
    */
   public static final SqlAggFunction PERCENTILE_DISC =
       SqlBasicAggFunction
-          .create(SqlKind.PERCENTILE_DISC, ReturnTypes.DOUBLE,
+          .create(SqlKind.PERCENTILE_DISC, ReturnTypes.PERCENTILE_DISC_CONT,
               OperandTypes.UNIT_INTERVAL_NUMERIC_LITERAL)
           .withFunctionType(SqlFunctionCategory.SYSTEM)
           .withGroupOrder(Optionality.MANDATORY)
@@ -2406,8 +2362,8 @@ public class SqlStdOperatorTable extends ReflectiveSqlOperatorTable {
   public static final SqlGroupedWindowFunction TUMBLE_OLD =
       new SqlGroupedWindowFunction("$TUMBLE", SqlKind.TUMBLE,
           null, ReturnTypes.ARG0, null,
-          OperandTypes.or(OperandTypes.DATETIME_INTERVAL,
-              OperandTypes.DATETIME_INTERVAL_TIME),
+          OperandTypes.DATETIME_INTERVAL
+              .or(OperandTypes.DATETIME_INTERVAL_TIME),
           SqlFunctionCategory.SYSTEM) {
         @Override public List<SqlGroupedWindowFunction> getAuxiliaryFunctions() {
           return ImmutableList.of(TUMBLE_START, TUMBLE_END);
@@ -2428,8 +2384,8 @@ public class SqlStdOperatorTable extends ReflectiveSqlOperatorTable {
   public static final SqlGroupedWindowFunction HOP_OLD =
       new SqlGroupedWindowFunction("$HOP", SqlKind.HOP, null,
           ReturnTypes.ARG0, null,
-          OperandTypes.or(OperandTypes.DATETIME_INTERVAL_INTERVAL,
-              OperandTypes.DATETIME_INTERVAL_INTERVAL_TIME),
+          OperandTypes.DATETIME_INTERVAL_INTERVAL
+              .or(OperandTypes.DATETIME_INTERVAL_INTERVAL_TIME),
           SqlFunctionCategory.SYSTEM) {
         @Override public List<SqlGroupedWindowFunction> getAuxiliaryFunctions() {
           return ImmutableList.of(HOP_START, HOP_END);
@@ -2450,8 +2406,8 @@ public class SqlStdOperatorTable extends ReflectiveSqlOperatorTable {
   public static final SqlGroupedWindowFunction SESSION_OLD =
       new SqlGroupedWindowFunction("$SESSION", SqlKind.SESSION,
           null, ReturnTypes.ARG0, null,
-          OperandTypes.or(OperandTypes.DATETIME_INTERVAL,
-              OperandTypes.DATETIME_INTERVAL_TIME),
+          OperandTypes.DATETIME_INTERVAL
+              .or(OperandTypes.DATETIME_INTERVAL_TIME),
           SqlFunctionCategory.SYSTEM) {
         @Override public List<SqlGroupedWindowFunction> getAuxiliaryFunctions() {
           return ImmutableList.of(SESSION_START, SESSION_END);
@@ -2563,6 +2519,9 @@ public class SqlStdOperatorTable extends ReflectiveSqlOperatorTable {
         }
       };
 
+  /** SetSemanticsTable represents as an input table with set semantics. */
+  public static final SqlInternalOperator SET_SEMANTICS_TABLE = new SqlSetSemanticsTableOperator();
+
   //~ Methods ----------------------------------------------------------------
 
   /**
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlSubstringFunction.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlSubstringFunction.java
index fae15cbd62b..ffbf4761fce 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlSubstringFunction.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlSubstringFunction.java
@@ -28,11 +28,10 @@
 import org.apache.calcite.sql.SqlOperatorBinding;
 import org.apache.calcite.sql.SqlUtil;
 import org.apache.calcite.sql.SqlWriter;
-import org.apache.calcite.sql.type.FamilyOperandTypeChecker;
 import org.apache.calcite.sql.type.OperandTypes;
 import org.apache.calcite.sql.type.ReturnTypes;
 import org.apache.calcite.sql.type.SqlOperandCountRanges;
-import org.apache.calcite.sql.type.SqlTypeFamily;
+import org.apache.calcite.sql.type.SqlSingleOperandTypeChecker;
 import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.sql.type.SqlTypeUtil;
 import org.apache.calcite.sql.validate.SqlMonotonicity;
@@ -47,6 +46,12 @@
  * Definition of the "SUBSTRING" builtin SQL function.
  */
 public class SqlSubstringFunction extends SqlFunction {
+  /** Type checker for 3 argument calls. Put the STRING_NUMERIC_NUMERIC checker
+   * first because almost every other type can be coerced to STRING. */
+  private static final SqlSingleOperandTypeChecker CHECKER3 =
+      OperandTypes.STRING_NUMERIC_NUMERIC
+          .or(OperandTypes.STRING_STRING_STRING);
+
   //~ Constructors -----------------------------------------------------------
 
   /**
@@ -96,27 +101,20 @@ public class SqlSubstringFunction extends SqlFunction {
   @Override public boolean checkOperandTypes(
       SqlCallBinding callBinding,
       boolean throwOnFailure) {
-    List<SqlNode> operands = callBinding.operands();
-    int n = operands.size();
-    assert (3 == n) || (2 == n);
-    if (2 == n) {
-      return OperandTypes.family(SqlTypeFamily.STRING, SqlTypeFamily.NUMERIC)
+    switch (callBinding.operands().size()) {
+    default:
+      throw new AssertionError();
+    case 2:
+      return OperandTypes.STRING_NUMERIC
           .checkOperandTypes(callBinding, throwOnFailure);
-    } else {
-      final FamilyOperandTypeChecker checker1 = OperandTypes.STRING_STRING_STRING;
-      final FamilyOperandTypeChecker checker2 = OperandTypes.family(
-          SqlTypeFamily.STRING,
-          SqlTypeFamily.NUMERIC,
-          SqlTypeFamily.NUMERIC);
-      // Put the STRING_NUMERIC_NUMERIC checker first because almost every other type
-      // can be coerced to STRING.
-      if (!OperandTypes.or(checker2, checker1)
+    case 3:
+      if (!CHECKER3
           .checkOperandTypes(callBinding, throwOnFailure)) {
         return false;
       }
       // Reset the operands because they may be coerced during
       // implicit type coercion.
-      operands = callBinding.getCall().getOperandList();
+      final List<SqlNode> operands = callBinding.getCall().getOperandList();
       final RelDataType t1 = callBinding.getOperandType(1);
       final RelDataType t2 = callBinding.getOperandType(2);
       if (SqlTypeUtil.inCharFamily(t1)) {
@@ -131,8 +129,8 @@ public class SqlSubstringFunction extends SqlFunction {
         }
         return false;
       }
+      return true;
     }
-    return true;
   }
 
   @Override public SqlOperandCountRange getOperandCountRange() {
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlThrowOperator.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlThrowOperator.java
index 61c90b0b838..ef4c8efac7d 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlThrowOperator.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlThrowOperator.java
@@ -33,7 +33,7 @@
  * of it in constructs such as the following:</p>
  *
  * <blockquote><code>CASE<br>
- * WHEN &lt;conditionn&gt; THEN true<br>
+ * WHEN &lt;condition&gt; THEN true<br>
  * ELSE throw("what's wrong with you man?")<br>
  * END</code></blockquote>
  */
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlTimestampAddFunction.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlTimestampAddFunction.java
index 1af0056acfc..7cef98c0974 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlTimestampAddFunction.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlTimestampAddFunction.java
@@ -19,15 +19,22 @@
 import org.apache.calcite.avatica.util.TimeUnit;
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeFactory;
+import org.apache.calcite.sql.SqlCall;
 import org.apache.calcite.sql.SqlFunction;
 import org.apache.calcite.sql.SqlFunctionCategory;
+import org.apache.calcite.sql.SqlIntervalQualifier;
 import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.type.OperandTypes;
 import org.apache.calcite.sql.type.SqlReturnTypeInference;
 import org.apache.calcite.sql.type.SqlTypeFamily;
 import org.apache.calcite.sql.type.SqlTypeName;
+import org.apache.calcite.sql.type.SqlTypeTransforms;
+import org.apache.calcite.sql.validate.SqlValidator;
+import org.apache.calcite.sql.validate.SqlValidatorScope;
 
-import static org.apache.calcite.sql.validate.SqlNonNullableAccessors.getOperandLiteralValueOrThrow;
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+import static org.apache.calcite.util.Util.first;
 
 /**
  * The <code>TIMESTAMPADD</code> function, which adds an interval to a
@@ -61,50 +68,76 @@ public class SqlTimestampAddFunction extends SqlFunction {
   private static final int MICROSECOND_PRECISION = 6;
 
   private static final SqlReturnTypeInference RETURN_TYPE_INFERENCE =
-      opBinding -> {
-        final RelDataTypeFactory typeFactory = opBinding.getTypeFactory();
-        return deduceType(typeFactory,
-            getOperandLiteralValueOrThrow(opBinding, 0, TimeUnit.class),
-            opBinding.getOperandType(1), opBinding.getOperandType(2));
-      };
+      opBinding ->
+          deduceType(opBinding.getTypeFactory(),
+              opBinding.getOperandLiteralValue(0, TimeUnit.class),
+              opBinding.getOperandType(2));
 
+  @Deprecated // to be removed before 2.0
   public static RelDataType deduceType(RelDataTypeFactory typeFactory,
-      TimeUnit timeUnit, RelDataType operandType1, RelDataType operandType2) {
-    final RelDataType type;
-    switch (timeUnit) {
+      @Nullable TimeUnit timeUnit, RelDataType operandType1,
+      RelDataType operandType2) {
+    final RelDataType type = deduceType(typeFactory, timeUnit, operandType2);
+    return typeFactory.createTypeWithNullability(type,
+        operandType1.isNullable() || operandType2.isNullable());
+  }
+
+  static RelDataType deduceType(RelDataTypeFactory typeFactory,
+      @Nullable TimeUnit timeUnit, RelDataType datetimeType) {
+    TimeUnit timeUnit2 = first(timeUnit, TimeUnit.EPOCH);
+    switch (timeUnit2) {
+    case MILLISECOND:
+      return typeFactory.createSqlType(SqlTypeName.TIMESTAMP,
+          MILLISECOND_PRECISION);
+
+    case MICROSECOND:
+      return typeFactory.createSqlType(SqlTypeName.TIMESTAMP,
+          MICROSECOND_PRECISION);
+
     case HOUR:
     case MINUTE:
     case SECOND:
-    case MILLISECOND:
-    case MICROSECOND:
-      switch (timeUnit) {
-      case MILLISECOND:
-        type = typeFactory.createSqlType(SqlTypeName.TIMESTAMP,
-            MILLISECOND_PRECISION);
-        break;
-      case MICROSECOND:
-        type = typeFactory.createSqlType(SqlTypeName.TIMESTAMP,
-            MICROSECOND_PRECISION);
+      SqlTypeName typeName = datetimeType.getSqlTypeName();
+      switch (typeName) {
+      case TIME:
+      case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
         break;
       default:
-        if (operandType2.getSqlTypeName() == SqlTypeName.TIME) {
-          type = typeFactory.createSqlType(SqlTypeName.TIME);
-        } else {
-          type = typeFactory.createSqlType(SqlTypeName.TIMESTAMP);
-        }
+        // If it is not a TIMESTAMP_WITH_LOCAL_TIME_ZONE, operations involving
+        // HOUR, MINUTE, SECOND with DATE or TIMESTAMP types will result in
+        // TIMESTAMP type.
+        typeName = SqlTypeName.TIMESTAMP;
+        break;
       }
-      break;
+      return typeFactory.createSqlType(typeName);
+
     default:
-      type = operandType2;
+    case EPOCH:
+      return datetimeType;
     }
-    return typeFactory.createTypeWithNullability(type,
-        operandType1.isNullable()
-            || operandType2.isNullable());
+  }
+
+  @Override public void validateCall(SqlCall call, SqlValidator validator,
+      SqlValidatorScope scope, SqlValidatorScope operandScope) {
+    super.validateCall(call, validator, scope, operandScope);
+
+    // This is either a time unit or a time frame:
+    //
+    //  * In "TIMESTAMPADD(YEAR, 2, x)" operand 0 is a SqlIntervalQualifier
+    //    with startUnit = YEAR and timeFrameName = null.
+    //
+    //  * In "TIMESTAMPADD(MINUTE15, 2, x) operand 0 is a SqlIntervalQualifier
+    //    with startUnit = EPOCH and timeFrameName = 'MINUTE15'.
+    //
+    // If the latter, check that timeFrameName is valid.
+    validator.validateTimeFrame(
+        (SqlIntervalQualifier) call.getOperandList().get(0));
   }
 
   /** Creates a SqlTimestampAddFunction. */
-  SqlTimestampAddFunction() {
-    super("TIMESTAMPADD", SqlKind.TIMESTAMP_ADD, RETURN_TYPE_INFERENCE, null,
+  SqlTimestampAddFunction(String name) {
+    super(name, SqlKind.TIMESTAMP_ADD,
+        RETURN_TYPE_INFERENCE.andThen(SqlTypeTransforms.TO_NULLABLE), null,
         OperandTypes.family(SqlTypeFamily.ANY, SqlTypeFamily.INTEGER,
             SqlTypeFamily.DATETIME),
         SqlFunctionCategory.TIMEDATE);
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlTimestampDiffFunction.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlTimestampDiffFunction.java
index 3b62f56f35a..44b077da0d9 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlTimestampDiffFunction.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlTimestampDiffFunction.java
@@ -17,14 +17,18 @@
 package org.apache.calcite.sql.fun;
 
 import org.apache.calcite.avatica.util.TimeUnit;
+import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeFactory;
+import org.apache.calcite.sql.SqlCall;
 import org.apache.calcite.sql.SqlFunction;
 import org.apache.calcite.sql.SqlFunctionCategory;
+import org.apache.calcite.sql.SqlIntervalQualifier;
 import org.apache.calcite.sql.SqlKind;
-import org.apache.calcite.sql.type.OperandTypes;
-import org.apache.calcite.sql.type.SqlReturnTypeInference;
-import org.apache.calcite.sql.type.SqlTypeFamily;
+import org.apache.calcite.sql.SqlOperatorBinding;
+import org.apache.calcite.sql.type.SqlOperandTypeChecker;
 import org.apache.calcite.sql.type.SqlTypeName;
+import org.apache.calcite.sql.validate.SqlValidator;
+import org.apache.calcite.sql.validate.SqlValidatorScope;
 
 /**
  * The <code>TIMESTAMPDIFF</code> function, which calculates the difference
@@ -54,25 +58,58 @@
  * interval.
  */
 class SqlTimestampDiffFunction extends SqlFunction {
-  /** Creates a SqlTimestampDiffFunction. */
-  private static final SqlReturnTypeInference RETURN_TYPE_INFERENCE =
-      opBinding -> {
-        final RelDataTypeFactory typeFactory = opBinding.getTypeFactory();
-        SqlTypeName sqlTypeName =
-            opBinding.getOperandLiteralValue(0, TimeUnit.class) == TimeUnit.NANOSECOND
-                ? SqlTypeName.BIGINT
-                : SqlTypeName.INTEGER;
-        return typeFactory.createTypeWithNullability(
-            typeFactory.createSqlType(sqlTypeName),
-            opBinding.getOperandType(1).isNullable()
-            || opBinding.getOperandType(2).isNullable());
-      };
+  private static RelDataType inferReturnType2(SqlOperatorBinding opBinding) {
+    final RelDataTypeFactory typeFactory = opBinding.getTypeFactory();
+    final TimeUnit timeUnit;
+    final RelDataType type1;
+    final RelDataType type2;
+    if (opBinding.isOperandTimeFrame(0)) {
+      timeUnit = opBinding.getOperandLiteralValue(0, TimeUnit.class);
+      type1 = opBinding.getOperandType(1);
+      type2 = opBinding.getOperandType(2);
+    } else {
+      type1 = opBinding.getOperandType(0);
+      type2 = opBinding.getOperandType(1);
+      timeUnit = opBinding.getOperandLiteralValue(2, TimeUnit.class);
+    }
+    SqlTypeName sqlTypeName =
+        timeUnit == TimeUnit.NANOSECOND
+            ? SqlTypeName.BIGINT
+            : SqlTypeName.INTEGER;
+    return typeFactory.createTypeWithNullability(
+        typeFactory.createSqlType(sqlTypeName),
+        type1.isNullable()
+            || type2.isNullable());
+  }
 
-  SqlTimestampDiffFunction() {
-    super("TIMESTAMPDIFF", SqlKind.TIMESTAMP_DIFF,
-        RETURN_TYPE_INFERENCE, null,
-        OperandTypes.family(SqlTypeFamily.ANY, SqlTypeFamily.DATETIME,
-            SqlTypeFamily.DATETIME),
+  /** Creates a SqlTimestampDiffFunction. */
+  SqlTimestampDiffFunction(String name, SqlOperandTypeChecker operandTypeChecker) {
+    super(name, SqlKind.TIMESTAMP_DIFF,
+        SqlTimestampDiffFunction::inferReturnType2, null, operandTypeChecker,
         SqlFunctionCategory.TIMEDATE);
   }
+
+  @Override public void validateCall(SqlCall call, SqlValidator validator,
+      SqlValidatorScope scope, SqlValidatorScope operandScope) {
+    super.validateCall(call, validator, scope, operandScope);
+
+    // This is either a time unit or a time frame:
+    //
+    //  * In "TIMESTAMPDIFF(YEAR, timestamp1, timestamp2)" operand 0 is a
+    //    SqlIntervalQualifier with startUnit = YEAR and timeFrameName = null.
+    //    The same is true for BigQuery's TIMESTAMP_DIFF(), however the
+    //    SqlIntervalQualifier is operand 2 due to differing parameter orders.
+    //
+    //  * In "TIMESTAMP_ADD(MINUTE15, timestamp1, timestamp2) operand 0 is a
+    //    SqlIntervalQualifier with startUnit = EPOCH and timeFrameName =
+    //    'MINUTE15'. As above, for BigQuery's TIMESTAMP_DIFF() the
+    //    SqlIntervalQualifier is found in operand 2 instead.
+    //
+    // If the latter, check that timeFrameName is valid.
+    if (call.operand(2) instanceof SqlIntervalQualifier) {
+      validator.validateTimeFrame(call.operand(2));
+    } else {
+      validator.validateTimeFrame(call.operand(0));
+    }
+  }
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlTrimFunction.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlTrimFunction.java
index 420ad81f7bd..7373bbc9002 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlTrimFunction.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlTrimFunction.java
@@ -28,10 +28,8 @@
 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.SameOperandTypeChecker;
 import org.apache.calcite.sql.type.SqlReturnTypeInference;
 import org.apache.calcite.sql.type.SqlSingleOperandTypeChecker;
-import org.apache.calcite.sql.type.SqlTypeFamily;
 import org.apache.calcite.sql.type.SqlTypeTransforms;
 import org.apache.calcite.sql.type.SqlTypeUtil;
 
@@ -40,7 +38,6 @@
 import org.checkerframework.checker.nullness.qual.Nullable;
 
 import java.util.Arrays;
-import java.util.List;
 
 /**
  * Definition of the "TRIM" builtin SQL function.
@@ -50,16 +47,8 @@ public class SqlTrimFunction extends SqlFunction {
       new SqlTrimFunction("TRIM", SqlKind.TRIM,
           ReturnTypes.ARG2.andThen(SqlTypeTransforms.TO_NULLABLE)
               .andThen(SqlTypeTransforms.TO_VARYING),
-          OperandTypes.and(
-              OperandTypes.family(SqlTypeFamily.ANY, SqlTypeFamily.STRING,
-                  SqlTypeFamily.STRING),
-              // Arguments 1 and 2 must have same type
-              new SameOperandTypeChecker(3) {
-                @Override protected List<Integer>
-                getOperandList(int operandCount) {
-                  return ImmutableList.of(1, 2);
-                }
-              }));
+          OperandTypes.ANY_STRING_STRING.and(
+              OperandTypes.same(3, 1, 2)));
 
   //~ Enums ------------------------------------------------------------------
 
diff --git a/core/src/main/java/org/apache/calcite/sql/parser/Span.java b/core/src/main/java/org/apache/calcite/sql/parser/Span.java
index 0753044cb0b..c682769e6f6 100644
--- a/core/src/main/java/org/apache/calcite/sql/parser/Span.java
+++ b/core/src/main/java/org/apache/calcite/sql/parser/Span.java
@@ -19,6 +19,8 @@
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.sql.SqlNodeList;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.List;
@@ -94,7 +96,7 @@ public Span add(SqlNode n) {
 
   /** Adds a node's position to the list if the node is not null,
    * and returns this Span. */
-  public Span addIf(SqlNode n) {
+  public Span addIf(@Nullable SqlNode n) {
     return n == null ? this : add(n);
   }
 
diff --git a/core/src/main/java/org/apache/calcite/sql/parser/SqlAbstractParserImpl.java b/core/src/main/java/org/apache/calcite/sql/parser/SqlAbstractParserImpl.java
index cab77f96a33..3337442e4a5 100644
--- a/core/src/main/java/org/apache/calcite/sql/parser/SqlAbstractParserImpl.java
+++ b/core/src/main/java/org/apache/calcite/sql/parser/SqlAbstractParserImpl.java
@@ -17,16 +17,22 @@
 package org.apache.calcite.sql.parser;
 
 import org.apache.calcite.avatica.util.Casing;
+import org.apache.calcite.avatica.util.TimeUnit;
 import org.apache.calcite.config.CharLiteralStyle;
+import org.apache.calcite.rel.type.TimeFrameSet;
 import org.apache.calcite.runtime.CalciteContextException;
+import org.apache.calcite.runtime.CalciteException;
+import org.apache.calcite.runtime.Resources;
 import org.apache.calcite.sql.SqlCall;
 import org.apache.calcite.sql.SqlFunctionCategory;
 import org.apache.calcite.sql.SqlIdentifier;
+import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.SqlLiteral;
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.sql.SqlNodeList;
 import org.apache.calcite.sql.SqlOperator;
 import org.apache.calcite.sql.SqlUnresolvedFunction;
+import org.apache.calcite.sql.SqlUtil;
 import org.apache.calcite.sql.validate.SqlConformance;
 import org.apache.calcite.util.Glossary;
 
@@ -35,7 +41,6 @@
 import com.google.common.collect.Iterables;
 
 import org.checkerframework.checker.initialization.qual.UnderInitialization;
-import org.checkerframework.checker.nullness.qual.NonNull;
 import org.checkerframework.checker.nullness.qual.Nullable;
 
 import java.io.Reader;
@@ -46,11 +51,13 @@
 import java.util.EnumSet;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.NavigableSet;
 import java.util.Set;
-import java.util.SortedSet;
 import java.util.TreeSet;
 
+import static org.apache.calcite.util.Static.RESOURCE;
+
 /**
  * Abstract base for parsers generated from CommonParser.jj.
  */
@@ -323,9 +330,31 @@ protected enum ExprContext {
 
     /**
      * Accept only query expressions in this context.
+     *
+     * <p>Valid: "SELECT x FROM a",
+     * "SELECT x FROM a UNION SELECT y FROM b",
+     * "TABLE a",
+     * "VALUES (1, 2), (3, 4)",
+     * "(SELECT x FROM a UNION SELECT y FROM b) INTERSECT SELECT z FROM c",
+     * "(SELECT x FROM a UNION SELECT y FROM b) ORDER BY 1 LIMIT 10".
+     * Invalid: "e CROSS JOIN d".
+     * Debatable: "(SELECT x FROM a)".
      */
     ACCEPT_QUERY,
 
+    /**
+     * Accept only query expressions or joins in this context.
+     *
+     * <p>Valid: "(SELECT x FROM a)",
+     * "e CROSS JOIN d",
+     * "((SELECT x FROM a) CROSS JOIN d)",
+     * "((e CROSS JOIN d) LEFT JOIN c)".
+     * Invalid: "e, d",
+     * "SELECT x FROM a",
+     * "(e)".
+     */
+    ACCEPT_QUERY_OR_JOIN,
+
     /**
      * Accept only non-query expressions in this context.
      */
@@ -348,6 +377,33 @@ protected enum ExprContext {
 
     @Deprecated // to be removed before 2.0
     public static final ExprContext ACCEPT_NONQUERY = ACCEPT_NON_QUERY;
+
+    public void throwIfNotCompatible(SqlNode e) {
+      switch (this) {
+      case ACCEPT_NON_QUERY:
+      case ACCEPT_SUB_QUERY:
+      case ACCEPT_CURSOR:
+        if (e.isA(SqlKind.QUERY)) {
+          throw SqlUtil.newContextException(e.getParserPosition(),
+              RESOURCE.illegalQueryExpression());
+        }
+        break;
+      case ACCEPT_QUERY:
+        if (!e.isA(SqlKind.QUERY)) {
+          throw SqlUtil.newContextException(e.getParserPosition(),
+              RESOURCE.illegalNonQueryExpression());
+        }
+        break;
+      case ACCEPT_QUERY_OR_JOIN:
+        if (!e.isA(SqlKind.QUERY) && e.getKind() != SqlKind.JOIN) {
+          throw SqlUtil.newContextException(e.getParserPosition(),
+              RESOURCE.expectedQueryOrJoinExpression());
+        }
+        break;
+      default:
+        break;
+      }
+    }
   }
 
   //~ Instance fields --------------------------------------------------------
@@ -489,11 +545,23 @@ protected SqlCall createCall(
    */
   public abstract void setIdentifierMaxLength(int identifierMaxLength);
 
+  /**
+   * Sets the map from identifier to time unit.
+   */
+  @Deprecated // to be removed before 2.0
+  public void setTimeUnitCodes(Map<String, TimeUnit> timeUnitCodes) {
+  }
+
   /**
    * Sets the SQL language conformance level.
    */
   public abstract void setConformance(SqlConformance conformance);
 
+  /**
+   * Parses string to array literal.
+   */
+  public abstract SqlNode parseArray() throws SqlParseException;
+
   /**
    * Sets the SQL text that is being parsed.
    */
diff --git a/core/src/main/java/org/apache/calcite/sql/parser/SqlParser.java b/core/src/main/java/org/apache/calcite/sql/parser/SqlParser.java
index 352f1eadc08..237a366606c 100644
--- a/core/src/main/java/org/apache/calcite/sql/parser/SqlParser.java
+++ b/core/src/main/java/org/apache/calcite/sql/parser/SqlParser.java
@@ -18,8 +18,11 @@
 
 import org.apache.calcite.avatica.util.Casing;
 import org.apache.calcite.avatica.util.Quoting;
+import org.apache.calcite.avatica.util.TimeUnit;
 import org.apache.calcite.config.CharLiteralStyle;
 import org.apache.calcite.config.Lex;
+import org.apache.calcite.rel.type.RelDataTypeSystem;
+import org.apache.calcite.rel.type.TimeFrameSet;
 import org.apache.calcite.runtime.CalciteContextException;
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.sql.SqlNodeList;
@@ -29,6 +32,7 @@
 import org.apache.calcite.sql.validate.SqlDelegatingConformance;
 import org.apache.calcite.util.SourceStringReader;
 
+import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
 
 import org.immutables.value.Value;
@@ -36,6 +40,7 @@
 import java.io.Reader;
 import java.io.StringReader;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
 /**
@@ -45,6 +50,14 @@
 @SuppressWarnings("deprecation")
 public class SqlParser {
   public static final int DEFAULT_IDENTIFIER_MAX_LENGTH = 128;
+
+  /** Default value of {@link Config#timeUnitCodes()}.
+   * The map is empty, which means that there are no abbreviations other than
+   * the time unit names ("YEAR", "SECOND", etc.) */
+  @Deprecated // to be removed before 2.0
+  public static final ImmutableMap<String, TimeUnit> DEFAULT_IDENTIFIER_TIMEUNIT_MAP =
+      ImmutableMap.of();
+
   @Deprecated // to be removed before 2.0
   public static final boolean DEFAULT_ALLOW_BANG_EQUAL =
       SqlConformanceEnum.DEFAULT.isBangEqualAllowed();
@@ -60,6 +73,7 @@ private SqlParser(SqlAbstractParserImpl parser,
     parser.setQuotedCasing(config.quotedCasing());
     parser.setUnquotedCasing(config.unquotedCasing());
     parser.setIdentifierMaxLength(config.identifierMaxLength());
+    parser.setTimeUnitCodes(config.timeUnitCodes());
     parser.setConformance(config.conformance());
     parser.switchTo(SqlAbstractParserImpl.LexicalState.forConfig(config));
   }
@@ -309,6 +323,25 @@ public interface Config {
     /** Sets {@link #charLiteralStyles()}. */
     Config withCharLiteralStyles(Iterable<CharLiteralStyle> charLiteralStyles);
 
+    /** Returns a mapping from abbreviations to time units.
+     *
+     * <p>For example, if the map contains the entry
+     * ("Y", {@link TimeUnit#YEAR}) then you can write
+     * "{@code EXTRACT(S FROM orderDate)}".
+     *
+     * @deprecated This property is deprecated, and has no effect. All
+     * non-standard time units are now parsed as identifiers, and resolved in
+     * the validator. You can define custom time frames using
+     * {@link RelDataTypeSystem#deriveTimeFrameSet(TimeFrameSet)}. To alias a
+     * time frame, use {@link TimeFrameSet.Builder#addAlias(String, String)}. */
+    @Deprecated // to be removed before 2.0
+    @Value.Default default Map<String, TimeUnit> timeUnitCodes() {
+      return DEFAULT_IDENTIFIER_TIMEUNIT_MAP;
+    }
+
+    /** Sets {@link #timeUnitCodes()}. */
+    Config withTimeUnitCodes(Map<String, ? extends TimeUnit> timeUnitCodes);
+
     @Value.Default default SqlParserImplFactory parserFactory() {
       return SqlParserImpl.FACTORY;
     }
@@ -358,6 +391,11 @@ public ConfigBuilder setIdentifierMaxLength(int identifierMaxLength) {
       return setConfig(config.withIdentifierMaxLength(identifierMaxLength));
     }
 
+    public ConfigBuilder setIdentifierTimeUnitMap(
+        ImmutableMap<String, TimeUnit> identifierTimeUnitMap) {
+      return setConfig(config.withTimeUnitCodes(identifierTimeUnitMap));
+    }
+
     @SuppressWarnings("unused")
     @Deprecated // to be removed before 2.0
     public ConfigBuilder setAllowBangEqual(final boolean allowBangEqual) {
diff --git a/core/src/main/java/org/apache/calcite/sql/parser/SqlParserUtil.java b/core/src/main/java/org/apache/calcite/sql/parser/SqlParserUtil.java
index d60a579585f..1c304706fd8 100644
--- a/core/src/main/java/org/apache/calcite/sql/parser/SqlParserUtil.java
+++ b/core/src/main/java/org/apache/calcite/sql/parser/SqlParserUtil.java
@@ -39,6 +39,8 @@
 import org.apache.calcite.sql.SqlTimestampLiteral;
 import org.apache.calcite.sql.SqlUtil;
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
+import org.apache.calcite.sql.parser.impl.SqlParserImpl;
+import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.util.DateString;
 import org.apache.calcite.util.PrecedenceClimbingParser;
 import org.apache.calcite.util.TimeString;
@@ -52,6 +54,7 @@
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.slf4j.Logger;
 
+import java.io.StringReader;
 import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.nio.charset.Charset;
@@ -61,12 +64,12 @@
 import java.util.Calendar;
 import java.util.List;
 import java.util.Locale;
-import java.util.Objects;
 import java.util.StringTokenizer;
 import java.util.function.Predicate;
 
 import static org.apache.calcite.util.Static.RESOURCE;
 
+import static java.lang.Integer.parseInt;
 import static java.util.Objects.requireNonNull;
 
 /**
@@ -110,6 +113,156 @@ public static String parseString(String s) {
     return strip(s, "'", "'", "''", Casing.UNCHANGED);
   }
 
+  /**
+   * Converts the contents of a SQL quoted character literal with C-style
+   * escapes into the corresponding Java string representation.
+   *
+   * @throws MalformedUnicodeEscape if input contains invalid unicode escapes
+   */
+  public static String parseCString(String s) throws MalformedUnicodeEscape {
+    final String s2 = parseString(s);
+    return replaceEscapedChars(s2);
+  }
+
+  /**
+   * Converts the contents of a character literal  with escapes like those used
+   * in the C programming language to the corresponding Java string
+   * representation.
+   *
+   * <p>If the literal "{@code E'a\tc'}" occurs in the SQL source text, then
+   * this method will be invoked with the string "{@code a\tc}" (4 characters)
+   * and will return a Java string with the three characters 'a', TAB, 'b'.
+   *
+   * <p>The format is the same as the Postgres; see
+   * <a href="https://www.postgresql.org/docs/14/sql-syntax-lexical.html#SQL-SYNTAX-CONSTANTS">
+   * Postgres 4.1.2.2. String Constants With C-Style Escapes</a>.
+   *
+   * @param input String that contains C-style escapes
+   * @return String with escapes converted into Java characters
+   * @throws MalformedUnicodeEscape if input contains invalid unicode escapes
+   */
+  public static String replaceEscapedChars(String input)
+      throws MalformedUnicodeEscape {
+    // The implementation of this method is based on Crate's method
+    // Literals.replaceEscapedChars.
+    final int length = input.length();
+    if (length <= 1) {
+      return input;
+    }
+    final StringBuilder builder = new StringBuilder(length);
+    int endIdx;
+    for (int i = 0; i < length; i++) {
+      char currentChar = input.charAt(i);
+      if (currentChar == '\\' && i + 1 < length) {
+        char nextChar = input.charAt(i + 1);
+        switch (nextChar) {
+        case 'b':
+          builder.append('\b');
+          i++;
+          break;
+        case 'f':
+          builder.append('\f');
+          i++;
+          break;
+        case 'n':
+          builder.append('\n');
+          i++;
+          break;
+        case 'r':
+          builder.append('\r');
+          i++;
+          break;
+        case 't':
+          builder.append('\t');
+          i++;
+          break;
+        case '\\':
+        case '\'':
+          builder.append(nextChar);
+          i++;
+          break;
+        case 'u':
+        case 'U':
+          // handle unicode case
+          final int charsToConsume = (nextChar == 'u') ? 4 : 8;
+          if (i + 1 + charsToConsume >= length) {
+            throw new MalformedUnicodeEscape(i);
+          }
+          endIdx =
+              calculateMaxCharsInSequence(input, i + 2, charsToConsume,
+                  SqlParserUtil::isHexDigit);
+          if (endIdx != i + 2 + charsToConsume) {
+            throw new MalformedUnicodeEscape(i);
+          }
+          builder.appendCodePoint(parseInt(input.substring(i + 2, endIdx), 16));
+          i = endIdx - 1; // skip already consumed chars
+          break;
+        case 'x':
+          // handle hex byte case - up to 2 chars for hex value
+          endIdx =
+              calculateMaxCharsInSequence(input, i + 2, 2,
+                  SqlParserUtil::isHexDigit);
+          if (endIdx > i + 2) {
+            builder.appendCodePoint(parseInt(input.substring(i + 2, endIdx), 16));
+            i = endIdx - 1; // skip already consumed chars
+          } else {
+            // hex sequence unmatched - output original char
+            builder.append(nextChar);
+            i++;
+          }
+          break;
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+          // handle octal case - up to 3 chars
+          endIdx =
+              calculateMaxCharsInSequence(input, i + 2,
+                  2, // first char is already "consumed"
+                  SqlParserUtil::isOctalDigit);
+          builder.appendCodePoint(parseInt(input.substring(i + 1, endIdx), 8));
+          i = endIdx - 1; // skip already consumed chars
+          break;
+        default:
+          // non-valid escaped char sequence
+          builder.append(currentChar);
+        }
+      } else {
+        builder.append(currentChar);
+      }
+    }
+    return builder.toString();
+  }
+
+  /**
+   * Calculates the maximum number of consecutive characters of the
+   * {@link CharSequence} argument, starting from {@code beginIndex}, that match
+   * a given {@link Predicate}. The number of characters to match are either
+   * capped from the {@code maxCharsToMatch} parameter or the sequence length.
+   *
+   * <p>Examples:
+   * <pre>
+   * {@code
+   *    calculateMaxCharsInSequence("12345", 0, 2, Character::isDigit) -> 2
+   *    calculateMaxCharsInSequence("12345", 3, 2, Character::isDigit) -> 5
+   *    calculateMaxCharsInSequence("12345", 4, 2, Character::isDigit) -> 5
+   * }
+   * </pre>
+   *
+   * @return the index of the first non-matching character
+   */
+  private static int calculateMaxCharsInSequence(CharSequence seq,
+      int beginIndex,
+      int maxCharsToMatch,
+      Predicate<Character> predicate) {
+    int idx = beginIndex;
+    final int end = Math.min(seq.length(), beginIndex + maxCharsToMatch);
+    while (idx < end && predicate.test(seq.charAt(idx))) {
+      idx++;
+    }
+    return idx;
+  }
+
   public static BigDecimal parseDecimal(String s) {
     return new BigDecimal(s);
   }
@@ -118,6 +271,22 @@ public static BigDecimal parseInteger(String s) {
     return new BigDecimal(s);
   }
 
+  /**
+   * Returns true if the specific character is a base-8 digit.
+   */
+  public static boolean isOctalDigit(final char ch) {
+    return ch >= '0' && ch <= '7';
+  }
+
+  /**
+   * Returns true if the specified character is a base-16 digit.
+   */
+  public static boolean isHexDigit(final char ch) {
+    return (ch >= '0' && ch <= '9')
+        || (ch >= 'A' && ch <= 'F')
+        || (ch >= 'a' && ch <= 'f');
+  }
+
   // CHECKSTYLE: IGNORE 1
   /** @deprecated this method is not localized for Farrago standards */
   @Deprecated // to be removed before 2.0
@@ -140,9 +309,8 @@ public static java.sql.Timestamp parseTimestamp(String s) {
   }
 
   public static SqlDateLiteral parseDateLiteral(String s, SqlParserPos pos) {
-    final String dateStr = parseString(s);
     final Calendar cal =
-        DateTimeUtils.parseDateFormat(dateStr, Format.get().date,
+        DateTimeUtils.parseDateFormat(s, Format.get().date,
             DateTimeUtils.UTC_ZONE);
     if (cal == null) {
       throw SqlUtil.newContextException(pos,
@@ -154,9 +322,8 @@ public static SqlDateLiteral parseDateLiteral(String s, SqlParserPos pos) {
   }
 
   public static SqlTimeLiteral parseTimeLiteral(String s, SqlParserPos pos) {
-    final String dateStr = parseString(s);
     final DateTimeUtils.PrecisionTime pt =
-        DateTimeUtils.parsePrecisionDateTimeLiteral(dateStr,
+        DateTimeUtils.parsePrecisionDateTimeLiteral(s,
             Format.get().time, DateTimeUtils.UTC_ZONE, -1);
     if (pt == null) {
       throw SqlUtil.newContextException(pos,
@@ -170,39 +337,66 @@ public static SqlTimeLiteral parseTimeLiteral(String s, SqlParserPos pos) {
 
   public static SqlTimestampLiteral parseTimestampLiteral(String s,
       SqlParserPos pos) {
-    final String dateStr = parseString(s);
+    return parseTimestampLiteral(SqlTypeName.TIMESTAMP, s, pos);
+  }
+
+  public static SqlTimestampLiteral parseTimestampWithLocalTimeZoneLiteral(
+      String s, SqlParserPos pos) {
+    return parseTimestampLiteral(SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE, s,
+        pos);
+  }
+
+  private static SqlTimestampLiteral parseTimestampLiteral(SqlTypeName typeName,
+      String s, SqlParserPos pos) {
     final Format format = Format.get();
     DateTimeUtils.PrecisionTime pt = null;
     // Allow timestamp literals with and without time fields (as does
     // PostgreSQL); TODO: require time fields except in Babel's lenient mode
     final DateFormat[] dateFormats = {format.timestamp, format.date};
     for (DateFormat dateFormat : dateFormats) {
-      pt = DateTimeUtils.parsePrecisionDateTimeLiteral(dateStr,
-          dateFormat, DateTimeUtils.UTC_ZONE, -1);
+      pt =
+          DateTimeUtils.parsePrecisionDateTimeLiteral(s,
+              dateFormat, DateTimeUtils.UTC_ZONE, -1);
       if (pt != null) {
         break;
       }
     }
     if (pt == null) {
       throw SqlUtil.newContextException(pos,
-          RESOURCE.illegalLiteral("TIMESTAMP", s,
+          RESOURCE.illegalLiteral(typeName.getName().replace('_', ' '), s,
               RESOURCE.badFormat(DateTimeUtils.TIMESTAMP_FORMAT_STRING).str()));
     }
     final TimestampString ts =
         TimestampString.fromCalendarFields(pt.getCalendar())
             .withFraction(pt.getFraction());
-    return SqlLiteral.createTimestamp(ts, pt.getPrecision(), pos);
+    return SqlLiteral.createTimestamp(typeName, ts, pt.getPrecision(), pos);
   }
 
   public static SqlIntervalLiteral parseIntervalLiteral(SqlParserPos pos,
       int sign, String s, SqlIntervalQualifier intervalQualifier) {
-    final String intervalStr = parseString(s);
-    if (intervalStr.equals("")) {
+    if (s.equals("")) {
       throw SqlUtil.newContextException(pos,
           RESOURCE.illegalIntervalLiteral(s + " "
               + intervalQualifier.toString(), pos.toString()));
     }
-    return SqlLiteral.createInterval(sign, intervalStr, intervalQualifier, pos);
+    return SqlLiteral.createInterval(sign, s, intervalQualifier, pos);
+  }
+
+  /**
+   * Parses string to array literal
+   * using {@link org.apache.calcite.sql.parser.impl.SqlParserImpl} parser.
+   * String format description can be found at the
+   * <a href="https://www.postgresql.org/docs/current/arrays.html#ARRAYS-INPUT">link</a>
+   *
+   * @param s a string to parse
+   * @return a array value
+   *
+   * @throws SqlParseException if there is a parse error
+   */
+  public static SqlNode parseArrayLiteral(String s) throws SqlParseException {
+    SqlAbstractParserImpl parser =
+        SqlParserImpl.FACTORY.getParser(new StringReader(s));
+    return parser.parseArray();
   }
 
   /**
@@ -236,9 +430,9 @@ public static long intervalToMillis(
         "interval must be day time");
     int[] ret;
     try {
-      ret = intervalQualifier.evaluateIntervalLiteral(literal,
-          intervalQualifier.getParserPosition(), RelDataTypeSystem.DEFAULT);
-      assert ret != null;
+      ret =
+          intervalQualifier.evaluateIntervalLiteral(literal,
+              intervalQualifier.getParserPosition(), RelDataTypeSystem.DEFAULT);
     } catch (CalciteContextException e) {
       throw new RuntimeException("while parsing day-to-second interval "
           + literal, e);
@@ -277,9 +471,9 @@ public static long intervalToMonths(
         "interval must be year month");
     int[] ret;
     try {
-      ret = intervalQualifier.evaluateIntervalLiteral(literal,
-          intervalQualifier.getParserPosition(), RelDataTypeSystem.DEFAULT);
-      assert ret != null;
+      ret =
+          intervalQualifier.evaluateIntervalLiteral(literal,
+              intervalQualifier.getParserPosition(), RelDataTypeSystem.DEFAULT);
     } catch (CalciteContextException e) {
       throw new RuntimeException("Error while parsing year-to-month interval "
           + literal, e);
@@ -306,7 +500,7 @@ public static int parsePositiveInt(String value) {
     if (value.charAt(0) == '-') {
       throw new NumberFormatException(value);
     }
-    return Integer.parseInt(value);
+    return parseInt(value);
   }
 
   /**
@@ -352,9 +546,8 @@ public static byte[] parseBinaryString(String s) {
   public static String strip(String s, @Nullable String startQuote,
       @Nullable String endQuote, @Nullable String escape, Casing casing) {
     if (startQuote != null) {
-      return stripQuotes(s, Objects.requireNonNull(startQuote, "startQuote"),
-          Objects.requireNonNull(endQuote, "endQuote"), Objects.requireNonNull(escape, "escape"),
-          casing);
+      return stripQuotes(s, startQuote, requireNonNull(endQuote, "endQuote"),
+          requireNonNull(escape, "escape"), casing);
     } else {
       return toCase(s, casing);
     }
@@ -655,8 +848,8 @@ public static <T> void replaceSublist(
    */
   public static SqlNode toTreeEx(SqlSpecialOperator.TokenSequence list,
       int start, final int minPrec, final SqlKind stopperKind) {
-    PrecedenceClimbingParser parser = list.parser(start,
-        token -> {
+    PrecedenceClimbingParser parser =
+        list.parser(start, token -> {
           if (token instanceof PrecedenceClimbingParser.Op) {
             PrecedenceClimbingParser.Op tokenOp = (PrecedenceClimbingParser.Op) token;
             final SqlOperator op = ((ToTreeListItem) tokenOp.o()).op;
@@ -835,8 +1028,9 @@ private TokenSequenceImpl(PrecedenceClimbingParser parser) {
     }
 
     @Override public SqlOperator op(int i) {
-      ToTreeListItem o = (ToTreeListItem) requireNonNull(list.get(i).o,
-          () -> "list.get(" + i + ").o is null in " + list);
+      ToTreeListItem o =
+          (ToTreeListItem) requireNonNull(list.get(i).o,
+              () -> "list.get(" + i + ").o is null in " + list);
       return o.getOperator();
     }
 
@@ -929,8 +1123,9 @@ private OldTokenSequenceImpl(List<@Nullable Object> list) {
     }
 
     @Override public SqlOperator op(int i) {
-      ToTreeListItem item = (ToTreeListItem) requireNonNull(list.get(i),
-          () -> "list.get(" + i + ")");
+      ToTreeListItem item =
+          (ToTreeListItem) requireNonNull(list.get(i),
+              () -> "list.get(" + i + ")");
       return item.op;
     }
 
@@ -973,4 +1168,13 @@ private static Format get() {
     final DateFormat date =
         new SimpleDateFormat(DateTimeUtils.DATE_FORMAT_STRING, Locale.ROOT);
   }
+
+  /** Thrown by {@link #replaceEscapedChars(String)}. */
+  public static class MalformedUnicodeEscape extends Exception {
+    public final int i;
+
+    MalformedUnicodeEscape(int i) {
+      this.i = i;
+    }
+  }
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/pretty/SqlPrettyWriter.java b/core/src/main/java/org/apache/calcite/sql/pretty/SqlPrettyWriter.java
index e39e5ffa7bc..3a5d380e72b 100644
--- a/core/src/main/java/org/apache/calcite/sql/pretty/SqlPrettyWriter.java
+++ b/core/src/main/java/org/apache/calcite/sql/pretty/SqlPrettyWriter.java
@@ -396,8 +396,9 @@ public void setWindowDeclListNewline(boolean windowDeclListNewline) {
 
   @Override public boolean inQuery() {
     return (frame == null)
+        || (frame.frameType == FrameTypeEnum.SELECT)
         || (frame.frameType == FrameTypeEnum.ORDER_BY)
-        || (frame.frameType == FrameTypeEnum.WITH)
+        || (frame.frameType == FrameTypeEnum.WITH_BODY)
         || (frame.frameType == FrameTypeEnum.SETOP);
   }
 
@@ -1387,7 +1388,7 @@ private static class Bean {
       for (Method method : o.getClass().getMethods()) {
         if (method.getName().startsWith("set")
             && (method.getReturnType() == Void.class)
-            && (method.getParameterTypes().length == 1)) {
+            && (method.getParameterCount() == 1)) {
           String attributeName =
               stripPrefix(
                   method.getName(),
@@ -1396,7 +1397,7 @@ private static class Bean {
         }
         if (method.getName().startsWith("get")
             && (method.getReturnType() != Void.class)
-            && (method.getParameterTypes().length == 0)) {
+            && (method.getParameterCount() == 0)) {
           String attributeName =
               stripPrefix(
                   method.getName(),
@@ -1405,7 +1406,7 @@ private static class Bean {
         }
         if (method.getName().startsWith("is")
             && (method.getReturnType() == Boolean.class)
-            && (method.getParameterTypes().length == 0)) {
+            && (method.getParameterCount() == 0)) {
           String attributeName =
               stripPrefix(
                   method.getName(),
@@ -1421,10 +1422,9 @@ private static String stripPrefix(String name, int offset) {
     }
 
     public void set(String name, String value) {
-      final Method method = requireNonNull(
-          setterMethods.get(name),
-          () -> "setter method " + name + " not found"
-      );
+      final Method method =
+          requireNonNull(setterMethods.get(name),
+              () -> "setter method " + name + " not found");
       try {
         method.invoke(o, value);
       } catch (IllegalAccessException | InvocationTargetException e) {
@@ -1433,10 +1433,9 @@ public void set(String name, String value) {
     }
 
     public @Nullable Object get(String name) {
-      final Method method = requireNonNull(
-          getterMethods.get(name),
-          () -> "getter method " + name + " not found"
-      );
+      final Method method =
+          requireNonNull(getterMethods.get(name),
+              () -> "getter method " + name + " not found");
       try {
         return method.invoke(o);
       } catch (IllegalAccessException | InvocationTargetException e) {
diff --git a/core/src/main/java/org/apache/calcite/sql/type/ApplySqlType.java b/core/src/main/java/org/apache/calcite/sql/type/ApplySqlType.java
new file mode 100644
index 00000000000..baef6c4ca24
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/sql/type/ApplySqlType.java
@@ -0,0 +1,56 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.sql.type;
+
+import org.apache.calcite.linq4j.Ord;
+import org.apache.calcite.rel.type.RelDataType;
+
+import com.google.common.collect.ImmutableList;
+
+/** Type that applies generic type to type parameters. */
+abstract class ApplySqlType extends AbstractSqlType {
+  protected final ImmutableList<? extends RelDataType> types;
+
+  ApplySqlType(SqlTypeName typeName, boolean isNullable,
+      Iterable<? extends RelDataType> types) {
+    super(typeName, isNullable, null);
+    this.types = ImmutableList.copyOf(types);
+  }
+
+  //~ Methods ----------------------------------------------------------------
+
+  /**
+   * {@inheritDoc}
+   *
+   * <p>Generate, for example, {@code MEASURE<INTEGER>}.
+   */
+  @Override protected void generateTypeString(StringBuilder sb, boolean withDetail) {
+    sb.append(typeName)
+        .append('<');
+    Ord.forEach(types, (type, i) -> {
+      if (i > 0) {
+        sb.append(", ");
+      }
+      if (withDetail) {
+        sb.append(type.getFullTypeString());
+      } else {
+        sb.append(type.toString());
+      }
+    });
+    sb.append('>');
+  }
+}
diff --git a/core/src/main/java/org/apache/calcite/sql/type/AssignableOperandTypeChecker.java b/core/src/main/java/org/apache/calcite/sql/type/AssignableOperandTypeChecker.java
index 7be007e9755..9f65e9ee470 100644
--- a/core/src/main/java/org/apache/calcite/sql/type/AssignableOperandTypeChecker.java
+++ b/core/src/main/java/org/apache/calcite/sql/type/AssignableOperandTypeChecker.java
@@ -59,10 +59,6 @@ public AssignableOperandTypeChecker(List<RelDataType> paramTypes,
 
   //~ Methods ----------------------------------------------------------------
 
-  @Override public boolean isOptional(int i) {
-    return false;
-  }
-
   @Override public SqlOperandCountRange getOperandCountRange() {
     return SqlOperandCountRanges.of(paramTypes.size());
   }
@@ -106,8 +102,4 @@ public AssignableOperandTypeChecker(List<RelDataType> paramTypes,
     sb.append(")");
     return sb.toString();
   }
-
-  @Override public Consistency getConsistency() {
-    return Consistency.NONE;
-  }
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/type/CompositeOperandTypeChecker.java b/core/src/main/java/org/apache/calcite/sql/type/CompositeOperandTypeChecker.java
index 058b4aae7cb..f7a32fda499 100644
--- a/core/src/main/java/org/apache/calcite/sql/type/CompositeOperandTypeChecker.java
+++ b/core/src/main/java/org/apache/calcite/sql/type/CompositeOperandTypeChecker.java
@@ -34,6 +34,7 @@
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.function.BiFunction;
 import java.util.stream.Collectors;
 
 import static java.util.Objects.requireNonNull;
@@ -45,8 +46,8 @@
  *
  * <blockquote>
  * <pre><code>
- * CompositeOperandsTypeChecking newCompositeRule =
- *     new CompositeOperandsTypeChecking(Composition.OR,
+ * CompositeOperandTypeChecker newCompositeRule =
+ *     new CompositeOperandTypeChecker(Composition.OR,
  *         new SqlOperandTypeChecker[]{stringRule, numericRule});
  * </code></pre>
  * </blockquote>
@@ -55,8 +56,8 @@
  *
  * <blockquote>
  * <pre><code>
- * CompositeOperandsTypeChecking newCompositeRule =
- *     new CompositeOperandsTypeChecking(Composition.AND,
+ * CompositeOperandTypeChecker newCompositeRule =
+ *     new CompositeOperandTypeChecker(Composition.AND,
  *         new SqlOperandTypeChecker[]{numericRule, literalRule});
  * </code></pre>
  * </blockquote>
@@ -66,8 +67,8 @@
  *
  * <blockquote>
  * <pre><code>
- * CompositeOperandsTypeChecking newCompositeRule =
- *     new CompositeOperandsTypeChecking(Composition.SEQUENCE,
+ * CompositeOperandTypeChecker newCompositeRule =
+ *     new CompositeOperandTypeChecker(Composition.SEQUENCE,
  *         new SqlOperandTypeChecker[]{stringRule, numericRule});
  * </code></pre>
  * </blockquote>
@@ -92,21 +93,22 @@ public enum Composition {
   protected final ImmutableList<@UnknownKeyFor ? extends SqlOperandTypeChecker> allowedRules;
   protected final Composition composition;
   private final @Nullable String allowedSignatures;
+  private final @Nullable BiFunction<SqlOperator, String, String> signatureGenerator;
 
   //~ Constructors -----------------------------------------------------------
 
-  /**
-   * Package private. Use {@link OperandTypes#and},
-   * {@link OperandTypes#or}.
-   */
-  CompositeOperandTypeChecker(
-      Composition composition,
+  /** Creates a CompositeOperandTypeChecker. Outside this package, use
+   * {@link SqlOperandTypeChecker#and(SqlOperandTypeChecker)},
+   * {@link OperandTypes#and}, {@link OperandTypes#or} and similar. */
+  protected CompositeOperandTypeChecker(Composition composition,
       ImmutableList<? extends SqlOperandTypeChecker> allowedRules,
       @Nullable String allowedSignatures,
+      @Nullable BiFunction<SqlOperator, String, String> signatureGenerator,
       @Nullable SqlOperandCountRange range) {
     this.allowedRules = requireNonNull(allowedRules, "allowedRules");
     this.composition = requireNonNull(composition, "composition");
     this.allowedSignatures = allowedSignatures;
+    this.signatureGenerator = signatureGenerator;
     this.range = range;
     assert (range != null) == (composition == Composition.REPEAT);
     assert allowedRules.size() + (range == null ? 0 : 1) > 1;
@@ -114,6 +116,14 @@ public enum Composition {
 
   //~ Methods ----------------------------------------------------------------
 
+  @Override public CompositeOperandTypeChecker withGenerator(
+      BiFunction<SqlOperator, String, String> signatureGenerator) {
+    return this.signatureGenerator == signatureGenerator
+        ? this
+        : new CompositeOperandTypeChecker(composition, allowedRules,
+            allowedSignatures, signatureGenerator, range);
+  }
+
   @Override public boolean isOptional(int i) {
     for (SqlOperandTypeChecker allowedRule : allowedRules) {
       if (allowedRule.isOptional(i)) {
@@ -127,14 +137,13 @@ public ImmutableList<? extends SqlOperandTypeChecker> getRules() {
     return allowedRules;
   }
 
-  @Override public Consistency getConsistency() {
-    return Consistency.NONE;
-  }
-
   @Override public String getAllowedSignatures(SqlOperator op, String opName) {
     if (allowedSignatures != null) {
       return allowedSignatures;
     }
+    if (signatureGenerator != null) {
+      return signatureGenerator.apply(op, opName);
+    }
     if (composition == Composition.SEQUENCE) {
       throw new AssertionError(
           "specify allowedSignatures or override getAllowedSignatures");
@@ -251,16 +260,19 @@ private int maxMax(List<SqlOperandCountRange> ranges) {
       final TypeCoercion typeCoercion = callBinding.getValidator().getTypeCoercion();
       typeCoercion.binaryArithmeticCoercion(callBinding);
     }
-    if (check(callBinding)) {
+    if (check(callBinding, false)) {
       return true;
     }
     if (!throwOnFailure) {
       return false;
     }
-    if (composition == Composition.OR) {
-      for (SqlOperandTypeChecker allowedRule : allowedRules) {
-        allowedRule.checkOperandTypes(callBinding, true);
-      }
+    // Check again, to cause error to be thrown.
+    switch (composition) {
+    default:
+      break;
+    case OR:
+    case SEQUENCE:
+      check(callBinding, true);
     }
 
     // If no exception thrown, just throw a generic validation
@@ -268,7 +280,7 @@ private int maxMax(List<SqlOperandCountRange> ranges) {
     throw callBinding.newValidationSignatureError();
   }
 
-  private boolean check(SqlCallBinding callBinding) {
+  private boolean check(SqlCallBinding callBinding, boolean throwOnFailure) {
     switch (composition) {
     case REPEAT:
       if (!requireNonNull(range, "range").isValidCount(callBinding.getOperandCount())) {
@@ -280,7 +292,7 @@ private boolean check(SqlCallBinding callBinding) {
               callBinding,
               callBinding.getCall().operand(operand),
               0,
-              false)) {
+              throwOnFailure)) {
             if (callBinding.isTypeCoercionEnabled()) {
               return coerceOperands(callBinding, true);
             }
@@ -300,8 +312,8 @@ private boolean check(SqlCallBinding callBinding) {
         if (!((SqlSingleOperandTypeChecker) rule).checkSingleOperandType(
             callBinding,
             callBinding.getCall().operand(ord.i),
-            0,
-            false)) {
+            rule.getClass() == FamilyOperandTypeChecker.class ? 0 : ord.i,
+            throwOnFailure)) {
           if (callBinding.isTypeCoercionEnabled()) {
             return coerceOperands(callBinding, false);
           }
@@ -314,7 +326,7 @@ private boolean check(SqlCallBinding callBinding) {
       for (Ord<SqlOperandTypeChecker> ord
           : Ord.<SqlOperandTypeChecker>zip(allowedRules)) {
         SqlOperandTypeChecker rule = ord.e;
-        if (!rule.checkOperandTypes(callBinding, false)) {
+        if (!rule.checkOperandTypes(callBinding, throwOnFailure)) {
           // Avoid trying other rules in AND if the first one fails.
           return false;
         }
@@ -330,7 +342,7 @@ private boolean check(SqlCallBinding callBinding) {
       for (Ord<SqlOperandTypeChecker> ord
           : Ord.<SqlOperandTypeChecker>zip(allowedRules)) {
         SqlOperandTypeChecker rule = ord.e;
-        if (rule.checkOperandTypes(callBinding, false)) {
+        if (rule.checkOperandTypes(callBinding, throwOnFailure)) {
           return true;
         }
       }
diff --git a/core/src/main/java/org/apache/calcite/sql/type/CompositeSingleOperandTypeChecker.java b/core/src/main/java/org/apache/calcite/sql/type/CompositeSingleOperandTypeChecker.java
index 16f150e211b..bc105a384a1 100644
--- a/core/src/main/java/org/apache/calcite/sql/type/CompositeSingleOperandTypeChecker.java
+++ b/core/src/main/java/org/apache/calcite/sql/type/CompositeSingleOperandTypeChecker.java
@@ -35,15 +35,14 @@ public class CompositeSingleOperandTypeChecker
 
   //~ Constructors -----------------------------------------------------------
 
-  /**
-   * Package private. Use {@link org.apache.calcite.sql.type.OperandTypes#and},
-   * {@link org.apache.calcite.sql.type.OperandTypes#or}.
-   */
+  /** Creates a CompositeSingleOperandTypeChecker. Outside this package, use
+   * {@link SqlSingleOperandTypeChecker#and(SqlSingleOperandTypeChecker)},
+   * {@link OperandTypes#and}, {@link OperandTypes#or} and similar. */
   CompositeSingleOperandTypeChecker(
       CompositeOperandTypeChecker.Composition composition,
       ImmutableList<? extends SqlSingleOperandTypeChecker> allowedRules,
       @Nullable String allowedSignatures) {
-    super(composition, allowedRules, allowedSignatures, null);
+    super(composition, allowedRules, allowedSignatures, null, null);
   }
 
   //~ Methods ----------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/sql/type/ExplicitOperandTypeChecker.java b/core/src/main/java/org/apache/calcite/sql/type/ExplicitOperandTypeChecker.java
index 56e299fa686..fb68086d347 100644
--- a/core/src/main/java/org/apache/calcite/sql/type/ExplicitOperandTypeChecker.java
+++ b/core/src/main/java/org/apache/calcite/sql/type/ExplicitOperandTypeChecker.java
@@ -40,10 +40,6 @@ public ExplicitOperandTypeChecker(RelDataType type) {
     this.type = Objects.requireNonNull(type, "type");
   }
 
-  @Override public boolean isOptional(int i) {
-    return false;
-  }
-
   @Override public boolean checkOperandTypes(
       SqlCallBinding callBinding,
       boolean throwOnFailure) {
@@ -73,8 +69,4 @@ public ExplicitOperandTypeChecker(RelDataType type) {
   @Override public String getAllowedSignatures(SqlOperator op, String opName) {
     return "<TYPE> " + opName + " <TYPE>";
   }
-
-  @Override public Consistency getConsistency() {
-    return Consistency.NONE;
-  }
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/type/FamilyOperandTypeChecker.java b/core/src/main/java/org/apache/calcite/sql/type/FamilyOperandTypeChecker.java
index 782f6d009a9..fd7338b7cbd 100644
--- a/core/src/main/java/org/apache/calcite/sql/type/FamilyOperandTypeChecker.java
+++ b/core/src/main/java/org/apache/calcite/sql/type/FamilyOperandTypeChecker.java
@@ -189,8 +189,4 @@ public class FamilyOperandTypeChecker implements SqlSingleOperandTypeChecker,
   @Override public String getAllowedSignatures(SqlOperator op, String opName) {
     return SqlUtil.getAliasedSignature(op, opName, families);
   }
-
-  @Override public Consistency getConsistency() {
-    return Consistency.NONE;
-  }
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/type/IntervalOperandTypeChecker.java b/core/src/main/java/org/apache/calcite/sql/type/IntervalOperandTypeChecker.java
new file mode 100644
index 00000000000..f86299ebbfe
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/sql/type/IntervalOperandTypeChecker.java
@@ -0,0 +1,60 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.sql.type;
+
+import org.apache.calcite.sql.SqlCallBinding;
+import org.apache.calcite.sql.SqlIntervalQualifier;
+import org.apache.calcite.sql.SqlNode;
+import org.apache.calcite.sql.SqlOperator;
+import org.apache.calcite.util.Static;
+import org.apache.calcite.util.Util;
+
+import java.util.function.Predicate;
+
+/**
+ * Parameter type-checking strategy whether the operand must be an interval.
+ */
+public class IntervalOperandTypeChecker implements SqlSingleOperandTypeChecker {
+
+  private final Predicate<SqlIntervalQualifier> predicate;
+
+  IntervalOperandTypeChecker(Predicate<SqlIntervalQualifier> predicate) {
+    this.predicate = predicate;
+  }
+
+  @Override public boolean checkSingleOperandType(SqlCallBinding callBinding,
+      SqlNode node, int iFormalOperand, boolean throwOnFailure) {
+    final SqlNode operand = callBinding.operand(iFormalOperand);
+    if (operand instanceof SqlIntervalQualifier) {
+      final SqlIntervalQualifier interval = (SqlIntervalQualifier) operand;
+      if (predicate.test(interval)) {
+        return true;
+      }
+      if (throwOnFailure) {
+        final String name =
+            Util.first(interval.timeFrameName, interval.timeUnitRange.name());
+        throw callBinding.getValidator().newValidationError(operand,
+            Static.RESOURCE.invalidTimeFrame(name));
+      }
+    }
+    return false;
+  }
+
+  @Override public String getAllowedSignatures(SqlOperator op, String opName) {
+    return "<INTERVAL>";
+  }
+}
diff --git a/core/src/main/java/org/apache/calcite/sql/type/JavaToSqlTypeConversionRules.java b/core/src/main/java/org/apache/calcite/sql/type/JavaToSqlTypeConversionRules.java
index 4b211d3e003..f1941b29fef 100644
--- a/core/src/main/java/org/apache/calcite/sql/type/JavaToSqlTypeConversionRules.java
+++ b/core/src/main/java/org/apache/calcite/sql/type/JavaToSqlTypeConversionRules.java
@@ -17,11 +17,11 @@
 package org.apache.calcite.sql.type;
 
 import org.apache.calcite.avatica.util.ArrayImpl;
-import org.apache.calcite.runtime.Geometries;
 
 import com.google.common.collect.ImmutableMap;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
+import org.locationtech.jts.geom.Geometry;
 
 import java.math.BigDecimal;
 import java.sql.Date;
@@ -73,7 +73,7 @@ public class JavaToSqlTypeConversionRules {
           .put(Time.class, SqlTypeName.TIME)
           .put(BigDecimal.class, SqlTypeName.DECIMAL)
 
-          .put(Geometries.Geom.class, SqlTypeName.GEOMETRY)
+          .put(Geometry.class, SqlTypeName.GEOMETRY)
 
           .put(ResultSet.class, SqlTypeName.CURSOR)
           .put(ColumnList.class, SqlTypeName.COLUMN_LIST)
diff --git a/core/src/main/java/org/apache/calcite/sql/type/LiteralOperandTypeChecker.java b/core/src/main/java/org/apache/calcite/sql/type/LiteralOperandTypeChecker.java
index 771714965ae..2c0309c8d4a 100644
--- a/core/src/main/java/org/apache/calcite/sql/type/LiteralOperandTypeChecker.java
+++ b/core/src/main/java/org/apache/calcite/sql/type/LiteralOperandTypeChecker.java
@@ -18,7 +18,6 @@
 
 import org.apache.calcite.sql.SqlCallBinding;
 import org.apache.calcite.sql.SqlNode;
-import org.apache.calcite.sql.SqlOperandCountRange;
 import org.apache.calcite.sql.SqlOperator;
 import org.apache.calcite.sql.SqlUtil;
 import org.apache.calcite.util.Util;
@@ -34,7 +33,7 @@
 public class LiteralOperandTypeChecker implements SqlSingleOperandTypeChecker {
   //~ Instance fields --------------------------------------------------------
 
-  private boolean allowNull;
+  private final boolean allowNull;
 
   //~ Constructors -----------------------------------------------------------
 
@@ -44,10 +43,6 @@ public LiteralOperandTypeChecker(boolean allowNull) {
 
   //~ Methods ----------------------------------------------------------------
 
-  @Override public boolean isOptional(int i) {
-    return false;
-  }
-
   @Override public boolean checkSingleOperandType(
       SqlCallBinding callBinding,
       SqlNode node,
@@ -78,25 +73,7 @@ public LiteralOperandTypeChecker(boolean allowNull) {
     return true;
   }
 
-  @Override public boolean checkOperandTypes(
-      SqlCallBinding callBinding,
-      boolean throwOnFailure) {
-    return checkSingleOperandType(
-        callBinding,
-        callBinding.operand(0),
-        0,
-        throwOnFailure);
-  }
-
-  @Override public SqlOperandCountRange getOperandCountRange() {
-    return SqlOperandCountRanges.of(1);
-  }
-
   @Override public String getAllowedSignatures(SqlOperator op, String opName) {
     return "<LITERAL>";
   }
-
-  @Override public Consistency getConsistency() {
-    return Consistency.NONE;
-  }
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/type/MeasureSqlType.java b/core/src/main/java/org/apache/calcite/sql/type/MeasureSqlType.java
new file mode 100644
index 00000000000..e6e4fb567cf
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/sql/type/MeasureSqlType.java
@@ -0,0 +1,40 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.sql.type;
+
+import org.apache.calcite.rel.type.RelDataType;
+
+import com.google.common.collect.ImmutableList;
+
+/**
+ * Measure SQL type.
+ *
+ * <p>The type serves as a tag that the measure must be expanded
+ * into an expression before use.
+ */
+public class MeasureSqlType extends ApplySqlType {
+  /** Private constructor. */
+  private MeasureSqlType(RelDataType elementType, boolean isNullable) {
+    super(SqlTypeName.MEASURE, isNullable, ImmutableList.of(elementType));
+    computeDigest();
+  }
+
+  /** Creates a MeasureSqlType. */
+  static MeasureSqlType create(RelDataType elementType) {
+    return new MeasureSqlType(elementType, elementType.isNullable());
+  }
+}
diff --git a/core/src/main/java/org/apache/calcite/sql/type/MultisetOperandTypeChecker.java b/core/src/main/java/org/apache/calcite/sql/type/MultisetOperandTypeChecker.java
index 1303f907e88..fec7eaa1dae 100644
--- a/core/src/main/java/org/apache/calcite/sql/type/MultisetOperandTypeChecker.java
+++ b/core/src/main/java/org/apache/calcite/sql/type/MultisetOperandTypeChecker.java
@@ -36,10 +36,6 @@
 public class MultisetOperandTypeChecker implements SqlOperandTypeChecker {
   //~ Methods ----------------------------------------------------------------
 
-  @Override public boolean isOptional(int i) {
-    return false;
-  }
-
   @Override public boolean checkOperandTypes(
       SqlCallBinding callBinding,
       boolean throwOnFailure) {
@@ -88,8 +84,4 @@ public class MultisetOperandTypeChecker implements SqlOperandTypeChecker {
   @Override public String getAllowedSignatures(SqlOperator op, String opName) {
     return "<MULTISET> " + opName + " <MULTISET>";
   }
-
-  @Override public Consistency getConsistency() {
-    return Consistency.NONE;
-  }
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/type/OperandHandlers.java b/core/src/main/java/org/apache/calcite/sql/type/OperandHandlers.java
new file mode 100644
index 00000000000..b45560390cf
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/sql/type/OperandHandlers.java
@@ -0,0 +1,112 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.sql.type;
+
+import org.apache.calcite.linq4j.Ord;
+import org.apache.calcite.rel.type.TimeFrame;
+import org.apache.calcite.sql.SqlCall;
+import org.apache.calcite.sql.SqlIdentifier;
+import org.apache.calcite.sql.SqlIntervalQualifier;
+import org.apache.calcite.sql.SqlNode;
+import org.apache.calcite.sql.validate.SqlValidator;
+
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+
+/**
+ * Strategies for handling operands.
+ *
+ * <p>This class defines singleton instances of strategy objects for operand
+ * expansion. {@link OperandTypes}, {@link ReturnTypes} and {@link InferTypes}
+ * provide similar strategies for operand type checking and inference,
+ * and operator return type inference.
+ *
+ * @see SqlOperandTypeChecker
+ * @see ReturnTypes
+ * @see InferTypes
+ */
+public abstract class OperandHandlers {
+  /** The default operand handler visits all operands. */
+  public static final SqlOperandHandler DEFAULT =
+      new SqlOperandHandler() {
+      };
+
+  /** An operand handler that tries to convert operand #1 (0-based) into a time
+   * frame.
+   *
+   * <p>For example, the {@code DATE_TRUNC} function uses this; the calls
+   * {@code DATE_TRUNC('month', orders.order_date)},
+   * {@code DATE_TRUNC(orders.order_date, MONTH)},
+   * {@code DATE_TRUNC(orders.order_date, MINUTE15)}
+   * are all valid. The last uses a user-defined time frame, which appears
+   * to the validator as a {@link SqlIdentifier} and is then converted to a
+   * {@link SqlIntervalQualifier} when it matches a defined time frame. */
+  public static final SqlOperandHandler OPERAND_1_MIGHT_BE_TIME_FRAME =
+      new TimeFrameOperandHandler(1);
+
+  /** Creates an operand handler that applies a function to a call. */
+  public static SqlOperandHandler of(BiFunction<SqlValidator, SqlCall, SqlCall> fn) {
+    return new SqlOperandHandler() {
+      @Override public SqlNode rewriteCall(SqlValidator validator, SqlCall call) {
+        return fn.apply(validator, call);
+      }
+    };
+  }
+
+  /** Operand handler for a function whose {@code timeFrameOperand} operand
+   * (0-based) may be a time frame. If the operand is of type
+   * {@link SqlIdentifier}, looks up the custom time frame and converts it to a
+   * {@link SqlIntervalQualifier}. */
+  private static class TimeFrameOperandHandler implements SqlOperandHandler {
+    private final int timeFrameOperand;
+
+    TimeFrameOperandHandler(int timeFrameOperand) {
+      this.timeFrameOperand = timeFrameOperand;
+    }
+
+    private SqlNode getOperand(int i, SqlNode operand,
+        Function<String, @Nullable TimeFrame> timeFrameResolver) {
+      if (i == timeFrameOperand
+          && operand instanceof SqlIdentifier
+          && ((SqlIdentifier) operand).isSimple()) {
+        final String name = ((SqlIdentifier) operand).getSimple();
+        final TimeFrame timeFrame = timeFrameResolver.apply(name);
+        if (timeFrame != null) {
+          return new SqlIntervalQualifier(name, operand.getParserPosition());
+        }
+      }
+      return operand;
+    }
+
+    @Override public SqlNode rewriteCall(SqlValidator validator, SqlCall call) {
+      final List<SqlNode> newOperandList = new ArrayList<>();
+      Ord.forEach(call.getOperandList(), (operand, i) ->
+          newOperandList.add(
+              getOperand(i, operand, name ->
+                  validator.getTimeFrameSet().getOpt(name))));
+      if (newOperandList.equals(call.getOperandList())) {
+        return call;
+      }
+      return call.getOperator().createCall(call.getFunctionQuantifier(),
+          call.getParserPosition(), newOperandList);
+    }
+  }
+}
diff --git a/core/src/main/java/org/apache/calcite/sql/type/OperandTypes.java b/core/src/main/java/org/apache/calcite/sql/type/OperandTypes.java
index 67db9053e73..b891ba7699a 100644
--- a/core/src/main/java/org/apache/calcite/sql/type/OperandTypes.java
+++ b/core/src/main/java/org/apache/calcite/sql/type/OperandTypes.java
@@ -16,26 +16,42 @@
  */
 package org.apache.calcite.sql.type;
 
+import org.apache.calcite.avatica.util.TimeUnitRange;
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeComparability;
 import org.apache.calcite.rel.type.RelDataTypeFactory;
 import org.apache.calcite.sql.SqlCallBinding;
+import org.apache.calcite.sql.SqlIntervalQualifier;
 import org.apache.calcite.sql.SqlLiteral;
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.sql.SqlOperandCountRange;
 import org.apache.calcite.sql.SqlOperator;
 import org.apache.calcite.sql.SqlUtil;
+import org.apache.calcite.sql.validate.SqlValidatorScope;
+import org.apache.calcite.util.ImmutableIntList;
+import org.apache.calcite.util.Util;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+
+import org.checkerframework.checker.nullness.qual.Nullable;
 
 import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
+import java.util.Set;
+import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.function.IntFunction;
 import java.util.function.Predicate;
 
+import static com.google.common.base.Preconditions.checkArgument;
+
 import static org.apache.calcite.util.Static.RESOURCE;
 
+import static java.util.Objects.requireNonNull;
+
 /**
  * Strategies for checking operand types.
  *
@@ -54,6 +70,7 @@
  * @see org.apache.calcite.sql.type.InferTypes
  */
 public abstract class OperandTypes {
+
   private OperandTypes() {
   }
 
@@ -83,6 +100,49 @@ public static FamilyOperandTypeChecker family(List<SqlTypeFamily> families) {
     return family(families, i -> false);
   }
 
+  /**
+   * Creates a single-operand checker that passes if the operand's type has a
+   * particular {@link SqlTypeName}.
+   */
+  public static SqlSingleOperandTypeChecker typeName(SqlTypeName typeName) {
+    return new TypeNameChecker(typeName);
+  }
+
+  /**
+   * Creates a checker that passes if the operand is an interval appropriate for
+   * a given date/time type. For example, the time frame HOUR is appropriate for
+   * type TIMESTAMP or DATE but not TIME.
+   */
+  public static SqlSingleOperandTypeChecker interval(
+      Iterable<TimeUnitRange> ranges) {
+    final Set<TimeUnitRange> set = ImmutableSet.copyOf(ranges);
+    return new IntervalOperandTypeChecker(intervalQualifier ->
+        set.contains(intervalQualifier.timeUnitRange));
+  }
+
+  /**
+   * Creates a checker for DATE intervals (YEAR, WEEK, ISOWEEK,
+   * WEEK_WEDNESDAY, etc.)
+   */
+  public static SqlSingleOperandTypeChecker dateInterval() {
+    return new IntervalOperandTypeChecker(SqlIntervalQualifier::isDate);
+  }
+
+  /**
+   * Creates a checker for TIME intervals (HOUR, SECOND, etc.)
+   */
+  public static SqlSingleOperandTypeChecker timeInterval() {
+    return new IntervalOperandTypeChecker(SqlIntervalQualifier::isTime);
+  }
+
+  /**
+   * Creates a checker for TIMESTAMP intervals (YEAR, WEEK, ISOWEEK,
+   * WEEK_WEDNESDAY, HOUR, SECOND, etc.)
+   */
+  public static SqlSingleOperandTypeChecker timestampInterval() {
+    return new IntervalOperandTypeChecker(SqlIntervalQualifier::isTimestamp);
+  }
+
   /**
    * Creates a checker for user-defined functions (including user-defined
    * aggregate functions, table functions, and table macros).
@@ -104,18 +164,21 @@ public static SqlOperandMetadata operandMetadata(List<SqlTypeFamily> families,
    * Creates a checker that passes if any one of the rules passes.
    */
   public static SqlOperandTypeChecker or(SqlOperandTypeChecker... rules) {
-    return new CompositeOperandTypeChecker(
-        CompositeOperandTypeChecker.Composition.OR,
-        ImmutableList.copyOf(rules), null, null);
+    return composite(CompositeOperandTypeChecker.Composition.OR,
+        ImmutableList.copyOf(rules), null, null, null);
   }
 
   /**
    * Creates a checker that passes if all of the rules pass.
    */
   public static SqlOperandTypeChecker and(SqlOperandTypeChecker... rules) {
-    return new CompositeOperandTypeChecker(
-        CompositeOperandTypeChecker.Composition.AND,
-        ImmutableList.copyOf(rules), null, null);
+    return and_(ImmutableList.copyOf(rules));
+  }
+
+  private static SqlOperandTypeChecker and_(
+      Iterable<SqlOperandTypeChecker> rules) {
+    return composite(CompositeOperandTypeChecker.Composition.AND,
+        ImmutableList.copyOf(rules), null, null, null);
   }
 
   /**
@@ -124,8 +187,7 @@ public static SqlOperandTypeChecker and(SqlOperandTypeChecker... rules) {
    */
   public static SqlSingleOperandTypeChecker or(
       SqlSingleOperandTypeChecker... rules) {
-    return new CompositeSingleOperandTypeChecker(
-        CompositeOperandTypeChecker.Composition.OR,
+    return compositeSingle(CompositeOperandTypeChecker.Composition.OR,
         ImmutableList.copyOf(rules), null);
   }
 
@@ -135,11 +197,35 @@ public static SqlSingleOperandTypeChecker or(
    */
   public static SqlSingleOperandTypeChecker and(
       SqlSingleOperandTypeChecker... rules) {
-    return new CompositeSingleOperandTypeChecker(
-        CompositeOperandTypeChecker.Composition.AND,
+    return compositeSingle(CompositeOperandTypeChecker.Composition.AND,
         ImmutableList.copyOf(rules), null);
   }
 
+  /** Creates a CompositeSingleOperandTypeChecker. Outside this package, use
+   * {@link SqlSingleOperandTypeChecker#and(SqlSingleOperandTypeChecker)},
+   * {@link OperandTypes#and}, {@link OperandTypes#or} and similar. */
+  private static SqlSingleOperandTypeChecker compositeSingle(
+      CompositeOperandTypeChecker.Composition composition,
+      List<? extends SqlSingleOperandTypeChecker> allowedRules,
+      @Nullable String allowedSignatures) {
+    final List<SqlSingleOperandTypeChecker> list = new ArrayList<>(allowedRules);
+    switch (composition) {
+    default:
+      break;
+    case AND:
+    case OR:
+      flatten(list, c -> c instanceof CompositeSingleOperandTypeChecker
+          && ((CompositeSingleOperandTypeChecker) c).composition == composition
+          ? ((CompositeSingleOperandTypeChecker) c).getRules()
+          : null);
+    }
+    if (list.size() == 1) {
+      return list.get(0);
+    }
+    return new CompositeSingleOperandTypeChecker(composition,
+        ImmutableList.copyOf(list), allowedSignatures);
+  }
+
   /**
    * Creates an operand checker from a sequence of single-operand checkers.
    */
@@ -147,7 +233,7 @@ public static SqlOperandTypeChecker sequence(String allowedSignatures,
       SqlSingleOperandTypeChecker... rules) {
     return new CompositeOperandTypeChecker(
         CompositeOperandTypeChecker.Composition.SEQUENCE,
-        ImmutableList.copyOf(rules), allowedSignatures, null);
+        ImmutableList.copyOf(rules), allowedSignatures, null, null);
   }
 
   /**
@@ -158,7 +244,61 @@ public static SqlOperandTypeChecker repeat(SqlOperandCountRange range,
       SqlSingleOperandTypeChecker... rules) {
     return new CompositeOperandTypeChecker(
         CompositeOperandTypeChecker.Composition.REPEAT,
-        ImmutableList.copyOf(rules), null, range);
+        ImmutableList.copyOf(rules), null, null, range);
+  }
+
+  /**
+   * Creates an operand checker that applies a single-operand checker to
+   * the {@code ordinal}th operand.
+   */
+  public static SqlOperandTypeChecker nth(int ordinal, int operandCount,
+      SqlSingleOperandTypeChecker rule) {
+    SqlSingleOperandTypeChecker[] rules =
+        new SqlSingleOperandTypeChecker[operandCount];
+    Arrays.fill(rules, ANY);
+    rules[ordinal] = rule;
+    return sequence("", rules);
+  }
+
+  /** Creates a CompositeOperandTypeChecker. Outside this package, use
+   * {@link SqlSingleOperandTypeChecker#and(SqlSingleOperandTypeChecker)},
+   * {@link OperandTypes#and}, {@link OperandTypes#or} and similar. */
+  static SqlOperandTypeChecker composite(
+      CompositeOperandTypeChecker.Composition composition,
+      List<? extends SqlOperandTypeChecker> allowedRules,
+      @Nullable String allowedSignatures,
+      @Nullable BiFunction<SqlOperator, String, String> signatureGenerator,
+      @Nullable SqlOperandCountRange range) {
+    final List<SqlOperandTypeChecker> list = new ArrayList<>(allowedRules);
+    switch (composition) {
+    default:
+      break;
+    case AND:
+    case OR:
+      flatten(list, c -> c instanceof CompositeOperandTypeChecker
+          && ((CompositeOperandTypeChecker) c).composition == composition
+          ? ((CompositeOperandTypeChecker) c).getRules()
+          : null);
+    }
+    if (list.size() == 1) {
+      return list.get(0);
+    }
+    return new CompositeOperandTypeChecker(composition,
+        ImmutableList.copyOf(list), allowedSignatures, signatureGenerator, range);
+  }
+
+  /** Helper for {@link #compositeSingle} and {@link #composite}. */
+  private static <E> void flatten(List<E> list,
+      Function<E, @Nullable List<? extends E>> expander) {
+    for (int i  = 0; i < list.size();) {
+      @Nullable List<? extends E> list2 = expander.apply(list.get(i));
+      if (list2 == null) {
+        ++i;
+      } else {
+        list.remove(i);
+        list.addAll(i, list2);
+      }
+    }
   }
 
   // ----------------------------------------------------------------------
@@ -199,14 +339,6 @@ public static SqlOperandTypeChecker variadic(
       @Override public String getAllowedSignatures(SqlOperator op, String opName) {
         return opName + "(...)";
       }
-
-      @Override public boolean isOptional(int i) {
-        return false;
-      }
-
-      @Override public Consistency getConsistency() {
-        return Consistency.NONE;
-      }
     };
   }
 
@@ -222,6 +354,11 @@ public static SqlOperandTypeChecker variadic(
   public static final SqlSingleOperandTypeChecker INTEGER =
       family(SqlTypeFamily.INTEGER);
 
+  public static final SqlSingleOperandTypeChecker NUMERIC_OPTIONAL_NUMERIC =
+      family(ImmutableList.of(SqlTypeFamily.NUMERIC, SqlTypeFamily.NUMERIC),
+          // Second operand optional (operand index 0, 1)
+          number -> number == 1);
+
   public static final SqlSingleOperandTypeChecker NUMERIC_OPTIONAL_INTEGER =
       family(ImmutableList.of(SqlTypeFamily.NUMERIC, SqlTypeFamily.INTEGER),
           // Second operand optional (operand index 0, 1)
@@ -242,17 +379,35 @@ public static SqlOperandTypeChecker variadic(
   public static final SqlSingleOperandTypeChecker BINARY =
       family(SqlTypeFamily.BINARY);
 
+  public static final SqlSingleOperandTypeChecker BINARY_BINARY =
+      family(SqlTypeFamily.BINARY, SqlTypeFamily.BINARY);
+
   public static final SqlSingleOperandTypeChecker STRING =
       family(SqlTypeFamily.STRING);
 
   public static final FamilyOperandTypeChecker STRING_STRING =
       family(SqlTypeFamily.STRING, SqlTypeFamily.STRING);
 
+  public static final FamilyOperandTypeChecker STRING_OPTIONAL_STRING =
+      family(
+          ImmutableList.of(SqlTypeFamily.STRING, SqlTypeFamily.STRING),
+          // Second operand optional (operand index 0, 1)
+          number -> number == 1);
+
   public static final FamilyOperandTypeChecker STRING_STRING_STRING =
       family(SqlTypeFamily.STRING, SqlTypeFamily.STRING, SqlTypeFamily.STRING);
 
   public static final FamilyOperandTypeChecker STRING_STRING_OPTIONAL_STRING =
-      family(ImmutableList.of(SqlTypeFamily.STRING, SqlTypeFamily.STRING, SqlTypeFamily.STRING),
+      family(
+          ImmutableList.of(SqlTypeFamily.STRING, SqlTypeFamily.STRING,
+              SqlTypeFamily.STRING),
+          // Third operand optional (operand index 0, 1, 2)
+          number -> number == 2);
+
+  public static final FamilyOperandTypeChecker STRING_NUMERIC_OPTIONAL_STRING =
+      family(
+          ImmutableList.of(SqlTypeFamily.STRING, SqlTypeFamily.NUMERIC,
+              SqlTypeFamily.STRING),
           // Third operand optional (operand index 0, 1, 2)
           number -> number == 2);
 
@@ -265,20 +420,42 @@ public static SqlOperandTypeChecker variadic(
   public static final SqlSingleOperandTypeChecker DATE =
       family(SqlTypeFamily.DATE);
 
+  public static final SqlSingleOperandTypeChecker TIME =
+      family(SqlTypeFamily.TIME);
+
   public static final SqlSingleOperandTypeChecker TIMESTAMP =
       family(SqlTypeFamily.TIMESTAMP);
 
+  /** Type-checker that matches "TIMESTAMP WITH LOCAL TIME ZONE" but not other
+   * members of the "TIMESTAMP" family (e.g. "TIMESTAMP"). */
+  public static final SqlSingleOperandTypeChecker TIMESTAMP_LTZ =
+      new TypeNameChecker(SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE);
+
+  /** Type-checker that matches "TIMESTAMP" but not other members of the
+   * "TIMESTAMP" family (e.g. "TIMESTAMP WITH LOCAL TIME ZONE"). */
+  public static final SqlSingleOperandTypeChecker TIMESTAMP_NTZ =
+      new TypeNameChecker(SqlTypeName.TIMESTAMP);
+
   public static final SqlSingleOperandTypeChecker INTERVAL =
       family(SqlTypeFamily.DATETIME_INTERVAL);
 
+  public static final SqlSingleOperandTypeChecker CHARACTER_CHARACTER =
+      family(SqlTypeFamily.CHARACTER, SqlTypeFamily.CHARACTER);
+
   public static final SqlSingleOperandTypeChecker CHARACTER_CHARACTER_DATETIME =
       family(SqlTypeFamily.CHARACTER, SqlTypeFamily.CHARACTER, SqlTypeFamily.DATETIME);
 
+  public static final SqlSingleOperandTypeChecker CHARACTER_DATE =
+      family(SqlTypeFamily.CHARACTER, SqlTypeFamily.DATE);
+
+  public static final SqlSingleOperandTypeChecker CHARACTER_TIME =
+      family(SqlTypeFamily.CHARACTER, SqlTypeFamily.TIME);
+
   public static final SqlSingleOperandTypeChecker PERIOD =
       new PeriodOperandTypeChecker();
 
   public static final SqlSingleOperandTypeChecker PERIOD_OR_DATETIME =
-      or(PERIOD, DATETIME);
+      PERIOD.or(DATETIME);
 
   public static final FamilyOperandTypeChecker INTERVAL_INTERVAL =
       family(SqlTypeFamily.DATETIME_INTERVAL, SqlTypeFamily.DATETIME_INTERVAL);
@@ -291,13 +468,12 @@ public static SqlOperandTypeChecker variadic(
   /** Checks that returns whether a value is a multiset or an array.
    * Cf Java, where list and set are collections but a map is not. */
   public static final SqlSingleOperandTypeChecker COLLECTION =
-      or(family(SqlTypeFamily.MULTISET),
-          family(SqlTypeFamily.ARRAY));
+      family(SqlTypeFamily.MULTISET).or(family(SqlTypeFamily.ARRAY));
 
   public static final SqlSingleOperandTypeChecker COLLECTION_OR_MAP =
-      or(family(SqlTypeFamily.MULTISET),
-          family(SqlTypeFamily.ARRAY),
-          family(SqlTypeFamily.MAP));
+      family(SqlTypeFamily.MULTISET)
+          .or(family(SqlTypeFamily.ARRAY))
+          .or(family(SqlTypeFamily.MAP));
 
   /**
    * Operand type-checking strategy where type must be a literal or NULL.
@@ -441,12 +617,27 @@ private boolean hasFractionalPart(BigDecimal bd) {
    */
   public static final SqlOperandTypeChecker AT_LEAST_ONE_SAME_VARIADIC =
       new SameOperandTypeChecker(-1) {
-        @Override public SqlOperandCountRange
-        getOperandCountRange() {
+        @Override public SqlOperandCountRange getOperandCountRange() {
           return SqlOperandCountRanges.from(1);
         }
       };
 
+  /**
+   * Operand type-checking strategy where a given list of operands must all
+   * have the same type.
+   */
+  public static SqlSingleOperandTypeChecker same(int operandCount,
+      int... ordinals) {
+    final ImmutableIntList ordinalList = ImmutableIntList.of(ordinals);
+    checkArgument(ordinalList.size() >= 2);
+    checkArgument(Util.isDistinct(ordinalList));
+    return new SameOperandTypeChecker(operandCount) {
+      @Override protected List<Integer> getOperandList(int operandCount) {
+        return ordinalList;
+      }
+    };
+  }
+
   /**
    * Operand type-checking strategy where operand types must allow ordered
    * comparisons.
@@ -477,14 +668,14 @@ private boolean hasFractionalPart(BigDecimal bd) {
    * same string type family.
    */
   public static final SqlSingleOperandTypeChecker STRING_SAME_SAME =
-      OperandTypes.and(STRING_STRING, SAME_SAME);
+      STRING_STRING.and(SAME_SAME);
 
   /**
    * Operand type-checking strategy where three operands must all be in the
    * same string type family.
    */
   public static final SqlSingleOperandTypeChecker STRING_SAME_SAME_SAME =
-      OperandTypes.and(STRING_STRING_STRING, SAME_SAME_SAME);
+      STRING_STRING_STRING.and(SAME_SAME_SAME);
 
   public static final SqlSingleOperandTypeChecker STRING_STRING_INTEGER =
       family(SqlTypeFamily.STRING, SqlTypeFamily.STRING, SqlTypeFamily.INTEGER);
@@ -505,19 +696,25 @@ private boolean hasFractionalPart(BigDecimal bd) {
           ImmutableList.of(SqlTypeFamily.STRING, SqlTypeFamily.INTEGER,
               SqlTypeFamily.INTEGER), i -> i == 2);
 
+  public static final SqlSingleOperandTypeChecker STRING_NUMERIC =
+      family(SqlTypeFamily.STRING, SqlTypeFamily.NUMERIC);
+
+  public static final SqlSingleOperandTypeChecker STRING_NUMERIC_NUMERIC =
+      family(SqlTypeFamily.STRING, SqlTypeFamily.NUMERIC, SqlTypeFamily.NUMERIC);
+
   /** Operand type-checking strategy where the first operand is a character or
    * binary string (CHAR, VARCHAR, BINARY or VARBINARY), and the second operand
    * is INTEGER. */
   public static final SqlSingleOperandTypeChecker CBSTRING_INTEGER =
-      or(family(SqlTypeFamily.STRING, SqlTypeFamily.INTEGER),
-          family(SqlTypeFamily.BINARY, SqlTypeFamily.INTEGER));
+      family(SqlTypeFamily.STRING, SqlTypeFamily.INTEGER)
+          .or(family(SqlTypeFamily.BINARY, SqlTypeFamily.INTEGER));
 
   /**
    * Operand type-checking strategy where two operands must both be in the
    * same string type family and last type is INTEGER.
    */
   public static final SqlSingleOperandTypeChecker STRING_SAME_SAME_INTEGER =
-      OperandTypes.and(STRING_STRING_INTEGER, SAME_SAME_INTEGER);
+      STRING_STRING_INTEGER.and(SAME_SAME_INTEGER);
 
   public static final SqlSingleOperandTypeChecker STRING_SAME_SAME_OR_ARRAY_SAME_SAME =
       or(STRING_SAME_SAME,
@@ -534,16 +731,68 @@ private boolean hasFractionalPart(BigDecimal bd) {
       family(SqlTypeFamily.IGNORE, SqlTypeFamily.ANY);
   public static final SqlSingleOperandTypeChecker ANY_NUMERIC =
       family(SqlTypeFamily.ANY, SqlTypeFamily.NUMERIC);
+  public static final SqlSingleOperandTypeChecker ANY_NUMERIC_ANY =
+      family(SqlTypeFamily.ANY, SqlTypeFamily.NUMERIC, SqlTypeFamily.ANY);
+  public static final SqlSingleOperandTypeChecker ANY_STRING_STRING =
+      family(SqlTypeFamily.ANY, SqlTypeFamily.STRING, SqlTypeFamily.STRING);
+
+  /**
+   * Operand type-checking strategy used by {@code ARG_MIN(value, comp)} and
+   * similar functions, where the first operand can have any type and the second
+   * must be comparable.
+   */
+  public static final SqlOperandTypeChecker ANY_COMPARABLE =
+      new SqlOperandTypeChecker() {
+        @Override public boolean checkOperandTypes(SqlCallBinding callBinding,
+            boolean throwOnFailure) {
+          getOperandCountRange().isValidCount(callBinding.getOperandCount());
+          RelDataType type = callBinding.getOperandType(1);
+          return type.getComparability() == RelDataTypeComparability.ALL;
+        }
+
+        @Override public SqlOperandCountRange getOperandCountRange() {
+          return SqlOperandCountRanges.of(2);
+        }
+
+        @Override public String getAllowedSignatures(SqlOperator op, String opName) {
+          return opName + "(<ANY>, <COMPARABLE_TYPE>)";
+        }
+  };
 
   public static final SqlSingleOperandTypeChecker CURSOR =
       family(SqlTypeFamily.CURSOR);
 
+  public static final SqlOperandTypeChecker MEASURE =
+      new FamilyOperandTypeChecker(ImmutableList.of(SqlTypeFamily.ANY),
+          i -> false) {
+        @Override public boolean checkSingleOperandType(
+            SqlCallBinding callBinding, SqlNode node,
+            int iFormalOperand, boolean throwOnFailure) {
+          if (!super.checkSingleOperandType(callBinding, node, iFormalOperand,
+              throwOnFailure)) {
+            return false;
+          }
+          // Scope is non-null at validate time, which is when we need to make
+          // this check.
+          final @Nullable SqlValidatorScope scope = callBinding.getScope();
+          if (scope != null && !scope.isMeasureRef(node)) {
+            if (throwOnFailure) {
+              throw callBinding.newValidationError(
+                  RESOURCE.argumentMustBeMeasure(
+                      callBinding.getOperator().getName()));
+            }
+            return false;
+          }
+          return true;
+        }
+      };
+
   /**
    * Parameter type-checking strategy where type must a nullable time interval,
    * nullable time interval.
    */
   public static final SqlSingleOperandTypeChecker INTERVAL_SAME_SAME =
-      OperandTypes.and(INTERVAL_INTERVAL, SAME_SAME);
+      INTERVAL_INTERVAL.and(SAME_SAME);
 
   public static final SqlSingleOperandTypeChecker NUMERIC_INTERVAL =
       family(SqlTypeFamily.NUMERIC, SqlTypeFamily.DATETIME_INTERVAL);
@@ -551,6 +800,21 @@ private boolean hasFractionalPart(BigDecimal bd) {
   public static final SqlSingleOperandTypeChecker INTERVAL_NUMERIC =
       family(SqlTypeFamily.DATETIME_INTERVAL, SqlTypeFamily.NUMERIC);
 
+  public static final SqlSingleOperandTypeChecker TIME_INTERVAL =
+      family(SqlTypeFamily.TIME, SqlTypeFamily.DATETIME_INTERVAL);
+
+  public static final SqlSingleOperandTypeChecker TIMESTAMP_INTERVAL =
+      family(SqlTypeFamily.TIMESTAMP, SqlTypeFamily.DATETIME_INTERVAL);
+
+  public static final SqlSingleOperandTypeChecker DATE_INTERVAL =
+      family(SqlTypeFamily.DATE, SqlTypeFamily.DATETIME_INTERVAL);
+
+  public static final SqlSingleOperandTypeChecker DATE_CHARACTER =
+      family(SqlTypeFamily.DATE, SqlTypeFamily.CHARACTER);
+
+  public static final SqlSingleOperandTypeChecker DATE_TIME =
+      family(SqlTypeFamily.DATE, SqlTypeFamily.TIME);
+
   public static final SqlSingleOperandTypeChecker DATETIME_INTERVAL =
       family(SqlTypeFamily.DATETIME, SqlTypeFamily.DATETIME_INTERVAL);
 
@@ -570,29 +834,33 @@ private boolean hasFractionalPart(BigDecimal bd) {
       family(SqlTypeFamily.DATETIME_INTERVAL, SqlTypeFamily.DATETIME);
 
   public static final SqlSingleOperandTypeChecker INTERVALINTERVAL_INTERVALDATETIME =
-      OperandTypes.or(INTERVAL_SAME_SAME, INTERVAL_DATETIME);
+      INTERVAL_SAME_SAME.or(INTERVAL_DATETIME);
 
   // TODO: datetime+interval checking missing
   // TODO: interval+datetime checking missing
   public static final SqlSingleOperandTypeChecker PLUS_OPERATOR =
-      OperandTypes.or(NUMERIC_NUMERIC, INTERVAL_SAME_SAME, DATETIME_INTERVAL,
-          INTERVAL_DATETIME);
+      NUMERIC_NUMERIC
+          .or(INTERVAL_SAME_SAME)
+          .or(DATETIME_INTERVAL)
+          .or(INTERVAL_DATETIME);
 
   /**
    * Type-checking strategy for the "*" operator.
    */
   public static final SqlSingleOperandTypeChecker MULTIPLY_OPERATOR =
-      OperandTypes.or(NUMERIC_NUMERIC, INTERVAL_NUMERIC, NUMERIC_INTERVAL);
+      NUMERIC_NUMERIC
+          .or(INTERVAL_NUMERIC)
+          .or(NUMERIC_INTERVAL);
 
   /**
    * Type-checking strategy for the "/" operator.
    */
   public static final SqlSingleOperandTypeChecker DIVISION_OPERATOR =
-      OperandTypes.or(NUMERIC_NUMERIC, INTERVAL_NUMERIC);
+      NUMERIC_NUMERIC.or(INTERVAL_NUMERIC);
 
   public static final SqlSingleOperandTypeChecker MINUS_OPERATOR =
       // TODO:  compatibility check
-      OperandTypes.or(NUMERIC_NUMERIC, INTERVAL_SAME_SAME, DATETIME_INTERVAL);
+      NUMERIC_NUMERIC.or(INTERVAL_SAME_SAME).or(DATETIME_INTERVAL);
 
   public static final FamilyOperandTypeChecker MINUS_DATE_OPERATOR =
       new FamilyOperandTypeChecker(
@@ -610,10 +878,10 @@ private boolean hasFractionalPart(BigDecimal bd) {
       };
 
   public static final SqlSingleOperandTypeChecker NUMERIC_OR_INTERVAL =
-      OperandTypes.or(NUMERIC, INTERVAL);
+      NUMERIC.or(INTERVAL);
 
   public static final SqlSingleOperandTypeChecker NUMERIC_OR_STRING =
-      OperandTypes.or(NUMERIC, STRING);
+      NUMERIC.or(STRING);
 
   /** Checker that returns whether a value is a multiset of records or an
    * array of records.
@@ -629,7 +897,6 @@ private boolean hasFractionalPart(BigDecimal bd) {
         }
       };
 
-
   /**
    * Checker for record just has one field.
    */
@@ -667,37 +934,15 @@ private RecordTypeWithOneFieldChecker(Predicate<SqlTypeName> predicate) {
       }
       return !validationError;
     }
-
-    @Override public boolean checkOperandTypes(
-        SqlCallBinding callBinding,
-        boolean throwOnFailure) {
-      return checkSingleOperandType(
-          callBinding,
-          callBinding.operand(0),
-          0,
-          throwOnFailure);
-    }
-
-    @Override public SqlOperandCountRange getOperandCountRange() {
-      return SqlOperandCountRanges.of(1);
-    }
-
-    @Override public boolean isOptional(int i) {
-      return false;
-    }
-
-    @Override public Consistency getConsistency() {
-      return Consistency.NONE;
-    }
   }
 
   /** Checker that returns whether a value is a collection (multiset or array)
    * of scalar or record values. */
   public static final SqlSingleOperandTypeChecker SCALAR_OR_RECORD_COLLECTION =
-      OperandTypes.or(COLLECTION, RECORD_COLLECTION);
+      COLLECTION.or(RECORD_COLLECTION);
 
   public static final SqlSingleOperandTypeChecker SCALAR_OR_RECORD_COLLECTION_OR_MAP =
-      OperandTypes.or(COLLECTION_OR_MAP,
+      COLLECTION_OR_MAP.or(
           new RecordTypeWithOneFieldChecker(
               sqlTypeName ->
                   sqlTypeName != SqlTypeName.MULTISET
@@ -741,32 +986,10 @@ private RecordTypeWithOneFieldChecker(Predicate<SqlTypeName> predicate) {
           return !validationError;
         }
 
-        @Override public boolean checkOperandTypes(
-            SqlCallBinding callBinding,
-            boolean throwOnFailure) {
-          return checkSingleOperandType(
-              callBinding,
-              callBinding.operand(0),
-              0,
-              throwOnFailure);
-        }
-
-        @Override public SqlOperandCountRange getOperandCountRange() {
-          return SqlOperandCountRanges.of(1);
-        }
-
         @Override public String getAllowedSignatures(SqlOperator op, String opName) {
           return SqlUtil.getAliasedSignature(op, opName,
               ImmutableList.of("RECORDTYPE(SINGLE FIELD)"));
         }
-
-        @Override public boolean isOptional(int i) {
-          return false;
-        }
-
-        @Override public Consistency getConsistency() {
-          return Consistency.NONE;
-        }
       };
 
   /** Operand type-checker that accepts period types. Examples:
@@ -805,28 +1028,43 @@ private static class PeriodOperandTypeChecker
       return valid;
     }
 
-    @Override public boolean checkOperandTypes(SqlCallBinding callBinding,
-        boolean throwOnFailure) {
-      return checkSingleOperandType(callBinding, callBinding.operand(0), 0,
-          throwOnFailure);
-    }
-
-    @Override public SqlOperandCountRange getOperandCountRange() {
-      return SqlOperandCountRanges.of(1);
-    }
-
     @Override public String getAllowedSignatures(SqlOperator op, String opName) {
       return SqlUtil.getAliasedSignature(op, opName,
           ImmutableList.of("PERIOD (DATETIME, INTERVAL)",
               "PERIOD (DATETIME, DATETIME)"));
     }
+  }
+
+  /** Checker that passes if the operand's type has a particular
+   * {@link SqlTypeName}. */
+  private static class TypeNameChecker implements SqlSingleOperandTypeChecker,
+      ImplicitCastOperandTypeChecker {
+    final SqlTypeName typeName;
+
+    TypeNameChecker(SqlTypeName typeName) {
+      this.typeName = requireNonNull(typeName, "typeName");
+    }
 
-    @Override public boolean isOptional(int i) {
-      return false;
+    @Override public boolean checkSingleOperandType(SqlCallBinding callBinding,
+        SqlNode operand, int iFormalOperand, boolean throwOnFailure) {
+      final RelDataType operandType =
+          callBinding.getValidator().getValidatedNodeType(operand);
+      return operandType.getSqlTypeName() == typeName;
     }
 
-    @Override public Consistency getConsistency() {
-      return Consistency.NONE;
+    @Override public boolean checkOperandTypesWithoutTypeCoercion(
+        SqlCallBinding callBinding, boolean throwOnFailure) {
+      // FIXME we assume that there is exactly one operand
+      return checkSingleOperandType(callBinding, callBinding.operand(0), 0,
+          throwOnFailure);
+    }
+
+    @Override public SqlTypeFamily getOperandSqlTypeFamily(int iFormalOperand) {
+      return requireNonNull(typeName.getFamily(), "family");
+    }
+
+    @Override public String getAllowedSignatures(SqlOperator op, String opName) {
+      return opName + "(" + typeName.getSpaceName() + ")";
     }
   }
 }
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 3512ba3a3eb..ab4aac17843 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
@@ -328,6 +328,13 @@ public static SqlCall stripSeparator(SqlCall call) {
   public static final SqlReturnTypeInference TIMESTAMP_NULLABLE =
       TIMESTAMP.andThen(SqlTypeTransforms.TO_NULLABLE);
 
+  /**
+   * Type-inference strategy whereby the result type of a call is TIMESTAMP
+   * WITH LOCAL TIME ZONE.
+   */
+  public static final SqlReturnTypeInference TIMESTAMP_LTZ =
+      explicit(SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE);
+
   /**
    * Type-inference strategy whereby the result type of a call is Double.
    */
@@ -347,6 +354,13 @@ public static SqlCall stripSeparator(SqlCall call) {
   public static final SqlReturnTypeInference CHAR =
           explicit(SqlTypeName.CHAR);
 
+  /**
+   * Type-inference strategy whereby the result type of a call is a nullable
+   * CHAR(1).
+   */
+  public static final SqlReturnTypeInference CHAR_FORCE_NULLABLE =
+      CHAR.andThen(SqlTypeTransforms.FORCE_NULLABLE);
+
   /**
    * Type-inference strategy whereby the result type of a call is an Integer.
    */
@@ -515,6 +529,12 @@ public static SqlCall stripSeparator(SqlCall call) {
   public static final SqlReturnTypeInference TO_MAP =
       ARG0.andThen(SqlTypeTransforms.TO_MAP);
 
+  /**
+   * Type-inference strategy that always returns GEOMETRY.
+   */
+  public static final SqlReturnTypeInference GEOMETRY =
+      explicit(SqlTypeName.GEOMETRY);
+
   /**
    * Type-inference strategy whereby the result type of a call is
    * {@link #ARG0_INTERVAL_NULLABLE} and {@link #LEAST_RESTRICTIVE}. These rules
@@ -723,10 +743,12 @@ public static SqlCall stripSeparator(SqlCall call) {
                     argType1.getFullTypeString()));
           }
 
-          pickedCollation = requireNonNull(
-              SqlCollation.getCoercibilityDyadicOperator(
-                  getCollation(argType0), getCollation(argType1)),
-              () -> "getCoercibilityDyadicOperator is null for " + argType0 + " and " + argType1);
+          pickedCollation =
+              requireNonNull(
+                  SqlCollation.getCoercibilityDyadicOperator(
+                      getCollation(argType0), getCollation(argType1)),
+                  () -> "getCoercibilityDyadicOperator is null for " + argType0
+                      + " and " + argType1);
         }
 
         // Determine whether result is variable-length
@@ -766,8 +788,9 @@ public static SqlCall stripSeparator(SqlCall call) {
                   getCharset(pickedType), getCollation(pickedType));
         }
         if (ret.getSqlTypeName() == SqlTypeName.NULL) {
-          ret = typeFactory.createTypeWithNullability(
-              typeFactory.createSqlType(SqlTypeName.VARCHAR), true);
+          ret =
+              typeFactory.createTypeWithNullability(
+                  typeFactory.createSqlType(SqlTypeName.VARCHAR), true);
         }
         return ret;
       };
@@ -988,4 +1011,7 @@ public static SqlCall stripSeparator(SqlCall call) {
       return relDataType;
     }
   };
+
+  public static final SqlReturnTypeInference PERCENTILE_DISC_CONT = opBinding ->
+      opBinding.getCollationType();
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/type/SameOperandTypeChecker.java b/core/src/main/java/org/apache/calcite/sql/type/SameOperandTypeChecker.java
index 2ea62fd327a..4eb271dbfa2 100644
--- a/core/src/main/java/org/apache/calcite/sql/type/SameOperandTypeChecker.java
+++ b/core/src/main/java/org/apache/calcite/sql/type/SameOperandTypeChecker.java
@@ -53,14 +53,6 @@ public SameOperandTypeChecker(
 
   //~ Methods ----------------------------------------------------------------
 
-  @Override public Consistency getConsistency() {
-    return Consistency.NONE;
-  }
-
-  @Override public boolean isOptional(int i) {
-    return false;
-  }
-
   @Override public boolean checkOperandTypes(
       SqlCallBinding callBinding,
       boolean throwOnFailure) {
@@ -124,7 +116,6 @@ public boolean checkOperandTypes(
     return checkOperandTypesImpl(operatorBinding, false, null);
   }
 
-  // implement SqlOperandTypeChecker
   @Override public SqlOperandCountRange getOperandCountRange() {
     if (nOperands == -1) {
       return SqlOperandCountRanges.any();
diff --git a/core/src/main/java/org/apache/calcite/sql/type/SetopOperandTypeChecker.java b/core/src/main/java/org/apache/calcite/sql/type/SetopOperandTypeChecker.java
index 39332d00b67..4bd50d05980 100644
--- a/core/src/main/java/org/apache/calcite/sql/type/SetopOperandTypeChecker.java
+++ b/core/src/main/java/org/apache/calcite/sql/type/SetopOperandTypeChecker.java
@@ -44,10 +44,6 @@
 public class SetopOperandTypeChecker implements SqlOperandTypeChecker {
   //~ Methods ----------------------------------------------------------------
 
-  @Override public boolean isOptional(int i) {
-    return false;
-  }
-
   @Override public boolean checkOperandTypes(
       SqlCallBinding callBinding,
       boolean throwOnFailure) {
@@ -121,10 +117,9 @@ public class SetopOperandTypeChecker implements SqlOperandTypeChecker {
             TypeCoercion typeCoercion = validator.getTypeCoercion();
             RelDataType widenType = typeCoercion.getWiderTypeFor(columnIthTypes, true);
             if (null != widenType) {
-              coerced = typeCoercion.rowTypeCoercion(
-                  callBinding.getScope(),
-                  callBinding.operand(j), i, widenType)
-                  || coerced;
+              coerced =
+                  typeCoercion.rowTypeCoercion(callBinding.getScope(),
+                      callBinding.operand(j), i, widenType) || coerced;
             }
           }
         }
@@ -152,8 +147,4 @@ public class SetopOperandTypeChecker implements SqlOperandTypeChecker {
   @Override public String getAllowedSignatures(SqlOperator op, String opName) {
     return "{0} " + opName + " {1}";
   }
-
-  @Override public Consistency getConsistency() {
-    return Consistency.NONE;
-  }
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/type/SqlOperandHandler.java b/core/src/main/java/org/apache/calcite/sql/type/SqlOperandHandler.java
new file mode 100644
index 00000000000..7ed3aee6d21
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/sql/type/SqlOperandHandler.java
@@ -0,0 +1,32 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.sql.type;
+
+import org.apache.calcite.sql.SqlCall;
+import org.apache.calcite.sql.SqlNode;
+import org.apache.calcite.sql.validate.SqlValidator;
+
+/**
+ * Strategy interface to process operands of an operator call.
+ *
+ * @see OperandHandlers
+ */
+public interface SqlOperandHandler {
+  default SqlNode rewriteCall(SqlValidator validator, SqlCall call) {
+    return call;
+  }
+}
diff --git a/core/src/main/java/org/apache/calcite/sql/type/SqlOperandTypeChecker.java b/core/src/main/java/org/apache/calcite/sql/type/SqlOperandTypeChecker.java
index 03e16558998..2689f2a0dc2 100644
--- a/core/src/main/java/org/apache/calcite/sql/type/SqlOperandTypeChecker.java
+++ b/core/src/main/java/org/apache/calcite/sql/type/SqlOperandTypeChecker.java
@@ -22,6 +22,8 @@
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 
+import java.util.function.BiFunction;
+
 /**
  * Strategy interface to check for allowed operand types of an operator call.
  *
@@ -59,10 +61,21 @@ boolean checkOperandTypes(
   String getAllowedSignatures(SqlOperator op, String opName);
 
   /** Returns the strategy for making the arguments have consistency types. */
-  Consistency getConsistency();
+  default Consistency getConsistency() {
+    return Consistency.NONE;
+  }
+
+  /** Returns a copy of this checker with the given signature generator. */
+  default CompositeOperandTypeChecker withGenerator(
+      BiFunction<SqlOperator, String, String> signatureGenerator) {
+    // We should support for all subclasses but don't yet.
+    throw new UnsupportedOperationException("withGenerator");
+  }
 
   /** Returns whether the {@code i}th operand is optional. */
-  boolean isOptional(int i);
+  default boolean isOptional(int i) {
+    return false;
+  }
 
   /** Returns whether the list of parameters is fixed-length. In standard SQL,
    * user-defined functions are fixed-length.
@@ -79,6 +92,16 @@ default boolean isFixedParameters() {
     return null;
   }
 
+  /** Composes this with another checker using AND. */
+  default SqlOperandTypeChecker and(SqlOperandTypeChecker checker) {
+    return OperandTypes.and(this, checker);
+  }
+
+  /** Composes this with another checker using OR. */
+  default SqlOperandTypeChecker or(SqlOperandTypeChecker checker) {
+    return OperandTypes.or(this, checker);
+  }
+
   /** Strategy used to make arguments consistent. */
   enum Consistency {
     /** Do not try to make arguments consistent. */
diff --git a/core/src/main/java/org/apache/calcite/sql/type/SqlSingleOperandTypeChecker.java b/core/src/main/java/org/apache/calcite/sql/type/SqlSingleOperandTypeChecker.java
index 08b4b36ff06..2e5420c8e4c 100644
--- a/core/src/main/java/org/apache/calcite/sql/type/SqlSingleOperandTypeChecker.java
+++ b/core/src/main/java/org/apache/calcite/sql/type/SqlSingleOperandTypeChecker.java
@@ -18,6 +18,7 @@
 
 import org.apache.calcite.sql.SqlCallBinding;
 import org.apache.calcite.sql.SqlNode;
+import org.apache.calcite.sql.SqlOperandCountRange;
 
 /**
  * SqlSingleOperandTypeChecker is an extension of {@link SqlOperandTypeChecker}
@@ -68,4 +69,26 @@ boolean checkSingleOperandType(
       SqlNode operand,
       int iFormalOperand,
       boolean throwOnFailure);
+
+  @Override default boolean checkOperandTypes(SqlCallBinding callBinding,
+      boolean throwOnFailure) {
+    return checkSingleOperandType(callBinding, callBinding.operand(0), 0,
+        throwOnFailure);
+  }
+
+  @Override default SqlOperandCountRange getOperandCountRange() {
+    return SqlOperandCountRanges.of(1);
+  }
+
+  /** Composes this with another single-operand checker using AND. */
+  default SqlSingleOperandTypeChecker and(
+      SqlSingleOperandTypeChecker checker) {
+    return OperandTypes.and(this, checker);
+  }
+
+  /** Composes this with another single-operand checker using OR. */
+  default SqlSingleOperandTypeChecker or(
+      SqlSingleOperandTypeChecker checker) {
+    return OperandTypes.or(this, checker);
+  }
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/type/SqlTypeAssignmentRule.java b/core/src/main/java/org/apache/calcite/sql/type/SqlTypeAssignmentRule.java
index c345105b5b8..65048143551 100644
--- a/core/src/main/java/org/apache/calcite/sql/type/SqlTypeAssignmentRule.java
+++ b/core/src/main/java/org/apache/calcite/sql/type/SqlTypeAssignmentRule.java
@@ -181,7 +181,11 @@ private SqlTypeAssignmentRule(
         EnumSet.of(SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE));
 
     // GEOMETRY is assignable from ...
-    rules.add(SqlTypeName.GEOMETRY, EnumSet.of(SqlTypeName.GEOMETRY));
+    rule.clear();
+    rule.add(SqlTypeName.GEOMETRY);
+    rule.add(SqlTypeName.CHAR);
+    rule.add(SqlTypeName.VARCHAR);
+    rules.add(SqlTypeName.GEOMETRY, rule);
 
     // ARRAY is assignable from ...
     rules.add(SqlTypeName.ARRAY, EnumSet.of(SqlTypeName.ARRAY));
@@ -189,6 +193,9 @@ private SqlTypeAssignmentRule(
     // MAP is assignable from ...
     rules.add(SqlTypeName.MAP, EnumSet.of(SqlTypeName.MAP));
 
+    // SYMBOL is assignable from ...
+    rules.add(SqlTypeName.SYMBOL, EnumSet.of(SqlTypeName.SYMBOL));
+
     // ANY is assignable from ...
     rule.clear();
     rule.add(SqlTypeName.TINYINT);
diff --git a/core/src/main/java/org/apache/calcite/sql/type/SqlTypeCoercionRule.java b/core/src/main/java/org/apache/calcite/sql/type/SqlTypeCoercionRule.java
index 4d01356311b..7a01fdae97f 100644
--- a/core/src/main/java/org/apache/calcite/sql/type/SqlTypeCoercionRule.java
+++ b/core/src/main/java/org/apache/calcite/sql/type/SqlTypeCoercionRule.java
@@ -266,6 +266,12 @@ private SqlTypeCoercionRule(Map<SqlTypeName, ImmutableSet<SqlTypeName>> map) {
             .addAll(SqlTypeName.NUMERIC_TYPES)
             .build());
 
+    // GEOMETRY is castable from ...
+    coerceRules.add(SqlTypeName.GEOMETRY,
+        coerceRules.copyValues(SqlTypeName.GEOMETRY)
+            .addAll(SqlTypeName.CHAR_TYPES)
+            .build());
+
     INSTANCE = new SqlTypeCoercionRule(coerceRules.map);
   }
 
diff --git a/core/src/main/java/org/apache/calcite/sql/type/SqlTypeFactoryImpl.java b/core/src/main/java/org/apache/calcite/sql/type/SqlTypeFactoryImpl.java
index 8521c8419b2..ff08400ff8d 100644
--- a/core/src/main/java/org/apache/calcite/sql/type/SqlTypeFactoryImpl.java
+++ b/core/src/main/java/org/apache/calcite/sql/type/SqlTypeFactoryImpl.java
@@ -119,6 +119,11 @@ public SqlTypeFactoryImpl(RelDataTypeSystem typeSystem) {
     return canonize(newType);
   }
 
+  @Override public RelDataType createMeasureType(RelDataType valueType) {
+    MeasureSqlType newType = MeasureSqlType.create(valueType);
+    return canonize(newType);
+  }
+
   @Override public RelDataType createSqlIntervalType(
       SqlIntervalQualifier intervalQualifier) {
     RelDataType newType =
@@ -499,9 +504,17 @@ private static void assertBasic(SqlTypeName typeName) {
                 nullCount > 0 || nullableCount > 0);
           }
         }
+
+        if (type.getSqlTypeName() == resultType.getSqlTypeName()
+            && type.getSqlTypeName().allowsPrec()
+            && type.getPrecision() != resultType.getPrecision()) {
+          final int precision =
+              SqlTypeUtil.maxPrecision(resultType.getPrecision(),
+                  type.getPrecision());
+
+          resultType = createSqlType(type.getSqlTypeName(), precision);
+        }
       } else {
-        // TODO:  datetime precision details; for now we let
-        // leastRestrictiveByCast handle it
         return null;
       }
     }
diff --git a/core/src/main/java/org/apache/calcite/sql/type/SqlTypeFamily.java b/core/src/main/java/org/apache/calcite/sql/type/SqlTypeFamily.java
index d7a185ef232..7c45e017bdb 100644
--- a/core/src/main/java/org/apache/calcite/sql/type/SqlTypeFamily.java
+++ b/core/src/main/java/org/apache/calcite/sql/type/SqlTypeFamily.java
@@ -200,7 +200,7 @@ public Collection<SqlTypeName> getTypeNames() {
     case DATETIME_INTERVAL:
       return SqlTypeName.INTERVAL_TYPES;
     case GEO:
-      return ImmutableList.of(SqlTypeName.GEOMETRY);
+      return SqlTypeName.GEOMETRY_TYPES;
     case MULTISET:
       return ImmutableList.of(SqlTypeName.MULTISET);
     case ARRAY:
diff --git a/core/src/main/java/org/apache/calcite/sql/type/SqlTypeName.java b/core/src/main/java/org/apache/calcite/sql/type/SqlTypeName.java
index 47c57ad6e24..c337580fecb 100644
--- a/core/src/main/java/org/apache/calcite/sql/type/SqlTypeName.java
+++ b/core/src/main/java/org/apache/calcite/sql/type/SqlTypeName.java
@@ -69,8 +69,8 @@ public enum SqlTypeName {
       SqlTypeFamily.TIME),
   TIMESTAMP(PrecScale.NO_NO | PrecScale.YES_NO, false, Types.TIMESTAMP,
       SqlTypeFamily.TIMESTAMP),
-  TIMESTAMP_WITH_LOCAL_TIME_ZONE(PrecScale.NO_NO | PrecScale.YES_NO, false, Types.OTHER,
-      SqlTypeFamily.TIMESTAMP),
+  TIMESTAMP_WITH_LOCAL_TIME_ZONE(PrecScale.NO_NO | PrecScale.YES_NO, false,
+      Types.TIMESTAMP, SqlTypeFamily.TIMESTAMP),
   INTERVAL_YEAR(PrecScale.NO_NO, false, Types.OTHER,
       SqlTypeFamily.INTERVAL_YEAR_MONTH),
   INTERVAL_YEAR_MONTH(PrecScale.NO_NO, false, Types.OTHER,
@@ -126,6 +126,7 @@ public enum SqlTypeName {
   /** Spatial type. Though not standard, it is common to several DBs, so we
    * do not flag it 'special' (internal). */
   GEOMETRY(PrecScale.NO_NO, false, ExtraSqlTypes.GEOMETRY, SqlTypeFamily.GEO),
+  MEASURE(PrecScale.NO_NO, true, Types.OTHER, SqlTypeFamily.ANY),
   SARG(PrecScale.NO_NO, true, Types.OTHER, SqlTypeFamily.ANY);
 
   public static final int MAX_DATETIME_PRECISION = 3;
@@ -187,6 +188,9 @@ public enum SqlTypeName {
   public static final List<SqlTypeName> STRING_TYPES =
       combine(CHAR_TYPES, BINARY_TYPES);
 
+  public static final List<SqlTypeName> GEOMETRY_TYPES =
+      ImmutableList.of(GEOMETRY);
+
   public static final List<SqlTypeName> DATETIME_TYPES =
       ImmutableList.of(DATE, TIME, TIME_WITH_LOCAL_TIME_ZONE,
           TIMESTAMP, TIMESTAMP_WITH_LOCAL_TIME_ZONE);
@@ -212,6 +216,12 @@ public enum SqlTypeName {
       Sets.immutableEnumSet(
           Iterables.concat(YEAR_INTERVAL_TYPES, DAY_INTERVAL_TYPES));
 
+  /** The possible types of a time frame argument to a function such as
+   * {@code TIMESTAMP_DIFF}. */
+  public static final Set<SqlTypeName> TIME_FRAME_TYPES =
+      Sets.immutableEnumSet(
+          Iterables.concat(INTERVAL_TYPES, ImmutableList.of(SYMBOL)));
+
   private static final Map<Integer, SqlTypeName> JDBC_TYPE_TO_NAME =
       ImmutableMap.<Integer, SqlTypeName>builder()
           .put(Types.TINYINT, TINYINT)
@@ -294,6 +304,14 @@ public enum SqlTypeName {
     return VALUES_MAP.get(name);
   }
 
+  /** Returns the SqlTypeName value whose name or {@link #getSpaceName()}
+   * matches the given name, or throws {@link IllegalArgumentException}; never
+   * returns null. */
+  public static SqlTypeName lookup(String tag) {
+    String tag2 = tag.replace(' ', '_');
+    return valueOf(tag2);
+  }
+
   public boolean allowsNoPrecNoScale() {
     return (signatures & PrecScale.NO_NO) != 0;
   }
@@ -941,7 +959,7 @@ public SqlLiteral createLiteral(Object o, SqlParserPos pos) {
           ? TimeString.fromCalendarFields((Calendar) o)
           : (TimeString) o, 0 /* todo */, pos);
     case TIMESTAMP:
-      return SqlLiteral.createTimestamp(o instanceof Calendar
+      return SqlLiteral.createTimestamp(this, o instanceof Calendar
           ? TimestampString.fromCalendarFields((Calendar) o)
           : (TimestampString) o, 0 /* todo */, pos);
     default:
@@ -951,7 +969,13 @@ public SqlLiteral createLiteral(Object o, SqlParserPos pos) {
 
   /** Returns the name of this type. */
   public String getName() {
-    return toString();
+    return name();
+  }
+
+  /** Returns the name of this type, with underscores converted to spaces,
+   * for example "TIMESTAMP WITH LOCAL TIME ZONE", "DATE". */
+  public String getSpaceName() {
+    return name().replace('_', ' ');
   }
 
   /**
diff --git a/core/src/main/java/org/apache/calcite/sql/type/SqlTypeTransforms.java b/core/src/main/java/org/apache/calcite/sql/type/SqlTypeTransforms.java
index cc4e63794bf..92ce99f0851 100644
--- a/core/src/main/java/org/apache/calcite/sql/type/SqlTypeTransforms.java
+++ b/core/src/main/java/org/apache/calcite/sql/type/SqlTypeTransforms.java
@@ -174,6 +174,17 @@ private SqlTypeName toVar(RelDataType type) {
       (opBinding, typeToTransform) ->
           opBinding.getTypeFactory().createMultisetType(typeToTransform, -1);
 
+  /**
+   * Parameter type-inference transform strategy that wraps a given type in a multiset or
+   * wraps a field of the given type in a multiset if the given type is struct with one field.
+   * It is used when a multiset input is a sub-query.
+   */
+  public static final SqlTypeTransform TO_MULTISET_QUERY =
+      (opBinding, typeToTransform) ->
+          TO_MULTISET.transformType(opBinding,
+              SqlTypeUtil.deriveCollectionQueryComponentType(SqlTypeName.MULTISET,
+                  typeToTransform));
+
   /**
    * Parameter type-inference transform strategy that wraps a given type
    * in a array.
@@ -184,6 +195,28 @@ private SqlTypeName toVar(RelDataType type) {
       (opBinding, typeToTransform) ->
           opBinding.getTypeFactory().createArrayType(typeToTransform, -1);
 
+  /** Parameter type-inference transform that transforms {@code T} to
+   * {@code MEASURE<T>} for some type T. */
+  public static final SqlTypeTransform TO_MEASURE =
+      (opBinding, typeToTransform) ->
+          opBinding.getTypeFactory().createMeasureType(typeToTransform);
+
+  /** Parameter type-inference transform that transforms {@code MEASURE<T>} to
+   * {@code T} for some type T. Inverse of {@link #TO_MEASURE}. */
+  public static final SqlTypeTransform FROM_MEASURE =
+      (opBinding, typeToTransform) ->
+          ((MeasureSqlType) typeToTransform).types.get(0);
+
+  /**
+   * Parameter type-inference transform strategy that wraps a given type in an array or
+   * wraps a field of the given type in an array if the given type is struct with one field.
+   * It is used when an array input is a sub-query.
+   */
+  public static final SqlTypeTransform TO_ARRAY_QUERY =
+      (opBinding, typeToTransform) ->
+        TO_ARRAY.transformType(opBinding,
+            SqlTypeUtil.deriveCollectionQueryComponentType(SqlTypeName.ARRAY, typeToTransform));
+
   /**
    * Parameter type-inference transform strategy that converts a two-field
    * record type to a MAP type.
@@ -206,4 +239,5 @@ private SqlTypeName toVar(RelDataType type) {
         assert fields.size() == 1;
         return fields.get(0).getType();
       };
+
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/type/SqlTypeUtil.java b/core/src/main/java/org/apache/calcite/sql/type/SqlTypeUtil.java
index 3f5a8ec9672..9895c989f9b 100644
--- a/core/src/main/java/org/apache/calcite/sql/type/SqlTypeUtil.java
+++ b/core/src/main/java/org/apache/calcite/sql/type/SqlTypeUtil.java
@@ -140,6 +140,28 @@ public static boolean isCharTypeComparable(
     return true;
   }
 
+  /**
+   * Derives component type for ARRAY, MULTISET, MAP when input is sub-query.
+   *
+   * @param origin original component type
+   * @return component type
+   */
+  public static RelDataType deriveCollectionQueryComponentType(
+      SqlTypeName collectionType,
+      RelDataType origin) {
+    switch (collectionType) {
+    case ARRAY:
+    case MULTISET:
+      return origin.isStruct() && origin.getFieldCount() == 1
+          ? origin.getFieldList().get(0).getType() : origin;
+    case MAP:
+      return origin;
+    default:
+      throw new AssertionError(
+          "Impossible to derive component type for " + collectionType);
+    }
+  }
+
   /**
    * Iterates over all operands, derives their types, and collects them into
    * a list.
@@ -905,10 +927,9 @@ public static boolean canCastFrom(
     RelDataType c1 = toType.getComponentType();
     if (c1 != null) {
       RelDataType c2 = fromType.getComponentType();
-      if (c2 == null) {
-        return false;
+      if (c2 != null) {
+        return canCastFrom(c1, c2, coerce);
       }
-      return canCastFrom(c1, c2, coerce);
     }
     if ((isInterval(fromType) && isExactNumeric(toType))
         || (isInterval(toType) && isExactNumeric(fromType))) {
@@ -1064,7 +1085,9 @@ public static SqlDataTypeSpec convertTypeToSpec(RelDataType type,
     assert typeName != null;
 
     final SqlTypeNameSpec typeNameSpec;
-    if (isAtomic(type) || isNull(type) || type.getSqlTypeName() == SqlTypeName.UNKNOWN) {
+    if (isAtomic(type) || isNull(type)
+        || type.getSqlTypeName() == SqlTypeName.UNKNOWN
+        || type.getSqlTypeName() == SqlTypeName.GEOMETRY) {
       int precision = typeName.allowsPrec() ? type.getPrecision() : -1;
       // fix up the precision.
       if (maxPrecision > 0 && precision > maxPrecision) {
@@ -1075,17 +1098,14 @@ public static SqlDataTypeSpec convertTypeToSpec(RelDataType type,
         scale = maxScale;
       }
 
-      typeNameSpec = new SqlBasicTypeNameSpec(
-          typeName,
-          precision,
-          scale,
-          charSetName,
-          SqlParserPos.ZERO);
+      typeNameSpec =
+          new SqlBasicTypeNameSpec(typeName, precision, scale, charSetName,
+              SqlParserPos.ZERO);
     } else if (isCollection(type)) {
-      typeNameSpec = new SqlCollectionTypeNameSpec(
-          convertTypeToSpec(getComponentTypeOrThrow(type)).getTypeNameSpec(),
-          typeName,
-          SqlParserPos.ZERO);
+      typeNameSpec =
+          new SqlCollectionTypeNameSpec(
+              convertTypeToSpec(getComponentTypeOrThrow(type)).getTypeNameSpec(),
+              typeName, SqlParserPos.ZERO);
     } else if (isRow(type)) {
       RelRecordType recordType = (RelRecordType) type;
       List<RelDataTypeField> fields = recordType.getFieldList();
diff --git a/core/src/main/java/org/apache/calcite/sql/util/ListSqlOperatorTable.java b/core/src/main/java/org/apache/calcite/sql/util/ListSqlOperatorTable.java
index ad008633a99..c37549f9e4d 100644
--- a/core/src/main/java/org/apache/calcite/sql/util/ListSqlOperatorTable.java
+++ b/core/src/main/java/org/apache/calcite/sql/util/ListSqlOperatorTable.java
@@ -40,16 +40,36 @@ public class ListSqlOperatorTable implements SqlOperatorTable {
 
   //~ Constructors -----------------------------------------------------------
 
+  /** Creates an empty, mutable ListSqlOperatorTable.
+   *
+   * @deprecated Use {@link SqlOperatorTables#of}, which creates an immutable
+   * table. */
+  @Deprecated // to be removed before 2.0
   public ListSqlOperatorTable() {
-    this(new ArrayList<>());
+    this(new ArrayList<>(), false);
   }
 
+  /** Creates a mutable ListSqlOperatorTable backed by a given list.
+   *
+   * @deprecated Use {@link SqlOperatorTables#of}, which creates an immutable
+   * table. */
+  @Deprecated // to be removed before 2.0
   public ListSqlOperatorTable(List<SqlOperator> operatorList) {
+    this(operatorList, false);
+  }
+
+  // internal constructor
+  ListSqlOperatorTable(List<SqlOperator> operatorList, boolean ignored) {
     this.operatorList = operatorList;
   }
 
   //~ Methods ----------------------------------------------------------------
 
+  /** Adds an operator to this table.
+   *
+   * @deprecated Use {@link SqlOperatorTables#of}, which creates an immutable
+   * table. */
+  @Deprecated // to be removed before 2.0
   public void add(SqlOperator op) {
     operatorList.add(op);
   }
diff --git a/core/src/main/java/org/apache/calcite/sql/util/SqlOperatorTables.java b/core/src/main/java/org/apache/calcite/sql/util/SqlOperatorTables.java
index 232d752c3d3..8e248a17830 100644
--- a/core/src/main/java/org/apache/calcite/sql/util/SqlOperatorTables.java
+++ b/core/src/main/java/org/apache/calcite/sql/util/SqlOperatorTables.java
@@ -16,29 +16,26 @@
  */
 package org.apache.calcite.sql.util;
 
-import org.apache.calcite.prepare.CalciteCatalogReader;
-import org.apache.calcite.runtime.GeoFunctions;
+import org.apache.calcite.sql.SqlOperator;
 import org.apache.calcite.sql.SqlOperatorTable;
-import org.apache.calcite.sql.fun.SqlGeoFunctions;
+import org.apache.calcite.sql.SqlSpatialTypeOperatorTable;
 
 import com.google.common.base.Suppliers;
 import com.google.common.collect.ImmutableList;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.function.Supplier;
 
 /**
  * Utilities for {@link SqlOperatorTable}s.
  */
-public class SqlOperatorTables extends ReflectiveSqlOperatorTable {
+public class SqlOperatorTables {
+  private SqlOperatorTables() {}
 
+  @SuppressWarnings("FunctionalExpressionCanBeFolded")
   private static final Supplier<SqlOperatorTable> SPATIAL =
-      Suppliers.memoize(SqlOperatorTables::createSpatial)::get;
-
-  private static SqlOperatorTable createSpatial() {
-    return CalciteCatalogReader.operatorTable(
-        GeoFunctions.class.getName(),
-        SqlGeoFunctions.class.getName());
-  }
+      Suppliers.memoize(SqlSpatialTypeOperatorTable::new)::get;
 
   /** Returns the Spatial operator table, creating it if necessary. */
   public static SqlOperatorTable spatialInstance() {
@@ -47,16 +44,54 @@ public static SqlOperatorTable spatialInstance() {
 
   /** Creates a composite operator table. */
   public static SqlOperatorTable chain(Iterable<SqlOperatorTable> tables) {
-    final ImmutableList<SqlOperatorTable> list =
-        ImmutableList.copyOf(tables);
+    final List<SqlOperatorTable> list = new ArrayList<>();
+    for (SqlOperatorTable table : tables) {
+      addFlattened(list, table);
+    }
     if (list.size() == 1) {
       return list.get(0);
     }
-    return new ChainedSqlOperatorTable(list);
+    return new ChainedSqlOperatorTable(ImmutableList.copyOf(list));
+  }
+
+  @SuppressWarnings("StatementWithEmptyBody")
+  private static void addFlattened(List<SqlOperatorTable> list,
+      SqlOperatorTable table) {
+    if (table instanceof ChainedSqlOperatorTable) {
+      ChainedSqlOperatorTable chainedTable = (ChainedSqlOperatorTable) table;
+      for (SqlOperatorTable table2 : chainedTable.tableList) {
+        addFlattened(list, table2);
+      }
+    } else if (table instanceof ImmutableListSqlOperatorTable
+        && table.getOperatorList().isEmpty()) {
+      // Table is empty and will remain empty; don't add it.
+    } else {
+      list.add(table);
+    }
   }
 
   /** Creates a composite operator table from an array of tables. */
   public static SqlOperatorTable chain(SqlOperatorTable... tables) {
     return chain(ImmutableList.copyOf(tables));
   }
+
+  /** Creates an operator table that contains an immutable list of operators. */
+  public static SqlOperatorTable of(Iterable<? extends SqlOperator> list) {
+    return new ImmutableListSqlOperatorTable(ImmutableList.copyOf(list));
+  }
+
+  /** Creates an operator table that contains the given operator or
+   * operators. */
+  public static SqlOperatorTable of(SqlOperator... operators) {
+    return of(ImmutableList.copyOf(operators));
+  }
+
+  /** Subclass of {@link ListSqlOperatorTable} that is immutable.
+   * Operators cannot be added or removed after creation. */
+  private static class ImmutableListSqlOperatorTable
+      extends ListSqlOperatorTable {
+    ImmutableListSqlOperatorTable(ImmutableList<SqlOperator> operatorList) {
+      super(operatorList, false);
+    }
+  }
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/util/SqlVisitor.java b/core/src/main/java/org/apache/calcite/sql/util/SqlVisitor.java
index c91bebac8d4..0bcd91e9373 100644
--- a/core/src/main/java/org/apache/calcite/sql/util/SqlVisitor.java
+++ b/core/src/main/java/org/apache/calcite/sql/util/SqlVisitor.java
@@ -98,4 +98,9 @@ public interface SqlVisitor<R> {
    * @see SqlIntervalQualifier#accept(SqlVisitor)
    */
   R visit(SqlIntervalQualifier intervalQualifier);
+
+  /** Asks a {@code SqlNode} to accept this visitor. */
+  default R visitNode(SqlNode n) {
+    return n.accept(this);
+  }
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/AbstractNamespace.java b/core/src/main/java/org/apache/calcite/sql/validate/AbstractNamespace.java
index ad543108f33..40c16bee84b 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/AbstractNamespace.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/AbstractNamespace.java
@@ -18,6 +18,7 @@
 
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeFactory;
+import org.apache.calcite.rel.type.RelDataTypeField;
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.util.Pair;
 import org.apache.calcite.util.Util;
@@ -30,8 +31,6 @@
 import java.util.List;
 import java.util.Objects;
 
-import static org.apache.calcite.linq4j.Nullness.castNonNull;
-
 /**
  * Abstract implementation of {@link SqlValidatorNamespace}.
  */
@@ -151,9 +150,9 @@ abstract class AbstractNamespace implements SqlValidatorNamespace {
         name);
   }
 
-  @Override public boolean fieldExists(String name) {
+  @Override public @Nullable RelDataTypeField field(String name) {
     final RelDataType rowType = getRowType();
-    return validator.catalogReader.nameMatcher().field(rowType, name) != null;
+    return validator.catalogReader.nameMatcher().field(rowType, name);
   }
 
   @Override public List<Pair<SqlNode, SqlMonotonicity>> getMonotonicExprs() {
@@ -221,10 +220,7 @@ protected RelDataType toStruct(RelDataType type, @Nullable SqlNode unnest) {
     }
     return validator.getTypeFactory().builder()
         .add(
-            castNonNull(
-                validator.deriveAlias(
-                    Objects.requireNonNull(unnest, "unnest"),
-                    0)),
+            SqlValidatorUtil.alias(Objects.requireNonNull(unnest, "unnest"), 0),
             type)
         .build();
   }
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/AggChecker.java b/core/src/main/java/org/apache/calcite/sql/validate/AggChecker.java
index fa04f8c0317..170411eafe1 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/AggChecker.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/AggChecker.java
@@ -27,6 +27,8 @@
 import org.apache.calcite.sql.util.SqlBasicVisitor;
 import org.apache.calcite.util.Litmus;
 
+import com.google.common.collect.Iterables;
+
 import java.util.ArrayDeque;
 import java.util.Deque;
 import java.util.List;
@@ -45,9 +47,10 @@ class AggChecker extends SqlBasicVisitor<Void> {
 
   private final Deque<SqlValidatorScope> scopes = new ArrayDeque<>();
   private final List<SqlNode> extraExprs;
+  private final List<SqlNode> measureExprs;
   private final List<SqlNode> groupExprs;
-  private boolean distinct;
-  private SqlValidatorImpl validator;
+  private final boolean distinct;
+  private final SqlValidatorImpl validator;
 
   //~ Constructors -----------------------------------------------------------
 
@@ -56,6 +59,9 @@ class AggChecker extends SqlBasicVisitor<Void> {
    *
    * @param validator  Validator
    * @param scope      Scope
+   * @param extraExprs Expressions in GROUP BY (or SELECT DISTINCT) clause,
+   *                   that are therefore available
+   * @param measureExprs Expressions that are the names of measures
    * @param groupExprs Expressions in GROUP BY (or SELECT DISTINCT) clause,
    *                   that are therefore available
    * @param distinct   Whether aggregation checking is because of a SELECT
@@ -65,10 +71,12 @@ class AggChecker extends SqlBasicVisitor<Void> {
       SqlValidatorImpl validator,
       AggregatingScope scope,
       List<SqlNode> extraExprs,
+      List<SqlNode> measureExprs,
       List<SqlNode> groupExprs,
       boolean distinct) {
     this.validator = validator;
     this.extraExprs = extraExprs;
+    this.measureExprs = measureExprs;
     this.groupExprs = groupExprs;
     this.distinct = distinct;
     this.scopes.push(scope);
@@ -76,15 +84,18 @@ class AggChecker extends SqlBasicVisitor<Void> {
 
   //~ Methods ----------------------------------------------------------------
 
-  boolean isGroupExpr(SqlNode expr) {
-    for (SqlNode groupExpr : groupExprs) {
-      if (groupExpr.equalsDeep(expr, Litmus.IGNORE)) {
+  boolean isGroupExpr(SqlNode e) {
+    for (SqlNode expr : Iterables.concat(extraExprs, measureExprs, groupExprs)) {
+      if (expr.equalsDeep(e, Litmus.IGNORE)) {
         return true;
       }
     }
+    return false;
+  }
 
-    for (SqlNode extraExpr : extraExprs) {
-      if (extraExpr.equalsDeep(expr, Litmus.IGNORE)) {
+  boolean isMeasureExp(SqlNode e) {
+    for (SqlNode expr : measureExprs) {
+      if (expr.equalsDeep(e, Litmus.IGNORE)) {
         return true;
       }
     }
@@ -92,11 +103,22 @@ boolean isGroupExpr(SqlNode expr) {
   }
 
   @Override public Void visit(SqlIdentifier id) {
-    if (isGroupExpr(id) || id.isStar()) {
+    if (id.isStar()) {
       // Star may validly occur in "SELECT COUNT(*) OVER w"
       return null;
     }
 
+    if (!validator.config().nakedMeasures()
+        && isMeasureExp(id)) {
+      SqlNode originalExpr = validator.getOriginal(id);
+      throw validator.newValidationError(originalExpr,
+          RESOURCE.measureIllegal());
+    }
+
+    if (isGroupExpr(id)) {
+      return null;
+    }
+
     // Is it a call to a parentheses-free function?
     final SqlCall call = validator.makeNullaryCall(id);
     if (call != null) {
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/AggregatingSelectScope.java b/core/src/main/java/org/apache/calcite/sql/validate/AggregatingSelectScope.java
index 53cc201f287..86cd0eda8e3 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/AggregatingSelectScope.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/AggregatingSelectScope.java
@@ -20,28 +20,27 @@
 import org.apache.calcite.linq4j.Ord;
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.sql.SqlCall;
+import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.sql.SqlNodeList;
 import org.apache.calcite.sql.SqlSelect;
+import org.apache.calcite.sql.SqlUtil;
 import org.apache.calcite.util.ImmutableBitSet;
 import org.apache.calcite.util.Litmus;
-import org.apache.calcite.util.Pair;
+import org.apache.calcite.util.Util;
 
-import com.google.common.base.Suppliers;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSortedMultiset;
 
-import org.checkerframework.checker.nullness.qual.Nullable;
-
-import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
 import java.util.Map;
-import java.util.Objects;
-import java.util.function.Supplier;
 
 import static org.apache.calcite.sql.SqlUtil.stripAs;
 
+import static java.util.Objects.requireNonNull;
+
 /**
  * Scope for resolving identifiers within a SELECT statement that has a
  * GROUP BY clause.
@@ -56,13 +55,6 @@ public class AggregatingSelectScope
   private final SqlSelect select;
   private final boolean distinct;
 
-  /** Use while resolving. */
-  private SqlValidatorUtil.@Nullable GroupAnalyzer groupAnalyzer;
-
-  @SuppressWarnings("methodref.receiver.bound.invalid")
-  public final Supplier<Resolved> resolved =
-      Suppliers.memoize(this::resolve)::get;
-
   //~ Constructors -----------------------------------------------------------
 
   /**
@@ -86,49 +78,69 @@ public class AggregatingSelectScope
 
   //~ Methods ----------------------------------------------------------------
 
-  private Resolved resolve() {
-    assert groupAnalyzer == null : "resolve already in progress";
-    SqlValidatorUtil.GroupAnalyzer groupAnalyzer = new SqlValidatorUtil.GroupAnalyzer();
-    this.groupAnalyzer = groupAnalyzer;
-    try {
-      final ImmutableList.Builder<ImmutableList<ImmutableBitSet>> builder =
-          ImmutableList.builder();
-      if (select.getGroup() != null) {
-        final SqlNodeList groupList = select.getGroup();
-        for (SqlNode groupExpr : groupList) {
-          SqlValidatorUtil.analyzeGroupItem(this, groupAnalyzer, builder,
-              groupExpr);
-        }
-      }
+  @Override protected void analyze(SqlValidatorUtil.GroupAnalyzer analyzer) {
+    super.analyze(analyzer);
 
-      final List<ImmutableBitSet> flatGroupSets = new ArrayList<>();
-      for (List<ImmutableBitSet> groupSet : Linq4j.product(builder.build())) {
-        flatGroupSets.add(ImmutableBitSet.union(groupSet));
+    final ImmutableList.Builder<ImmutableList<ImmutableBitSet>> builder =
+        ImmutableList.builder();
+    boolean groupByDistinct = false;
+    if (select.getGroup() != null) {
+      SqlNodeList groupList = select.getGroup();
+      // if the DISTINCT keyword of GROUP BY is present it can be the only item
+      if (groupList.size() == 1
+          && groupList.get(0).getKind() == SqlKind.GROUP_BY_DISTINCT) {
+        groupList =
+            new SqlNodeList(((SqlCall) groupList.get(0)).getOperandList(),
+                groupList.getParserPosition());
+        groupByDistinct = true;
       }
-
-      // For GROUP BY (), we need a singleton grouping set.
-      if (flatGroupSets.isEmpty()) {
-        flatGroupSets.add(ImmutableBitSet.of());
+      for (SqlNode groupExpr : groupList) {
+        SqlValidatorUtil.analyzeGroupItem(this, analyzer, builder,
+            groupExpr);
       }
+    }
 
-      return new Resolved(groupAnalyzer.extraExprs, groupAnalyzer.groupExprs,
-          flatGroupSets, groupAnalyzer.groupExprProjection);
-    } finally {
-      this.groupAnalyzer = null;
+    for (List<ImmutableBitSet> groupSet : Linq4j.product(builder.build())) {
+      analyzer.flatGroupSets.add(ImmutableBitSet.union(groupSet));
+    }
+
+    // For GROUP BY (), we need a singleton grouping set.
+    if (analyzer.flatGroupSets.isEmpty()) {
+      analyzer.flatGroupSets.add(ImmutableBitSet.of());
+    }
+
+    if (groupByDistinct) {
+      assign(analyzer.flatGroupSets, Util.distinctList(analyzer.flatGroupSets));
     }
   }
 
+  /** Replaces the contents of {@code target} collection with the contents of
+   * {@code source}. */
+  private static <E> void assign(Collection<E> target, Collection<E> source) {
+    if (source == target) {
+      return;
+    }
+    target.clear();
+    target.addAll(source);
+  }
+
   /**
    * Returns the expressions that are in the GROUP BY clause (or the SELECT
    * DISTINCT clause, if distinct) and that can therefore be referenced
    * without being wrapped in aggregate functions.
    *
+   * <p>Also identifies measure expressions, which are not in {@code GROUP BY}
+   * but can still be referenced without aggregate functions. (Some dialects
+   * require measures to be wrapped in
+   * {@link org.apache.calcite.sql.fun.SqlLibraryOperators#AGGREGATE};
+   * see {@link SqlValidator.Config#nakedMeasures()}.)
+   *
    * <p>The expressions are fully-qualified, and any "*" in select clauses are
    * expanded.
-   *
-   * @return list of grouping expressions
    */
-  private Pair<ImmutableList<SqlNode>, ImmutableList<SqlNode>> getGroupExprs() {
+  private void gatherGroupExprs(ImmutableList.Builder<SqlNode> extraExprs,
+      ImmutableList.Builder<SqlNode> measureExprs,
+      ImmutableList.Builder<SqlNode> groupExprs) {
     if (distinct) {
       // Cannot compute this in the constructor: select list has not been
       // expanded yet.
@@ -136,27 +148,26 @@ private Pair<ImmutableList<SqlNode>, ImmutableList<SqlNode>> getGroupExprs() {
 
       // Remove the AS operator so the expressions are consistent with
       // OrderExpressionExpander.
-      ImmutableList.Builder<SqlNode> groupExprs = ImmutableList.builder();
       final SelectScope selectScope = (SelectScope) parent;
-      List<SqlNode> expandedSelectList = Objects.requireNonNull(
-          selectScope.getExpandedSelectList(),
-          () -> "expandedSelectList for " + selectScope);
+      List<SqlNode> expandedSelectList =
+          requireNonNull(selectScope.getExpandedSelectList(),
+              () -> "expandedSelectList for " + selectScope);
       for (SqlNode selectItem : expandedSelectList) {
         groupExprs.add(stripAs(selectItem));
       }
-      return Pair.of(ImmutableList.of(), groupExprs.build());
-    } else if (select.getGroup() != null) {
+    } else {
       SqlValidatorUtil.GroupAnalyzer groupAnalyzer = this.groupAnalyzer;
       if (groupAnalyzer != null) {
         // we are in the middle of resolving
-        return Pair.of(ImmutableList.of(),
-            ImmutableList.copyOf(groupAnalyzer.groupExprs));
+        extraExprs.addAll(groupAnalyzer.extraExprs);
+        measureExprs.addAll(groupAnalyzer.measureExprs);
+        groupExprs.addAll(groupAnalyzer.groupExprs);
       } else {
         final Resolved resolved = this.resolved.get();
-        return Pair.of(resolved.extraExprList, resolved.groupExprList);
+        extraExprs.addAll(resolved.extraExprList);
+        measureExprs.addAll(resolved.measureExprList);
+        groupExprs.addAll(resolved.groupExprList);
       }
-    } else {
-      return Pair.of(ImmutableList.of(), ImmutableList.of());
     }
   }
 
@@ -211,9 +222,13 @@ private Pair<ImmutableList<SqlNode>, ImmutableList<SqlNode>> getGroupExprs() {
     }
 
     // Make sure expression is valid, throws if not.
-    Pair<ImmutableList<SqlNode>, ImmutableList<SqlNode>> pair = getGroupExprs();
+    final ImmutableList.Builder<SqlNode> extraExprs = ImmutableList.builder();
+    final ImmutableList.Builder<SqlNode> measureExprs = ImmutableList.builder();
+    final ImmutableList.Builder<SqlNode> groupExprs = ImmutableList.builder();
+    gatherGroupExprs(extraExprs, measureExprs, groupExprs);
     final AggChecker aggChecker =
-        new AggChecker(validator, this, pair.left, pair.right, distinct);
+        new AggChecker(validator, this, extraExprs.build(),
+            measureExprs.build(), groupExprs.build(), distinct);
     if (deep) {
       expr.accept(aggChecker);
     }
@@ -230,18 +245,19 @@ private Pair<ImmutableList<SqlNode>, ImmutableList<SqlNode>> getGroupExprs() {
   /** Information about an aggregating scope that can only be determined
    * after validation has occurred. Therefore it cannot be populated when
    * the scope is created. */
-  @SuppressWarnings("UnstableApiUsage")
   public static class Resolved {
     public final ImmutableList<SqlNode> extraExprList;
+    public final ImmutableList<SqlNode> measureExprList;
     public final ImmutableList<SqlNode> groupExprList;
     public final ImmutableBitSet groupSet;
     public final ImmutableSortedMultiset<ImmutableBitSet> groupSets;
     public final Map<Integer, Integer> groupExprProjection;
 
-    Resolved(List<SqlNode> extraExprList, List<SqlNode> groupExprList,
-        Iterable<ImmutableBitSet> groupSets,
+    Resolved(List<SqlNode> extraExprList, List<SqlNode> measureExprList,
+        List<SqlNode> groupExprList, Iterable<ImmutableBitSet> groupSets,
         Map<Integer, Integer> groupExprProjection) {
       this.extraExprList = ImmutableList.copyOf(extraExprList);
+      this.measureExprList = ImmutableList.copyOf(measureExprList);
       this.groupExprList = ImmutableList.copyOf(groupExprList);
       this.groupSet = ImmutableBitSet.range(groupExprList.size());
       this.groupSets = ImmutableSortedMultiset.copyOf(groupSets);
@@ -260,12 +276,7 @@ public boolean isGroupingExpr(SqlNode operand) {
     }
 
     public int lookupGroupingExpr(SqlNode operand) {
-      for (Ord<SqlNode> groupExpr : Ord.zip(groupExprList)) {
-        if (operand.equalsDeep(groupExpr.e, Litmus.IGNORE)) {
-          return groupExpr.i;
-        }
-      }
-      return -1;
+      return SqlUtil.indexOfDeep(groupExprList, operand, Litmus.IGNORE);
     }
   }
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/AliasNamespace.java b/core/src/main/java/org/apache/calcite/sql/validate/AliasNamespace.java
index be293fc9c45..f3f7b343c3d 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/AliasNamespace.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/AliasNamespace.java
@@ -19,10 +19,13 @@
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeFactoryImpl;
 import org.apache.calcite.rel.type.RelDataTypeField;
+import org.apache.calcite.sql.SqlBasicCall;
 import org.apache.calcite.sql.SqlCall;
 import org.apache.calcite.sql.SqlIdentifier;
+import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.sql.SqlNodeList;
+import org.apache.calcite.sql.SqlUnnestOperator;
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
 import org.apache.calcite.sql.parser.SqlParserPos;
 import org.apache.calcite.util.Pair;
@@ -81,6 +84,7 @@ protected AliasNamespace(
     final RelDataType rowType = childNs.getRowTypeSansSystemColumns();
     final RelDataType aliasedType;
     if (operands.size() == 2) {
+      final SqlNode node = operands.get(0);
       // Alias is 'AS t' (no column list).
       // If the sub-query is UNNEST or VALUES,
       // and the sub-query has one column,
@@ -91,6 +95,17 @@ protected AliasNamespace(
             .add(((SqlIdentifier) operands.get(1)).getSimple(),
                 rowType.getFieldList().get(0).getType())
             .build();
+        // If the sub-query is UNNEST with ordinality
+        // and the sub-query has two columns: data column, ordinality column
+        // then the namespace's sole column is named after the alias.
+      } else if (node.getKind() == SqlKind.UNNEST && rowType.getFieldCount() == 2
+          && ((SqlUnnestOperator) ((SqlBasicCall) node).getOperator()).withOrdinality) {
+        aliasedType = validator.getTypeFactory().builder()
+            .kind(rowType.getStructKind())
+            .add(((SqlIdentifier) operands.get(1)).getSimple(),
+                rowType.getFieldList().get(0).getType())
+            .add(rowType.getFieldList().get(1))
+            .build();
       } else {
         aliasedType = rowType;
       }
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/DelegatingNamespace.java b/core/src/main/java/org/apache/calcite/sql/validate/DelegatingNamespace.java
index 97d6abdf1a3..a5aee4e79e3 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/DelegatingNamespace.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/DelegatingNamespace.java
@@ -17,6 +17,7 @@
 package org.apache.calcite.sql.validate;
 
 import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.rel.type.RelDataTypeField;
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.util.Pair;
 
@@ -87,8 +88,8 @@ protected DelegatingNamespace(SqlValidatorNamespace namespace) {
     return namespace.lookupChild(name);
   }
 
-  @Override public boolean fieldExists(String name) {
-    return namespace.fieldExists(name);
+  @Override public @Nullable RelDataTypeField field(String name) {
+    return namespace.field(name);
   }
 
   @Override public List<Pair<SqlNode, SqlMonotonicity>> getMonotonicExprs() {
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/DelegatingScope.java b/core/src/main/java/org/apache/calcite/sql/validate/DelegatingScope.java
index 40d4b48a237..aa079cb71a0 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/DelegatingScope.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/DelegatingScope.java
@@ -30,19 +30,24 @@
 import org.apache.calcite.sql.SqlSelect;
 import org.apache.calcite.sql.SqlWindow;
 import org.apache.calcite.sql.parser.SqlParserPos;
+import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.util.Pair;
 import org.apache.calcite.util.Util;
 
+import com.google.common.base.Preconditions;
+import com.google.common.base.Suppliers;
 import com.google.common.collect.ImmutableList;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;
 import java.util.Map;
+import java.util.function.Supplier;
 
 import static org.apache.calcite.util.Static.RESOURCE;
 
@@ -65,6 +70,15 @@ public abstract class DelegatingScope implements SqlValidatorScope {
   protected final SqlValidatorScope parent;
   protected final SqlValidatorImpl validator;
 
+  /** Computes and stores information that cannot be computed on construction,
+   * but only after sub-queries have been validated. */
+  @SuppressWarnings({"methodref.receiver.bound.invalid", "FunctionalExpressionCanBeFolded"})
+  public final Supplier<AggregatingSelectScope.Resolved> resolved =
+      Suppliers.memoize(this::resolve)::get;
+
+  /** Use while resolving. */
+  SqlValidatorUtil.@Nullable GroupAnalyzer groupAnalyzer;
+
   //~ Constructors -----------------------------------------------------------
 
   /**
@@ -74,9 +88,8 @@ public abstract class DelegatingScope implements SqlValidatorScope {
    */
   DelegatingScope(SqlValidatorScope parent) {
     super();
-    assert parent != null;
+    this.parent = requireNonNull(parent, "parent");
     this.validator = (SqlValidatorImpl) parent.getValidator();
-    this.parent = parent;
   }
 
   //~ Methods ----------------------------------------------------------------
@@ -116,8 +129,9 @@ void resolveInNamespace(SqlValidatorNamespace ns, boolean nullable,
             final List<String> remainder = entry.getValue();
             final SqlValidatorNamespace ns2 =
                 new FieldNamespace(validator, field.getType());
-            final Step path2 = path.plus(rowType, field.getIndex(),
-                field.getName(), StructKind.FULLY_QUALIFIED);
+            final Step path2 =
+                path.plus(rowType, field.getIndex(), field.getName(),
+                    StructKind.FULLY_QUALIFIED);
             resolveInNamespace(ns2, nullable, remainder, nameMatcher, path2,
                 resolved);
           }
@@ -128,11 +142,12 @@ void resolveInNamespace(SqlValidatorNamespace ns, boolean nullable,
       final String name = names.get(0);
       final RelDataTypeField field0 = nameMatcher.field(rowType, name);
       if (field0 != null) {
-        final SqlValidatorNamespace ns2 = requireNonNull(
-            ns.lookupChild(field0.getName()),
-            () -> "field " + field0.getName() + " is not found in " + ns);
-        final Step path2 = path.plus(rowType, field0.getIndex(),
-            field0.getName(), StructKind.FULLY_QUALIFIED);
+        final SqlValidatorNamespace ns2 =
+            requireNonNull(ns.lookupChild(field0.getName()),
+                () -> "field " + field0.getName() + " is not found in " + ns);
+        final Step path2 =
+            path.plus(rowType, field0.getIndex(),
+                field0.getName(), StructKind.FULLY_QUALIFIED);
         resolveInNamespace(ns2, nullable, names.subList(1, names.size()),
             nameMatcher, path2, resolved);
       } else {
@@ -141,11 +156,12 @@ void resolveInNamespace(SqlValidatorNamespace ns, boolean nullable,
           case PEEK_FIELDS:
           case PEEK_FIELDS_DEFAULT:
           case PEEK_FIELDS_NO_EXPAND:
-            final Step path2 = path.plus(rowType, field.getIndex(),
-                field.getName(), field.getType().getStructKind());
-            final SqlValidatorNamespace ns2 = requireNonNull(
-                ns.lookupChild(field.getName()),
-                () -> "field " + field.getName() + " is not found in " + ns);
+            final Step path2 =
+                path.plus(rowType, field.getIndex(),
+                    field.getName(), field.getType().getStructKind());
+            final SqlValidatorNamespace ns2 =
+                requireNonNull(ns.lookupChild(field.getName()),
+                    () -> "field " + field.getName() + " is not found in " + ns);
             resolveInNamespace(ns2, nullable, names, nameMatcher, path2,
                 resolved);
             break;
@@ -397,8 +413,8 @@ protected void addColumnNames(
       // change "e.empno" to "E.empno".
       if (fromNs.getEnclosingNode() != null
           && !(this instanceof MatchRecognizeScope)) {
-        String alias =
-            SqlValidatorUtil.getAlias(fromNs.getEnclosingNode(), -1);
+        @Nullable String alias =
+            SqlValidatorUtil.alias(fromNs.getEnclosingNode());
         if (alias != null
             && i > 0
             && !alias.equals(identifier.names.get(i - 1))) {
@@ -587,6 +603,53 @@ private static boolean hasAmbiguousField(RelDataType rowType,
     return false;
   }
 
+  private AggregatingSelectScope.Resolved resolve() {
+    Preconditions.checkArgument(groupAnalyzer == null,
+        "resolve already in progress");
+    SqlValidatorUtil.GroupAnalyzer groupAnalyzer = new SqlValidatorUtil.GroupAnalyzer();
+    this.groupAnalyzer = groupAnalyzer;
+    try {
+      analyze(groupAnalyzer);
+      return groupAnalyzer.finish();
+    } finally {
+      this.groupAnalyzer = null;
+    }
+  }
+
+  /** Analyzes expressions in this scope and populates a
+   * {@code GroupAnalyzer}. */
+  protected void analyze(SqlValidatorUtil.GroupAnalyzer analyzer) {
+    final SelectScope selectScope = SqlValidatorUtil.getEnclosingSelectScope(this);
+    if (selectScope != null) {
+      // Find all expressions in this scope that reference measures
+      for (ScopeChild child : selectScope.children) {
+        final RelDataType rowType = child.namespace.getRowType();
+        if (child.namespace instanceof SelectNamespace) {
+          final SqlSelect select = ((SelectNamespace) child.namespace).getNode();
+          Pair.forEach(select.getSelectList(),
+              rowType.getFieldList(),
+              (selectItem, field) -> {
+                if (SqlValidatorUtil.isMeasure(selectItem)) {
+                  analyzer.measureExprs.add(
+                      new SqlIdentifier(
+                          Arrays.asList(child.name, field.getName()),
+                          SqlParserPos.ZERO));
+                }
+              });
+        } else {
+          rowType.getFieldList().forEach(field -> {
+            if (field.getType().getSqlTypeName() == SqlTypeName.MEASURE) {
+              analyzer.measureExprs.add(
+                  new SqlIdentifier(
+                      Arrays.asList(child.name, field.getName()),
+                      SqlParserPos.ZERO));
+            }
+          });
+        }
+      }
+    }
+  }
+
   /**
    * Returns the parent scope of this <code>DelegatingScope</code>.
    */
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/EmptyScope.java b/core/src/main/java/org/apache/calcite/sql/validate/EmptyScope.java
index 1a7a06ed7f1..e5eba1b1a90 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/EmptyScope.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/EmptyScope.java
@@ -137,15 +137,15 @@ private void resolve_(final CalciteSchema rootSchema, List<String> names,
         path = path.plus(null, -1, subSchema.name, StructKind.NONE);
         remainingNames = Util.skip(remainingNames);
         schema = subSchema;
-        namespace = new SchemaNamespace(validator,
-            ImmutableList.copyOf(path.stepNames()));
+        namespace = new SchemaNamespace(validator, path.stepNames());
         continue;
       }
       CalciteSchema.TableEntry entry =
           schema.getTable(schemaName, nameMatcher.isCaseSensitive());
       if (entry == null) {
-        entry = schema.getTableBasedOnNullaryFunction(schemaName,
-            nameMatcher.isCaseSensitive());
+        entry =
+            schema.getTableBasedOnNullaryFunction(schemaName,
+                nameMatcher.isCaseSensitive());
       }
       if (entry != null) {
         path = path.plus(null, -1, entry.name, StructKind.NONE);
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/FieldNamespace.java b/core/src/main/java/org/apache/calcite/sql/validate/FieldNamespace.java
index 59607e74637..e830d9a998c 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/FieldNamespace.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/FieldNamespace.java
@@ -17,6 +17,7 @@
 package org.apache.calcite.sql.validate;
 
 import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.rel.type.RelDataTypeField;
 import org.apache.calcite.sql.SqlNode;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
@@ -70,7 +71,7 @@ class FieldNamespace extends AbstractNamespace {
     return null;
   }
 
-  @Override public boolean fieldExists(String name) {
-    return false;
+  @Override public @Nullable RelDataTypeField field(String name) {
+    return null;
   }
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/GroupByScope.java b/core/src/main/java/org/apache/calcite/sql/validate/GroupByScope.java
index d7c5d208094..7db2e49224b 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/GroupByScope.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/GroupByScope.java
@@ -56,7 +56,8 @@ public class GroupByScope extends DelegatingScope {
   }
 
   @Override public void validateExpr(SqlNode expr) {
-    SqlNode expanded = validator.expandGroupByOrHavingExpr(expr, this, select, false);
+    SqlNode expanded =
+        validator.extendedExpandGroupBy(expr, this, select);
 
     // expression needs to be valid in parent scope too
     parent.validateExpr(expanded);
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/ListScope.java b/core/src/main/java/org/apache/calcite/sql/validate/ListScope.java
index 656205b3c72..b86472d5b46 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/ListScope.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/ListScope.java
@@ -80,6 +80,24 @@ public List<SqlValidatorNamespace> getChildren() {
     return Util.transform(children, scopeChild -> scopeChild.name);
   }
 
+  /**
+   * Whether the ith child namespace produces nullable result.
+   *
+   * For example, in below query,
+   * <pre>
+   *   SELECT *
+   *   FROM EMPS
+   *   LEFT OUTER JOIN DEPT
+   * </pre>
+   * the namespace which corresponding to 'DEPT' is nullable.
+   *
+   * @param i The child index.
+   * @return Whether it's nullable.
+   */
+  public boolean isChildNullable(int i) {
+    return children.get(i).nullable;
+  }
+
   private @Nullable ScopeChild findChild(List<String> names,
       SqlNameMatcher nameMatcher) {
     for (ScopeChild child : children) {
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/OrderByScope.java b/core/src/main/java/org/apache/calcite/sql/validate/OrderByScope.java
index 2b48c7da10a..0cbe802d33b 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/OrderByScope.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/OrderByScope.java
@@ -101,7 +101,7 @@ public class OrderByScope extends DelegatingScope {
   private int aliasCount(SqlNameMatcher nameMatcher, String name) {
     int n = 0;
     for (SqlNode s : getSelectList(select)) {
-      final String alias = SqlValidatorUtil.getAlias(s, -1);
+      final @Nullable String alias = SqlValidatorUtil.alias(s);
       if (alias != null && nameMatcher.matches(alias, name)) {
         n++;
       }
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/SchemaNamespace.java b/core/src/main/java/org/apache/calcite/sql/validate/SchemaNamespace.java
index 769c6d2d641..2dce1178c65 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/SchemaNamespace.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/SchemaNamespace.java
@@ -26,7 +26,6 @@
 import org.checkerframework.checker.nullness.qual.Nullable;
 
 import java.util.List;
-import java.util.Objects;
 
 import static java.util.Objects.requireNonNull;
 
@@ -39,9 +38,9 @@ class SchemaNamespace extends AbstractNamespace {
   private final ImmutableList<String> names;
 
   /** Creates a SchemaNamespace. */
-  SchemaNamespace(SqlValidatorImpl validator, ImmutableList<String> names) {
+  SchemaNamespace(SqlValidatorImpl validator, List<String> names) {
     super(validator, null);
-    this.names = Objects.requireNonNull(names, "names");
+    this.names = ImmutableList.copyOf(names);
   }
 
   @Override protected RelDataType validateImpl(RelDataType targetRowType) {
@@ -50,9 +49,9 @@ class SchemaNamespace extends AbstractNamespace {
     for (SqlMoniker moniker
         : validator.catalogReader.getAllSchemaObjectNames(names)) {
       final List<String> names1 = moniker.getFullyQualifiedNames();
-      final SqlValidatorTable table = requireNonNull(
-          validator.catalogReader.getTable(names1),
-          () -> "table " + names1 + " is not found in scope " + names);
+      final SqlValidatorTable table =
+          requireNonNull(validator.catalogReader.getTable(names1),
+              () -> "table " + names1 + " is not found in scope " + names);
       builder.add(Util.last(names1), table.getRowType());
     }
     return builder.build();
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/SelectNamespace.java b/core/src/main/java/org/apache/calcite/sql/validate/SelectNamespace.java
index f34b19235bd..e45458b38eb 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/SelectNamespace.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/SelectNamespace.java
@@ -21,8 +21,6 @@
 import org.apache.calcite.sql.SqlSelect;
 import org.apache.calcite.sql.type.SqlTypeUtil;
 
-import org.checkerframework.checker.nullness.qual.Nullable;
-
 import static java.util.Objects.requireNonNull;
 
 /**
@@ -55,8 +53,7 @@ public SelectNamespace(
 
   //~ Methods ----------------------------------------------------------------
 
-  // implement SqlValidatorNamespace, overriding return type
-  @Override public @Nullable SqlNode getNode() {
+  @Override public SqlSelect getNode() {
     return select;
   }
 
@@ -72,12 +69,12 @@ public SelectNamespace(
   @Override public SqlMonotonicity getMonotonicity(String columnName) {
     final RelDataType rowType = this.getRowTypeSansSystemColumns();
     final int field = SqlTypeUtil.findField(rowType, columnName);
-    SelectScope selectScope = requireNonNull(
-        validator.getRawSelectScope(select),
-        () -> "rawSelectScope for " + select);
-    final SqlNode selectItem = requireNonNull(
-        selectScope.getExpandedSelectList(),
-        () -> "expandedSelectList for selectScope of " + select).get(field);
+    SelectScope selectScope =
+        requireNonNull(validator.getRawSelectScope(select),
+            () -> "rawSelectScope for " + select);
+    final SqlNode selectItem =
+        requireNonNull(selectScope.getExpandedSelectList(),
+            () -> "expandedSelectList for selectScope of " + select).get(field);
     return validator.getSelectScope(select).getMonotonicity(selectItem);
   }
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/SelectScope.java b/core/src/main/java/org/apache/calcite/sql/validate/SelectScope.java
index e042fa43676..83306732c27 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/SelectScope.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/SelectScope.java
@@ -32,7 +32,8 @@
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Objects;
+
+import static java.util.Objects.requireNonNull;
 
 /**
  * The name-resolution scope of a SELECT clause. The objects visible are those
@@ -135,12 +136,13 @@ public class SelectScope extends ListScope {
   }
 
   @Override public @Nullable SqlWindow lookupWindow(String name) {
-    final SqlNodeList windowList = select.getWindowList();
-    for (int i = 0; i < windowList.size(); i++) {
-      SqlWindow window = (SqlWindow) windowList.get(i);
-      final SqlIdentifier declId = Objects.requireNonNull(
-          window.getDeclName(),
-          () -> "declName of window " + window);
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    final List<SqlWindow> windowList =
+        (List<SqlWindow>) (List) select.getWindowList();
+    for (SqlWindow window : windowList) {
+      final SqlIdentifier declId =
+          requireNonNull(window.getDeclName(),
+              () -> "declName of window " + window);
       assert declId.isSimple();
       if (declId.names.get(0).equals(name)) {
         return window;
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/SetopNamespace.java b/core/src/main/java/org/apache/calcite/sql/validate/SetopNamespace.java
index 6062b2d12ac..58c381e80c3 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/SetopNamespace.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/SetopNamespace.java
@@ -67,12 +67,12 @@ protected SetopNamespace(
     }
     for (SqlNode operand : call.getOperandList()) {
       final SqlValidatorNamespace namespace =
-          requireNonNull(
-              validator.getNamespace(operand),
+          requireNonNull(validator.getNamespace(operand),
               () -> "namespace for " + operand);
-      monotonicity = combine(monotonicity,
-          namespace.getMonotonicity(
-              namespace.getRowType().getFieldNames().get(index)));
+      monotonicity =
+          combine(monotonicity,
+              namespace.getMonotonicity(
+                  namespace.getRowType().getFieldNames().get(index)));
     }
     return Util.first(monotonicity, SqlMonotonicity.NOT_MONOTONIC);
   }
@@ -102,9 +102,9 @@ private static SqlMonotonicity combine(@Nullable SqlMonotonicity m0,
     case UNION:
     case INTERSECT:
     case EXCEPT:
-      final SqlValidatorScope scope = requireNonNull(
-          validator.scopes.get(call),
-          () -> "scope for " + call);
+      final SqlValidatorScope scope =
+          requireNonNull(validator.scopes.get(call),
+              () -> "scope for " + call);
       for (SqlNode operand : call.getOperandList()) {
         if (!operand.isA(SqlKind.QUERY)) {
           throw validator.newValidationError(operand,
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/SqlAbstractConformance.java b/core/src/main/java/org/apache/calcite/sql/validate/SqlAbstractConformance.java
index 92d0889baa8..c4e456dedfd 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/SqlAbstractConformance.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/SqlAbstractConformance.java
@@ -101,6 +101,10 @@ public abstract class SqlAbstractConformance implements SqlConformance {
     return SqlConformanceEnum.DEFAULT.isLimitStartCountAllowed();
   }
 
+  @Override public boolean isOffsetLimitAllowed() {
+    return SqlConformanceEnum.DEFAULT.isOffsetLimitAllowed();
+  }
+
   @Override public boolean isPercentRemainderAllowed() {
     return SqlConformanceEnum.DEFAULT.isPercentRemainderAllowed();
   }
@@ -129,8 +133,15 @@ public abstract class SqlAbstractConformance implements SqlConformance {
     return SqlConformanceEnum.DEFAULT.allowAliasUnnestItems();
   }
 
+  @Override public boolean isValueAllowed() {
+    return SqlConformanceEnum.DEFAULT.isValueAllowed();
+  }
+
   @Override public SqlLibrary semantics() {
     return SqlConformanceEnum.DEFAULT.semantics();
   }
 
+  @Override public boolean allowCoercionStringToArray() {
+    return SqlConformanceEnum.DEFAULT.allowCoercionStringToArray();
+  }
 }
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 15902fb0e8b..eef63adefac 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
@@ -16,6 +16,7 @@
  */
 package org.apache.calcite.sql.validate;
 
+import org.apache.calcite.linq4j.function.Experimental;
 import org.apache.calcite.sql.fun.SqlLibrary;
 
 /**
@@ -155,6 +156,7 @@ public interface SqlConformance {
    * <p>Among the built-in conformance levels, true in
    * {@link SqlConformanceEnum#DEFAULT},
    * {@link SqlConformanceEnum#BABEL},
+   * {@link SqlConformanceEnum#BIG_QUERY},
    * {@link SqlConformanceEnum#LENIENT},
    * {@link SqlConformanceEnum#MYSQL_5},
    * {@link SqlConformanceEnum#ORACLE_10},
@@ -401,6 +403,24 @@ public interface SqlConformance {
    */
   boolean isLimitStartCountAllowed();
 
+  /**
+   * Whether to allow the SQL syntax "{@code OFFSET start LIMIT count}"
+   * (that is, {@code OFFSET} before {@code LIMIT},
+   * in addition to {@code LIMIT} before {@code OFFSET}
+   * and {@code OFFSET} before {@code FETCH}).
+   *
+   * <p>The equivalent syntax in standard SQL is
+   * "{@code OFFSET start ROW FETCH FIRST count ROWS ONLY}".
+   *
+   * <p>Trino allows this behavior.
+   *
+   * <p>Among the built-in conformance levels, true in
+   * {@link SqlConformanceEnum#BABEL},
+   * {@link SqlConformanceEnum#LENIENT};
+   * false otherwise.
+   */
+  boolean isOffsetLimitAllowed();
+
   /**
    * Whether to allow geo-spatial extensions, including the GEOMETRY type.
    *
@@ -504,6 +524,18 @@ public interface SqlConformance {
    */
   boolean allowQualifyingCommonColumn();
 
+  /**
+   * Whether {@code VALUE} is allowed as an alternative to {@code VALUES} in
+   * the parser.
+   *
+   * <p>Among the built-in conformance levels, true in
+   * {@link SqlConformanceEnum#BABEL},
+   * {@link SqlConformanceEnum#LENIENT},
+   * {@link SqlConformanceEnum#MYSQL_5};
+   * false otherwise.
+   */
+  boolean isValueAllowed();
+
   /**
    * Controls the behavior of operators that are part of Standard SQL but
    * nevertheless have different behavior in different databases.
@@ -529,4 +561,19 @@ public interface SqlConformance {
    * </ul>
    */
   SqlLibrary semantics();
+
+  /**
+   * Whether to allow coercion string literal to array literal
+   *
+   * <p>For example,
+   *
+   * <blockquote><pre>SELECT ARRAY[0,1,2] == '{0,1,2}'
+   * </pre></blockquote>
+   *
+   * <p>Among the built-in conformance levels, true in
+   * {@link SqlConformanceEnum#BABEL},
+   * false otherwise.
+   */
+  @Experimental
+  boolean allowCoercionStringToArray();
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/SqlConformanceEnum.java b/core/src/main/java/org/apache/calcite/sql/validate/SqlConformanceEnum.java
index aaeda4807df..5ff78027187 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/SqlConformanceEnum.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/SqlConformanceEnum.java
@@ -166,6 +166,7 @@ public enum SqlConformanceEnum implements SqlConformance {
     case DEFAULT:
     case BABEL:
     case LENIENT:
+    case BIG_QUERY:
     case MYSQL_5:
     case ORACLE_10:
     case ORACLE_12:
@@ -216,6 +217,7 @@ public enum SqlConformanceEnum implements SqlConformance {
     switch (this) {
     case LENIENT:
     case BABEL:
+    case BIG_QUERY:
     case MYSQL_5:
     case ORACLE_10:
     case ORACLE_12:
@@ -242,6 +244,7 @@ public enum SqlConformanceEnum implements SqlConformance {
     switch (this) {
     case BABEL:
     case LENIENT:
+    case BIG_QUERY:
     case MYSQL_5:
     case PRESTO:
       return true;
@@ -319,6 +322,16 @@ public enum SqlConformanceEnum implements SqlConformance {
     }
   }
 
+  @Override public boolean isOffsetLimitAllowed() {
+    switch (this) {
+    case BABEL:
+    case LENIENT:
+      return true;
+    default:
+      return false;
+    }
+  }
+
   @Override public boolean allowGeometry() {
     switch (this) {
     case BABEL:
@@ -393,6 +406,17 @@ public enum SqlConformanceEnum implements SqlConformance {
     }
   }
 
+  @Override public boolean isValueAllowed() {
+    switch (this) {
+    case BABEL:
+    case LENIENT:
+    case MYSQL_5:
+      return true;
+    default:
+      return false;
+    }
+  }
+
   @Override public SqlLibrary semantics() {
     switch (this) {
     case BIG_QUERY:
@@ -407,4 +431,12 @@ public enum SqlConformanceEnum implements SqlConformance {
     }
   }
 
+  @Override public boolean allowCoercionStringToArray() {
+    switch (this) {
+    case BABEL:
+      return true;
+    default:
+      return false;
+    }
+  }
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/SqlDelegatingConformance.java b/core/src/main/java/org/apache/calcite/sql/validate/SqlDelegatingConformance.java
index 8cc42555f36..3b55d083baa 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/SqlDelegatingConformance.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/SqlDelegatingConformance.java
@@ -79,6 +79,10 @@ protected SqlDelegatingConformance(SqlConformance delegate) {
     return delegate.allowAliasUnnestItems();
   }
 
+  @Override public boolean isValueAllowed() {
+    return delegate.isValueAllowed();
+  }
+
   @Override public SqlLibrary semantics() {
     return delegate.semantics();
   }
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/SqlMoniker.java b/core/src/main/java/org/apache/calcite/sql/validate/SqlMoniker.java
index 3f3b385a59c..0f55ba20760 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/SqlMoniker.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/SqlMoniker.java
@@ -35,8 +35,9 @@ public interface SqlMoniker {
         @Override public int compare(SqlMoniker o1, SqlMoniker o2) {
           int c = o1.getType().compareTo(o2.getType());
           if (c == 0) {
-            c = listOrdering.compare(o1.getFullyQualifiedNames(),
-                o2.getFullyQualifiedNames());
+            c =
+                listOrdering.compare(o1.getFullyQualifiedNames(),
+                    o2.getFullyQualifiedNames());
           }
           return c;
         }
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/SqlNameMatcher.java b/core/src/main/java/org/apache/calcite/sql/validate/SqlNameMatcher.java
index b2c040cf0c6..dee642efa3f 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/SqlNameMatcher.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/SqlNameMatcher.java
@@ -19,6 +19,7 @@
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeField;
 
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Iterables;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
@@ -68,6 +69,19 @@ public interface SqlNameMatcher {
    * <p>Similar to {@link java.util.Collections#frequency}. */
   int frequency(Iterable<String> names, String name);
 
+  /** Returns a copy of a collection, removing duplicates and retaining
+   * iteration order. */
+  default List<String> distinctCopy(Iterable<String> names) {
+    final ImmutableList.Builder<String> list = ImmutableList.builder();
+    final Set<String> set = createSet();
+    for (String name : names) {
+      if (set.add(name)) {
+        list.add(name);
+      }
+    }
+    return list.build();
+  }
+
   /** Returns the index of the first element of a collection that matches. */
   default int indexOf(Iterable<String> names, String name) {
     return Iterables.indexOf(names, n -> matches(n, name));
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/SqlNameMatchers.java b/core/src/main/java/org/apache/calcite/sql/validate/SqlNameMatchers.java
index 6b4f0b2eb51..c01b7187acd 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/SqlNameMatchers.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/SqlNameMatchers.java
@@ -162,10 +162,11 @@ private static class LiberalNameMatcher extends BaseMatcher {
 
     @Override protected void matched(List<String> prefixNames,
         List<String> names) {
-      matchedNames = ImmutableList.copyOf(
-          Util.startsWith(names, prefixNames)
-              ? Util.skip(names, prefixNames.size())
-              : names);
+      matchedNames =
+          ImmutableList.copyOf(
+              Util.startsWith(names, prefixNames)
+                  ? Util.skip(names, prefixNames.size())
+                  : names);
     }
 
     @Override public List<String> bestMatch() {
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/SqlValidator.java b/core/src/main/java/org/apache/calcite/sql/validate/SqlValidator.java
index 1143e0afc45..4c05824ce7f 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/SqlValidator.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/SqlValidator.java
@@ -20,6 +20,8 @@
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeFactory;
 import org.apache.calcite.rel.type.RelDataTypeField;
+import org.apache.calcite.rel.type.TimeFrame;
+import org.apache.calcite.rel.type.TimeFrameSet;
 import org.apache.calcite.runtime.CalciteContextException;
 import org.apache.calcite.runtime.CalciteException;
 import org.apache.calcite.runtime.Resources;
@@ -703,6 +705,13 @@ CalciteException handleUnresolvedFunction(SqlCall call,
    */
   SqlNode expand(SqlNode expr, SqlValidatorScope scope);
 
+  /** Resolves a literal.
+   *
+   * <p>Usually returns the literal unchanged, but if the literal is of type
+   * {@link org.apache.calcite.sql.type.SqlTypeName#UNKNOWN} looks up its type
+   * and converts to the appropriate literal subclass. */
+  SqlLiteral resolveLiteral(SqlLiteral literal);
+
   /**
    * Returns whether a field is a system field. Such fields may have
    * particular properties such as sortedness and nullability.
@@ -782,6 +791,21 @@ boolean validateModality(SqlSelect select, SqlModality modality,
   @API(status = API.Status.INTERNAL, since = "1.23")
   SqlValidator transform(UnaryOperator<SqlValidator.Config> transform);
 
+  /** Returns the set of allowed time frames. */
+  TimeFrameSet getTimeFrameSet();
+
+  /** Validates a time frame.
+   *
+   * <p>A time frame is either a built-in time frame based on a time unit such
+   * as {@link org.apache.calcite.avatica.util.TimeUnitRange#HOUR},
+   * or is a custom time frame represented by a name in
+   * {@link SqlIntervalQualifier#timeFrameName}. A custom time frame is
+   * validated against {@link #getTimeFrameSet()}.
+   *
+   * <p>Returns a time frame, or throws.
+   */
+  TimeFrame validateTimeFrame(SqlIntervalQualifier intervalQualifier);
+
   //~ Inner Class ------------------------------------------------------------
 
   /**
@@ -872,6 +896,16 @@ public interface Config {
      */
     Config withLenientOperatorLookup(boolean lenient);
 
+    /** Returns whether the validator allows measures to be used without the
+     * AGGREGATE function. Default is true. */
+    @Value.Default default boolean nakedMeasures() {
+      return true;
+    }
+
+    /** Sets whether the validator allows measures to be used without the
+     * AGGREGATE function. */
+    Config withNakedMeasures(boolean nakedMeasures);
+
     /** Returns whether the validator supports implicit type coercion. */
     @Value.Default default boolean typeCoercionEnabled() {
       return true;
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java b/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
index 2978f1a7007..941733175a8 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
@@ -22,11 +22,15 @@
 import org.apache.calcite.plan.RelOptUtil;
 import org.apache.calcite.prepare.Prepare;
 import org.apache.calcite.rel.type.DynamicRecordType;
+import org.apache.calcite.rel.type.RelCrossType;
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeFactory;
 import org.apache.calcite.rel.type.RelDataTypeField;
 import org.apache.calcite.rel.type.RelDataTypeSystem;
 import org.apache.calcite.rel.type.RelRecordType;
+import org.apache.calcite.rel.type.TimeFrame;
+import org.apache.calcite.rel.type.TimeFrameSet;
+import org.apache.calcite.rel.type.TimeFrames;
 import org.apache.calcite.rex.RexNode;
 import org.apache.calcite.rex.RexPatternFieldRef;
 import org.apache.calcite.rex.RexVisitor;
@@ -72,6 +76,7 @@
 import org.apache.calcite.sql.SqlSnapshot;
 import org.apache.calcite.sql.SqlSyntax;
 import org.apache.calcite.sql.SqlTableFunction;
+import org.apache.calcite.sql.SqlUnknownLiteral;
 import org.apache.calcite.sql.SqlUnpivot;
 import org.apache.calcite.sql.SqlUnresolvedFunction;
 import org.apache.calcite.sql.SqlUpdate;
@@ -80,6 +85,7 @@
 import org.apache.calcite.sql.SqlWindowTableFunction;
 import org.apache.calcite.sql.SqlWith;
 import org.apache.calcite.sql.SqlWithItem;
+import org.apache.calcite.sql.TableCharacteristic;
 import org.apache.calcite.sql.fun.SqlCase;
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
 import org.apache.calcite.sql.parser.SqlParserPos;
@@ -234,11 +240,11 @@ public class SqlValidatorImpl implements SqlValidatorWithHints {
 
   private int nextGeneratedId;
   protected final RelDataTypeFactory typeFactory;
-
-  /** The type of dynamic parameters until a type is imposed on them. */
   protected final RelDataType unknownType;
   private final RelDataType booleanType;
 
+  protected final TimeFrameSet timeFrameSet;
+
   /**
    * Map of derived RelDataType for each node. This is an IdentityHashMap
    * since in some cases (such as null literals) we need to discriminate by
@@ -293,24 +299,45 @@ protected SqlValidatorImpl(
     this.opTab = requireNonNull(opTab, "opTab");
     this.catalogReader = requireNonNull(catalogReader, "catalogReader");
     this.typeFactory = requireNonNull(typeFactory, "typeFactory");
+    final RelDataTypeSystem typeSystem = typeFactory.getTypeSystem();
+    this.timeFrameSet =
+        requireNonNull(typeSystem.deriveTimeFrameSet(TimeFrames.CORE),
+            "timeFrameSet");
     this.config = requireNonNull(config, "config");
 
-    unknownType = typeFactory.createUnknownType();
+    // It is assumed that unknown type is nullable by default
+    unknownType = typeFactory.createTypeWithNullability(typeFactory.createUnknownType(), true);
     booleanType = typeFactory.createSqlType(SqlTypeName.BOOLEAN);
 
     final SqlNameMatcher nameMatcher = catalogReader.nameMatcher();
     aggFinder = new AggFinder(opTab, false, true, false, null, nameMatcher);
     aggOrOverFinder =
         new AggFinder(opTab, true, true, false, null, nameMatcher);
-    overFinder = new AggFinder(opTab, true, false, false, aggOrOverFinder,
-        nameMatcher);
+    overFinder =
+        new AggFinder(opTab, true, false, false, aggOrOverFinder, nameMatcher);
     groupFinder = new AggFinder(opTab, false, false, true, null, nameMatcher);
-    aggOrOverOrGroupFinder = new AggFinder(opTab, true, true, true, null,
-        nameMatcher);
+    aggOrOverOrGroupFinder =
+        new AggFinder(opTab, true, true, true, null, nameMatcher);
     @SuppressWarnings("argument.type.incompatible")
     TypeCoercion typeCoercion = config.typeCoercionFactory().create(typeFactory, this);
     this.typeCoercion = typeCoercion;
-    if (config.typeCoercionRules() != null) {
+
+    if (config.conformance().allowCoercionStringToArray()) {
+      SqlTypeCoercionRule rules = requireNonNull(config.typeCoercionRules() != null
+          ? config.typeCoercionRules() : SqlTypeCoercionRule.THREAD_PROVIDERS.get());
+
+      ImmutableSet<SqlTypeName> arrayMapping = ImmutableSet.<SqlTypeName>builder()
+          .addAll(rules.getTypeMapping().getOrDefault(SqlTypeName.ARRAY, ImmutableSet.of()))
+          .add(SqlTypeName.VARCHAR)
+          .add(SqlTypeName.CHAR)
+          .build();
+
+      Map<SqlTypeName, ImmutableSet<SqlTypeName>> mapping = new HashMap(rules.getTypeMapping());
+      mapping.replace(SqlTypeName.ARRAY, arrayMapping);
+      rules = SqlTypeCoercionRule.instance(mapping);
+
+      SqlTypeCoercionRule.THREAD_PROVIDERS.set(rules);
+    } else if (config.typeCoercionRules() != null) {
       SqlTypeCoercionRule.THREAD_PROVIDERS.set(config.typeCoercionRules());
     }
   }
@@ -340,6 +367,10 @@ public SqlConformance getConformance() {
     return unknownType;
   }
 
+  @Override public TimeFrameSet getTimeFrameSet() {
+    return timeFrameSet;
+  }
+
   @Override public SqlNodeList expandStar(
       SqlNodeList selectList,
       SqlSelect select,
@@ -379,7 +410,7 @@ public SqlConformance getConformance() {
     SelectScope cursorScope = new SelectScope(parentScope, null, select);
     clauseScopes.put(IdPair.of(select, Clause.CURSOR), cursorScope);
     final SelectNamespace selectNs = createSelectNamespace(select, select);
-    String alias = deriveAlias(select, nextGeneratedId++);
+    final String alias = SqlValidatorUtil.alias(select, nextGeneratedId++);
     registerNamespace(cursorScope, alias, selectNs, false);
   }
 
@@ -433,17 +464,13 @@ private boolean expandSelectItem(
     // calls.
     SqlNode expanded = expandSelectExpr(selectItem, scope, select);
     final String alias =
-        deriveAliasNonNull(
-            selectItem,
-            aliases.size());
+        SqlValidatorUtil.alias(selectItem, aliases.size());
 
     // If expansion has altered the natural alias, supply an explicit 'AS'.
     final SqlValidatorScope selectScope = getSelectScope(select);
     if (expanded != selectItem) {
       String newAlias =
-          deriveAliasNonNull(
-              expanded,
-              aliases.size());
+          SqlValidatorUtil.alias(expanded, aliases.size());
       if (!Objects.equals(newAlias, alias)) {
         expanded =
             SqlStdOperatorTable.AS.createCall(
@@ -457,10 +484,19 @@ private boolean expandSelectItem(
     selectItems.add(expanded);
     aliases.add(alias);
 
-    if (expanded != null) {
-      inferUnknownTypes(targetType, scope, expanded);
+    inferUnknownTypes(targetType, selectScope, expanded);
+
+    RelDataType type = deriveType(selectScope, expanded);
+    // Re-derive SELECT ITEM's data type that may be nullable in
+    // AggregatingSelectScope when it appears in advanced grouping elements such
+    // as CUBE, ROLLUP, GROUPING SETS. For example, in
+    //   SELECT CASE WHEN c = 1 THEN '1' ELSE '23' END AS x
+    //   FROM t
+    //   GROUP BY CUBE(x)
+    // the 'x' should be nullable even if x's literal values are not null.
+    if (selectScope instanceof AggregatingSelectScope) {
+      type = requireNonNull(selectScope.nullifyType(stripAs(expanded), type));
     }
-    final RelDataType type = deriveType(selectScope, expanded);
     setValidatedNodeType(expanded, type);
     fields.add(Pair.of(alias, type));
     return false;
@@ -477,8 +513,7 @@ private static SqlNode expandExprFromJoin(SqlJoin join, SqlIdentifier identifier
       if (identifier.getSimple().equals(name)) {
         final List<SqlNode> qualifiedNode = new ArrayList<>();
         for (ScopeChild child : requireNonNull(scope, "scope").children) {
-          if (child.namespace.getRowType()
-              .getFieldNames().indexOf(name) >= 0) {
+          if (child.namespace.getRowType().getFieldNames().contains(name)) {
             final SqlIdentifier exp =
                 new SqlIdentifier(
                     ImmutableList.of(child.name, name),
@@ -513,27 +548,26 @@ private static SqlNode expandExprFromJoin(SqlJoin join, SqlIdentifier identifier
   public @Nullable List<String> usingNames(SqlJoin join) {
     switch (join.getConditionType()) {
     case USING:
-      final ImmutableList.Builder<String> list = ImmutableList.builder();
-      final Set<String> names = catalogReader.nameMatcher().createSet();
-      for (String name
-          : SqlIdentifier.simpleNames((SqlNodeList) getCondition(join))) {
-        if (names.add(name)) {
-          list.add(name);
-        }
-      }
-      return list.build();
+      SqlNodeList condition = (SqlNodeList) getCondition(join);
+      List<String> simpleNames = SqlIdentifier.simpleNames(condition);
+      return catalogReader.nameMatcher().distinctCopy(simpleNames);
+
     case NONE:
       if (join.isNatural()) {
-        final RelDataType t0 = getValidatedNodeType(join.getLeft());
-        final RelDataType t1 = getValidatedNodeType(join.getRight());
-        return SqlValidatorUtil.deriveNaturalJoinColumnList(
-            catalogReader.nameMatcher(), t0, t1);
+        return deriveNaturalJoinColumnList(join);
       }
-      break;
+      return null;
+
     default:
-      break;
+      return null;
     }
-    return null;
+  }
+
+  private List<String> deriveNaturalJoinColumnList(SqlJoin join) {
+    return SqlValidatorUtil.deriveNaturalJoinColumnList(
+        catalogReader.nameMatcher(),
+        getNamespaceOrThrow(join.getLeft()).getRowType(),
+        getNamespaceOrThrow(join.getRight()).getRowType());
   }
 
   private static SqlNode expandCommonColumn(SqlSelect sqlSelect,
@@ -659,8 +693,9 @@ private boolean expandStar(List<SqlNode> selectItems, Set<String> aliases,
       // If NATURAL JOIN or USING is present, move key fields to the front of
       // the list, per standard SQL. Disabled if there are dynamic fields.
       if (!hasDynamicStruct || Bug.CALCITE_2400_FIXED) {
-        SqlNode from = requireNonNull(scope.getNode().getFrom(),
-            () -> "getFrom for " + scope.getNode());
+        SqlNode from =
+            requireNonNull(scope.getNode().getFrom(),
+                () -> "getFrom for " + scope.getNode());
         new Permute(from, 0).permute(selectItems, fields);
       }
       return true;
@@ -1444,7 +1479,7 @@ private void handleOffsetFetch(@Nullable SqlNode offset, @Nullable SqlNode fetch
         orderList = orderBy.orderList;
       }
       return new SqlSelect(SqlParserPos.ZERO, null, selectList, orderBy.query,
-          null, null, null, null, orderList, orderBy.offset,
+          null, null, null, null, null, orderList, orderBy.offset,
           orderBy.fetch, null);
     }
 
@@ -1454,7 +1489,7 @@ private void handleOffsetFetch(@Nullable SqlNode offset, @Nullable SqlNode fetch
       final SqlNodeList selectList = new SqlNodeList(SqlParserPos.ZERO);
       selectList.add(SqlIdentifier.star(SqlParserPos.ZERO));
       return new SqlSelect(SqlParserPos.ZERO, null, selectList, call.operand(0),
-          null, null, null, null, null, null, null, null);
+          null, null, null, null, null, null, null, null, null);
     }
 
     case DELETE: {
@@ -1551,7 +1586,7 @@ private static void rewriteMerge(SqlMerge call) {
             call.getCondition());
     SqlSelect select =
         new SqlSelect(SqlParserPos.ZERO, null, selectList, outerJoin, null,
-            null, null, null, null, null, null, null);
+            null, null, null, null, null, null, null, null);
     call.setSourceSelect(select);
 
     // Source for the insert call is a select of the source table
@@ -1569,7 +1604,7 @@ private static void rewriteMerge(SqlMerge call) {
       final SqlNode insertSource = SqlNode.clone(sourceTableRef);
       select =
           new SqlSelect(SqlParserPos.ZERO, null, selectList, insertSource, null,
-              null, null, null, null, null, null, null);
+              null, null, null, null, null, null, null, null);
       insertCall.setSource(select);
     }
   }
@@ -1636,7 +1671,7 @@ private SqlNode rewriteUpdateToMerge(
     }
     source =
         new SqlSelect(SqlParserPos.ZERO, null, selectList, source, null, null,
-            null, null, null, null, null, null);
+            null, null, null, null, null, null, null);
     source = SqlValidatorUtil.addAlias(source, UPDATE_SRC_ALIAS);
     SqlMerge mergeCall =
         new SqlMerge(updateCall.getParserPosition(), target, condition, source,
@@ -1692,7 +1727,7 @@ protected SqlSelect createSourceSelectForUpdate(SqlUpdate call) {
               alias.getSimple());
     }
     return new SqlSelect(SqlParserPos.ZERO, null, selectList, sourceTable,
-        call.getCondition(), null, null, null, null, null, null, null);
+        call.getCondition(), null, null, null, null, null, null, null, null);
   }
 
   /**
@@ -1714,7 +1749,7 @@ protected SqlSelect createSourceSelectForDelete(SqlDelete call) {
               alias.getSimple());
     }
     return new SqlSelect(SqlParserPos.ZERO, null, selectList, sourceTable,
-        call.getCondition(), null, null, null, null, null, null, null);
+        call.getCondition(), null, null, null, null, null, null, null, null);
   }
 
   /**
@@ -1736,7 +1771,7 @@ protected SqlSelect createSourceSelectForDelete(SqlDelete call) {
       final List<String> aliasList = new ArrayList<>();
       final List<RelDataType> typeList = new ArrayList<>();
       for (Ord<SqlNode> column : Ord.zip(rowConstructor.getOperandList())) {
-        final String alias = deriveAliasNonNull(column.e, column.i);
+        final String alias = SqlValidatorUtil.alias(column.e, column.i);
         aliasList.add(alias);
         final RelDataType type = deriveType(scope, column.e);
         typeList.add(type);
@@ -2021,9 +2056,9 @@ protected void inferUnknownTypes(
         inferUnknownTypes(returnType, scope, sqlNode);
       }
 
-      SqlNode elseOperand = requireNonNull(
-          caseCall.getElseOperand(),
-          () -> "elseOperand for " + caseCall);
+      SqlNode elseOperand =
+          requireNonNull(caseCall.getElseOperand(),
+              () -> "elseOperand for " + caseCall);
       if (!SqlUtil.isNullLiteral(elseOperand, false)) {
         inferUnknownTypes(
             returnType,
@@ -2071,7 +2106,7 @@ protected void addToSelectList(
       SqlNode exp,
       SelectScope scope,
       final boolean includeSystemVars) {
-    String alias = SqlValidatorUtil.getAlias(exp, -1);
+    final @Nullable String alias = SqlValidatorUtil.alias(exp);
     String uniqueAlias =
         SqlValidatorUtil.uniquify(
             alias, aliases, SqlValidatorUtil.EXPR_SUGGESTER);
@@ -2085,13 +2120,8 @@ protected void addToSelectList(
   @Override public @Nullable String deriveAlias(
       SqlNode node,
       int ordinal) {
-    return SqlValidatorUtil.getAlias(node, ordinal);
-  }
-
-  private String deriveAliasNonNull(SqlNode node, int ordinal) {
-    return requireNonNull(
-        deriveAlias(node, ordinal),
-        () -> "non-null alias expected for node = " + node + ", ordinal = " + ordinal);
+    return ordinal < 0 ? SqlValidatorUtil.alias(node)
+        : SqlValidatorUtil.alias(node, ordinal);
   }
 
   protected boolean shouldAllowIntermediateOrderBy() {
@@ -2116,8 +2146,9 @@ private void registerMatchRecognize(
 
     // parse input query
     SqlNode expr = call.getTableRef();
-    SqlNode newExpr = registerFrom(usingScope, matchRecognizeScope, true, expr,
-        expr, null, null, forceNullable, false);
+    SqlNode newExpr =
+        registerFrom(usingScope, matchRecognizeScope, true, expr,
+            expr, null, null, forceNullable, false);
     if (expr != newExpr) {
       call.setOperand(0, newExpr);
     }
@@ -2146,8 +2177,9 @@ private void registerPivot(
 
     // parse input query
     SqlNode expr = pivot.query;
-    SqlNode newExpr = registerFrom(parentScope, scope, true, expr,
-        expr, null, null, forceNullable, false);
+    SqlNode newExpr =
+        registerFrom(parentScope, scope, true, expr,
+            expr, null, null, forceNullable, false);
     if (expr != newExpr) {
       pivot.setOperand(0, newExpr);
     }
@@ -2175,8 +2207,9 @@ private void registerUnpivot(
 
     // parse input query
     SqlNode expr = call.query;
-    SqlNode newExpr = registerFrom(parentScope, scope, true, expr,
-        expr, null, null, forceNullable, false);
+    SqlNode newExpr =
+        registerFrom(parentScope, scope, true, expr,
+            expr, null, null, forceNullable, false);
     if (expr != newExpr) {
       call.setOperand(0, newExpr);
     }
@@ -2263,9 +2296,9 @@ private SqlNode registerFrom(
       switch (kind) {
       case IDENTIFIER:
       case OVER:
-        alias = deriveAlias(node, -1);
+        alias = SqlValidatorUtil.alias(node);
         if (alias == null) {
-          alias = deriveAliasNonNull(node, nextGeneratedId++);
+          alias = SqlValidatorUtil.alias(node, nextGeneratedId++);
         }
         if (config.identifierExpansion()) {
           newNode = SqlValidatorUtil.addAlias(node, alias);
@@ -2286,7 +2319,7 @@ private SqlNode registerFrom(
 
         // give this anonymous construct a name since later
         // query processing stages rely on it
-        alias = deriveAliasNonNull(node, nextGeneratedId++);
+        alias = SqlValidatorUtil.alias(node, nextGeneratedId++);
         if (config.identifierExpansion()) {
           // Since we're expanding identifiers, we should make the
           // aliases explicit too, otherwise the expanded query
@@ -2326,18 +2359,14 @@ private SqlNode registerFrom(
         alias = String.valueOf(call.operand(1));
       }
       expr = call.operand(0);
-      final boolean needAlias = call.operandCount() > 2
+      final boolean needAliasNamespace = call.operandCount() > 2
           || expr.getKind() == SqlKind.VALUES
-          || expr.getKind() == SqlKind.UNNEST
-          && (((SqlCall) expr).operand(0).getKind()
-                  == SqlKind.ARRAY_VALUE_CONSTRUCTOR
-              || ((SqlCall) expr).operand(0).getKind()
-                  == SqlKind.MULTISET_VALUE_CONSTRUCTOR);
+          || expr.getKind() == SqlKind.UNNEST;
       newExpr =
           registerFrom(
               parentScope,
               usingScope,
-              !needAlias,
+              !needAliasNamespace,
               expr,
               enclosingNode,
               alias,
@@ -2350,7 +2379,7 @@ private SqlNode registerFrom(
 
       // If alias has a column list, introduce a namespace to translate
       // column names. We skipped registering it just now.
-      if (needAlias) {
+      if (needAliasNamespace) {
         registerNamespace(
             usingScope,
             alias,
@@ -2525,7 +2554,7 @@ private SqlNode registerFrom(
     case WITH:
     case OTHER_FUNCTION:
       if (alias == null) {
-        alias = deriveAliasNonNull(node, nextGeneratedId++);
+        alias = SqlValidatorUtil.alias(node, nextGeneratedId++);
       }
       registerQuery(
           parentScope,
@@ -2597,16 +2626,16 @@ private SqlNode registerFrom(
     case SNAPSHOT:
       call = (SqlCall) node;
       operand = call.operand(0);
-      newOperand = registerFrom(
-          parentScope,
-          usingScope,
-          register,
-          operand,
-          enclosingNode,
-          alias,
-          extendList,
-          forceNullable,
-          lateral);
+      newOperand =
+          registerFrom(parentScope,
+              usingScope,
+              register,
+              operand,
+              enclosingNode,
+              alias,
+              extendList,
+              forceNullable,
+              lateral);
       if (newOperand != operand) {
         call.setOperand(0, newOperand);
       }
@@ -2727,6 +2756,12 @@ private void registerQuery(
           select,
           SqlSelect.WHERE_OPERAND);
 
+      // Register subqueries in the QUALIFY clause
+      registerOperandSubQueries(
+          selectScope,
+          select,
+          SqlSelect.QUALIFY_OPERAND);
+
       // Register FROM with the inherited scope 'parentScope', not
       // 'selectScope', otherwise tables in the FROM clause would be
       // able to see each other.
@@ -2994,7 +3029,7 @@ private void registerQuery(
       CollectScope cs = new CollectScope(parentScope, usingScope, call);
       final CollectNamespace tableConstructorNs =
           new CollectNamespace(call, cs, enclosingNode);
-      final String alias2 = deriveAliasNonNull(node, nextGeneratedId++);
+      final String alias2 = SqlValidatorUtil.alias(node, nextGeneratedId++);
       registerNamespace(
           usingScope,
           alias2,
@@ -3281,8 +3316,9 @@ private void registerOperandSubQueries(
         validateIntervalQualifier(intervalQualifier);
         String intervalStr = interval.getIntervalLiteral();
         // throws CalciteContextException if string is invalid
-        int[] values = intervalQualifier.evaluateIntervalLiteral(intervalStr,
-            literal.getParserPosition(), typeFactory.getTypeSystem());
+        int[] values =
+            intervalQualifier.evaluateIntervalLiteral(intervalStr,
+                literal.getParserPosition(), typeFactory.getTypeSystem());
         Util.discard(values);
       }
       break;
@@ -3336,6 +3372,21 @@ private void validateLiteralAsDouble(SqlLiteral literal) {
     }
   }
 
+  @Override public TimeFrame validateTimeFrame(SqlIntervalQualifier qualifier) {
+    if (qualifier.timeFrameName == null) {
+      final TimeFrame timeFrame = timeFrameSet.get(qualifier.getUnit());
+      return requireNonNull(timeFrame,
+          () -> "time frame for " + qualifier.getUnit());
+    }
+    final @Nullable TimeFrame timeFrame =
+        timeFrameSet.getOpt(qualifier.timeFrameName);
+    if (timeFrame != null) {
+      return timeFrame;
+    }
+    throw newValidationError(qualifier,
+        RESOURCE.invalidTimeFrame(qualifier.timeFrameName));
+  }
+
   /**
    * Validates the FROM clause of a query, or (recursively) a child node of
    * the FROM clause: AS, OVER, JOIN, VALUES, or sub-query.
@@ -3371,6 +3422,9 @@ protected void validateFrom(
     case UNNEST:
       validateUnnest((SqlCall) node, scope, targetRowType);
       break;
+    case COLLECTION_TABLE:
+      validateTableFunction((SqlCall) node, scope, targetRowType);
+      break;
     default:
       validateQuery(node, scope, targetRowType);
       break;
@@ -3381,6 +3435,65 @@ protected void validateFrom(
     getNamespaceOrThrow(node, scope).validate(targetRowType);
   }
 
+  protected void validateTableFunction(SqlCall node, SqlValidatorScope scope,
+      RelDataType targetRowType) {
+    // Dig out real call; TABLE() wrapper is just syntactic.
+    SqlCall call = node.operand(0);
+    if (call.getOperator() instanceof SqlTableFunction) {
+      SqlTableFunction tableFunction = (SqlTableFunction) call.getOperator();
+      boolean visitedRowSemanticsTable = false;
+      for (int idx = 0; idx < call.operandCount(); idx++) {
+        TableCharacteristic tableCharacteristic = tableFunction.tableCharacteristic(idx);
+        if (tableCharacteristic != null) {
+          // Skip validate if current input table has set semantics
+          if (tableCharacteristic.semantics == TableCharacteristic.Semantics.SET) {
+            continue;
+          }
+          // A table function at most has one input table with row semantics
+          if (visitedRowSemanticsTable) {
+            throw newValidationError(
+                call,
+                RESOURCE.multipleRowSemanticsTables(call.getOperator().getName()));
+          }
+          visitedRowSemanticsTable = true;
+        }
+        // If table function defines the parameter is not table parameter, or is an input table
+        // parameter with row semantics, then it should not be with PARTITION BY OR ORDER BY.
+        SqlNode currentNode = call.operand(idx);
+        if (currentNode instanceof SqlCall) {
+          SqlOperator op = ((SqlCall) currentNode).getOperator();
+          if (op == SqlStdOperatorTable.ARGUMENT_ASSIGNMENT) {
+            // Dig out the underlying operand
+            SqlNode realNode = ((SqlBasicCall) currentNode).operand(0);
+            if (realNode instanceof SqlCall) {
+              currentNode = realNode;
+              op = ((SqlCall) realNode).getOperator();
+            }
+          }
+          if (op == SqlStdOperatorTable.SET_SEMANTICS_TABLE) {
+            throwInvalidRowSemanticsTable(call, idx, (SqlCall) currentNode);
+          }
+        }
+      }
+    }
+    validateQuery(node, scope, targetRowType);
+  }
+
+  private void throwInvalidRowSemanticsTable(SqlCall call, int idx, SqlCall table) {
+    SqlNodeList partitionList = table.operand(1);
+    if (!partitionList.isEmpty()) {
+      throw newValidationError(call,
+          RESOURCE.invalidPartitionKeys(
+              idx, call.getOperator().getName()));
+    }
+    SqlNodeList orderList = table.operand(2);
+    if (!orderList.isEmpty()) {
+      throw newValidationError(call,
+          RESOURCE.invalidOrderBy(
+              idx, call.getOperator().getName()));
+    }
+  }
+
   protected void validateOver(SqlCall call, SqlValidatorScope scope) {
     throw new AssertionError("OVER unexpected in this context");
   }
@@ -3411,10 +3524,9 @@ private void checkRollUpInUsing(SqlIdentifier identifier,
   }
 
   protected void validateJoin(SqlJoin join, SqlValidatorScope scope) {
-    SqlNode left = join.getLeft();
-    SqlNode right = join.getRight();
-    SqlNode condition = join.getCondition();
-    boolean natural = join.isNatural();
+    final SqlNode left = join.getLeft();
+    final SqlNode right = join.getRight();
+    final boolean natural = join.isNatural();
     final JoinType joinType = join.getJoinType();
     final JoinConditionType conditionType = join.getConditionType();
     final SqlValidatorScope joinScope = getScopeOrThrow(join); // getJoinScope?
@@ -3424,32 +3536,22 @@ protected void validateJoin(SqlJoin join, SqlValidatorScope scope) {
     // Validate condition.
     switch (conditionType) {
     case NONE:
-      Preconditions.checkArgument(condition == null);
+      Preconditions.checkArgument(join.getCondition() == null);
       break;
     case ON:
-      requireNonNull(condition, "join.getCondition()");
-      SqlNode expandedCondition = expand(condition, joinScope);
-      join.setOperand(5, expandedCondition);
-      condition = getCondition(join);
+      final SqlNode condition = expand(getCondition(join), joinScope);
+      join.setOperand(5, condition);
       validateWhereOrOn(joinScope, condition, "ON");
       checkRollUp(null, join, condition, joinScope, "ON");
       break;
     case USING:
-      SqlNodeList list = (SqlNodeList) requireNonNull(condition, "join.getCondition()");
+      @SuppressWarnings({"rawtypes", "unchecked"}) List<SqlIdentifier> list =
+          (List) getCondition(join);
 
       // Parser ensures that using clause is not empty.
-      Preconditions.checkArgument(list.size() > 0, "Empty USING clause");
-      for (SqlNode node : list) {
-        SqlIdentifier id = (SqlIdentifier) node;
-        final RelDataType leftColType = validateUsingCol(id, left);
-        final RelDataType rightColType = validateUsingCol(id, right);
-        if (!SqlTypeUtil.isComparable(leftColType, rightColType)) {
-          throw newValidationError(id,
-              RESOURCE.naturalOrUsingColumnNotCompatible(id.getSimple(),
-                  leftColType.toString(), rightColType.toString()));
-        }
-        checkRollUpInUsing(id, left, scope);
-        checkRollUpInUsing(id, right, scope);
+      Preconditions.checkArgument(!list.isEmpty(), "Empty USING clause");
+      for (SqlIdentifier id : list) {
+        validateCommonJoinColumn(id, left, right, scope, natural);
       }
       break;
     default:
@@ -3458,33 +3560,17 @@ protected void validateJoin(SqlJoin join, SqlValidatorScope scope) {
 
     // Validate NATURAL.
     if (natural) {
-      if (condition != null) {
-        throw newValidationError(condition,
+      if (join.getCondition() != null) {
+        throw newValidationError(getCondition(join),
             RESOURCE.naturalDisallowsOnOrUsing());
       }
 
-      // Join on fields that occur exactly once on each side. Ignore
-      // fields that occur more than once on either side.
-      final RelDataType leftRowType = getNamespaceOrThrow(left).getRowType();
-      final RelDataType rightRowType = getNamespaceOrThrow(right).getRowType();
-      final SqlNameMatcher nameMatcher = catalogReader.nameMatcher();
-      List<String> naturalColumnNames =
-          SqlValidatorUtil.deriveNaturalJoinColumnList(nameMatcher,
-              leftRowType, rightRowType);
-
+      // Join on fields that occur on each side.
       // Check compatibility of the chosen columns.
-      for (String name : naturalColumnNames) {
-        final RelDataType leftColType = requireNonNull(
-            nameMatcher.field(leftRowType, name),
-            () -> "unable to find left field " + name + " in " + leftRowType).getType();
-        final RelDataType rightColType = requireNonNull(
-            nameMatcher.field(rightRowType, name),
-            () -> "unable to find right field " + name + " in " + rightRowType).getType();
-        if (!SqlTypeUtil.isComparable(leftColType, rightColType)) {
-          throw newValidationError(join,
-              RESOURCE.naturalOrUsingColumnNotCompatible(name,
-                  leftColType.toString(), rightColType.toString()));
-        }
+      for (String name : deriveNaturalJoinColumnList(join)) {
+        final SqlIdentifier id =
+            new SqlIdentifier(name, join.isNaturalNode().getParserPosition());
+        validateCommonJoinColumn(id, left, right, scope, natural);
       }
     }
 
@@ -3501,13 +3587,13 @@ protected void validateJoin(SqlJoin join, SqlValidatorScope scope) {
     case LEFT:
     case RIGHT:
     case FULL:
-      if ((condition == null) && !natural) {
+      if ((join.getCondition() == null) && !natural) {
         throw newValidationError(join, RESOURCE.joinRequiresCondition());
       }
       break;
     case COMMA:
     case CROSS:
-      if (condition != null) {
+      if (join.getCondition() != null) {
         throw newValidationError(join.getConditionTypeNode(),
             RESOURCE.crossJoinDisallowsCondition());
       }
@@ -3548,22 +3634,62 @@ private void validateNoAggs(AggFinder aggFinder, SqlNode node,
     }
   }
 
-  private RelDataType validateUsingCol(SqlIdentifier id, SqlNode leftOrRight) {
-    if (id.names.size() == 1) {
-      String name = id.names.get(0);
-      final SqlValidatorNamespace namespace = getNamespaceOrThrow(leftOrRight);
-      final RelDataType rowType = namespace.getRowType();
-      final SqlNameMatcher nameMatcher = catalogReader.nameMatcher();
-      final RelDataTypeField field = nameMatcher.field(rowType, name);
-      if (field != null) {
-        if (nameMatcher.frequency(rowType.getFieldNames(), name) > 1) {
-          throw newValidationError(id,
-              RESOURCE.columnInUsingNotUnique(id.toString()));
-        }
-        return field.getType();
+  /** Validates a column in a USING clause, or an inferred join key in a NATURAL join. */
+  private void validateCommonJoinColumn(SqlIdentifier id, SqlNode left,
+      SqlNode right, SqlValidatorScope scope, boolean natural) {
+    if (id.names.size() != 1) {
+      throw newValidationError(id, RESOURCE.columnNotFound(id.toString()));
+    }
+
+    final RelDataType leftColType = natural
+        ? checkAndDeriveDataType(id, left)
+        : validateCommonInputJoinColumn(id, left, scope, natural);
+    final RelDataType rightColType = validateCommonInputJoinColumn(id, right, scope, natural);
+    if (!SqlTypeUtil.isComparable(leftColType, rightColType)) {
+      throw newValidationError(id,
+          RESOURCE.naturalOrUsingColumnNotCompatible(id.getSimple(),
+              leftColType.toString(), rightColType.toString()));
+    }
+  }
+
+  private RelDataType checkAndDeriveDataType(SqlIdentifier id, SqlNode node) {
+    Preconditions.checkArgument(id.names.size() == 1);
+    String name = id.names.get(0);
+    SqlNameMatcher nameMatcher = getCatalogReader().nameMatcher();
+    RelDataType rowType = getNamespaceOrThrow(node).getRowType();
+    final RelDataTypeField field =
+        requireNonNull(nameMatcher.field(rowType, name),
+            () -> "unable to find left field " + name + " in " + rowType);
+    return field.getType();
+  }
+
+  /** Validates a column in a USING clause, or an inferred join key in a
+   * NATURAL join, in the left or right input to the join. */
+  private RelDataType validateCommonInputJoinColumn(SqlIdentifier id,
+      SqlNode leftOrRight, SqlValidatorScope scope, boolean natural) {
+    Preconditions.checkArgument(id.names.size() == 1);
+    final String name = id.names.get(0);
+    final SqlValidatorNamespace namespace = getNamespaceOrThrow(leftOrRight);
+    final RelDataType rowType = namespace.getRowType();
+    final SqlNameMatcher nameMatcher = catalogReader.nameMatcher();
+    final RelDataTypeField field = nameMatcher.field(rowType, name);
+    if (field == null) {
+      throw newValidationError(id, RESOURCE.columnNotFound(name));
+    }
+    Collection<RelDataType> rowTypes;
+    if (!natural && rowType instanceof RelCrossType) {
+      final RelCrossType crossType = (RelCrossType) rowType;
+      rowTypes = new ArrayList<>(crossType.getTypes());
+    } else {
+      rowTypes = Collections.singleton(rowType);
+    }
+    for (RelDataType rowType0 : rowTypes) {
+      if (nameMatcher.frequency(rowType0.getFieldNames(), name) > 1) {
+        throw newValidationError(id, RESOURCE.columnInUsingNotUnique(name));
       }
     }
-    throw newValidationError(id, RESOURCE.columnNotFound(id.toString()));
+    checkRollUpInUsing(id, leftOrRight, scope);
+    return field.getType();
   }
 
   /**
@@ -3611,8 +3737,9 @@ protected void validateSelect(
     }
 
     // Make sure that items in FROM clause have distinct aliases.
-    final SelectScope fromScope = (SelectScope) requireNonNull(getFromScope(select),
-        () -> "fromScope for " + select);
+    final SelectScope fromScope =
+        (SelectScope) requireNonNull(getFromScope(select),
+            () -> "fromScope for " + select);
     List<@Nullable String> names = fromScope.getChildNames();
     if (!catalogReader.nameMatcher().isCaseSensitive()) {
       //noinspection RedundantTypeArguments
@@ -3643,6 +3770,7 @@ protected void validateSelect(
     validateGroupClause(select);
     validateHavingClause(select);
     validateWindowClause(select);
+    validateQualifyClause(select);
     handleOffsetFetch(select.getOffset(), select.getFetch());
 
     // Validate the SELECT clause late, because a select item might
@@ -3710,35 +3838,51 @@ private void checkRollUpInWindowDecl(SqlSelect select) {
     }
   }
 
-  private static @Nullable SqlNode stripDot(@Nullable SqlNode node) {
-    if (node != null && node.getKind() == SqlKind.DOT) {
-      return stripDot(((SqlCall) node).operand(0));
+  /**
+   * If the {@code node} is a DOT call, returns its first operand. Recurse, if
+   * the first operand is another DOT call.
+   *
+   * <p>In other words, it converts {@code a DOT b DOT c} to {@code a}.
+   *
+   * @param node The node to strip DOT
+   * @return the DOT's first operand
+   */
+  private static SqlNode stripDot(SqlNode node) {
+    SqlNode res = node;
+    while (res.getKind() == SqlKind.DOT) {
+      res = requireNonNull(((SqlCall) res).operand(0), "operand");
     }
-    return node;
+    return res;
   }
 
   private void checkRollUp(@Nullable SqlNode grandParent, @Nullable SqlNode parent,
-      @Nullable SqlNode current, SqlValidatorScope scope, @Nullable String optionalClause) {
+      @Nullable SqlNode current, SqlValidatorScope scope, @Nullable String contextClause) {
     current = stripAs(current);
     if (current instanceof SqlCall && !(current instanceof SqlSelect)) {
       // Validate OVER separately
       checkRollUpInWindow(getWindowInOver(current), scope);
       current = stripOver(current);
 
-      SqlNode stripDot = requireNonNull(stripDot(current), "stripDot(current)");
-      List<? extends @Nullable SqlNode> children =
-          ((SqlCall) stripAs(stripDot)).getOperandList();
-      for (SqlNode child : children) {
-        checkRollUp(parent, current, child, scope, optionalClause);
+      SqlNode stripDot = stripDot(current);
+      if (stripDot != current) {
+        // we stripped the field access. Recurse to this method, the DOT's operand
+        // can be another SqlCall, or an SqlIdentifier.
+        checkRollUp(grandParent, parent, stripDot, scope, contextClause);
+      } else {
+        List<? extends @Nullable SqlNode> children = ((SqlCall) stripDot).getOperandList();
+        for (SqlNode child : children) {
+          checkRollUp(parent, current, child, scope, contextClause);
+        }
       }
     } else if (current instanceof SqlIdentifier) {
       SqlIdentifier id = (SqlIdentifier) current;
       if (!id.isStar() && isRolledUpColumn(id, scope)) {
         if (!isAggregation(requireNonNull(parent, "parent").getKind())
             || !isRolledUpColumnAllowedInAgg(id, scope, (SqlCall) parent, grandParent)) {
-          String context = optionalClause != null ? optionalClause : parent.getKind().toString();
+          String context = contextClause != null ? contextClause : parent.getKind().toString();
           throw newValidationError(id,
-              RESOURCE.rolledUpNotAllowed(deriveAliasNonNull(id, 0), context));
+              RESOURCE.rolledUpNotAllowed(SqlValidatorUtil.alias(id, 0),
+                  context));
         }
       }
     }
@@ -4012,14 +4156,16 @@ protected void validateWindowClause(SqlSelect select) {
       return;
     }
 
-    final SelectScope windowScope = (SelectScope) requireNonNull(getFromScope(select),
-        () -> "fromScope for " + select);
+    final SelectScope windowScope =
+        (SelectScope) requireNonNull(getFromScope(select),
+            () -> "fromScope for " + select);
 
     // 1. ensure window names are simple
     // 2. ensure they are unique within this scope
     for (SqlWindow window : (List<SqlWindow>) (List) windowList) {
-      SqlIdentifier declName = requireNonNull(window.getDeclName(),
-          () -> "window.getDeclName() for " + window);
+      SqlIdentifier declName =
+          requireNonNull(window.getDeclName(),
+              () -> "window.getDeclName() for " + window);
       if (!declName.isSimple()) {
         throw newValidationError(declName, RESOURCE.windowNameMustBeSimple());
       }
@@ -4059,6 +4205,36 @@ protected void validateWindowClause(SqlSelect select) {
     windowList.validate(this, windowScope);
   }
 
+  protected void validateQualifyClause(SqlSelect select) {
+    SqlNode qualifyNode = select.getQualify();
+    if (qualifyNode == null) {
+      return;
+    }
+
+    SqlValidatorScope qualifyScope = getSelectScope(select);
+
+    qualifyNode = extendedExpand(qualifyNode, qualifyScope, select, Clause.QUALIFY);
+    select.setQualify(qualifyNode);
+
+    inferUnknownTypes(
+        booleanType,
+        qualifyScope,
+        qualifyNode);
+
+    qualifyNode.validate(this, qualifyScope);
+
+    final RelDataType type = deriveType(qualifyScope, qualifyNode);
+    if (!SqlTypeUtil.inBooleanFamily(type)) {
+      throw newValidationError(qualifyNode, RESOURCE.condMustBeBoolean("QUALIFY"));
+    }
+
+    boolean qualifyContainsWindowFunction = overFinder.findAgg(qualifyNode) != null;
+    if (!qualifyContainsWindowFunction) {
+      throw newValidationError(qualifyNode,
+          RESOURCE.qualifyExpressionMustContainWindowFunction(qualifyNode.toString()));
+    }
+  }
+
   @Override public void validateWith(SqlWith with, SqlValidatorScope scope) {
     final SqlValidatorNamespace namespace = getNamespaceOrThrow(with);
     validateNamespace(namespace, unknownType);
@@ -4157,9 +4333,8 @@ protected void validateOrderList(SqlSelect select) {
       expandList.add(expandedOrderItem);
     }
 
-    SqlNodeList expandedOrderList = new SqlNodeList(
-        expandList,
-        orderList.getParserPosition());
+    SqlNodeList expandedOrderList =
+        new SqlNodeList(expandList, orderList.getParserPosition());
     select.setOrderBy(expandedOrderList);
 
     for (SqlNode orderItem : expandedOrderList) {
@@ -4182,10 +4357,16 @@ private void validateGroupByItem(SqlSelect select, SqlNode groupByItem) {
   private void validateGroupByExpr(SqlNode groupByItem,
       SqlValidatorScope groupByScope) {
     switch (groupByItem.getKind()) {
+    case GROUP_BY_DISTINCT:
+      SqlCall call = (SqlCall) groupByItem;
+      for (SqlNode operand : call.getOperandList()) {
+        validateGroupByExpr(operand, groupByScope);
+      }
+      break;
     case GROUPING_SETS:
     case ROLLUP:
     case CUBE:
-      final SqlCall call = (SqlCall) groupByItem;
+      call = (SqlCall) groupByItem;
       for (SqlNode operand : call.getOperandList()) {
         validateExpr(operand, groupByScope);
       }
@@ -4245,7 +4426,8 @@ protected void validateGroupClause(SqlSelect select) {
     // expand the expression in group list.
     List<SqlNode> expandedList = new ArrayList<>();
     for (SqlNode groupItem : groupList) {
-      SqlNode expandedItem = expandGroupByOrHavingExpr(groupItem, groupScope, select, false);
+      SqlNode expandedItem =
+          extendedExpand(groupItem, groupScope, select, Clause.GROUP_BY);
       expandedList.add(expandedItem);
     }
     groupList = new SqlNodeList(expandedList, groupList.getParserPosition());
@@ -4260,6 +4442,7 @@ protected void validateGroupClause(SqlSelect select) {
     // expressions, because they do not have a type.
     for (SqlNode node : groupList) {
       switch (node.getKind()) {
+      case GROUP_BY_DISTINCT:
       case GROUPING_SETS:
       case ROLLUP:
       case CUBE:
@@ -4296,6 +4479,11 @@ private void validateGroupItem(SqlValidatorScope groupScope,
       @Nullable AggregatingSelectScope aggregatingScope,
       SqlNode groupItem) {
     switch (groupItem.getKind()) {
+    case GROUP_BY_DISTINCT:
+      for (SqlNode sqlNode : ((SqlCall) groupItem).getOperandList()) {
+        validateGroupItem(groupScope, aggregatingScope, sqlNode);
+      }
+      break;
     case GROUPING_SETS:
     case ROLLUP:
     case CUBE:
@@ -4346,7 +4534,7 @@ protected void validateWhereOrOn(
     }
   }
 
-  private boolean isReturnBooleanType(RelDataType relDataType) {
+  private static boolean isReturnBooleanType(RelDataType relDataType) {
     if (relDataType instanceof RelRecordType) {
       RelRecordType recordType = (RelRecordType) relDataType;
       Preconditions.checkState(recordType.getFieldList().size() == 1,
@@ -4369,7 +4557,7 @@ protected void validateHavingClause(SqlSelect select) {
     final AggregatingScope havingScope =
         (AggregatingScope) getSelectScope(select);
     if (config.conformance().isHavingAlias()) {
-      SqlNode newExpr = expandGroupByOrHavingExpr(having, havingScope, select, true);
+      SqlNode newExpr = extendedExpand(having, havingScope, select, Clause.HAVING);
       if (having != newExpr) {
         having = newExpr;
         select.setHaving(newExpr);
@@ -4470,6 +4658,16 @@ private void validateExpr(SqlNode expr, SqlValidatorScope scope) {
       }
     }
 
+    // Unless 'naked measures' are enabled, a non-aggregating query cannot
+    // reference measure columns. (An aggregating query can use them as
+    // argument to the AGGREGATE function.)
+    if (!config.nakedMeasures()
+        && !(scope instanceof AggregatingScope)
+        && scope.isMeasureRef(expr)) {
+      throw newValidationError(expr,
+          RESOURCE.measureMustBeInAggregateQuery());
+    }
+
     // Call on the expression to validate itself.
     expr.validateExpr(this, scope);
 
@@ -4506,9 +4704,7 @@ private void handleScalarSubQuery(
 
     // Get or generate alias and add to list.
     final String alias =
-        deriveAliasNonNull(
-            selectItem,
-            aliasList.size());
+        SqlValidatorUtil.alias(selectItem, aliasList.size());
     aliasList.add(alias);
 
     final SelectScope scope = (SelectScope) getWhereScope(parentSelect);
@@ -4576,8 +4772,9 @@ protected RelDataType createTargetRowType(
   @Override public void validateInsert(SqlInsert insert) {
     final SqlValidatorNamespace targetNamespace = getNamespaceOrThrow(insert);
     validateNamespace(targetNamespace, unknownType);
-    final RelOptTable relOptTable = SqlValidatorUtil.getRelOptTable(
-        targetNamespace, catalogReader.unwrap(Prepare.CatalogReader.class), null, null);
+    final RelOptTable relOptTable =
+        SqlValidatorUtil.getRelOptTable(targetNamespace,
+            catalogReader.unwrap(Prepare.CatalogReader.class), null, null);
     final SqlValidatorTable table = relOptTable == null
         ? getTable(targetNamespace)
         : relOptTable.unwrapOrThrow(SqlValidatorTable.class);
@@ -4615,10 +4812,12 @@ protected RelDataType createTargetRowType(
     final List<ColumnStrategy> strategies =
         table.unwrapOrThrow(RelOptTable.class).getColumnStrategies();
 
-    final RelDataType realTargetRowType = typeFactory.createStructType(
-        logicalTargetRowType.getFieldList()
-            .stream().filter(f -> strategies.get(f.getIndex()).canInsertInto())
-            .collect(Collectors.toList()));
+    final RelDataType realTargetRowType =
+        typeFactory.createStructType(
+            logicalTargetRowType.getFieldList()
+                .stream()
+                .filter(f -> strategies.get(f.getIndex()).canInsertInto())
+                .collect(Collectors.toList()));
 
     final RelDataType targetRowTypeToValidate =
         logicalSourceRowType.getFieldCount() == logicalTargetRowType.getFieldCount()
@@ -4885,29 +5084,28 @@ protected void checkTypeAssignment(
     // matched
     boolean isUpdateModifiableViewTable = false;
     if (query instanceof SqlUpdate) {
-      final SqlNodeList targetColumnList = ((SqlUpdate) query).getTargetColumnList();
-      if (targetColumnList != null) {
-        final int targetColumnCnt = targetColumnList.size();
-        targetRowType = SqlTypeUtil.extractLastNFields(typeFactory, targetRowType,
-            targetColumnCnt);
-        sourceRowType = SqlTypeUtil.extractLastNFields(typeFactory, sourceRowType,
-            targetColumnCnt);
-      }
-      isUpdateModifiableViewTable = table.unwrap(ModifiableViewTable.class) != null;
+      final SqlNodeList targetColumnList =
+          requireNonNull(((SqlUpdate) query).getTargetColumnList());
+      final int targetColumnCount = targetColumnList.size();
+      targetRowType =
+          SqlTypeUtil.extractLastNFields(typeFactory, targetRowType,
+              targetColumnCount);
+      sourceRowType =
+          SqlTypeUtil.extractLastNFields(typeFactory, sourceRowType,
+              targetColumnCount);
+      isUpdateModifiableViewTable =
+          table.unwrap(ModifiableViewTable.class) != null;
     }
     if (SqlTypeUtil.equalAsStructSansNullability(typeFactory,
-        sourceRowType,
-        targetRowType,
-        null)) {
+        sourceRowType, targetRowType, null)) {
       // Returns early if source and target row type equals sans nullability.
       return;
     }
     if (config.typeCoercionEnabled() && !isUpdateModifiableViewTable) {
       // Try type coercion first if implicit type coercion is allowed.
-      boolean coerced = typeCoercion.querySourceCoercion(sourceScope,
-          sourceRowType,
-          targetRowType,
-          query);
+      boolean coerced =
+          typeCoercion.querySourceCoercion(sourceScope, sourceRowType,
+              targetRowType, query);
       if (coerced) {
         return;
       }
@@ -4968,10 +5166,8 @@ private static SqlNode getNthExpr(SqlNode query, int ordinal, int sourceCount) {
       if (update.getSourceExpressionList() != null) {
         return update.getSourceExpressionList().get(ordinal);
       } else {
-        return getNthExpr(
-            SqlNonNullableAccessors.getSourceSelect(update),
-            ordinal,
-            sourceCount);
+        return getNthExpr(SqlNonNullableAccessors.getSourceSelect(update),
+            ordinal, sourceCount);
       }
     } else if (query instanceof SqlSelect) {
       SqlSelect select = (SqlSelect) query;
@@ -5000,27 +5196,22 @@ private static SqlNode getNthExpr(SqlNode query, int ordinal, int sourceCount) {
   @Override public void validateUpdate(SqlUpdate call) {
     final SqlValidatorNamespace targetNamespace = getNamespaceOrThrow(call);
     validateNamespace(targetNamespace, unknownType);
-    final RelOptTable relOptTable = SqlValidatorUtil.getRelOptTable(
-        targetNamespace, castNonNull(catalogReader.unwrap(Prepare.CatalogReader.class)),
-        null, null);
+    final RelOptTable relOptTable =
+        SqlValidatorUtil.getRelOptTable(targetNamespace,
+            castNonNull(catalogReader.unwrap(Prepare.CatalogReader.class)),
+            null, null);
     final SqlValidatorTable table = relOptTable == null
         ? getTable(targetNamespace)
         : relOptTable.unwrapOrThrow(SqlValidatorTable.class);
 
     final RelDataType targetRowType =
-        createTargetRowType(
-            table,
-            call.getTargetColumnList(),
-            true);
+        createTargetRowType(table, call.getTargetColumnList(), true);
 
     final SqlSelect select = SqlNonNullableAccessors.getSourceSelect(call);
     validateSelect(select, targetRowType);
 
     final RelDataType sourceRowType = getValidatedNodeType(select);
-    checkTypeAssignment(scopes.get(select),
-        table,
-        sourceRowType,
-        targetRowType,
+    checkTypeAssignment(scopes.get(select), table, sourceRowType, targetRowType,
         call);
 
     checkConstraint(table, call, targetRowType);
@@ -5054,18 +5245,14 @@ targetNamespace, castNonNull(catalogReader.unwrap(Prepare.CatalogReader.class)),
     SqlUpdate updateCall = call.getUpdateCall();
     if (updateCall != null) {
       requireNonNull(table, () -> "ns.getTable() for " + targetNamespace);
-      targetRowType = createTargetRowType(
-          table,
-          updateCall.getTargetColumnList(),
-          true);
+      targetRowType =
+          createTargetRowType(table, updateCall.getTargetColumnList(), true);
     }
     SqlInsert insertCall = call.getInsertCall();
     if (insertCall != null) {
       requireNonNull(table, () -> "ns.getTable() for " + targetNamespace);
-      targetRowType = createTargetRowType(
-          table,
-          insertCall.getTargetColumnList(),
-          false);
+      targetRowType =
+          createTargetRowType(table, insertCall.getTargetColumnList(), false);
     }
 
     validateSelect(sqlSelect, targetRowType);
@@ -5408,10 +5595,11 @@ public void setOriginal(SqlNode expr, SqlNode original) {
         node.validate(this, scope);
         SqlIdentifier identifier;
         if (node instanceof SqlBasicCall) {
-          identifier = (SqlIdentifier) ((SqlBasicCall) node).operand(0);
+          identifier = ((SqlBasicCall) node).operand(0);
         } else {
-          identifier = (SqlIdentifier) requireNonNull(node,
-              () -> "order by field is null. All fields: " + orderBy);
+          identifier =
+              requireNonNull((SqlIdentifier) node,
+                  () -> "order by field is null. All fields: " + orderBy);
         }
 
         if (allRows) {
@@ -5531,7 +5719,7 @@ private List<Map.Entry<String, RelDataType>> validateMeasure(SqlMatchRecognize m
 
     for (SqlNode measure : measures) {
       assert measure instanceof SqlCall;
-      final String alias = deriveAliasNonNull(measure, aliases.size());
+      final String alias = SqlValidatorUtil.alias(measure, aliases.size());
       aliases.add(alias);
 
       SqlNode expand = expand(measure, scope);
@@ -5631,8 +5819,9 @@ private static String alias(SqlNode item) {
   }
 
   public void validatePivot(SqlPivot pivot) {
-    final PivotScope scope = (PivotScope) requireNonNull(getJoinScope(pivot),
-        () -> "joinScope for " + pivot);
+    final PivotScope scope =
+        requireNonNull((PivotScope) getJoinScope(pivot),
+            () -> "joinScope for " + pivot);
 
     final PivotNamespace ns =
         getNamespaceOrThrow(pivot).unwrap(PivotNamespace.class);
@@ -5998,6 +6187,26 @@ protected void validateFeature(
     assert feature.getProperties().get("FeatureDefinition") != null;
   }
 
+  @Override public SqlLiteral resolveLiteral(SqlLiteral literal) {
+    switch (literal.getTypeName()) {
+    case UNKNOWN:
+      final SqlUnknownLiteral unknownLiteral = (SqlUnknownLiteral) literal;
+      final SqlIdentifier identifier =
+          new SqlIdentifier(unknownLiteral.tag, SqlParserPos.ZERO);
+      final @Nullable RelDataType type = catalogReader.getNamedType(identifier);
+      final SqlTypeName typeName;
+      if (type != null) {
+        typeName = type.getSqlTypeName();
+      } else {
+        typeName = SqlTypeName.lookup(unknownLiteral.tag);
+      }
+      return unknownLiteral.resolve(typeName);
+
+    default:
+      return literal;
+    }
+  }
+
   public SqlNode expandSelectExpr(SqlNode expr,
       SelectScope scope, SqlSelect select) {
     final Expander expander = new SelectExpander(this, scope, select);
@@ -6017,10 +6226,11 @@ public SqlNode expandSelectExpr(SqlNode expr,
     return newExpr;
   }
 
-  public SqlNode expandGroupByOrHavingExpr(SqlNode expr,
-      SqlValidatorScope scope, SqlSelect select, boolean havingExpression) {
-    final Expander expander = new ExtendedExpander(this, scope, select, expr,
-        havingExpression);
+  /** Expands an expression in a GROUP BY, HAVING or QUALIFY clause. */
+  private SqlNode extendedExpand(SqlNode expr,
+      SqlValidatorScope scope, SqlSelect select, Clause clause) {
+    final Expander expander =
+        new ExtendedExpander(this, scope, select, expr, clause);
     SqlNode newExpr = expander.go(expr);
     if (expr != newExpr) {
       setOriginal(newExpr, expr);
@@ -6028,6 +6238,11 @@ public SqlNode expandGroupByOrHavingExpr(SqlNode expr,
     return newExpr;
   }
 
+  public SqlNode extendedExpandGroupBy(SqlNode expr,
+      SqlValidatorScope scope, SqlSelect select) {
+    return extendedExpand(expr, scope, select, Clause.GROUP_BY);
+  }
+
   @Override public boolean isSystemField(RelDataTypeField field) {
     return false;
   }
@@ -6052,14 +6267,23 @@ public SqlNode expandGroupByOrHavingExpr(SqlNode expr,
     if (sqlQuery instanceof SqlSelect) {
       SqlSelect sqlSelect = (SqlSelect) sqlQuery;
       final SelectScope scope = getRawSelectScopeNonNull(sqlSelect);
-      final List<SqlNode> selectList = requireNonNull(scope.getExpandedSelectList(),
-          () -> "expandedSelectList for " + scope);
+      final List<SqlNode> selectList =
+          requireNonNull(scope.getExpandedSelectList(),
+              () -> "expandedSelectList for " + scope);
       final SqlNode selectItem = stripAs(selectList.get(i));
       if (selectItem instanceof SqlIdentifier) {
         final SqlQualified qualified =
             scope.fullyQualify((SqlIdentifier) selectItem);
-        SqlValidatorNamespace namespace = requireNonNull(qualified.namespace,
-            () -> "namespace for " + qualified);
+        SqlValidatorNamespace namespace =
+            requireNonNull(qualified.namespace,
+                () -> "namespace for " + qualified);
+        if (namespace.isWrapperFor(AliasNamespace.class)) {
+          AliasNamespace aliasNs = namespace.unwrap(AliasNamespace.class);
+          SqlNode aliased = requireNonNull(aliasNs.getNode(), () ->
+              "sqlNode for aliasNs " + aliasNs);
+          namespace = getNamespaceOrThrow(stripAs(aliased));
+        }
+
         final SqlValidatorTable table = namespace.getTable();
         if (table == null) {
           return null;
@@ -6067,7 +6291,16 @@ public SqlNode expandGroupByOrHavingExpr(SqlNode expr,
         final List<String> origin =
             new ArrayList<>(table.getQualifiedName());
         for (String name : qualified.suffix()) {
+          if (namespace.isWrapperFor(UnnestNamespace.class)) {
+            // If identifier is drawn from a repeated subrecord via unnest, add name of array field
+            UnnestNamespace unnestNamespace = namespace.unwrap(UnnestNamespace.class);
+            final SqlQualified columnUnnestedFrom = unnestNamespace.getColumnUnnestedFrom(name);
+            if (columnUnnestedFrom != null) {
+              origin.addAll(columnUnnestedFrom.suffix());
+            }
+          }
           namespace = namespace.lookupChild(name);
+
           if (namespace == null) {
             return null;
           }
@@ -6280,7 +6513,7 @@ private class DeriveTypeVisitor implements SqlVisitor<RelDataType> {
     }
 
     @Override public RelDataType visit(SqlLiteral literal) {
-      return literal.createSqlType(typeFactory);
+      return resolveLiteral(literal).createSqlType(typeFactory);
     }
 
     @Override public RelDataType visit(SqlCall call) {
@@ -6429,6 +6662,10 @@ public SqlNode go(SqlNode root) {
       return expandedExpr;
     }
 
+    @Override public @Nullable SqlNode visit(SqlLiteral literal) {
+      return validator.resolveLiteral(literal);
+    }
+
     @Override protected SqlNode visitScoped(SqlCall call) {
       switch (call.getKind()) {
       case SCALAR_QUERY:
@@ -6600,63 +6837,71 @@ static class SelectExpander extends Expander {
   static class ExtendedExpander extends Expander {
     final SqlSelect select;
     final SqlNode root;
-    final boolean havingExpr;
+    final Clause clause;
 
     ExtendedExpander(SqlValidatorImpl validator, SqlValidatorScope scope,
-        SqlSelect select, SqlNode root, boolean havingExpr) {
+        SqlSelect select, SqlNode root, Clause clause) {
       super(validator, scope);
       this.select = select;
       this.root = root;
-      this.havingExpr = havingExpr;
+      this.clause = clause;
     }
 
     @Override public @Nullable SqlNode visit(SqlIdentifier id) {
-      if (id.isSimple()
-          && (havingExpr
-              ? validator.config().conformance().isHavingAlias()
-              : validator.config().conformance().isGroupByAlias())) {
-        String name = id.getSimple();
-        SqlNode expr = null;
-        final SqlNameMatcher nameMatcher =
-            validator.catalogReader.nameMatcher();
-        int n = 0;
-        for (SqlNode s : SqlNonNullableAccessors.getSelectList(select)) {
-          final String alias = SqlValidatorUtil.getAlias(s, -1);
-          if (alias != null && nameMatcher.matches(alias, name)) {
-            expr = s;
-            n++;
-          }
-        }
-        if (n == 0) {
-          return super.visit(id);
-        } else if (n > 1) {
-          // More than one column has this alias.
-          throw validator.newValidationError(id,
-              RESOURCE.columnAmbiguous(name));
-        }
-        if (havingExpr && validator.isAggregate(root)) {
-          return super.visit(id);
-        }
-        expr = stripAs(expr);
-        if (expr instanceof SqlIdentifier) {
-          SqlIdentifier sid = (SqlIdentifier) expr;
-          final SqlIdentifier fqId = getScope().fullyQualify(sid).identifier;
-          expr = expandDynamicStar(sid, fqId);
-        }
-        return expr;
+      if (!id.isSimple()) {
+        return super.visit(id);
       }
-      if (id.isSimple()) {
+
+      final boolean replaceAliases = clause.shouldReplaceAliases(validator.config);
+      if (!replaceAliases) {
         final SelectScope scope = validator.getRawSelectScope(select);
         SqlNode node = expandCommonColumn(select, id, scope, validator);
         if (node != id) {
           return node;
         }
+        return super.visit(id);
+      }
+
+      String name = id.getSimple();
+      SqlNode expr = null;
+      final SqlNameMatcher nameMatcher =
+          validator.catalogReader.nameMatcher();
+      int n = 0;
+      for (SqlNode s : SqlNonNullableAccessors.getSelectList(select)) {
+        final @Nullable String alias = SqlValidatorUtil.alias(s);
+        if (alias != null && nameMatcher.matches(alias, name)) {
+          expr = s;
+          n++;
+        }
+      }
+
+      if (n == 0) {
+        return super.visit(id);
+      } else if (n > 1) {
+        // More than one column has this alias.
+        throw validator.newValidationError(id,
+            RESOURCE.columnAmbiguous(name));
+      }
+      Iterable<SqlCall> allAggList = validator.aggFinder.findAll(ImmutableList.of(root));
+      for (SqlCall agg : allAggList) {
+        if (clause == Clause.HAVING && containsIdentifier(agg, id)) {
+          return super.visit(id);
+        }
       }
-      return super.visit(id);
+
+      expr = stripAs(expr);
+      if (expr instanceof SqlIdentifier) {
+        SqlIdentifier sid = (SqlIdentifier) expr;
+        final SqlIdentifier fqId = getScope().fullyQualify(sid).identifier;
+        expr = expandDynamicStar(sid, fqId);
+      }
+
+      return expr;
     }
 
     @Override public @Nullable SqlNode visit(SqlLiteral literal) {
-      if (havingExpr || !validator.config().conformance().isGroupByOrdinal()) {
+      if (clause != Clause.GROUP_BY
+          || !validator.config().conformance().isGroupByOrdinal()) {
         return super.visit(literal);
       }
       boolean isOrdinalLiteral = literal == root;
@@ -6700,8 +6945,34 @@ static class ExtendedExpander extends Expander {
 
       return super.visit(literal);
     }
+
+    /**
+     * Returns whether a given node contains a {@link SqlIdentifier}.
+     *
+     * @param sqlNode a SqlNode
+     * @param target a SqlIdentifier
+     */
+    private boolean containsIdentifier(SqlNode sqlNode, SqlIdentifier target) {
+      try {
+        SqlVisitor<Void> visitor =
+            new SqlBasicVisitor<Void>() {
+              @Override public Void visit(SqlIdentifier identifier) {
+                if (identifier.equalsDeep(target, Litmus.IGNORE)) {
+                  throw new Util.FoundOne(target);
+                }
+                return super.visit(identifier);
+              }
+            };
+        sqlNode.accept(visitor);
+        return false;
+      } catch (Util.FoundOne e) {
+        Util.swallow(e, null);
+        return true;
+      }
+    }
   }
 
+
   /** Information about an identifier in a particular scope. */
   protected static class IdInfo {
     public final SqlValidatorScope scope;
@@ -6797,17 +7068,18 @@ private static class NavigationExpander extends NavigationModifier {
             SqlNode innerOffset = innerOperands.get(1);
             SqlOperator newOperator = innerKind == kind
                 ? SqlStdOperatorTable.PLUS : SqlStdOperatorTable.MINUS;
-            offset = newOperator.createCall(SqlParserPos.ZERO,
-              offset, innerOffset);
-            inner = call.getOperator().createCall(SqlParserPos.ZERO,
-              innerOperands.get(0), offset);
+            offset =
+              newOperator.createCall(SqlParserPos.ZERO, offset, innerOffset);
+            inner =
+              call.getOperator().createCall(SqlParserPos.ZERO,
+                  innerOperands.get(0), offset);
           }
         }
         SqlNode newInnerNode =
             inner.accept(new NavigationExpander(call.getOperator(), offset));
         if (op != null) {
-          newInnerNode = op.createCall(SqlParserPos.ZERO, newInnerNode,
-              this.offset);
+          newInnerNode =
+              op.createCall(SqlParserPos.ZERO, newInnerNode, this.offset);
         }
         return newInnerNode;
       }
@@ -7083,8 +7355,9 @@ private class Permute {
 
       default:
         rowType = getValidatedNodeType(from);
-        this.sources = Functions.generate(rowType.getFieldCount(),
-            i -> ImmutableIntList.of(offset + i));
+        this.sources =
+            Functions.generate(rowType.getFieldCount(),
+                i -> ImmutableIntList.of(offset + i));
         this.trivial = true;
       }
     }
@@ -7120,9 +7393,12 @@ public void permute(List<SqlNode> selectItems,
           // output is nullable only if both inputs are
           final boolean nullable = type.isNullable() && type1.isNullable();
           RelDataType currentType = type;
-          final RelDataType type2 = requireNonNull(
-              SqlTypeUtil.leastRestrictiveForComparison(typeFactory, type, type1),
-              () -> "leastRestrictiveForComparison for types " + currentType + " and " + type1);
+          final RelDataType type2 =
+              requireNonNull(
+                  SqlTypeUtil.leastRestrictiveForComparison(typeFactory, type,
+                      type1),
+                  () -> "leastRestrictiveForComparison for types " + currentType
+                      + " and " + type1);
           selectItem =
               SqlStdOperatorTable.AS.createCall(SqlParserPos.ZERO,
                   SqlStdOperatorTable.COALESCE.createCall(SqlParserPos.ZERO,
@@ -7165,6 +7441,45 @@ private enum Clause {
     GROUP_BY,
     SELECT,
     ORDER,
-    CURSOR
+    CURSOR,
+    HAVING,
+    QUALIFY;
+
+    /**
+     * Determines if the extender should replace aliases with expanded values.
+     * For example:
+     *
+     * <blockquote><pre>{@code
+     *  SELECT a + a as twoA
+     *  GROUP BY twoA
+     * }</pre></blockquote>
+     *
+     * <p>turns into
+     *
+     * <blockquote><pre>{@code
+     *  SELECT a + a as twoA
+     *  GROUP BY a + a
+     * }</pre></blockquote>
+     *
+     * <p>This is determined both by the clause and the config.
+     *
+     * @param config The configuration
+     * @return Whether we should replace the alias with its expanded value
+     */
+    boolean shouldReplaceAliases(Config config) {
+      switch (this) {
+      case GROUP_BY:
+        return config.conformance().isGroupByAlias();
+
+      case HAVING:
+        return config.conformance().isHavingAlias();
+
+      case QUALIFY:
+        return true;
+
+      default:
+        throw Util.unexpected(this);
+      }
+    }
   }
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorNamespace.java b/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorNamespace.java
index 735345a54b8..432b3fff1a5 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorNamespace.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorNamespace.java
@@ -17,6 +17,7 @@
 package org.apache.calcite.sql.validate;
 
 import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.rel.type.RelDataTypeField;
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.util.Pair;
 
@@ -147,7 +148,17 @@ public interface SqlValidatorNamespace {
    * @param name Field name
    * @return Whether field exists
    */
-  boolean fieldExists(String name);
+  default boolean fieldExists(String name) {
+    return field(name) != null;
+  }
+
+  /**
+   * Returns a field of a given name, or null.
+   *
+   * @param name Field name
+   * @return Field, or null
+   */
+  @Nullable RelDataTypeField field(String name);
 
   /**
    * Returns a list of expressions which are monotonic in this namespace. For
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorScope.java b/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorScope.java
index 83b98acdc20..92b6b16dcf1 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorScope.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorScope.java
@@ -17,6 +17,7 @@
 package org.apache.calcite.sql.validate;
 
 import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.rel.type.RelDataTypeField;
 import org.apache.calcite.rel.type.StructKind;
 import org.apache.calcite.sql.SqlCall;
 import org.apache.calcite.sql.SqlIdentifier;
@@ -24,6 +25,7 @@
 import org.apache.calcite.sql.SqlNodeList;
 import org.apache.calcite.sql.SqlSelect;
 import org.apache.calcite.sql.SqlWindow;
+import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.util.Pair;
 import org.apache.calcite.util.Util;
 
@@ -123,6 +125,26 @@ Map<String, ScopeChild> findQualifyingTableNames(String columnName,
    */
   SqlQualified fullyQualify(SqlIdentifier identifier);
 
+  /** Returns whether an expression is a reference to a measure column. */
+  default boolean isMeasureRef(SqlNode node) {
+    if (node instanceof SqlIdentifier) {
+      final SqlQualified q = fullyQualify((SqlIdentifier) node);
+      if (q.suffix().size() == 1
+          && q.namespace != null) {
+        final @Nullable RelDataTypeField f =
+            q.namespace.field(q.suffix().get(0));
+        if (q.namespace instanceof SelectNamespace) {
+          final SqlSelect select = ((SelectNamespace) q.namespace).getNode();
+          return f != null
+              && SqlValidatorUtil.isMeasure(select.getSelectList().get(f.getIndex()));
+        }
+        return f != null
+            && f.getType().getSqlTypeName() == SqlTypeName.MEASURE;
+      }
+    }
+    return false;
+  }
+
   /**
    * Registers a relation in this scope.
    *
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorUtil.java b/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorUtil.java
index e3564cecf3a..53d2111ba37 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorUtil.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorUtil.java
@@ -119,8 +119,8 @@ private SqlValidatorUtil() {}
           requireNonNull(catalogReader, "catalogReader"), datasetName, usedDataset,
           tableNamespace.extendedFields);
     } else if (namespace.isWrapperFor(SqlValidatorImpl.DmlNamespace.class)) {
-      final SqlValidatorImpl.DmlNamespace dmlNamespace = namespace.unwrap(
-          SqlValidatorImpl.DmlNamespace.class);
+      final SqlValidatorImpl.DmlNamespace dmlNamespace =
+          namespace.unwrap(SqlValidatorImpl.DmlNamespace.class);
       final SqlValidatorNamespace resolvedNamespace = dmlNamespace.resolve();
       if (resolvedNamespace.isWrapperFor(TableNamespace.class)) {
         final TableNamespace tableNamespace = resolvedNamespace.unwrap(TableNamespace.class);
@@ -163,7 +163,8 @@ tableNamespace, requireNonNull(catalogReader, "catalogReader"),
    * Gets a list of extended columns with field indices to the underlying table.
    */
   public static List<RelDataTypeField> getExtendedColumns(
-      @Nullable SqlValidator validator, SqlValidatorTable table, SqlNodeList extendedColumns) {
+      SqlValidator validator, SqlValidatorTable table,
+      SqlNodeList extendedColumns) {
     final ImmutableList.Builder<RelDataTypeField> extendedFields =
         ImmutableList.builder();
     final ExtensibleTable extTable = table.unwrap(ExtensibleTable.class);
@@ -234,8 +235,10 @@ public static ImmutableBitSet getOrdinalBitSet(
   public static ImmutableBitSet getOrdinalBitSet(
       RelDataType sourceRowType,
       Map<Integer, RelDataTypeField> indexToField) {
-    ImmutableBitSet source = ImmutableBitSet.of(
-        Util.transform(sourceRowType.getFieldList(), RelDataTypeField::getIndex));
+    ImmutableBitSet source =
+        ImmutableBitSet.of(
+            Util.transform(sourceRowType.getFieldList(),
+                RelDataTypeField::getIndex));
     // checkerframework: found   : Set<@KeyFor("indexToField") Integer>
     //noinspection RedundantCast
     ImmutableBitSet target =
@@ -282,8 +285,9 @@ public static void checkCharsetAndCollateConsistentIfCharType(
    */
   static void checkIdentifierListForDuplicates(List<? extends @Nullable SqlNode> columnList,
       SqlValidatorImpl.ValidationErrorFunction validationErrorFunction) {
-    final List<List<String>> names = Util.transform(columnList,
-        sqlNode -> ((SqlIdentifier) requireNonNull(sqlNode, "sqlNode")).names);
+    final List<List<String>> names =
+        Util.transform(columnList,
+            node -> ((SqlIdentifier) requireNonNull(node, "node")).names);
     final int i = Util.firstDuplicate(names);
     if (i >= 0) {
       throw validationErrorFunction.apply(
@@ -315,10 +319,34 @@ public static SqlNode addAlias(
    * <li>Anything else yields "expr$<i>ordinal</i>"
    * </ul>
    *
+   * @param node   Node
+   * @param ordinal Ordinal in SELECT clause (must be &ge; 0)
+   *
    * @return An alias, if one can be derived; or a synthetic alias
-   * "expr$<i>ordinal</i>" if ordinal &lt; 0; otherwise null
+   * "expr$<i>ordinal</i>"; never null
    */
+  public static String alias(SqlNode node, int ordinal) {
+    Preconditions.checkArgument(ordinal >= 0);
+    return requireNonNull(alias_(node, ordinal), "alias");
+  }
+
+  public static @Nullable String alias(SqlNode node) {
+    return alias_(node, -1);
+  }
+
+  /** Derives an alias for a node, and invents a mangled identifier if it
+   * cannot.
+   *
+   * @deprecated Use {@link #alias(SqlNode)} if {@code ordinal} is negative,
+   * or {@link #alias(SqlNode, int)} if {@code ordinal} is non-negative. */
+  @Deprecated // to be removed before 2.0
   public static @Nullable String getAlias(SqlNode node, int ordinal) {
+    return alias_(node, ordinal);
+  }
+
+  /** Returns an alias, if one can be derived; or a synthetic alias
+   * "expr$<i>ordinal</i>" if ordinal &ge; 0; otherwise null. */
+  private static @Nullable String alias_(SqlNode node, int ordinal) {
     switch (node.getKind()) {
     case AS:
       // E.g. "1 + 2 as foo" --> "foo"
@@ -496,16 +524,18 @@ public static RelDataType deriveJoinRowType(
     assert systemFieldList != null;
     switch (joinType) {
     case LEFT:
-      rightType = typeFactory.createTypeWithNullability(
-          requireNonNull(rightType, "rightType"), true);
+      rightType =
+          typeFactory.createTypeWithNullability(
+              requireNonNull(rightType, "rightType"), true);
       break;
     case RIGHT:
       leftType = typeFactory.createTypeWithNullability(leftType, true);
       break;
     case FULL:
       leftType = typeFactory.createTypeWithNullability(leftType, true);
-      rightType = typeFactory.createTypeWithNullability(
-          requireNonNull(rightType, "rightType"), true);
+      rightType =
+          typeFactory.createTypeWithNullability(
+              requireNonNull(rightType, "rightType"), true);
       break;
     case SEMI:
     case ANTI:
@@ -687,7 +717,7 @@ public static void getSchemaObjectMonikers(
 
   /**
    * Derives the list of column names suitable for NATURAL JOIN. These are the
-   * columns that occur exactly once on each side of the join.
+   * columns that occur at least once each side of the join.
    *
    * @param nameMatcher Whether matches are case-sensitive
    * @param leftRowType  Row type of left input to the join
@@ -698,16 +728,17 @@ public static List<String> deriveNaturalJoinColumnList(
       SqlNameMatcher nameMatcher,
       RelDataType leftRowType,
       RelDataType rightRowType) {
-    final List<String> naturalColumnNames = new ArrayList<>();
-    final List<String> leftNames = leftRowType.getFieldNames();
-    final List<String> rightNames = rightRowType.getFieldNames();
-    for (String name : leftNames) {
-      if (nameMatcher.frequency(leftNames, name) == 1
-          && nameMatcher.frequency(rightNames, name) == 1) {
-        naturalColumnNames.add(name);
+    final ImmutableList.Builder<String> naturalColumnNames =
+        ImmutableList.builder();
+    final Set<String> rightSet = nameMatcher.createSet();
+    rightSet.addAll(rightRowType.getFieldNames());
+    final Set<String> leftSet = nameMatcher.createSet();
+    for (String leftName : leftRowType.getFieldNames()) {
+      if (leftSet.add(leftName) && rightSet.contains(leftName)) {
+        naturalColumnNames.add(leftName);
       }
     }
-    return naturalColumnNames;
+    return naturalColumnNames.build();
   }
 
   public static RelDataType createTypeFromProjection(RelDataType type,
@@ -830,7 +861,7 @@ private static void convertGroupSet(SqlValidatorScope scope,
    * grouped, and returns a bitmap indicating which expressions this tuple
    * is grouping. */
   private static List<ImmutableBitSet> analyzeGroupTuple(SqlValidatorScope scope,
-       GroupAnalyzer groupAnalyzer, List<SqlNode> operandList) {
+      GroupAnalyzer groupAnalyzer, List<SqlNode> operandList) {
     List<ImmutableBitSet> list = new ArrayList<>();
     for (SqlNode operand : operandList) {
       list.add(
@@ -899,10 +930,10 @@ private static ImmutableBitSet analyzeGroupExpr(SqlValidatorScope scope,
         }
       }
 
-      RelDataTypeField field = requireNonNull(
-          nameMatcher.field(rowType, originalFieldName),
-          () -> "field " + originalFieldName + " is not found in " + rowType
-              + " with " + nameMatcher);
+      RelDataTypeField field =
+          requireNonNull(nameMatcher.field(rowType, originalFieldName),
+              () -> "field " + originalFieldName + " is not found in " + rowType
+                  + " with " + nameMatcher);
       int origPos = namespaceOffset + field.getIndex();
 
       groupAnalyzer.groupExprProjection.put(origPos, ref);
@@ -1070,8 +1101,7 @@ public static ImmutableList<ImmutableBitSet> cube(
           && nameMatcher.matches(schemaName, schema.getName())) {
         continue;
       }
-      schema = schema.getSubSchema(schemaName,
-          nameMatcher.isCaseSensitive());
+      schema = schema.getSubSchema(schemaName, nameMatcher.isCaseSensitive());
       if (schema == null) {
         return null;
       }
@@ -1084,8 +1114,7 @@ public static ImmutableList<ImmutableBitSet> cube(
     CalciteSchema.TableEntry entry =
         schema.getTable(name, caseSensitive);
     if (entry == null) {
-      entry = schema.getTableBasedOnNullaryFunction(name,
-          caseSensitive);
+      entry = schema.getTableBasedOnNullaryFunction(name, caseSensitive);
     }
     return entry;
   }
@@ -1171,19 +1200,17 @@ public static Pair<SqlNode, RelDataType> validateExprWithRowType(
       RelDataType rowType,
       SqlNode expr) {
     final String tableName = "_table_";
-    final SqlSelect select0 = new SqlSelect(SqlParserPos.ZERO, null,
-        new SqlNodeList(Collections.singletonList(expr), SqlParserPos.ZERO),
-        new SqlIdentifier(tableName, SqlParserPos.ZERO),
-        null, null, null, null, null, null, null, null);
-    Prepare.CatalogReader catalogReader = createSingleTableCatalogReader(
-        caseSensitive,
-        tableName,
-        typeFactory,
-        rowType);
-    SqlValidator validator = newValidator(operatorTable,
-        catalogReader,
-        typeFactory,
-        SqlValidator.Config.DEFAULT);
+    final SqlSelect select0 =
+        new SqlSelect(SqlParserPos.ZERO, null,
+            new SqlNodeList(Collections.singletonList(expr), SqlParserPos.ZERO),
+            new SqlIdentifier(tableName, SqlParserPos.ZERO),
+            null, null, null, null, null, null, null, null, null);
+    Prepare.CatalogReader catalogReader =
+        createSingleTableCatalogReader(caseSensitive, tableName, typeFactory,
+            rowType);
+    SqlValidator validator =
+        newValidator(operatorTable, catalogReader, typeFactory,
+            SqlValidator.Config.DEFAULT);
     final SqlSelect select = (SqlSelect) validator.validate(select0);
     SqlNodeList selectList = select.getSelectList();
     assert selectList.size() == 1
@@ -1223,17 +1250,12 @@ public static CalciteCatalogReader createSingleTableCatalogReader(
     // prepare root schema
     final ExplicitRowTypeTable table = new ExplicitRowTypeTable(rowType);
     final Map<String, Table> tableMap = Collections.singletonMap(tableName, table);
-    CalciteSchema schema = CalciteSchema.createRootSchema(
-        false,
-        false,
-        "",
-        new ExplicitTableSchema(tableMap));
-
-    return new CalciteCatalogReader(
-        schema,
-        new ArrayList<>(new ArrayList<>()),
-        typeFactory,
-        connectionConfig);
+    CalciteSchema schema =
+        CalciteSchema.createRootSchema(false, false, "",
+            new ExplicitTableSchema(tableMap));
+
+    return new CalciteCatalogReader(schema, new ArrayList<>(new ArrayList<>()),
+        typeFactory, connectionConfig);
   }
 
   /**
@@ -1261,6 +1283,22 @@ private static FlatAggregate flattenRecurse(@Nullable SqlCall filterCall,
     }
   }
 
+  /** Returns whether a select item is a measure. */
+  public static boolean isMeasure(SqlNode selectItem) {
+    return getMeasure(selectItem) != null;
+  }
+
+  /** Returns the measure expression if a select item is a measure, null
+   * otherwise.
+   *
+   * <p>For a measure, {@code selectItem} will have the form
+   * {@code AS(MEASURE(exp), alias)} and this method returns {@code exp}. */
+  public static @Nullable SqlNode getMeasure(SqlNode selectItem) {
+    // The implementation of this method will be extended when we add the
+    // 'AS MEASURE' construct in [CALCITE-4496].
+    return null;
+  }
+
   //~ Inner Classes ----------------------------------------------------------
 
   /**
@@ -1347,8 +1385,15 @@ static class GroupAnalyzer {
     /** Extra expressions, computed from the input as extra GROUP BY
      * expressions. For example, calls to the {@code TUMBLE} functions. */
     final List<SqlNode> extraExprs = new ArrayList<>();
+    final List<SqlNode> measureExprs = new ArrayList<>();
     final List<SqlNode> groupExprs = new ArrayList<>();
     final Map<Integer, Integer> groupExprProjection = new HashMap<>();
+    final List<ImmutableBitSet> flatGroupSets = new ArrayList<>();
+
+    AggregatingSelectScope.Resolved finish() {
+      return new AggregatingSelectScope.Resolved(extraExprs, measureExprs,
+          groupExprs, flatGroupSets, groupExprProjection);
+    }
   }
 
   /**
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/TableNamespace.java b/core/src/main/java/org/apache/calcite/sql/validate/TableNamespace.java
index 5595bbe165f..06da097639b 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/TableNamespace.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/TableNamespace.java
@@ -35,10 +35,11 @@
 
 import java.util.List;
 import java.util.Map;
-import java.util.Objects;
 
 import static org.apache.calcite.util.Static.RESOURCE;
 
+import static java.util.Objects.requireNonNull;
+
 /** Namespace based on a table from the catalog. */
 class TableNamespace extends AbstractNamespace {
   private final SqlValidatorTable table;
@@ -48,7 +49,7 @@ class TableNamespace extends AbstractNamespace {
   private TableNamespace(SqlValidatorImpl validator, SqlValidatorTable table,
       List<RelDataTypeField> fields) {
     super(validator, null);
-    this.table = Objects.requireNonNull(table, "table");
+    this.table = requireNonNull(table, "table");
     this.extendedFields = ImmutableList.copyOf(fields);
   }
 
@@ -106,7 +107,7 @@ public TableNamespace extend(SqlNodeList extendList) {
       final RelOptTable relOptTable =
           ((RelOptTable) table).extend(extendedFields);
       final SqlValidatorTable validatorTable =
-          Objects.requireNonNull(
+          requireNonNull(
             relOptTable.unwrap(SqlValidatorTable.class),
             () -> "cant unwrap SqlValidatorTable from " + relOptTable);
       return new TableNamespace(validator, validatorTable, ImmutableList.of());
@@ -119,9 +120,9 @@ public TableNamespace extend(SqlNodeList extendList) {
    * columns of the underlying table.
    */
   private RelDataType getBaseRowType() {
-    final Table schemaTable = Objects.requireNonNull(
-        table.unwrap(Table.class),
-        () -> "can't unwrap Table from " + table);
+    final Table schemaTable =
+        requireNonNull(table.unwrap(Table.class),
+            () -> "can't unwrap Table from " + table);
     if (schemaTable instanceof ModifiableViewTable) {
       final Table underlying =
           ((ModifiableViewTable) schemaTable).unwrap(Table.class);
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/UnnestNamespace.java b/core/src/main/java/org/apache/calcite/sql/validate/UnnestNamespace.java
index 531ba53a902..f3e732d9934 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/UnnestNamespace.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/UnnestNamespace.java
@@ -64,6 +64,33 @@ class UnnestNamespace extends AbstractNamespace {
     return null;
   }
 
+  /**
+   * Given a field name from SelectScope, find the column in this
+   * UnnestNamespace it originates from.
+   *
+   * @param queryFieldName Name of column
+   * @return A SqlQualified if subfield comes from this unnest, null if not found
+   */
+  @Nullable SqlQualified getColumnUnnestedFrom(String queryFieldName) {
+    for (SqlNode operand : unnest.getOperandList()) {
+      // Ignore operands that are inline ARRAY[] literals
+      if (operand instanceof SqlIdentifier) {
+        final SqlIdentifier id = (SqlIdentifier) operand;
+        final SqlQualified qualified = this.scope.fullyQualify(id);
+        RelDataType dataType = this.scope.resolveColumn(qualified.suffix().get(0), id);
+        if (dataType != null) {
+          RelDataType repeatedEntryType = dataType.getComponentType();
+          if (repeatedEntryType != null
+              && repeatedEntryType.isStruct()
+              && repeatedEntryType.getFieldNames().contains(queryFieldName)) {
+            return qualified;
+          }
+        }
+      }
+    }
+    return null;
+  }
+
   @Override protected RelDataType validateImpl(RelDataType targetRowType) {
     // Validate the call and its arguments, and infer the return type.
     validator.validateCall(unnest, scope);
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/implicit/AbstractTypeCoercion.java b/core/src/main/java/org/apache/calcite/sql/validate/implicit/AbstractTypeCoercion.java
index bf27dad3f58..82b7c52343f 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/implicit/AbstractTypeCoercion.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/implicit/AbstractTypeCoercion.java
@@ -23,6 +23,7 @@
 import org.apache.calcite.rel.type.RelDataTypeFactoryImpl;
 import org.apache.calcite.rel.type.RelDataTypeField;
 import org.apache.calcite.sql.SqlCall;
+import org.apache.calcite.sql.SqlCharStringLiteral;
 import org.apache.calcite.sql.SqlCollation;
 import org.apache.calcite.sql.SqlDynamicParam;
 import org.apache.calcite.sql.SqlIdentifier;
@@ -30,7 +31,9 @@
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.sql.SqlNodeList;
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
+import org.apache.calcite.sql.parser.SqlParseException;
 import org.apache.calcite.sql.parser.SqlParserPos;
+import org.apache.calcite.sql.parser.SqlParserUtil;
 import org.apache.calcite.sql.type.SqlTypeFamily;
 import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.sql.type.SqlTypeUtil;
@@ -103,12 +106,17 @@ protected boolean coerceOperandType(
       return false;
     }
     requireNonNull(scope, "scope");
+    RelDataType operandType = validator.deriveType(scope, operand);
+    if (coerceStringToArray(call, operand, index, operandType, targetType)) {
+      return true;
+    }
+
     // Check it early.
     if (!needToCast(scope, operand, targetType)) {
       return false;
     }
     // Fix up nullable attr.
-    RelDataType targetType1 = syncAttributes(validator.deriveType(scope, operand), targetType);
+    RelDataType targetType1 = syncAttributes(operandType, targetType);
     SqlNode desired = castTo(operand, targetType1);
     call.setOperand(index, desired);
     updateInferredType(desired, targetType1);
@@ -221,9 +229,9 @@ RelDataType syncAttributes(
         Charset charset = fromType.getCharset();
         if (charset != null && SqlTypeUtil.inCharFamily(syncedType)) {
           SqlCollation collation = getCollation(fromType);
-          syncedType = factory.createTypeWithCharsetAndCollation(syncedType,
-              charset,
-              collation);
+          syncedType =
+              factory.createTypeWithCharsetAndCollation(syncedType, charset,
+                  collation);
         }
       }
     }
@@ -394,8 +402,9 @@ protected void updateInferredColumnType(
 
     if (SqlTypeUtil.isArray(type1) && SqlTypeUtil.isArray(type2)) {
       if (SqlTypeUtil.equalSansNullability(factory, type1, type2)) {
-        resultType = factory.createTypeWithNullability(type1,
-            type1.isNullable() || type2.isNullable());
+        resultType =
+            factory.createTypeWithNullability(type1,
+                type1.isNullable() || type2.isNullable());
       }
     }
 
@@ -525,6 +534,16 @@ private RelDataType getTightestCommonTypeOrThrow(
       return type2;
     }
 
+    if (validator.config().conformance().allowCoercionStringToArray()) {
+      if (SqlTypeUtil.isString(type1) && SqlTypeUtil.isArray(type2)) {
+        return type2;
+      }
+
+      if (SqlTypeUtil.isString(type2) && SqlTypeUtil.isArray(type1)) {
+        return type1;
+      }
+    }
+
     return null;
   }
 
@@ -549,8 +568,9 @@ private RelDataType getTightestCommonTypeOrThrow(
     }
     if (null == resultType) {
       if (SqlTypeUtil.isArray(type1) && SqlTypeUtil.isArray(type2)) {
-        RelDataType valType = getWiderTypeForTwo(type1.getComponentType(),
-            type2.getComponentType(), stringPromotion);
+        RelDataType valType =
+            getWiderTypeForTwo(type1.getComponentType(),
+                type2.getComponentType(), stringPromotion);
         if (null != valType) {
           resultType = factory.createArrayType(valType, -1);
         }
@@ -666,14 +686,13 @@ boolean canImplicitTypeCast(List<RelDataType> types, List<SqlTypeFamily> familie
    * @return common type of implicit cast, null if we do not find any
    */
   public @Nullable RelDataType implicitCast(RelDataType in, SqlTypeFamily expected) {
-    List<SqlTypeFamily> numericFamilies = ImmutableList.of(
-        SqlTypeFamily.NUMERIC,
-        SqlTypeFamily.DECIMAL,
-        SqlTypeFamily.APPROXIMATE_NUMERIC,
-        SqlTypeFamily.EXACT_NUMERIC,
-        SqlTypeFamily.INTEGER);
-    List<SqlTypeFamily> dateTimeFamilies = ImmutableList.of(SqlTypeFamily.DATE,
-        SqlTypeFamily.TIME, SqlTypeFamily.TIMESTAMP);
+    List<SqlTypeFamily> numericFamilies =
+        ImmutableList.of(SqlTypeFamily.NUMERIC, SqlTypeFamily.DECIMAL,
+            SqlTypeFamily.APPROXIMATE_NUMERIC, SqlTypeFamily.EXACT_NUMERIC,
+            SqlTypeFamily.INTEGER);
+    List<SqlTypeFamily> dateTimeFamilies =
+        ImmutableList.of(SqlTypeFamily.DATE, SqlTypeFamily.TIME,
+            SqlTypeFamily.TIMESTAMP);
     // If the expected type is already a parent of the input type, no need to cast.
     if (expected.getTypeNames().contains(in.getSqlTypeName())) {
       return in;
@@ -719,6 +738,37 @@ boolean canImplicitTypeCast(List<RelDataType> types, List<SqlTypeFamily> familie
         || expected == SqlTypeFamily.CHARACTER)) {
       return expected.getDefaultConcreteType(factory);
     }
+    // CHAR -> GEOMETRY
+    if (SqlTypeUtil.isCharacter(in) && expected == SqlTypeFamily.GEO) {
+      return expected.getDefaultConcreteType(factory);
+    }
     return null;
   }
+
+  /**
+   * Coerce STRING type to ARRAY type.
+   */
+  protected Boolean coerceStringToArray(
+      SqlCall call,
+      SqlNode operand,
+      int index,
+      RelDataType fromType,
+      RelDataType targetType) {
+    if (validator.config().conformance().allowCoercionStringToArray()
+        && SqlTypeUtil.isString(fromType)
+        && SqlTypeUtil.isArray(targetType)
+        && operand instanceof SqlCharStringLiteral) {
+      try {
+        SqlNode arrayValue =
+            SqlParserUtil.parseArrayLiteral(
+                ((SqlCharStringLiteral) operand).getValueAs(String.class));
+        call.setOperand(index, arrayValue);
+        updateInferredType(arrayValue, targetType);
+      } catch (SqlParseException e) {
+        return false;
+      }
+      return true;
+    }
+    return false;
+  }
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/implicit/TypeCoercionImpl.java b/core/src/main/java/org/apache/calcite/sql/validate/implicit/TypeCoercionImpl.java
index ce562a9a516..bee2d5931f6 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/implicit/TypeCoercionImpl.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/implicit/TypeCoercionImpl.java
@@ -104,14 +104,17 @@ public TypeCoercionImpl(RelDataTypeFactory typeFactory, SqlValidator validator)
       updateInferredColumnType(scope1, query, columnIndex, targetType);
       return true;
     case VALUES:
+      boolean coerceValues = false;
       for (SqlNode rowConstructor : ((SqlCall) query).getOperandList()) {
-        if (!coerceOperandType(scope, (SqlCall) rowConstructor, columnIndex, targetType)) {
-          return false;
+        if (coerceOperandType(scope, (SqlCall) rowConstructor, columnIndex, targetType)) {
+          coerceValues = true;
         }
       }
-      updateInferredColumnType(
-          requireNonNull(scope, "scope"), query, columnIndex, targetType);
-      return true;
+      if (coerceValues) {
+        updateInferredColumnType(
+            requireNonNull(scope, "scope"), query, columnIndex, targetType);
+      }
+      return coerceValues;
     case WITH:
       SqlNode body = ((SqlWith) query).body;
       return rowTypeCoercion(validator.getOverScope(query), body, columnIndex, targetType);
@@ -121,8 +124,13 @@ public TypeCoercionImpl(RelDataTypeFactory typeFactory, SqlValidator validator)
       // Set operations are binary for now.
       final SqlCall operand0 = ((SqlCall) query).operand(0);
       final SqlCall operand1 = ((SqlCall) query).operand(1);
-      final boolean coerced = rowTypeCoercion(scope, operand0, columnIndex, targetType)
-          && rowTypeCoercion(scope, operand1, columnIndex, targetType);
+      // Operand1 should be coerced even if operand0 not need to be coerced.
+      // For example, we have one table named t:
+      // INSERT INTO t -- only one column is c(int).
+      // SELECT 1 UNION   -- operand0 not need to be coerced.
+      // SELECT 1.0  -- operand1 should be coerced.
+      boolean coerced = rowTypeCoercion(scope, operand0, columnIndex, targetType);
+      coerced = rowTypeCoercion(scope, operand1, columnIndex, targetType) || coerced;
       // Update the nested SET operator node type.
       if (coerced) {
         updateInferredColumnType(
@@ -402,8 +410,9 @@ protected boolean booleanEquality(SqlCallBinding binding,
           validator.deriveType(
               scope, node));
     }
-    SqlNode elseOp = requireNonNull(caseCall.getElseOperand(),
-        () -> "getElseOperand() is null for " + caseCall);
+    SqlNode elseOp =
+        requireNonNull(caseCall.getElseOperand(),
+            () -> "getElseOperand() is null for " + caseCall);
     RelDataType elseOpType = validator.deriveType(scope, elseOp);
     argTypes.add(elseOpType);
     // Entering this method means we have already got a wider type, recompute it here
@@ -497,10 +506,13 @@ protected boolean booleanEquality(SqlCallBinding binding,
           }
         };
 
-        RelDataType widenType = commonTypeForBinaryComparison(columnIthTypes.get(0),
-            columnIthTypes.get(1));
+        RelDataType widenType =
+            commonTypeForBinaryComparison(columnIthTypes.get(0),
+                columnIthTypes.get(1));
         if (widenType == null) {
-          widenType = getTightestCommonType(columnIthTypes.get(0), columnIthTypes.get(1));
+          widenType =
+              getTightestCommonType(columnIthTypes.get(0),
+                  columnIthTypes.get(1));
         }
         if (widenType == null) {
           // Can not find any common type, just return early.
@@ -585,9 +597,9 @@ && coerceOperandType(binding.getScope(), binding.getCall(), i, implicitType)
    */
   @Override public boolean userDefinedFunctionCoercion(SqlValidatorScope scope,
       SqlCall call, SqlFunction function) {
-    final SqlOperandMetadata operandMetadata = requireNonNull(
-        (SqlOperandMetadata) function.getOperandTypeChecker(),
-        () -> "getOperandTypeChecker is not defined for " + function);
+    final SqlOperandMetadata operandMetadata =
+        requireNonNull((SqlOperandMetadata) function.getOperandTypeChecker(),
+            () -> "getOperandTypeChecker is not defined for " + function);
     final List<RelDataType> paramTypes =
         operandMetadata.paramTypes(scope.getValidator().getTypeFactory());
     boolean coerced = false;
@@ -602,10 +614,12 @@ && coerceOperandType(binding.getScope(), binding.getCall(), i, implicitType)
           return false;
         }
         // Column list operand type is not supported now.
-        coerced = coerceOperandType(scope, (SqlCall) operand, 0,
-            paramTypes.get(formalIndex)) || coerced;
+        coerced =
+            coerceOperandType(scope, (SqlCall) operand, 0,
+                paramTypes.get(formalIndex)) || coerced;
       } else {
-        coerced = coerceOperandType(scope, call, i, paramTypes.get(i)) || coerced;
+        coerced =
+            coerceOperandType(scope, call, i, paramTypes.get(i)) || coerced;
       }
     }
     return coerced;
diff --git a/core/src/main/java/org/apache/calcite/sql2rel/DeduplicateCorrelateVariables.java b/core/src/main/java/org/apache/calcite/sql2rel/DeduplicateCorrelateVariables.java
index f6ba9b7dd03..b965b48f644 100644
--- a/core/src/main/java/org/apache/calcite/sql2rel/DeduplicateCorrelateVariables.java
+++ b/core/src/main/java/org/apache/calcite/sql2rel/DeduplicateCorrelateVariables.java
@@ -41,8 +41,9 @@ public class DeduplicateCorrelateVariables extends RelHomogeneousShuttle {
   /** Creates a DeduplicateCorrelateVariables. */
   private DeduplicateCorrelateVariables(RexBuilder builder,
       CorrelationId canonicalId, ImmutableSet<CorrelationId> alternateIds) {
-    dedupRex = new DeduplicateCorrelateVariablesShuttle(builder,
-        canonicalId, alternateIds, this);
+    dedupRex =
+        new DeduplicateCorrelateVariablesShuttle(builder, canonicalId,
+            alternateIds, this);
   }
 
   /**
diff --git a/core/src/main/java/org/apache/calcite/sql2rel/InitializerContext.java b/core/src/main/java/org/apache/calcite/sql2rel/InitializerContext.java
index 8006622a4de..95314fab836 100644
--- a/core/src/main/java/org/apache/calcite/sql2rel/InitializerContext.java
+++ b/core/src/main/java/org/apache/calcite/sql2rel/InitializerContext.java
@@ -30,15 +30,17 @@ public interface InitializerContext {
   RexBuilder getRexBuilder();
 
   /**
-   * Parse a column computation expression for a table. Usually this expression is declared
-   * in the create table statement, i.e.
-   * <pre>
+   * Parses a column computation expression for a table.
+   *
+   * <p>Usually this expression is declared in the {@code CREATE TABLE}
+   * statement, e.g.
+   *
+   * <blockquote><pre>{@code
    *   create table t(
    *     a int not null,
    *     b varchar(5) as (my_udf(a)) virtual,
-   *     c int not null as (a + 1)
-   *   );
-   * </pre>
+   *     c int not null as (a + 1));
+   * }</pre></blockquote>
    *
    * <p>You can use the string format expression "my_udf(a)" and "a + 1"
    * as the initializer expression of column b and c.
diff --git a/core/src/main/java/org/apache/calcite/sql2rel/ReflectiveConvertletTable.java b/core/src/main/java/org/apache/calcite/sql2rel/ReflectiveConvertletTable.java
index 9622c1d2692..d2ed1ba790f 100644
--- a/core/src/main/java/org/apache/calcite/sql2rel/ReflectiveConvertletTable.java
+++ b/core/src/main/java/org/apache/calcite/sql2rel/ReflectiveConvertletTable.java
@@ -90,10 +90,10 @@ private void registerNodeTypeMethod(
     map.put(parameterType, (SqlRexConvertlet) (cx, call) -> {
       try {
         @SuppressWarnings("argument.type.incompatible")
-        RexNode result = (RexNode) method.invoke(ReflectiveConvertletTable.this,
-            cx, call);
-        return requireNonNull(result, () -> "null result from " + method
-            + " for call " + call);
+        RexNode result =
+            (RexNode) method.invoke(ReflectiveConvertletTable.this, cx, call);
+        return requireNonNull(result,
+            () -> "null result from " + method + " for call " + call);
       } catch (IllegalAccessException | InvocationTargetException e) {
         throw new RuntimeException("while converting " + call, e);
       }
@@ -137,10 +137,11 @@ private void registerOpTypeMethod(
     map.put(opClass, (SqlRexConvertlet) (cx, call) -> {
       try {
         @SuppressWarnings("argument.type.incompatible")
-        RexNode result = (RexNode) method.invoke(ReflectiveConvertletTable.this,
-            cx, call.getOperator(), call);
-        return requireNonNull(result, () -> "null result from " + method
-            + " for call " + call);
+        RexNode result =
+            (RexNode) method.invoke(ReflectiveConvertletTable.this, cx,
+                call.getOperator(), call);
+        return requireNonNull(result,
+            () -> "null result from " + method + " for call " + call);
       } catch (IllegalAccessException | InvocationTargetException e) {
         throw new RuntimeException("while converting " + call, e);
       }
@@ -210,6 +211,8 @@ protected void addAlias(
               "call to wrong operator");
           final SqlCall newCall =
               target.createCall(SqlParserPos.ZERO, call.getOperandList());
+          cx.getValidator().setValidatedNodeType(newCall,
+              cx.getValidator().getValidatedNodeType(call));
           return cx.convertExpression(newCall);
         });
   }
diff --git a/core/src/main/java/org/apache/calcite/sql2rel/RelDecorrelator.java b/core/src/main/java/org/apache/calcite/sql2rel/RelDecorrelator.java
index 34f3205cf68..f272d3e3087 100644
--- a/core/src/main/java/org/apache/calcite/sql2rel/RelDecorrelator.java
+++ b/core/src/main/java/org/apache/calcite/sql2rel/RelDecorrelator.java
@@ -532,20 +532,21 @@ protected RexNode removeCorrelationExpr(
 
     int newPos = 0;
 
-    // oldInput has the original group by keys in the front.
+    final List<Integer> groupKeyIndices = rel.getGroupSet().asList();
     final NavigableMap<Integer, RexLiteral> omittedConstants = new TreeMap<>();
     for (int i = 0; i < oldGroupKeyCount; i++) {
-      final RexLiteral constant = projectedLiteral(newInput, i);
+      final int idx = groupKeyIndices.get(i);
+      final RexLiteral constant = projectedLiteral(newInput, idx);
       if (constant != null) {
         // Exclude constants. Aggregate({true}) occurs because Aggregate({})
         // would generate 1 row even when applied to an empty table.
-        omittedConstants.put(i, constant);
+        omittedConstants.put(idx, constant);
         continue;
       }
 
       // add mapping of group keys.
-      outputMap.put(i, newPos);
-      int newInputPos = requireNonNull(frame.oldToNewOutputs.get(i));
+      outputMap.put(idx, newPos);
+      int newInputPos = requireNonNull(frame.oldToNewOutputs.get(idx));
       projects.add(RexInputRef.of2(newInputPos, newInputOutput));
       mapNewInputToProjOutputs.put(newInputPos, newPos);
       newPos++;
@@ -585,8 +586,6 @@ protected RexNode removeCorrelationExpr(
         .projectNamed(Pair.left(projects), Pair.right(projects), true)
         .build();
 
-    newProject = RelOptUtil.copyRelHints(newInput, newProject);
-
     // update mappings:
     // oldInput ----> newInput
     //
@@ -681,7 +680,7 @@ protected RexNode removeCorrelationExpr(
       relBuilder.project(postProjects);
     }
 
-    RelNode newRel = RelOptUtil.copyRelHints(rel, relBuilder.build());
+    RelNode newRel = relBuilder.build();
 
     // Aggregate does not change input ordering so corVars will be
     // located at the same position as the input newProject.
@@ -792,8 +791,6 @@ private static void shiftMapping(Map<Integer, Integer> mapping, int startIndex,
         .projectNamed(Pair.left(projects), Pair.right(projects), true)
         .build();
 
-    newProject = RelOptUtil.copyRelHints(rel, newProject);
-
     return register(rel, newProject, mapOldToNewOutputs, corDefOutputs);
   }
 
@@ -859,8 +856,9 @@ private static void shiftMapping(Map<Integer, Integer> mapping, int startIndex,
       assert newInput != null;
 
       if (!joinedInputs.contains(newInput)) {
-        final List<Integer> positions = requireNonNull(mapNewInputToOutputs.get(newInput),
-            () -> "mapNewInputToOutputs.get(" + newInput + ")");
+        final List<Integer> positions =
+            requireNonNull(mapNewInputToOutputs.get(newInput),
+                () -> "mapNewInputToOutputs.get(" + newInput + ")");
 
         RelNode distinct = relBuilder.push(newInput)
             .project(relBuilder.fields(positions))
@@ -894,8 +892,9 @@ private static void shiftMapping(Map<Integer, Integer> mapping, int startIndex,
       final RelNode newInput = frame.r;
       assert newInput != null;
 
-      final List<Integer> newLocalOutputs = requireNonNull(mapNewInputToOutputs.get(newInput),
-          () -> "mapNewInputToOutputs.get(" + newInput + ")");
+      final List<Integer> newLocalOutputs =
+          requireNonNull(mapNewInputToOutputs.get(newInput),
+              () -> "mapNewInputToOutputs.get(" + newInput + ")");
 
       final int newLocalOutput = requireNonNull(frame.oldToNewOutputs.get(corRef.field));
 
@@ -928,8 +927,9 @@ private Frame getOrCreateFrame(RelNode r) {
   }
 
   private RelNode getCorRel(CorRef corVar) {
-    final RelNode r = requireNonNull(cm.mapCorToCorRel.get(corVar.corr),
-        () -> "cm.mapCorToCorRel.get(" + corVar.corr + ")");
+    final RelNode r =
+        requireNonNull(cm.mapCorToCorRel.get(corVar.corr),
+            () -> "cm.mapCorToCorRel.get(" + corVar.corr + ")");
     return requireNonNull(r.getInput(0),
         () -> "r.getInput(0) is null for " + r);
   }
@@ -1027,13 +1027,16 @@ private Frame decorrelateInputWithValueGenerator(RelNode rel, Frame frame) {
 
     // can directly add positions into corDefOutputs since join
     // does not change the output ordering from the inputs.
-    RelNode valueGen = requireNonNull(
-        createValueGenerator(corVarList, leftInputOutputCount, corDefOutputs),
-        "createValueGenerator(...) is null");
-
-    RelNode join = relBuilder.push(frame.r).push(valueGen)
-        .join(JoinRelType.INNER, relBuilder.literal(true),
-        ImmutableSet.of()).build();
+    final RelNode valueGen =
+        createValueGenerator(corVarList, leftInputOutputCount, corDefOutputs);
+    requireNonNull(valueGen, "valueGen");
+
+    RelNode join =
+        relBuilder
+            .push(frame.r)
+            .push(valueGen)
+            .join(JoinRelType.INNER)
+            .build();
 
     // Join or Filter does not change the old input ordering. All
     // input fields from newLeftInput (i.e. the original input to the old
@@ -1304,7 +1307,6 @@ private static boolean isWidening(RelDataType type, RelDataType type1) {
         .join(rel.getJoinType(),
             decorrelateExpr(castNonNull(currentRel), map, cm, rel.getCondition()),
             ImmutableSet.of())
-        .hints(rel.getHints())
         .build();
 
     // Create the mapping between the output of the old correlation rel
@@ -1358,8 +1360,9 @@ private static RexInputRef getNewForOldInputRef(RelNode currentRel,
         oldInput = oldInput0;
         break;
       }
-      RelNode newInput = requireNonNull(map.get(oldInput0),
-          () -> "map.get(oldInput0) for " + oldInput0).r;
+      RelNode newInput =
+          requireNonNull(map.get(oldInput0),
+              () -> "map.get(oldInput0) for " + oldInput0).r;
       newOrdinal += newInput.getRowType().getFieldCount();
       oldOrdinal -= n;
     }
@@ -1594,6 +1597,7 @@ static Map<Integer, Integer> identityMap(int count) {
   Frame register(RelNode rel, RelNode newRel,
       Map<Integer, Integer> oldToNewOutputs,
       NavigableMap<CorDef, Integer> corDefOutputs) {
+    newRel = RelOptUtil.copyRelHints(rel, newRel);
     final Frame frame = new Frame(rel, newRel, corDefOutputs, oldToNewOutputs);
     map.put(rel, frame);
     return frame;
@@ -1793,10 +1797,11 @@ private RexNode createCaseExpression(
 
     @Override public RexNode visitLiteral(RexLiteral literal) {
       // Use nullIndicator to decide whether to project null.
-      // Do nothing if the literal is null.
+      // Do nothing if the literal is null or symbol.
       if (!RexUtil.isNull(literal)
           && projectPulledAboveLeftCorrelator
-          && (nullIndicator != null)) {
+          && (nullIndicator != null)
+          && !RexUtil.isSymbolLiteral(literal)) {
         return createCaseExpression(nullIndicator, null, literal);
       }
       return literal;
@@ -2435,12 +2440,17 @@ static RemoveCorrelationForScalarAggregateRuleConfig config(RelDecorrelator d,
       int joinOutputProjExprCount =
           leftInputFieldCount + aggInputProjects.size() + 1;
 
-      right = d.createProjectWithAdditionalExprs(right,
-          ImmutableList.of(
-              Pair.of(rexBuilder.makeLiteral(true), "nullIndicator")));
-
-      Join join = (Join) d.relBuilder.push(left).push(right)
-          .join(joinType, joinCond).build();
+      right =
+          d.createProjectWithAdditionalExprs(right,
+              ImmutableList.of(
+                  Pair.of(rexBuilder.makeLiteral(true), "nullIndicator")));
+
+      Join join =
+          (Join) d.relBuilder
+              .push(left)
+              .push(right)
+              .join(joinType, joinCond)
+              .build();
 
       // To the consumer of joinOutputProjRel, nullIndicator is located
       // at the end
diff --git a/core/src/main/java/org/apache/calcite/sql2rel/RelFieldTrimmer.java b/core/src/main/java/org/apache/calcite/sql2rel/RelFieldTrimmer.java
index fff44d96947..c5a9fb20e5d 100644
--- a/core/src/main/java/org/apache/calcite/sql2rel/RelFieldTrimmer.java
+++ b/core/src/main/java/org/apache/calcite/sql2rel/RelFieldTrimmer.java
@@ -48,7 +48,6 @@
 import org.apache.calcite.rel.type.RelDataTypeImpl;
 import org.apache.calcite.rex.RexBuilder;
 import org.apache.calcite.rex.RexCorrelVariable;
-import org.apache.calcite.rex.RexDynamicParam;
 import org.apache.calcite.rex.RexFieldAccess;
 import org.apache.calcite.rex.RexLiteral;
 import org.apache.calcite.rex.RexNode;
@@ -265,7 +264,7 @@ protected TrimResult trimChildRestore(
     relBuilder.push(trimResult.left)
         .project(exprList, nameList);
     return result(relBuilder.build(),
-        Mappings.createIdentity(fieldList.size()));
+        Mappings.createIdentity(fieldList.size()), rel);
   }
 
   /**
@@ -302,11 +301,15 @@ protected final TrimResult dispatchTrimFields(
     return trimResult;
   }
 
+  protected TrimResult result(RelNode rel, final Mapping mapping, RelNode oldRel) {
+    return result(RelOptUtil.copyRelHints(oldRel, rel), mapping);
+  }
+
   protected TrimResult result(RelNode r, final Mapping mapping) {
     final RexBuilder rexBuilder = relBuilder.getRexBuilder();
     for (final CorrelationId correlation : r.getVariablesSet()) {
-      r = r.accept(
-          new CorrelationReferenceFinder() {
+      r =
+          r.accept(new CorrelationReferenceFinder() {
             @Override protected RexNode handle(RexFieldAccess fieldAccess) {
               final RexCorrelVariable v =
                   (RexCorrelVariable) fieldAccess.getReferenceExpr();
@@ -352,11 +355,25 @@ public TrimResult trimFields(
       RelNode rel,
       ImmutableBitSet fieldsUsed,
       Set<RelDataTypeField> extraFields) {
-    // We don't know how to trim this kind of relational expression, so give
-    // it back intact.
+    // We don't know how to trim this kind of relational expression
     Util.discard(fieldsUsed);
-    return result(rel,
-        Mappings.createIdentity(rel.getRowType().getFieldCount()));
+    if (rel.getInputs().isEmpty()) {
+      return result(rel, Mappings.createIdentity(rel.getRowType().getFieldCount()));
+    }
+
+    // We don't know how to trim this RelNode, but we can try to trim inside its inputs
+    List<RelNode> newInputs = new ArrayList<>(rel.getInputs().size());
+    for (RelNode input : rel.getInputs()) {
+      ImmutableBitSet inputFieldsUsed = ImmutableBitSet.range(input.getRowType().getFieldCount());
+      TrimResult trimResult = dispatchTrimFields(input, inputFieldsUsed, extraFields);
+      if (!trimResult.right.isIdentity()) {
+        throw new IllegalArgumentException("Expected identity mapping after processing RelNode "
+            + input + "; but got " + trimResult.right);
+      }
+      newInputs.add(trimResult.left);
+    }
+    RelNode newRel = rel.copy(rel.getTraitSet(), newInputs);
+    return result(newRel, Mappings.createIdentity(newRel.getRowType().getFieldCount()), rel);
   }
 
   /**
@@ -368,17 +385,12 @@ public TrimResult trimFields(
       ImmutableBitSet fieldsUsed,
       Set<RelDataTypeField> extraFields) {
     final RexProgram rexProgram = calc.getProgram();
-    final List<RexNode> projs = Util.transform(rexProgram.getProjectList(),
-        rexProgram::expandLocalRef);
-
-    RexNode conditionExpr = null;
-    if (rexProgram.getCondition() != null) {
-      final List<RexNode> filter = Util.transform(
-          ImmutableList.of(
-              rexProgram.getCondition()), rexProgram::expandLocalRef);
-      assert filter.size() == 1;
-      conditionExpr = filter.get(0);
-    }
+    final List<RexNode> projs =
+        Util.transform(rexProgram.getProjectList(), rexProgram::expandLocalRef);
+
+    final RexNode conditionExpr =
+        rexProgram.getCondition() == null ? null
+            : rexProgram.expandLocalRef(rexProgram.getCondition());
 
     final RelDataType rowType = calc.getRowType();
     final int fieldCount = rowType.getFieldCount();
@@ -444,11 +456,13 @@ public TrimResult trimFields(
     if (conditionExpr != null) {
       newConditionExpr = conditionExpr.accept(shuttle);
     }
-    final RexProgram newRexProgram = RexProgram.create(newInputRelNode.getRowType(),
-        newProjects, newConditionExpr, newRowType.getFieldNames(),
-        newInputRelNode.getCluster().getRexBuilder());
-    final Calc newCalc = calc.copy(calc.getTraitSet(), newInputRelNode, newRexProgram);
-    return result(newCalc, mapping);
+    final RexProgram newRexProgram =
+        RexProgram.create(newInputRelNode.getRowType(), newProjects,
+            newConditionExpr, newRowType.getFieldNames(),
+            newInputRelNode.getCluster().getRexBuilder());
+    final Calc newCalc =
+        calc.copy(calc.getTraitSet(), newInputRelNode, newRexProgram);
+    return result(newCalc, mapping, calc);
   }
 
   /**
@@ -518,8 +532,8 @@ public TrimResult trimFields(
 
     relBuilder.push(newInput);
     relBuilder.project(newProjects, newRowType.getFieldNames());
-    final RelNode newProject = RelOptUtil.propagateRelHints(project, relBuilder.build());
-    return result(newProject, mapping);
+    final RelNode newProject = relBuilder.build();
+    return result(newProject, mapping, project);
   }
 
   /** Creates a project with a dummy column, to protect the parts of the system
@@ -610,7 +624,7 @@ public TrimResult trimFields(
     // The result has the same mapping as the input gave us. Sometimes we
     // return fields that the consumer didn't ask for, because the filter
     // needs them for its condition.
-    return result(relBuilder.build(), inputMapping);
+    return result(relBuilder.build(), inputMapping, filter);
   }
 
   /**
@@ -648,25 +662,15 @@ public TrimResult trimFields(
       return result(sort, Mappings.createIdentity(fieldCount));
     }
 
-    // leave the Sort unchanged in case we have dynamic limits
-    if (sort.offset instanceof RexDynamicParam
-        || sort.fetch instanceof RexDynamicParam) {
-      return result(sort, inputMapping);
-    }
-
     relBuilder.push(newInput);
-    final int offset =
-        sort.offset == null ? 0 : RexLiteral.intValue(sort.offset);
-    final int fetch =
-        sort.fetch == null ? -1 : RexLiteral.intValue(sort.fetch);
     final ImmutableList<RexNode> fields =
         relBuilder.fields(RexUtil.apply(inputMapping, collation));
-    relBuilder.sortLimit(offset, fetch, fields);
+    relBuilder.sortLimit(sort.offset, sort.fetch, fields);
 
     // The result has the same mapping as the input gave us. Sometimes we
     // return fields that the consumer didn't ask for, because the filter
     // needs them for its condition.
-    return result(relBuilder.build(), inputMapping);
+    return result(relBuilder.build(), inputMapping, sort);
   }
 
   public TrimResult trimFields(
@@ -704,7 +708,7 @@ public TrimResult trimFields(
     final RelDistribution newDistribution = distribution.apply(inputMapping);
     relBuilder.exchange(newDistribution);
 
-    return result(relBuilder.build(), inputMapping);
+    return result(relBuilder.build(), inputMapping, exchange);
   }
 
   public TrimResult trimFields(
@@ -747,7 +751,7 @@ public TrimResult trimFields(
     RelDistribution newDistribution = distribution.apply(inputMapping);
     relBuilder.sortExchange(newDistribution, newCollation);
 
-    return result(relBuilder.build(), inputMapping);
+    return result(relBuilder.build(), inputMapping, sortExchange);
   }
 
   /**
@@ -877,9 +881,10 @@ public TrimResult trimFields(
         relBuilder.antiJoin(newConditionExpr);
       }
       Mapping inputMapping = inputMappings.get(0);
-      mapping = Mappings.create(MappingType.INVERSE_SURJECTION,
-          join.getRowType().getFieldCount(),
-          newSystemFieldCount + inputMapping.getTargetCount());
+      mapping =
+          Mappings.create(MappingType.INVERSE_SURJECTION,
+              join.getRowType().getFieldCount(),
+              newSystemFieldCount + inputMapping.getTargetCount());
       for (int i = 0; i < newSystemFieldCount; ++i) {
         mapping.set(i, i);
       }
@@ -892,8 +897,7 @@ public TrimResult trimFields(
     default:
       relBuilder.join(join.getJoinType(), newConditionExpr);
     }
-    relBuilder.hints(join.getHints());
-    return result(relBuilder.build(), mapping);
+    return result(relBuilder.build(), mapping, join);
   }
 
   /**
@@ -914,7 +918,7 @@ public TrimResult trimFields(
     // They can not be trimmed because the comparison needs
     // complete fields.
     if (!(setOp.kind == SqlKind.UNION && setOp.all)) {
-      return result(setOp, Mappings.createIdentity(fieldCount));
+      return trimFields((RelNode) setOp, fieldsUsed, extraFields);
     }
 
     int changeCount = 0;
@@ -981,7 +985,7 @@ public TrimResult trimFields(
     default:
       throw new AssertionError("unknown setOp " + setOp);
     }
-    return result(relBuilder.build(), mapping);
+    return result(relBuilder.build(), mapping, setOp);
   }
 
   /**
@@ -1088,18 +1092,17 @@ public TrimResult trimFields(
 
     if (newAggCallList.isEmpty() && newGroupSet.isEmpty()) {
       // Add a dummy call if all the column fields have been trimmed
-      mapping = Mappings.create(
-          MappingType.INVERSE_SURJECTION,
-          mapping.getSourceCount(),
-          1);
+      mapping =
+          Mappings.create(MappingType.INVERSE_SURJECTION,
+              mapping.getSourceCount(), 1);
       newAggCallList.add(relBuilder.count(false, "DUMMY"));
     }
 
     final RelBuilder.GroupKey groupKey = relBuilder.groupKey(newGroupSet, newGroupSets);
     relBuilder.aggregate(groupKey, newAggCallList);
 
-    final RelNode newAggregate = RelOptUtil.propagateRelHints(aggregate, relBuilder.build());
-    return result(newAggregate, mapping);
+    final RelNode newAggregate = relBuilder.build();
+    return result(newAggregate, mapping, aggregate);
   }
 
   /**
@@ -1146,7 +1149,7 @@ public TrimResult trimFields(
 
     // Always project all fields.
     Mapping mapping = Mappings.createIdentity(fieldCount);
-    return result(newModifier, mapping);
+    return result(newModifier, mapping, modifier);
   }
 
   /**
@@ -1177,15 +1180,16 @@ public TrimResult trimFields(
 
     LogicalTableFunctionScan newTabFun = tabFun;
     if (!tabFun.getInputs().equals(newInputs)) {
-      newTabFun = tabFun.copy(tabFun.getTraitSet(), newInputs,
-          tabFun.getCall(), tabFun.getElementType(), tabFun.getRowType(),
-          tabFun.getColumnMappings());
+      newTabFun =
+          tabFun.copy(tabFun.getTraitSet(), newInputs, tabFun.getCall(),
+              tabFun.getElementType(), tabFun.getRowType(),
+              tabFun.getColumnMappings());
     }
     assert newTabFun.getClass() == tabFun.getClass();
 
     // Always project all fields.
     Mapping mapping = Mappings.createIdentity(fieldCount);
-    return result(newTabFun, mapping);
+    return result(newTabFun, mapping, tabFun);
   }
 
   /**
@@ -1229,7 +1233,7 @@ public TrimResult trimFields(
     final LogicalValues newValues =
         LogicalValues.create(values.getCluster(), newRowType,
             newTuples.build());
-    return result(newValues, mapping);
+    return result(newValues, mapping, values);
   }
 
   protected Mapping createMapping(ImmutableBitSet fieldsUsed, int fieldCount) {
@@ -1281,7 +1285,7 @@ public TrimResult trimFields(
     }
 
     final Mapping mapping = createMapping(fieldsUsed, fieldCount);
-    return result(newTableAccessRel, mapping);
+    return result(newTableAccessRel, mapping, tableAccessRel);
   }
 
   //~ Inner Classes ----------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/sql2rel/RelStructuredTypeFlattener.java b/core/src/main/java/org/apache/calcite/sql2rel/RelStructuredTypeFlattener.java
index f4bf28aa245..1d0570eb7a7 100644
--- a/core/src/main/java/org/apache/calcite/sql2rel/RelStructuredTypeFlattener.java
+++ b/core/src/main/java/org/apache/calcite/sql2rel/RelStructuredTypeFlattener.java
@@ -35,6 +35,7 @@
 import org.apache.calcite.rel.logical.LogicalAggregate;
 import org.apache.calcite.rel.logical.LogicalCalc;
 import org.apache.calcite.rel.logical.LogicalCorrelate;
+import org.apache.calcite.rel.logical.LogicalExchange;
 import org.apache.calcite.rel.logical.LogicalFilter;
 import org.apache.calcite.rel.logical.LogicalIntersect;
 import org.apache.calcite.rel.logical.LogicalJoin;
@@ -43,6 +44,7 @@
 import org.apache.calcite.rel.logical.LogicalProject;
 import org.apache.calcite.rel.logical.LogicalSnapshot;
 import org.apache.calcite.rel.logical.LogicalSort;
+import org.apache.calcite.rel.logical.LogicalSortExchange;
 import org.apache.calcite.rel.logical.LogicalTableFunctionScan;
 import org.apache.calcite.rel.logical.LogicalTableModify;
 import org.apache.calcite.rel.logical.LogicalUnion;
@@ -264,14 +266,12 @@ private List<RexNode> restructureFields(RelDataType structuredType) {
   private RexNode restructure(RelDataType structuredType) {
     // Use ROW(f1,f2,...,fn) to put flattened data back together into a structure.
     List<RexNode> structFields = restructureFields(structuredType);
-    RexNode rowConstructor = rexBuilder.makeCall(
-        structuredType,
-        SqlStdOperatorTable.ROW,
+    return rexBuilder.makeCall(structuredType, SqlStdOperatorTable.ROW,
         structFields);
-    return rowConstructor;
   }
 
   protected void setNewForOldRel(RelNode oldRel, RelNode newRel) {
+    newRel = RelOptUtil.copyRelHints(oldRel, newRel);
     oldToNewRelMap.put(oldRel, newRel);
   }
 
@@ -337,8 +337,19 @@ private boolean noFlatteningForInput(int fieldIdx) {
     for (RelNode input : inputs) {
       fieldCnt += input.getRowType().getFieldCount();
       if (fieldCnt > fieldIdx) {
-        return getNewForOldRel(input).getRowType().getFieldList().size()
-            == input.getRowType().getFieldList().size();
+        List<RelDataTypeField> newTypeFields = getNewForOldRel(input).getRowType().getFieldList();
+        List<RelDataTypeField> inputTypeFields = input.getRowType().getFieldList();
+        if (newTypeFields.size() != inputTypeFields.size()) {
+          return false;
+        }
+        // Ensure single field nested structs aren't flattened
+        for (int i = 0; i < newTypeFields.size(); ++i) {
+          if (newTypeFields.get(i).getType().isStruct()
+              != inputTypeFields.get(i).getType().isStruct()) {
+            return false;
+          }
+        }
+        return true;
       }
     }
     return false;
@@ -416,8 +427,9 @@ public void rewriteRel(LogicalAggregate rel) {
       RelNode restructuredInput = tryRestructure(oldInput, getNewForOldRel(oldInput));
       // expected that after restructuring indexes in AggregateCalls again became relevant,
       // leave it as is but with new input
-      RelNode newRel = rel.copy(rel.getTraitSet(), restructuredInput, rel.getGroupSet(),
-          rel.getGroupSets(), rel.getAggCallList());
+      RelNode newRel =
+          rel.copy(rel.getTraitSet(), restructuredInput, rel.getGroupSet(),
+              rel.getGroupSets(), rel.getAggCallList());
       if (!SqlTypeUtil.isFlat(rel.getRowType())) {
         newRel = coverNewRelByFlatteningProjection(rel, newRel);
       }
@@ -591,6 +603,14 @@ public void rewriteRel(SelfFlatteningRel rel) {
     rel.flattenRel(this);
   }
 
+  public void rewriteRel(LogicalExchange rel) {
+    rewriteGeneric(rel);
+  }
+
+  public void rewriteRel(LogicalSortExchange rel) {
+    rewriteGeneric(rel);
+  }
+
   public void rewriteGeneric(RelNode rel) {
     RelNode newRel = rel.copy(rel.getTraitSet(), rel.getInputs());
     List<RelNode> oldInputs = rel.getInputs();
@@ -701,8 +721,9 @@ private void flattenProjection(RewriteRexShuttle shuttle,
             }
           }
         } else {
-          newExp = rexBuilder.makeCall(exp.getType(), operator,
-              shuttle.visitList(operands));
+          newExp =
+              rexBuilder.makeCall(exp.getType(), operator,
+                  shuttle.visitList(operands));
           // flatten call result type
           flattenResultTypeOfRexCall(newExp, fieldName, flattenedExps);
         }
@@ -757,8 +778,6 @@ public void rewriteRel(TableScan rel) {
     RelNode newRel = rel.getTable().toRel(toRelContext);
     if (!SqlTypeUtil.isFlat(rel.getRowType())) {
       newRel = coverNewRelByFlatteningProjection(rel, newRel);
-    } else {
-      newRel = RelOptUtil.copyRelHints(rel, newRel);
     }
     setNewForOldRel(rel, newRel);
   }
@@ -774,7 +793,6 @@ private RelNode coverNewRelByFlatteningProjection(RelNode rel, RelNode newRel) {
     newRel = relBuilder.push(newRel)
         .projectNamed(projects, fieldNames, true)
         .build();
-    newRel = RelOptUtil.copyRelHints(rel, newRel);
     return newRel;
   }
 
diff --git a/core/src/main/java/org/apache/calcite/sql2rel/SqlNodeToRexConverterImpl.java b/core/src/main/java/org/apache/calcite/sql2rel/SqlNodeToRexConverterImpl.java
index 0c329741611..eb8cee0cabd 100644
--- a/core/src/main/java/org/apache/calcite/sql2rel/SqlNodeToRexConverterImpl.java
+++ b/core/src/main/java/org/apache/calcite/sql2rel/SqlNodeToRexConverterImpl.java
@@ -18,7 +18,6 @@
 
 import org.apache.calcite.avatica.util.ByteString;
 import org.apache.calcite.rel.type.RelDataType;
-import org.apache.calcite.rel.type.RelDataTypeFactory;
 import org.apache.calcite.rex.RexBuilder;
 import org.apache.calcite.rex.RexLiteral;
 import org.apache.calcite.rex.RexNode;
@@ -27,8 +26,6 @@
 import org.apache.calcite.sql.SqlLiteral;
 import org.apache.calcite.sql.SqlTimeLiteral;
 import org.apache.calcite.sql.SqlTimestampLiteral;
-import org.apache.calcite.sql.type.SqlTypeName;
-import org.apache.calcite.sql.validate.SqlValidator;
 import org.apache.calcite.util.BitString;
 import org.apache.calcite.util.DateString;
 import org.apache.calcite.util.NlsString;
@@ -78,30 +75,18 @@ public class SqlNodeToRexConverterImpl implements SqlNodeToRexConverter {
   @Override public RexNode convertLiteral(
       SqlRexContext cx,
       SqlLiteral literal) {
-    RexBuilder rexBuilder = cx.getRexBuilder();
-    RelDataTypeFactory typeFactory = cx.getTypeFactory();
-    SqlValidator validator = cx.getValidator();
+    final RexBuilder rexBuilder = cx.getRexBuilder();
     if (literal.getValue() == null) {
-      // Since there is no eq. RexLiteral of SqlLiteral.Unknown we
-      // treat it as a cast(null as boolean)
-      RelDataType type;
-      if (literal.getTypeName() == SqlTypeName.BOOLEAN) {
-        type = typeFactory.createSqlType(SqlTypeName.BOOLEAN);
-        type = typeFactory.createTypeWithNullability(type, true);
-      } else {
-        type = validator.getValidatedNodeType(literal);
-      }
+      RelDataType type = cx.getValidator().getValidatedNodeType(literal);
       return rexBuilder.makeNullLiteral(type);
     }
 
-    final BitString bitString;
     switch (literal.getTypeName()) {
     case DECIMAL:
       // exact number
       BigDecimal bd = literal.getValueAs(BigDecimal.class);
-      return rexBuilder.makeExactLiteral(
-          bd,
-          literal.createSqlType(typeFactory));
+      RelDataType type = literal.createSqlType(cx.getTypeFactory());
+      return rexBuilder.makeExactLiteral(bd, type);
 
     case DOUBLE:
       // approximate type
@@ -113,13 +98,13 @@ public class SqlNodeToRexConverterImpl implements SqlNodeToRexConverter {
     case BOOLEAN:
       return rexBuilder.makeLiteral(literal.getValueAs(Boolean.class));
     case BINARY:
-      bitString = literal.getValueAs(BitString.class);
+      final BitString bitString = literal.getValueAs(BitString.class);
       Preconditions.checkArgument((bitString.getBitCount() % 8) == 0,
           "incomplete octet");
 
       // An even number of hexits (e.g. X'ABCD') makes whole number
       // of bytes.
-      ByteString byteString = new ByteString(bitString.getAsByteArray());
+      final ByteString byteString = new ByteString(bitString.getAsByteArray());
       return rexBuilder.makeBinaryLiteral(byteString);
     case SYMBOL:
       return rexBuilder.makeFlag(literal.getValueAs(Enum.class));
@@ -127,6 +112,10 @@ public class SqlNodeToRexConverterImpl implements SqlNodeToRexConverter {
       return rexBuilder.makeTimestampLiteral(
           literal.getValueAs(TimestampString.class),
           ((SqlTimestampLiteral) literal).getPrec());
+    case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
+      return rexBuilder.makeTimestampWithLocalTimeZoneLiteral(
+          literal.getValueAs(TimestampString.class),
+          ((SqlTimestampLiteral) literal).getPrec());
     case TIME:
       return rexBuilder.makeTimeLiteral(
           literal.getValueAs(TimeString.class),
@@ -152,6 +141,10 @@ public class SqlNodeToRexConverterImpl implements SqlNodeToRexConverter {
       return rexBuilder.makeIntervalLiteral(
           literal.getValueAs(BigDecimal.class),
           sqlIntervalQualifier);
+
+    case UNKNOWN:
+      return convertLiteral(cx, cx.getValidator().resolveLiteral(literal));
+
     default:
       throw Util.unexpected(literal.getTypeName());
     }
diff --git a/core/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java b/core/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java
index 91d223c62bf..a0659bfc905 100644
--- a/core/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java
+++ b/core/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java
@@ -17,7 +17,10 @@
 package org.apache.calcite.sql2rel;
 
 import org.apache.calcite.avatica.util.Spaces;
+import org.apache.calcite.config.NullCollation;
+import org.apache.calcite.jdbc.CalciteSchema;
 import org.apache.calcite.linq4j.Ord;
+import org.apache.calcite.linq4j.tree.TableExpressionFactory;
 import org.apache.calcite.plan.RelOptCluster;
 import org.apache.calcite.plan.RelOptPlanner;
 import org.apache.calcite.plan.RelOptSamplingParameters;
@@ -30,6 +33,8 @@
 import org.apache.calcite.rel.RelCollation;
 import org.apache.calcite.rel.RelCollationTraitDef;
 import org.apache.calcite.rel.RelCollations;
+import org.apache.calcite.rel.RelDistribution;
+import org.apache.calcite.rel.RelDistributions;
 import org.apache.calcite.rel.RelFieldCollation;
 import org.apache.calcite.rel.RelNode;
 import org.apache.calcite.rel.RelRoot;
@@ -66,6 +71,7 @@
 import org.apache.calcite.rel.logical.LogicalValues;
 import org.apache.calcite.rel.metadata.RelColumnMapping;
 import org.apache.calcite.rel.metadata.RelMetadataQuery;
+import org.apache.calcite.rel.rel2sql.SqlImplementor;
 import org.apache.calcite.rel.stream.Delta;
 import org.apache.calcite.rel.stream.LogicalDelta;
 import org.apache.calcite.rel.type.RelDataType;
@@ -80,6 +86,7 @@
 import org.apache.calcite.rex.RexInputRef;
 import org.apache.calcite.rex.RexLiteral;
 import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.rex.RexOver;
 import org.apache.calcite.rex.RexPatternFieldRef;
 import org.apache.calcite.rex.RexRangeRef;
 import org.apache.calcite.rex.RexShuttle;
@@ -90,6 +97,7 @@
 import org.apache.calcite.schema.ColumnStrategy;
 import org.apache.calcite.schema.ModifiableTable;
 import org.apache.calcite.schema.ModifiableView;
+import org.apache.calcite.schema.Schemas;
 import org.apache.calcite.schema.Table;
 import org.apache.calcite.schema.TranslatableTable;
 import org.apache.calcite.schema.Wrapper;
@@ -174,7 +182,6 @@
 import org.apache.calcite.util.Util;
 import org.apache.calcite.util.trace.CalciteTrace;
 
-import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSet;
@@ -206,7 +213,10 @@
 import java.util.function.UnaryOperator;
 import java.util.stream.Collectors;
 
+import static com.google.common.base.Preconditions.checkArgument;
+
 import static org.apache.calcite.linq4j.Nullness.castNonNull;
+import static org.apache.calcite.runtime.FlatLists.append;
 import static org.apache.calcite.sql.SqlUtil.stripAs;
 
 import static java.util.Objects.requireNonNull;
@@ -752,6 +762,8 @@ protected void convertSelectImpl(
           orderExprList);
     }
 
+    convertQualify(bb, select.getQualify());
+
     if (select.isDistinct()) {
       distinctify(bb, true);
     }
@@ -831,7 +843,7 @@ private void distinctify(
       }
       rel =
           LogicalProject.create(rel, ImmutableList.of(),
-              Pair.left(newProjects), Pair.right(newProjects));
+              Pair.left(newProjects), Pair.right(newProjects), project.getVariablesSet());
       bb.root = rel;
       distinctify(bb, false);
       rel = bb.root();
@@ -852,7 +864,7 @@ private void distinctify(
 
       rel =
           LogicalProject.create(rel, ImmutableList.of(),
-              Pair.left(undoProjects), Pair.right(undoProjects));
+              Pair.left(undoProjects), Pair.right(undoProjects), ImmutableSet.of());
       bb.setRoot(
           rel,
           false);
@@ -861,12 +873,12 @@ private void distinctify(
     }
 
     assert rel != null : "rel must not be null, root = " + bb.root;
-    // Usual case: all of the expressions in the SELECT clause are
-    // different.
+    // Usual case: all expressions in the SELECT clause are different.
     final ImmutableBitSet groupSet =
         ImmutableBitSet.range(rel.getRowType().getFieldCount());
-    rel = createAggregate(bb, groupSet, ImmutableList.of(groupSet),
-        ImmutableList.of());
+    rel =
+        createAggregate(bb, groupSet, ImmutableList.of(groupSet),
+            ImmutableList.of());
 
     bb.setRoot(
         rel,
@@ -931,7 +943,8 @@ protected void convertOrder(
           LogicalProject.create(bb.root(),
               ImmutableList.of(),
               exprs,
-              rowType.getFieldNames().subList(0, fieldCount)),
+              rowType.getFieldNames().subList(0, fieldCount),
+              ImmutableSet.of()),
           false);
     }
   }
@@ -1009,9 +1022,9 @@ private static SqlNode pushDownNotForIn(SqlValidatorScope scope,
                   thenOperand);
           thenOperands.add(pushDownNotForIn(scope, reg(scope, not)));
         }
-        SqlNode elseOperand = requireNonNull(
-            caseNode.getElseOperand(),
-            "getElseOperand for " + caseNode);
+        SqlNode elseOperand =
+            requireNonNull(caseNode.getElseOperand(),
+                "getElseOperand for " + caseNode);
         if (!SqlUtil.isNull(elseOperand)) {
           // "not(unknown)" is "unknown", so no need to simplify
           final SqlCall not =
@@ -1115,8 +1128,9 @@ private void convertWhere(
     if (p != null) {
       assert p.r instanceof Filter;
       Filter f = (Filter) p.r;
-      r = LogicalFilter.create(f.getInput(), f.getCondition(),
-          ImmutableSet.of(p.id));
+      r =
+          LogicalFilter.create(f.getInput(), f.getCondition(),
+              ImmutableSet.of(p.id));
     } else {
       r = filter;
     }
@@ -1128,7 +1142,15 @@ private void replaceSubQueries(
       final Blackboard bb,
       final SqlNode expr,
       RelOptUtil.Logic logic) {
-    findSubQueries(bb, expr, logic, false);
+    replaceSubQueries(bb, expr, logic, null);
+  }
+
+  private void replaceSubQueries(
+      final Blackboard bb,
+      final SqlNode expr,
+      RelOptUtil.Logic logic,
+      final SqlImplementor.@Nullable Clause clause) {
+    findSubQueries(bb, expr, logic, false, clause);
     for (SubQuery node : bb.subQueryList) {
       substituteSubQuery(bb, node);
     }
@@ -1324,8 +1346,9 @@ private void substituteSubQuery(Blackboard bb, SubQuery subQuery) {
         subQuery.expr = rexBuilder.makeLiteral(true);
         return;
       }
-      converted = RelOptUtil.createExistsPlan(seekRel,
-          RelOptUtil.SubQueryType.EXISTS, subQuery.logic, true, relBuilder);
+      converted =
+          RelOptUtil.createExistsPlan(seekRel,
+              RelOptUtil.SubQueryType.EXISTS, subQuery.logic, true, relBuilder);
       assert !converted.indicator;
       if (convertNonCorrelatedSubQuery(subQuery, bb, converted.r, true)) {
         return;
@@ -1342,8 +1365,9 @@ private void substituteSubQuery(Blackboard bb, SubQuery subQuery) {
       }
       call = (SqlBasicCall) subQuery.node;
       query = call.operand(0);
-      converted = convertExists(query, RelOptUtil.SubQueryType.SCALAR,
-          subQuery.logic, true, null);
+      converted =
+          convertExists(query, RelOptUtil.SubQueryType.SCALAR,
+              subQuery.logic, true, null);
       assert !converted.indicator;
       if (convertNonCorrelatedSubQuery(subQuery, bb, converted.r, false)) {
         return;
@@ -1357,8 +1381,9 @@ private void substituteSubQuery(Blackboard bb, SubQuery subQuery) {
       //
       // select * from unnest(select multiset[deptno] from emps);
       //
-      converted = convertExists(subQuery.node, RelOptUtil.SubQueryType.SCALAR,
-          subQuery.logic, true, null);
+      converted =
+          convertExists(subQuery.node, RelOptUtil.SubQueryType.SCALAR,
+              subQuery.logic, true, null);
       assert !converted.indicator;
       subQuery.expr = bb.register(converted.r, JoinRelType.LEFT);
 
@@ -1368,13 +1393,149 @@ private void substituteSubQuery(Blackboard bb, SubQuery subQuery) {
       //
       bb.cursors.add(converted.r);
       return;
-
+    case SET_SEMANTICS_TABLE:
+      if (!config.isExpand()) {
+        return;
+      }
+      substituteSubQueryOfSetSemanticsInputTable(bb, subQuery);
+      return;
     default:
       throw new AssertionError("unexpected kind of sub-query: "
           + subQuery.node);
     }
   }
 
+  private void substituteSubQueryOfSetSemanticsInputTable(
+      Blackboard bb,
+      SubQuery subQuery) {
+    SqlBasicCall call;
+    SqlNode query;
+    call = (SqlBasicCall) subQuery.node;
+    query = call.operand(0);
+    final SqlValidatorScope innerTableScope =
+        (query instanceof SqlSelect)
+            ? validator().getSelectScope((SqlSelect) query)
+            : null;
+    final Blackboard setSemanticsTableBb =
+        createBlackboard(innerTableScope, null, false);
+    final RelNode inputOfSetSemanticsTable =
+        convertQueryRecursive(query, false, null).project();
+    requireNonNull(inputOfSetSemanticsTable,
+        () -> "input RelNode is null for query " + query);
+    SqlNodeList partitionList = call.operand(1);
+    final ImmutableBitSet partitionKeys =
+        buildPartitionKeys(setSemanticsTableBb, partitionList);
+    // For set semantics table, distribution is singleton if does not specify
+    // partition keys
+    RelDistribution distribution = partitionKeys.isEmpty()
+        ? RelDistributions.SINGLETON
+        : RelDistributions.hash(partitionKeys.asList());
+    // ORDER BY
+    final SqlNodeList orderList = call.operand(2);
+    final RelCollation orders = buildCollation(setSemanticsTableBb, orderList);
+    relBuilder.push(inputOfSetSemanticsTable);
+    if (orderList.isEmpty()) {
+      relBuilder.exchange(distribution);
+    } else {
+      relBuilder.sortExchange(distribution, orders);
+    }
+    RelNode tableRel = relBuilder.build();
+    subQuery.expr = bb.register(tableRel, JoinRelType.LEFT);
+    // This is used when converting window table functions:
+    //
+    // select * from table(tumble(table emps, descriptor(deptno),
+    // interval '3' DAY))
+    //
+    bb.cursors.add(tableRel);
+  }
+
+  private ImmutableBitSet buildPartitionKeys(Blackboard bb, SqlNodeList partitionList) {
+    final ImmutableBitSet.Builder partitionKeys = ImmutableBitSet.builder();
+    for (SqlNode partition : partitionList) {
+      validator().deriveType(bb.scope(), partition);
+      RexNode e = bb.convertExpression(partition);
+      partitionKeys.set(parseFieldIdx(e));
+    }
+    return partitionKeys.build();
+  }
+
+  /**
+   * Note: The ORDER BY clause for input table parameter differs from the
+   * ORDER BY clause in some other contexts in that only columns may be sorted
+   * (not arbitrary expressions).
+   *
+   * @param bb              Scope within which to resolve identifiers
+   * @param orderList       Order by clause, may be null
+   * @return ordering of input table
+   */
+  private RelCollation buildCollation(Blackboard bb, SqlNodeList orderList) {
+    final List<RelFieldCollation> orderKeys = new ArrayList<>();
+    for (SqlNode orderItem : orderList) {
+      orderKeys.add(
+          convertOrderItem(
+              bb,
+              orderItem,
+              RelFieldCollation.Direction.ASCENDING,
+              RelFieldCollation.NullDirection.UNSPECIFIED));
+    }
+    return cluster.traitSet().canonize(RelCollations.of(orderKeys));
+  }
+
+  private RelFieldCollation convertOrderItem(
+      Blackboard bb,
+      SqlNode orderItem,
+      RelFieldCollation.Direction direction,
+      RelFieldCollation.NullDirection nullDirection) {
+    switch (orderItem.getKind()) {
+    case DESCENDING:
+      return convertOrderItem(
+          bb,
+          ((SqlCall) orderItem).operand(0),
+          RelFieldCollation.Direction.DESCENDING,
+          nullDirection);
+    case NULLS_FIRST:
+      return convertOrderItem(
+          bb,
+          ((SqlCall) orderItem).operand(0),
+          direction,
+          RelFieldCollation.NullDirection.FIRST);
+    case NULLS_LAST:
+      return convertOrderItem(
+          bb,
+          ((SqlCall) orderItem).operand(0),
+          direction,
+          RelFieldCollation.NullDirection.LAST);
+    default:
+      break;
+    }
+
+    switch (nullDirection) {
+    case UNSPECIFIED:
+      nullDirection = validator().config().defaultNullCollation().last(desc(direction))
+          ? RelFieldCollation.NullDirection.LAST
+          : RelFieldCollation.NullDirection.FIRST;
+      break;
+    default:
+      break;
+    }
+
+    RexNode e = bb.convertExpression(orderItem);
+    return new RelFieldCollation(parseFieldIdx(e), direction, nullDirection);
+  }
+
+  private static int parseFieldIdx(RexNode e) {
+    switch (e.getKind()) {
+    case FIELD_ACCESS:
+      final RexFieldAccess f = (RexFieldAccess) e;
+      return f.getField().getIndex();
+    case INPUT_REF:
+      final RexInputRef ref = (RexInputRef) e;
+      return ref.getIndex();
+    default:
+      throw new AssertionError();
+    }
+  }
+
   private RexNode translateIn(RelOptUtil.Logic logic, @Nullable RelNode root,
       final RexNode rex) {
     switch (logic) {
@@ -1405,7 +1566,8 @@ private RexNode translateIn(RelOptUtil.Logic logic, @Nullable RelNode root,
                 SqlStdOperatorTable.IS_NOT_NULL,
                 rexBuilder.makeFieldAccess(rex, i)));
       }
-      rexNode = rexBuilder.makeCall(rexNode.getType(), SqlStdOperatorTable.AND,
+      rexNode =
+          rexBuilder.makeCall(rexNode.getType(), SqlStdOperatorTable.AND,
               RexUtil.flatten(rexNodeBuilder.build(), SqlStdOperatorTable.AND));
       return rexNode;
 
@@ -1575,8 +1737,9 @@ public RelNode convertToSingleValueSubq(
       RexNode rexComparison;
       final SqlOperator comparisonOp;
       if (op instanceof SqlQuantifyOperator) {
-        comparisonOp = RelOptUtil.op(((SqlQuantifyOperator) op).comparisonKind,
-            SqlStdOperatorTable.EQUALS);
+        comparisonOp =
+            RelOptUtil.op(((SqlQuantifyOperator) op).comparisonKind,
+                SqlStdOperatorTable.EQUALS);
       } else {
         comparisonOp = SqlStdOperatorTable.EQUALS;
       }
@@ -1870,12 +2033,14 @@ private static boolean isRowConstructor(SqlNode node) {
    *                                     corresponds to a variation of a select
    *                                     node, only register it if it's a scalar
    *                                     sub-query
+   * @param clause A clause inside which sub-query is searched
    */
   private void findSubQueries(
       Blackboard bb,
       SqlNode node,
       RelOptUtil.Logic logic,
-      boolean registerOnlyScalarSubQueries) {
+      boolean registerOnlyScalarSubQueries,
+      SqlImplementor.@Nullable Clause clause) {
     final SqlKind kind = node.getKind();
     switch (kind) {
     case EXISTS:
@@ -1886,10 +2051,11 @@ private void findSubQueries(
     case ARRAY_QUERY_CONSTRUCTOR:
     case MAP_QUERY_CONSTRUCTOR:
     case CURSOR:
+    case SET_SEMANTICS_TABLE:
     case SCALAR_QUERY:
       if (!registerOnlyScalarSubQueries
           || (kind == SqlKind.SCALAR_QUERY)) {
-        bb.registerSubQuery(node, RelOptUtil.Logic.TRUE_FALSE);
+        bb.registerSubQuery(node, RelOptUtil.Logic.TRUE_FALSE, clause);
       }
       return;
     case IN:
@@ -1921,7 +2087,7 @@ private void findSubQueries(
           findSubQueries(bb, operand, logic,
               kind == SqlKind.IN || kind == SqlKind.NOT_IN
                   || kind == SqlKind.SOME || kind == SqlKind.ALL
-                  || registerOnlyScalarSubQueries);
+                  || registerOnlyScalarSubQueries, clause);
         }
       }
     } else if (node instanceof SqlNodeList) {
@@ -1929,7 +2095,7 @@ private void findSubQueries(
         findSubQueries(bb, child, logic,
             kind == SqlKind.IN || kind == SqlKind.NOT_IN
                 || kind == SqlKind.SOME || kind == SqlKind.ALL
-                || registerOnlyScalarSubQueries);
+                || registerOnlyScalarSubQueries, clause);
       }
     }
 
@@ -1958,7 +2124,17 @@ private void findSubQueries(
       default:
         break;
       }
-      bb.registerSubQuery(node, logic);
+      if (node instanceof SqlBasicCall
+          && ((SqlCall) node).getOperator() instanceof SqlQuantifyOperator
+          && ((SqlQuantifyOperator) ((SqlCall) node).getOperator())
+              .tryDeriveTypeForCollection(bb.getValidator(), bb.scope(), (SqlCall) node) != null) {
+        findSubQueries(bb, ((SqlCall) node).operand(0), logic, registerOnlyScalarSubQueries,
+            clause);
+        findSubQueries(bb, ((SqlCall) node).operand(1), logic, registerOnlyScalarSubQueries,
+            clause);
+        break;
+      }
+      bb.registerSubQuery(node, logic, clause);
       break;
     default:
       break;
@@ -2075,10 +2251,10 @@ private RexNode convertOver(Blackboard bb, SqlNode node) {
       validator().deriveType(bb.scope(), partition);
       partitionKeys.add(bb.convertExpression(partition));
     }
-    final RexNode lowerBound = bb.convertExpression(
-        requireNonNull(sqlLowerBound, "sqlLowerBound"));
-    final RexNode upperBound = bb.convertExpression(
-        requireNonNull(sqlUpperBound, "sqlUpperBound"));
+    final RexNode lowerBound =
+        bb.convertExpression(requireNonNull(sqlLowerBound, "sqlLowerBound"));
+    final RexNode upperBound =
+        bb.convertExpression(requireNonNull(sqlUpperBound, "sqlUpperBound"));
     if (orderList.size() == 0 && !rows) {
       // A logical range requires an ORDER BY clause. Use the implicit
       // ordering of this relation. There must be one, otherwise it would
@@ -2101,7 +2277,7 @@ private RexNode convertOver(Blackboard bb, SqlNode node) {
     }
 
     try {
-      Preconditions.checkArgument(bb.window == null,
+      checkArgument(bb.window == null,
           "already in window agg mode");
       bb.window = window;
       RexNode rexAgg = exprConverter.convertCall(bb, aggCall);
@@ -2194,8 +2370,9 @@ protected void convertFrom(
 
     case TABLESAMPLE:
       final List<SqlNode> operands = ((SqlCall) from).getOperandList();
-      SqlSampleSpec sampleSpec = SqlLiteral.sampleValue(
-          requireNonNull(operands.get(1), () -> "operand[1] of " + from));
+      SqlSampleSpec sampleSpec =
+          SqlLiteral.sampleValue(
+              requireNonNull(operands.get(1), () -> "operand[1] of " + from));
       if (sampleSpec instanceof SqlSampleSpec.SqlSubstitutionSampleSpec) {
         String sampleName =
             ((SqlSampleSpec.SqlSubstitutionSampleSpec) sampleSpec)
@@ -2286,10 +2463,11 @@ private void convertUnnest(Blackboard bb, SqlCall call, @Nullable List<String> f
       replaceSubQueries(bb, node, RelOptUtil.Logic.TRUE_FALSE_UNKNOWN);
     }
     final List<RexNode> exprs = new ArrayList<>();
-    for (Ord<SqlNode> node : Ord.zip(nodes)) {
-      exprs.add(
-          relBuilder.alias(bb.convertExpression(node.e), validator().deriveAlias(node.e, node.i)));
-    }
+    Ord.forEach(nodes, (node, i) -> {
+      final RexNode e = bb.convertExpression(node);
+      final String alias = SqlValidatorUtil.alias(node, i);
+      exprs.add(relBuilder.alias(e, alias));
+    });
     RelNode child =
         (null != bb.root) ? bb.root : LogicalValues.createOneRow(cluster);
     RelNode uncollect;
@@ -2326,13 +2504,10 @@ protected void convertMatchRecognize(Blackboard bb,
 
     // PARTITION BY
     final SqlNodeList partitionList = matchRecognize.getPartitionList();
-    final ImmutableBitSet.Builder partitionKeys = ImmutableBitSet.builder();
-    for (SqlNode partition : partitionList) {
-      RexNode e = matchBb.convertExpression(partition);
-      partitionKeys.set(((RexInputRef) e).getIndex());
-    }
+    final ImmutableBitSet partitionKeys = buildPartitionKeys(matchBb, partitionList);
 
     // ORDER BY
+    // TODO combine with buildCollation method after support NULLS_FIRST/NULLS_LAST
     final SqlNodeList orderList = matchRecognize.getOrderList();
     final List<RelFieldCollation> orderKeys = new ArrayList<>();
     for (SqlNode order : orderList) {
@@ -2470,7 +2645,7 @@ protected void convertMatchRecognize(Blackboard bb,
             rowType, matchRecognize.getStrictStart().booleanValue(),
             matchRecognize.getStrictEnd().booleanValue(),
             definitionNodes.build(), measureNodes.build(), after, subsetMap,
-            allRows, partitionKeys.build(), orders, intervalNode);
+            allRows, partitionKeys, orders, intervalNode);
     bb.setRoot(rel, false);
   }
 
@@ -2578,11 +2753,12 @@ protected void convertUnpivot(Blackboard bb, SqlUnpivot unpivot) {
         ImmutableList.builder();
     unpivot.forEachNameValues((nodeList, valueList) -> {
       if (valueList == null) {
-        valueList = new SqlNodeList(
-            Collections.nCopies(axisNames.size(),
-                SqlLiteral.createCharString(SqlUnpivot.aliasValue(nodeList),
-                    SqlParserPos.ZERO)),
-            SqlParserPos.ZERO);
+        valueList =
+            new SqlNodeList(
+                Collections.nCopies(axisNames.size(),
+                    SqlLiteral.createCharString(SqlUnpivot.aliasValue(nodeList),
+                        SqlParserPos.ZERO)),
+                SqlParserPos.ZERO);
       }
       final List<RexLiteral> literals = new ArrayList<>();
       Pair.forEach(valueList, unpivot.axisList, (value, axis) -> {
@@ -2619,15 +2795,15 @@ private void convertIdentifier(Blackboard bb, SqlIdentifier id,
       final SqlValidatorTable validatorTable =
           table.unwrapOrThrow(SqlValidatorTable.class);
       final List<RelDataTypeField> extendedFields =
-          SqlValidatorUtil.getExtendedColumns(validator, validatorTable,
+          SqlValidatorUtil.getExtendedColumns(validator(), validatorTable,
               extendedColumns);
       table = table.extend(extendedFields);
     }
     // Review Danny 2020-01-13: hacky to construct a new table scan
     // in order to apply the hint strategies.
-    final List<RelHint> hints = hintStrategies.apply(
-        SqlUtil.getRelHint(hintStrategies, tableHints),
-        LogicalTableScan.create(cluster, table, ImmutableList.of()));
+    final List<RelHint> hints =
+        hintStrategies.apply(SqlUtil.getRelHint(hintStrategies, tableHints),
+            LogicalTableScan.create(cluster, table, ImmutableList.of()));
     final RelNode tableRel = toRel(table, hints);
     bb.setRoot(tableRel, true);
 
@@ -2667,8 +2843,16 @@ protected void convertCollectionTable(
           (SqlUserDefinedTableMacro) operator;
       final TranslatableTable table = udf.getTable(callBinding);
       final RelDataType rowType = table.getRowType(typeFactory);
-      RelOptTable relOptTable = RelOptTableImpl.create(null, rowType, table,
-          udf.getNameAsId().names);
+      CalciteSchema schema =
+          Schemas.subSchema(catalogReader.getRootSchema(),
+              udf.getNameAsId().skipLast(1).names);
+      TableExpressionFactory expressionFunction =
+          clazz -> Schemas.getTableExpression(
+              Objects.requireNonNull(schema, "schema").plus(),
+              Util.last(udf.getNameAsId().names), table, clazz);
+      RelOptTable relOptTable =
+          RelOptTableImpl.create(null, rowType,
+              udf.getNameAsId().names, table, expressionFunction);
       RelNode converted = toRel(relOptTable, ImmutableList.of());
       bb.setRoot(converted, true);
       return;
@@ -2696,16 +2880,6 @@ protected void convertCollectionTable(
             validator().getValidatedNodeType(call),
             columnMappings);
 
-    final SqlValidatorScope selectScope =
-        ((DelegatingScope) bb.scope()).getParent();
-    final Blackboard seekBb = createBlackboard(selectScope, null, false);
-
-    final CorrelationUse p = getCorrelationUse(seekBb, callRel);
-    if (p != null) {
-      assert p.r instanceof LogicalTableFunctionScan;
-      callRel = (LogicalTableFunctionScan) p.r;
-    }
-
     bb.setRoot(callRel, true);
     afterTableFunction(bb, call, callRel);
   }
@@ -2837,9 +3011,9 @@ protected RelNode createJoin(
     SqlValidatorNamespace prevNs = null;
 
     for (CorrelationId correlName : correlatedVariables) {
-      DeferredLookup lookup = requireNonNull(
-          mapCorrelToDeferred.get(correlName),
-          () -> "correlation variable is not found: " + correlName);
+      DeferredLookup lookup =
+          requireNonNull(mapCorrelToDeferred.get(correlName),
+              () -> "correlation variable is not found: " + correlName);
       RexFieldAccess fieldAccess = lookup.getFieldAccess(correlName);
       String originalRelName = lookup.getOriginalRelName();
       String originalFieldName = fieldAccess.getField().getName();
@@ -2929,8 +3103,9 @@ protected RelNode createJoin(
     if (correlNames.size() > 1) {
       // The same table was referenced more than once.
       // So we deduplicate.
-      r = DeduplicateCorrelateVariables.go(rexBuilder, correlNames.get(0),
-          Util.skip(correlNames), r0);
+      r =
+          DeduplicateCorrelateVariables.go(rexBuilder, correlNames.get(0),
+              Util.skip(correlNames), r0);
       // Add new node to leaves.
       leaves.put(r, r.getRowType().getFieldCount());
     }
@@ -2951,9 +3126,9 @@ protected RelNode createJoin(
   private boolean isSubQueryNonCorrelated(RelNode subq, Blackboard bb) {
     Set<CorrelationId> correlatedVariables = RelOptUtil.getVariablesUsed(subq);
     for (CorrelationId correlName : correlatedVariables) {
-      DeferredLookup lookup = requireNonNull(
-          mapCorrelToDeferred.get(correlName),
-          () -> "correlation variable is not found: " + correlName);
+      DeferredLookup lookup =
+          requireNonNull(mapCorrelToDeferred.get(correlName),
+              () -> "correlation variable is not found: " + correlName);
       String originalRelName = lookup.getOriginalRelName();
 
       final SqlNameMatcher nameMatcher =
@@ -3016,8 +3191,8 @@ private void convertJoin(Blackboard bb, SqlJoin join) {
     final RexNode condition;
     final RelNode rightRel;
     if (join.isNatural()) {
-      condition = convertNaturalCondition(getNamespace(left),
-          getNamespace(right));
+      condition =
+          convertNaturalCondition(getNamespace(left), getNamespace(right));
       rightRel = tempRightRel;
     } else {
       switch (conditionType) {
@@ -3026,16 +3201,14 @@ private void convertJoin(Blackboard bb, SqlJoin join) {
         rightRel = tempRightRel;
         break;
       case USING:
-        condition = convertUsingCondition(join,
-            getNamespace(left),
-            getNamespace(right));
+        condition =
+            convertUsingCondition(join, getNamespace(left),
+                getNamespace(right));
         rightRel = tempRightRel;
         break;
       case ON:
-        Pair<RexNode, RelNode> conditionAndRightNode = convertOnCondition(fromBlackboard,
-            join,
-            leftRel,
-            tempRightRel);
+        Pair<RexNode, RelNode> conditionAndRightNode =
+            convertOnCondition(fromBlackboard, join, leftRel, tempRightRel);
         condition = conditionAndRightNode.left;
         rightRel = conditionAndRightNode.right;
         break;
@@ -3043,15 +3216,12 @@ private void convertJoin(Blackboard bb, SqlJoin join) {
         throw Util.unexpected(conditionType);
       }
     }
-    final RelNode joinRel = createJoin(
-        fromBlackboard,
-        leftRel,
-        rightRel,
-        condition,
-        convertJoinType(join.getJoinType()));
+    final RelNode joinRel =
+        createJoin(fromBlackboard, leftRel, rightRel, condition,
+            convertJoinType(join.getJoinType()));
     relBuilder.push(joinRel);
-    final RelNode newProjectRel = relBuilder.project(relBuilder.fields()).build();
-    bb.setRoot(newProjectRel, false);
+    relBuilder.project(relBuilder.fields());
+    bb.setRoot(relBuilder.build(), false);
   }
 
   private RexNode convertNaturalCondition(
@@ -3069,8 +3239,9 @@ private RexNode convertUsingCondition(
       SqlJoin join,
       SqlValidatorNamespace leftNamespace,
       SqlValidatorNamespace rightNamespace) {
-    final SqlNodeList list = (SqlNodeList) requireNonNull(join.getCondition(),
-        () -> "getCondition for join " + join);
+    final SqlNodeList list =
+        requireNonNull((SqlNodeList) join.getCondition(),
+            () -> "getCondition for join " + join);
     return convertUsing(leftNamespace, rightNamespace,
         ImmutableList.copyOf(SqlIdentifier.simpleNames(list)));
   }
@@ -3105,22 +3276,26 @@ private Pair<RexNode, RelNode> convertOnCondition(
       SqlJoin join,
       RelNode leftRel,
       RelNode rightRel) {
-    SqlNode condition = requireNonNull(join.getCondition(),
-        () -> "getCondition for join " + join);
+    SqlNode condition =
+        requireNonNull(join.getCondition(),
+            () -> "getCondition for join " + join);
 
     bb.setRoot(ImmutableList.of(leftRel, rightRel));
     replaceSubQueries(bb, condition, RelOptUtil.Logic.UNKNOWN_AS_FALSE);
-    final RelNode newRightRel = bb.root == null || bb.registered.size() == 0
-        ? rightRel
-        : bb.reRegister(rightRel);
+    final RelNode newRightRel =
+        bb.root == null || bb.registered.size() == 0
+            ? rightRel
+            : bb.reRegister(rightRel);
     bb.setRoot(ImmutableList.of(leftRel, newRightRel));
     RexNode conditionExp =  bb.convertExpression(condition);
     if (conditionExp instanceof RexInputRef && newRightRel != rightRel) {
       int leftFieldCount = leftRel.getRowType().getFieldCount();
       List<RelDataTypeField> rightFieldList = newRightRel.getRowType().getFieldList();
       int rightFieldCount = newRightRel.getRowType().getFieldCount();
-      conditionExp = rexBuilder.makeInputRef(rightFieldList.get(rightFieldCount - 1).getType(),
-          leftFieldCount + rightFieldCount - 1);
+      conditionExp =
+          rexBuilder.makeInputRef(
+              rightFieldList.get(rightFieldCount - 1).getType(),
+              leftFieldCount + rightFieldCount - 1);
     }
     return Pair.of(conditionExp, newRightRel);
   }
@@ -3234,13 +3409,13 @@ protected final void createAggImpl(
     // also replace sub-queries inside ordering spec in the aggregates
     replaceSubQueries(bb, aggregateFinder.orderList,
         RelOptUtil.Logic.TRUE_FALSE_UNKNOWN);
-
     // If group-by clause is missing, pretend that it has zero elements.
     if (groupList == null) {
       groupList = SqlNodeList.EMPTY;
     }
 
-    replaceSubQueries(bb, groupList, RelOptUtil.Logic.TRUE_FALSE_UNKNOWN);
+    replaceSubQueries(bb, groupList, RelOptUtil.Logic.TRUE_FALSE_UNKNOWN,
+        SqlImplementor.Clause.GROUP_BY);
 
     // register the group exprs
 
@@ -3250,9 +3425,9 @@ protected final void createAggImpl(
     // Calcite allows expressions, not just column references in
     // group by list. This is not SQL 2003 compliant, but hey.
 
-    final AggregatingSelectScope scope = requireNonNull(
-        aggConverter.aggregatingSelectScope,
-        "aggregatingSelectScope");
+    final AggregatingSelectScope scope =
+        requireNonNull(aggConverter.aggregatingSelectScope,
+            "aggregatingSelectScope");
     final AggregatingSelectScope.Resolved r = scope.resolved.get();
     for (SqlNode groupExpr : r.groupExprList) {
       aggConverter.addGroupExpr(groupExpr);
@@ -3262,7 +3437,7 @@ protected final void createAggImpl(
     final List<Pair<RexNode, String>> projects = new ArrayList<>();
 
     try {
-      Preconditions.checkArgument(bb.agg == null, "already in agg mode");
+      checkArgument(bb.agg == null, "already in agg mode");
       bb.agg = aggConverter;
 
       // convert the select and having expressions, so that the
@@ -3332,7 +3507,8 @@ protected final void createAggImpl(
       // This needs to be done separately from the sub-query inside
       // any aggregate in the select list, and after the aggregate rel
       // is allocated.
-      replaceSubQueries(bb, selectList, RelOptUtil.Logic.TRUE_FALSE_UNKNOWN);
+      replaceSubQueries(bb, selectList, RelOptUtil.Logic.TRUE_FALSE_UNKNOWN,
+          SqlImplementor.Clause.SELECT);
 
       // Now sub-queries in the entire select list have been converted.
       // Convert the select expressions to get the final list to be
@@ -3357,14 +3533,14 @@ protected final void createAggImpl(
         projects.add(
             Pair.of(bb.convertExpression(expr),
                 k < sysFieldCount
-                    ? castNonNull(validator().deriveAlias(expr, k++))
+                    ? SqlValidatorUtil.alias(expr, k++)
                     : names.get(k++ - sysFieldCount)));
       }
 
       for (SqlNode expr : orderExprList) {
         projects.add(
             Pair.of(bb.convertExpression(expr),
-                castNonNull(validator().deriveAlias(expr, k++))));
+                SqlValidatorUtil.alias(expr, k++)));
       }
     } finally {
       bb.agg = null;
@@ -3525,9 +3701,9 @@ protected RelFieldCollation convertOrderItem(
     }
 
     // Scan the select list and order exprs for an identical expression.
-    final SelectScope selectScope = requireNonNull(
-        validator().getRawSelectScope(select),
-        () -> "getRawSelectScope is not found for " + select);
+    final SelectScope selectScope =
+        requireNonNull(validator().getRawSelectScope(select),
+            () -> "getRawSelectScope is not found for " + select);
     int ordinal = -1;
     List<SqlNode> expandedSelectList = selectScope.getExpandedSelectList();
     for (SqlNode selectItem : requireNonNull(expandedSelectList, "expandedSelectList")) {
@@ -3755,8 +3931,9 @@ public RelNode toRel(final RelOptTable table, final List<RelHint> hints) {
 
     if (hasVirtualFields) {
       final RexNode sourceRef = rexBuilder.makeRangeReference(scan);
-      final Blackboard bb = createInsertBlackboard(table, sourceRef,
-          table.getRowType().getFieldNames());
+      final Blackboard bb =
+          createInsertBlackboard(table, sourceRef,
+              table.getRowType().getFieldNames());
       final List<RexNode> list = new ArrayList<>();
       for (RelDataTypeField f : table.getRowType().getFieldList()) {
         final ColumnStrategy strategy =
@@ -4006,16 +4183,19 @@ protected void collectInsertTargets(
 
   private RelNode convertDelete(SqlDelete call) {
     RelOptTable targetTable = getTargetTable(call);
-    RelNode sourceRel = convertSelect(
-        requireNonNull(call.getSourceSelect(), () -> "sourceSelect for " + call),
-        false);
+    final SqlSelect sourceSelect =
+        requireNonNull(call.getSourceSelect(),
+            () -> "sourceSelect for " + call);
+    RelNode sourceRel = convertSelect(sourceSelect, false);
     return LogicalTableModify.create(targetTable, catalogReader, sourceRel,
         LogicalTableModify.Operation.DELETE, null, null, false);
   }
 
   private RelNode convertUpdate(SqlUpdate call) {
-    final SqlValidatorScope scope = validator().getWhereScope(
-        requireNonNull(call.getSourceSelect(), () -> "sourceSelect for " + call));
+    final SqlSelect sourceSelect =
+        requireNonNull(call.getSourceSelect(),
+            () -> "sourceSelect for " + call);
+    final SqlValidatorScope scope = validator().getWhereScope(sourceSelect);
     Blackboard bb = createBlackboard(scope, null, false);
 
     replaceSubQueries(bb, call, RelOptUtil.Logic.TRUE_FALSE_UNKNOWN);
@@ -4030,15 +4210,15 @@ private RelNode convertUpdate(SqlUpdate call) {
       RelDataTypeField field =
           SqlValidatorUtil.getTargetField(
               targetRowType, typeFactory, id, catalogReader, targetTable);
-      assert field != null : "column " + id.toString() + " not found";
+      assert field != null : "column " + id + " not found";
       targetColumnNameList.add(field.getName());
     }
 
-    RelNode sourceRel = convertSelect(
-        requireNonNull(call.getSourceSelect(), () -> "sourceSelect for " + call), false);
+    RelNode sourceRel = convertSelect(sourceSelect, false);
 
     bb.setRoot(sourceRel, false);
-    ImmutableList.Builder<RexNode> rexNodeSourceExpressionListBuilder = ImmutableList.builder();
+    ImmutableList.Builder<RexNode> rexNodeSourceExpressionListBuilder =
+        ImmutableList.builder();
     for (SqlNode n : call.getSourceExpressionList()) {
       RexNode rn = bb.convertExpression(n);
       rexNodeSourceExpressionListBuilder.add(rn);
@@ -4076,8 +4256,10 @@ private RelNode convertMerge(SqlMerge call) {
 
     // first, convert the merge's source select to construct the columns
     // from the target table and the set expressions in the update call
-    RelNode mergeSourceRel = convertSelect(
-        requireNonNull(call.getSourceSelect(), () -> "sourceSelect for " + call), false);
+    final SqlSelect sourceSelect =
+        requireNonNull(call.getSourceSelect(),
+            () -> "sourceSelect for " + call);
+    RelNode mergeSourceRel = convertSelect(sourceSelect, false);
 
     // then, convert the insert statement so we can get the insert
     // values expressions
@@ -4225,7 +4407,7 @@ protected RexNode adjustInputRef(
   private RelNode convertRowConstructor(
       Blackboard bb,
       SqlCall rowConstructor) {
-    Preconditions.checkArgument(isRowConstructor(rowConstructor));
+    checkArgument(isRowConstructor(rowConstructor));
     final List<SqlNode> operands = rowConstructor.getOperandList();
     return convertMultisets(operands, bb);
   }
@@ -4297,13 +4479,9 @@ private RelNode convertMultisets(final List<SqlNode> operands,
         joinList.add(lastList);
       }
       lastList = new ArrayList<>();
-      final SqlTypeName typeName =
-          requireNonNull(validator, "validator")
-              .getValidatedNodeType(call)
-              .getSqlTypeName();
       relBuilder.push(
           Collect.create(requireNonNull(input, "input"),
-              typeName, castNonNull(validator().deriveAlias(call, i))));
+              call.getKind(), SqlValidatorUtil.alias(call, i)));
       joinList.add(relBuilder.build());
     }
 
@@ -4363,6 +4541,8 @@ private void convertSelectList(
     selectList = validator().expandStar(selectList, select, false);
 
     replaceSubQueries(bb, selectList, RelOptUtil.Logic.TRUE_FALSE_UNKNOWN);
+    replaceSubQueries(bb, new SqlNodeList(orderList, SqlParserPos.ZERO),
+        RelOptUtil.Logic.TRUE_FALSE_UNKNOWN);
 
     List<String> fieldNames = new ArrayList<>();
     final List<RexNode> exprs = new ArrayList<>();
@@ -4395,12 +4575,30 @@ private void convertSelectList(
       fieldNames.add(deriveAlias(expr, aliases, i));
     }
 
-    fieldNames = SqlValidatorUtil.uniquify(fieldNames,
-        catalogReader.nameMatcher().isCaseSensitive());
+    fieldNames =
+        SqlValidatorUtil.uniquify(fieldNames,
+            catalogReader.nameMatcher().isCaseSensitive());
 
     relBuilder.push(bb.root())
         .projectNamed(exprs, fieldNames, true);
-    bb.setRoot(relBuilder.build(), false);
+
+    RelNode project = relBuilder.build();
+
+    final RelNode r;
+    final CorrelationUse p = getCorrelationUse(bb, project);
+    if (p != null) {
+      assert p.r instanceof Project;
+      // correlation variables have been normalized in p.r, we should use expressions
+      // in p.r instead of the original exprs
+      Project project1 = (Project) p.r;
+      r = relBuilder.push(bb.root())
+          .projectNamed(project1.getProjects(), fieldNames, true, ImmutableSet.of(p.id))
+          .build();
+    } else {
+      r = project;
+    }
+
+    bb.setRoot(r, false);
 
     assert bb.columnMonotonicities.isEmpty();
     bb.columnMonotonicities.addAll(columnMonotonicityList);
@@ -4432,13 +4630,14 @@ protected void extraSelectItems(
       List<SqlMonotonicity> columnMonotonicityList) {
   }
 
-  private String deriveAlias(
+  private static String deriveAlias(
       final SqlNode node,
       Collection<String> aliases,
       final int ordinal) {
-    String alias = validator().deriveAlias(node, ordinal);
-    if (alias == null || aliases.contains(alias)) {
-      final String aliasBase = Util.first(alias, SqlUtil.GENERATED_EXPR_ALIAS_PREFIX);
+    checkArgument(ordinal >= 0);
+    String alias = SqlValidatorUtil.alias(node, ordinal);
+    if (aliases.contains(alias)) {
+      final String aliasBase = alias;
       for (int j = 0;; j++) {
         alias = aliasBase + j;
         if (!aliases.contains(alias)) {
@@ -4450,6 +4649,113 @@ private String deriveAlias(
     return alias;
   }
 
+  private void convertQualify(Blackboard bb, @Nullable SqlNode qualify) {
+    if (qualify == null) {
+      return;
+    }
+
+    final LogicalProject projectionFromSelect =
+        requireNonNull((LogicalProject) bb.root, "root");
+
+    // Convert qualify SqlNode to a RexNode
+    replaceSubQueries(bb, qualify, RelOptUtil.Logic.UNKNOWN_AS_FALSE);
+    final RelNode originalRoot = requireNonNull(bb.root, "root");
+    RexNode qualifyRexNode;
+    try {
+      // Set the root to the input of the project,
+      // since QUALIFY might have an expression in the OVER clause
+      // that references a column not in the SELECT.
+      bb.setRoot(projectionFromSelect.getInput(), false);
+      qualifyRexNode = bb.convertExpression(qualify);
+    } finally {
+      bb.setRoot(originalRoot, false);
+    }
+
+    // Check to see if the qualify expression has a referenced expression and
+    // do some referencing accordingly
+    final RexNode qualifyWithReferencesRexNode =
+        qualifyRexNode.accept(
+            new DuplicateEliminator(projectionFromSelect.getProjects()));
+
+    // Create a Project with the QUALIFY expression
+    if (qualifyWithReferencesRexNode.equals(qualifyRexNode)) {
+      // The QUALIFY expression does not depend on any references like so:
+      //
+      //  SELECT A, B
+      //  FROM tbl
+      //  QUALIFY WINDOW(C) = 1
+      //
+      // Meaning we should generate a plan like:
+      //  Project(A, B, WINDOW(C) = 1 as QualifyExpression)
+      //    TableScan(tbl)
+      //
+      relBuilder.push(projectionFromSelect.getInput())
+          .project(
+              append(projectionFromSelect.getProjects(), qualifyRexNode),
+              append(projectionFromSelect.getRowType().getFieldNames(),
+                  "QualifyExpression"));
+    } else {
+      // The QUALIFY expression depended on a reference meaning
+      // we need to introduce an extra project like so:
+      //
+      //  SELECT A, B, WINDOW(C) as window_val
+      //  FROM tbl
+      //  QUALIFY window_val = 1
+      //
+      // Meaning we should generate a plan like:
+      //
+      //  Project($0, $1, $2, =($2, 1) as QualifyExpression)
+      //    Project(A, B, WINDOW(C) as window_val)
+      //      TableScan(tbl)
+      //
+      // This is a very specific application of Common Subexpression Elimination
+      // (CSE), since the window value pops up twice.
+      relBuilder.push(requireNonNull(bb.root, "root"))
+          .project(
+              append(relBuilder.fields(), qualifyWithReferencesRexNode),
+              append(relBuilder.peek().getRowType().getFieldNames(),
+                  "QualifyExpression"));
+    }
+
+    // Filter on that extra column
+    relBuilder.filter(Util.last(relBuilder.fields()));
+
+    // Remove that extra column from the projection
+    relBuilder.project(
+        Util.first(relBuilder.fields(),
+            projectionFromSelect.getProjects().size()));
+
+    // Update the root
+    bb.setRoot(relBuilder.build(), false);
+  }
+
+  /** Eliminates a common sub-expression by looking for a {@link RexNode}
+   * in the expressions of a {@link Project}; if found, returns a refIndex
+   * instead of the raw node. */
+  private static final class DuplicateEliminator extends RexShuttle {
+    private final List<RexNode> projects;
+
+    DuplicateEliminator(List<RexNode> projects) {
+      this.projects = projects;
+    }
+
+    @Override public RexNode visitCall(RexCall call) {
+      final int i = projects.indexOf(call);
+      if (i >= 0) {
+        return new RexInputRef(i, projects.get(i).getType());
+      }
+      return super.visitCall(call);
+    }
+
+    @Override public RexNode visitOver(RexOver over) {
+      final int i = projects.indexOf(over);
+      if (i >= 0) {
+        return new RexInputRef(i, projects.get(i).getType());
+      }
+      return over;
+    }
+  }
+
   /**
    * Converts a WITH sub-query into a relational expression.
    */
@@ -4502,12 +4808,10 @@ private void convertValuesImpl(
       replaceSubQueries(tmpBb, rowConstructor,
           RelOptUtil.Logic.TRUE_FALSE_UNKNOWN);
       final List<Pair<RexNode, String>> exps = new ArrayList<>();
-      for (Ord<SqlNode> operand : Ord.zip(rowConstructor.getOperandList())) {
-        exps.add(
-            Pair.of(
-                tmpBb.convertExpression(operand.e),
-                castNonNull(validator().deriveAlias(operand.e, operand.i))));
-      }
+      Ord.forEach(rowConstructor.getOperandList(), (operand, i) ->
+          exps.add(
+              Pair.of(tmpBb.convertExpression(operand),
+                  SqlValidatorUtil.alias(operand, i))));
       RelNode in =
           (null == tmpBb.root)
               ? LogicalValues.createOneRow(cluster)
@@ -4775,8 +5079,8 @@ public RelNode reRegister(RelNode root) {
         RelNode relNode = reg.rel;
         relBuilder.push(relNode);
         final RelMetadataQuery mq = relBuilder.getCluster().getMetadataQuery();
-        final Boolean unique = mq.areColumnsUnique(relBuilder.peek(),
-            ImmutableBitSet.of());
+        final Boolean unique =
+            mq.areColumnsUnique(relBuilder.peek(), ImmutableBitSet.of());
         if (unique == null || !unique) {
           relBuilder.aggregate(relBuilder.groupKey(),
               relBuilder.aggregateCall(SqlStdOperatorTable.SINGLE_VALUE,
@@ -4902,7 +5206,13 @@ void setRoot(List<RelNode> inputs) {
           int i = 0;
           int offset = 0;
           for (SqlValidatorNamespace c : ancestorScope1.getChildren()) {
-            builder.addAll(c.getRowType().getFieldList());
+            if (ancestorScope1.isChildNullable(i)) {
+              for (final RelDataTypeField f : c.getRowType().getFieldList()) {
+                builder.add(f.getName(), typeFactory.createTypeWithNullability(f.getType(), true));
+              }
+            } else {
+              builder.addAll(c.getRowType().getFieldList());
+            }
             if (i == resolve.path.steps().get(0).i) {
               for (RelDataTypeField field : c.getRowType().getFieldList()) {
                 fields.put(field.getName(), field.getIndex() + offset);
@@ -4980,26 +5290,30 @@ public void flatten(
       }
     }
 
-    void registerSubQuery(SqlNode node, RelOptUtil.Logic logic) {
-      for (SubQuery subQuery : subQueryList) {
-        // Compare the reference to make sure the matched node has
-        // exact scope where it belongs.
-        if (node == subQuery.node) {
-          return;
-        }
+    void registerSubQuery(SqlNode node, RelOptUtil.Logic logic,
+        SqlImplementor.@Nullable Clause clause) {
+      if (getSubQuery(node, clause) == null) {
+        subQueryList.add(new SubQuery(node, logic, clause));
       }
-      subQueryList.add(new SubQuery(node, logic));
     }
 
-    @Nullable SubQuery getSubQuery(SqlNode expr) {
+    @Nullable SubQuery getSubQuery(SqlNode expr, SqlImplementor.@Nullable Clause exprClause) {
       for (SubQuery subQuery : subQueryList) {
         // Compare the reference to make sure the matched node has
         // exact scope where it belongs.
         if (expr == subQuery.node) {
           return subQuery;
         }
-      }
 
+        // Reference comparing does not work in case when select list has column which refers
+        // to the column inside `GROUP BY` clause.
+        // For example: SELECT deptno IN (1,2) FROM emp.deptno GROUP BY deptno IN (1,2);
+        if (exprClause == SqlImplementor.Clause.SELECT
+            && subQuery.clause == SqlImplementor.Clause.GROUP_BY
+            && expr.equalsDeep(subQuery.node, Litmus.IGNORE)) {
+          return subQuery;
+        }
+      }
       return null;
     }
 
@@ -5147,10 +5461,14 @@ ImmutableList<RelNode> retrieveCursors() {
       case CURSOR:
       case IN:
       case NOT_IN:
-        subQuery = requireNonNull(getSubQuery(expr));
+        subQuery = getSubQuery(expr, null);
+        if (subQuery == null && (kind == SqlKind.SOME || kind == SqlKind.ALL)) {
+          break;
+        }
+        assert subQuery != null;
         rex = requireNonNull(subQuery.expr);
         return StandardConvertletTable.castToValidatedType(expr, rex,
-            validator(), rexBuilder);
+            validator(), rexBuilder, false);
 
       case SELECT:
       case EXISTS:
@@ -5158,7 +5476,7 @@ ImmutableList<RelNode> retrieveCursors() {
       case ARRAY_QUERY_CONSTRUCTOR:
       case MAP_QUERY_CONSTRUCTOR:
       case MULTISET_QUERY_CONSTRUCTOR:
-        subQuery = getSubQuery(expr);
+        subQuery = getSubQuery(expr, null);
         assert subQuery != null;
         rex = subQuery.expr;
         assert rex != null : "rex != null";
@@ -5205,6 +5523,7 @@ && isConvertedSubq(rex)) {
      * Converts an item in an ORDER BY clause inside a window (OVER) clause,
      * extracting DESC, NULLS LAST and NULLS FIRST flags first.
      */
+    @Deprecated // to be removed before 2.0
     public RexFieldCollation convertSortExpression(SqlNode expr,
         RelFieldCollation.Direction direction,
         RelFieldCollation.NullDirection nullDirection) {
@@ -5233,6 +5552,8 @@ <R> R convertSortExpression(SqlNode expr,
       }
     }
 
+    // Only used by deprecated method "convertSortExpression", and will be
+    // removed with that method.
     private RexFieldCollation sortToRexFieldCollation(SqlNode expr,
         RelFieldCollation.Direction direction,
         RelFieldCollation.NullDirection nullDirection) {
@@ -5270,9 +5591,21 @@ private RexNode sortToRex(SqlNode expr,
         RelFieldCollation.Direction direction,
         RelFieldCollation.NullDirection nullDirection) {
       RexNode node = convertExpression(expr);
-      if (direction == RelFieldCollation.Direction.DESCENDING) {
+      final boolean desc = direction == RelFieldCollation.Direction.DESCENDING;
+      if (desc) {
         node = relBuilder.desc(node);
       }
+      if (nullDirection == RelFieldCollation.NullDirection.UNSPECIFIED) {
+        final NullCollation nullCollation =
+            validator().config().defaultNullCollation();
+        final boolean nullsLast = nullCollation.last(desc);
+        final boolean nullsFirst = !nullsLast;
+        if (!NullCollation.HIGH.isDefaultOrder(nullsFirst, desc)) {
+          nullDirection = nullsLast
+              ? RelFieldCollation.NullDirection.LAST
+              : RelFieldCollation.NullDirection.FIRST;
+        }
+      }
       if (nullDirection == RelFieldCollation.NullDirection.FIRST) {
         node = relBuilder.nullsFirst(node);
       }
@@ -5328,7 +5661,7 @@ private boolean isConvertedSubq(RexNode rex) {
     }
 
     @Override public RexRangeRef getSubQueryExpr(SqlCall call) {
-      final SubQuery subQuery = getSubQuery(call);
+      final SubQuery subQuery = getSubQuery(call, null);
       assert subQuery != null;
       return (RexRangeRef) requireNonNull(subQuery.expr, () -> "subQuery.expr for " + call);
     }
@@ -5535,8 +5868,7 @@ public AggConverter(Blackboard bb, SqlSelect select) {
           name = call.operand(1).toString();
         }
         if (name == null) {
-          name = validator().deriveAlias(selectItem, i);
-          assert name != null : "alias must not be null for " + selectItem + ", i=" + i;
+          name = SqlValidatorUtil.alias(selectItem, i);
         }
         nameMap.put(selectItem.toString(), name);
       }
@@ -5864,14 +6196,15 @@ private void translateAgg(SqlCall call, @Nullable SqlNode filter,
         try {
           // switch out of agg mode
           bb.agg = null;
-          collation = RelCollations.of(
-              orderList.stream()
-                  .map(order ->
-                      bb.convertSortExpression(order,
-                          RelFieldCollation.Direction.ASCENDING,
-                          RelFieldCollation.NullDirection.UNSPECIFIED,
-                          this::sortToFieldCollation))
-                  .collect(Collectors.toList()));
+          collation =
+              RelCollations.of(
+                  orderList.stream()
+                      .map(order ->
+                          bb.convertSortExpression(order,
+                              RelFieldCollation.Direction.ASCENDING,
+                              RelFieldCollation.NullDirection.UNSPECIFIED,
+                              this::sortToFieldCollation))
+                      .collect(Collectors.toList()));
         } finally {
           // switch back into agg mode
           bb.agg = this;
@@ -6200,10 +6533,13 @@ private static class SubQuery {
     final SqlNode node;
     final RelOptUtil.Logic logic;
     @Nullable RexNode expr;
+    final SqlImplementor.@Nullable Clause clause;
 
-    private SubQuery(SqlNode node, RelOptUtil.Logic logic) {
+    private SubQuery(SqlNode node, RelOptUtil.Logic logic,
+        SqlImplementor.@Nullable Clause clause) {
       this.node = node;
       this.logic = logic;
+      this.clause = clause;
     }
   }
 
@@ -6369,13 +6705,19 @@ public interface Config {
     Config withExplain(boolean explain);
 
     /** Returns the {@code expand} option. Controls whether to expand
-     * sub-queries. If false, each sub-query becomes a
-     * {@link org.apache.calcite.rex.RexSubQuery}. */
+     * sub-queries. If false (the default), each sub-query becomes a
+     * {@link org.apache.calcite.rex.RexSubQuery}.
+     *
+     * <p>Setting {@code expand} to true is deprecated. Expansion still works,
+     * but there will be less development effort in that area. */
     @Value.Default default boolean isExpand() {
-      return true;
+      return false;
     }
 
-    /** Sets {@link #isExpand()}. */
+    /** Sets {@link #isExpand()}.
+     *
+     * <p>Expansion is deprecated. We recommend that you do not call this
+     * method, and use the default value of {@link #isExpand()}, false. */
     Config withExpand(boolean expand);
 
     /** Returns the {@code inSubQueryThreshold} option,
@@ -6475,7 +6817,8 @@ private class NestedJsonFunctionRelRewriter extends RelShuttleImpl {
           newInput,
           project.getHints(),
           newProjections.build(),
-          project.getRowType().getFieldNames());
+          project.getRowType().getFieldNames(),
+          project.getVariablesSet());
     }
 
     private Set<Integer> requiredJsonOutputFromParent(RelNode relNode) {
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 686df63a963..e9b5e7d7b02 100644
--- a/core/src/main/java/org/apache/calcite/sql2rel/StandardConvertletTable.java
+++ b/core/src/main/java/org/apache/calcite/sql2rel/StandardConvertletTable.java
@@ -23,6 +23,7 @@
 import org.apache.calcite.rel.type.RelDataTypeFactory;
 import org.apache.calcite.rel.type.RelDataTypeFamily;
 import org.apache.calcite.rel.type.RelDataTypeField;
+import org.apache.calcite.rel.type.TimeFrame;
 import org.apache.calcite.rex.RexBuilder;
 import org.apache.calcite.rex.RexCall;
 import org.apache.calcite.rex.RexCallBinding;
@@ -49,13 +50,16 @@
 import org.apache.calcite.sql.SqlNumericLiteral;
 import org.apache.calcite.sql.SqlOperator;
 import org.apache.calcite.sql.SqlOperatorBinding;
+import org.apache.calcite.sql.SqlTableFunction;
 import org.apache.calcite.sql.SqlUtil;
 import org.apache.calcite.sql.SqlWindowTableFunction;
 import org.apache.calcite.sql.fun.SqlArrayValueConstructor;
 import org.apache.calcite.sql.fun.SqlBetweenOperator;
 import org.apache.calcite.sql.fun.SqlCase;
+import org.apache.calcite.sql.fun.SqlCastFunction;
 import org.apache.calcite.sql.fun.SqlDatetimeSubtractionOperator;
 import org.apache.calcite.sql.fun.SqlExtractFunction;
+import org.apache.calcite.sql.fun.SqlInternalOperators;
 import org.apache.calcite.sql.fun.SqlJsonValueFunction;
 import org.apache.calcite.sql.fun.SqlLibrary;
 import org.apache.calcite.sql.fun.SqlLibraryOperators;
@@ -75,7 +79,6 @@
 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.sql.validate.SqlValidatorImpl;
 import org.apache.calcite.util.Pair;
 import org.apache.calcite.util.Util;
 
@@ -90,8 +93,14 @@
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
+import java.util.function.UnaryOperator;
+import java.util.stream.Collectors;
 
+import static com.google.common.base.Preconditions.checkArgument;
+
+import static org.apache.calcite.sql.fun.SqlStdOperatorTable.QUANTIFY_OPERATORS;
 import static org.apache.calcite.sql.type.NonNullableAccessors.getComponentTypeOrThrow;
+import static org.apache.calcite.util.Util.first;
 
 import static java.util.Objects.requireNonNull;
 
@@ -111,17 +120,22 @@ private StandardConvertletTable() {
 
     // Register aliases (operators which have a different name but
     // identical behavior to other operators).
+    addAlias(SqlLibraryOperators.LENGTH,
+        SqlStdOperatorTable.CHAR_LENGTH);
     addAlias(SqlStdOperatorTable.CHARACTER_LENGTH,
         SqlStdOperatorTable.CHAR_LENGTH);
     addAlias(SqlStdOperatorTable.IS_UNKNOWN,
         SqlStdOperatorTable.IS_NULL);
     addAlias(SqlStdOperatorTable.IS_NOT_UNKNOWN,
         SqlStdOperatorTable.IS_NOT_NULL);
-    addAlias(SqlLibraryOperators.NULL_SAFE_EQUAL, SqlStdOperatorTable.IS_NOT_DISTINCT_FROM);
+    addAlias(SqlLibraryOperators.NULL_SAFE_EQUAL,
+        SqlStdOperatorTable.IS_NOT_DISTINCT_FROM);
     addAlias(SqlStdOperatorTable.PERCENT_REMAINDER, SqlStdOperatorTable.MOD);
+    addAlias(SqlLibraryOperators.IFNULL, SqlLibraryOperators.NVL);
 
     // Register convertlets for specific objects.
     registerOp(SqlStdOperatorTable.CAST, this::convertCast);
+    registerOp(SqlLibraryOperators.SAFE_CAST, this::convertCast);
     registerOp(SqlLibraryOperators.INFIX_CAST, this::convertCast);
     registerOp(SqlStdOperatorTable.IS_DISTINCT_FROM,
         (cx, call) -> convertIsDistinctFrom(cx, call, false));
@@ -145,6 +159,19 @@ private StandardConvertletTable() {
           }
         });
 
+    // DATE(string) is equivalent to CAST(string AS DATE),
+    // but other DATE variants are treated as regular functions.
+    registerOp(SqlLibraryOperators.DATE,
+        (cx, call) -> {
+          final RexCall e =
+              (RexCall) StandardConvertletTable.this.convertCall(cx, call);
+          if (e.getOperands().size() == 1
+              && SqlTypeUtil.isString(e.getOperands().get(0).getType())) {
+            return cx.getRexBuilder().makeCast(e.type, e.getOperands().get(0));
+          }
+          return e;
+        });
+
     registerOp(SqlLibraryOperators.LTRIM,
         new TrimConvertlet(SqlTrimFunction.Flag.LEADING));
     registerOp(SqlLibraryOperators.RTRIM,
@@ -161,6 +188,34 @@ private StandardConvertletTable() {
     registerOp(SqlLibraryOperators.SUBSTR_POSTGRESQL,
         new SubstrConvertlet(SqlLibrary.POSTGRESQL));
 
+    registerOp(SqlLibraryOperators.DATE_ADD,
+        new TimestampAddConvertlet());
+    registerOp(SqlLibraryOperators.DATE_DIFF,
+        new TimestampDiffConvertlet());
+    registerOp(SqlLibraryOperators.DATE_SUB,
+        new TimestampSubConvertlet());
+    registerOp(SqlLibraryOperators.DATETIME_ADD,
+        new TimestampAddConvertlet());
+    registerOp(SqlLibraryOperators.DATETIME_DIFF,
+        new TimestampDiffConvertlet());
+    registerOp(SqlLibraryOperators.DATETIME_SUB,
+        new TimestampSubConvertlet());
+    registerOp(SqlLibraryOperators.TIME_ADD,
+        new TimestampAddConvertlet());
+    registerOp(SqlLibraryOperators.TIME_DIFF,
+        new TimestampDiffConvertlet());
+    registerOp(SqlLibraryOperators.TIME_SUB,
+        new TimestampSubConvertlet());
+    registerOp(SqlLibraryOperators.TIMESTAMP_ADD2,
+        new TimestampAddConvertlet());
+    registerOp(SqlLibraryOperators.TIMESTAMP_DIFF3,
+        new TimestampDiffConvertlet());
+    registerOp(SqlLibraryOperators.TIMESTAMP_SUB,
+        new TimestampSubConvertlet());
+
+    QUANTIFY_OPERATORS.forEach(operator ->
+        registerOp(operator, StandardConvertletTable::convertQuantifyOperator));
+
     registerOp(SqlLibraryOperators.NVL, StandardConvertletTable::convertNvl);
     registerOp(SqlLibraryOperators.DECODE,
         StandardConvertletTable::convertDecode);
@@ -215,6 +270,13 @@ private StandardConvertletTable() {
                 call.operand(0),
                 SqlLiteral.createExactNumeric("0.5", SqlParserPos.ZERO))));
 
+    // "STRPOS(string, substring) is equivalent to
+    // "POSITION(substring IN string)"
+    registerOp(SqlLibraryOperators.STRPOS,
+        (cx, call) -> cx.convertExpression(
+            SqlStdOperatorTable.POSITION.createCall(SqlParserPos.ZERO,
+                call.operand(1), call.operand(0))));
+
     // REVIEW jvs 24-Apr-2006: This only seems to be working from within a
     // windowed agg.  I have added an optimizer rule
     // org.apache.calcite.rel.rules.AggregateReduceFunctionsRule which handles
@@ -257,7 +319,6 @@ private StandardConvertletTable() {
     final SqlRexConvertlet floorCeilConvertlet = new FloorCeilConvertlet();
     registerOp(SqlStdOperatorTable.FLOOR, floorCeilConvertlet);
     registerOp(SqlStdOperatorTable.CEIL, floorCeilConvertlet);
-
     registerOp(SqlStdOperatorTable.TIMESTAMP_ADD, new TimestampAddConvertlet());
     registerOp(SqlStdOperatorTable.TIMESTAMP_DIFF,
         new TimestampDiffConvertlet());
@@ -300,7 +361,22 @@ private StandardConvertletTable() {
     }
   }
 
-  /** Converts a call to the NVL function. */
+  /** Converts ALL or SOME operators. */
+  private static RexNode convertQuantifyOperator(SqlRexContext cx, SqlCall call) {
+    final RexBuilder rexBuilder = cx.getRexBuilder();
+    final RexNode left = cx.convertExpression(call.getOperandList().get(0));
+    assert call.getOperandList().get(1) instanceof SqlNodeList;
+    final RexNode right = cx.convertExpression(((SqlNodeList) call.getOperandList().get(1)).get(0));
+    final RelDataType rightComponentType = requireNonNull(right.getType().getComponentType());
+    final RelDataType returnType =
+        cx.getTypeFactory().createTypeWithNullability(
+            cx.getTypeFactory().createSqlType(SqlTypeName.BOOLEAN), right.getType().isNullable()
+                || left.getType().isNullable() || rightComponentType.isNullable());
+    return rexBuilder.makeCall(returnType, call.getOperator(), ImmutableList.of(left, right));
+  }
+
+  /** Converts a call to the {@code NVL} function (and also its synonym,
+   * {@code IFNULL}). */
   private static RexNode convertNvl(SqlRexContext cx, SqlCall call) {
     final RexBuilder rexBuilder = cx.getRexBuilder();
     final RexNode operand0 =
@@ -321,8 +397,7 @@ private static RexNode convertNvl(SqlRexContext cx, SqlCall call) {
             rexBuilder.makeCast(
                 cx.getTypeFactory()
                     .createTypeWithNullability(type, operand1.getType().isNullable()),
-                operand1)
-        ));
+                operand1)));
   }
 
   /** Converts a call to the DECODE function. */
@@ -438,10 +513,10 @@ public RexNode convertCase(
     RexBuilder rexBuilder = cx.getRexBuilder();
     final List<RexNode> exprList = new ArrayList<>();
     final RelDataTypeFactory typeFactory = rexBuilder.getTypeFactory();
-    final RexLiteral unknownLiteral = rexBuilder.makeNullLiteral(
-        typeFactory.createSqlType(SqlTypeName.BOOLEAN));
-    final RexLiteral nullLiteral = rexBuilder.makeNullLiteral(
-        typeFactory.createSqlType(SqlTypeName.NULL));
+    final RexLiteral unknownLiteral =
+        rexBuilder.makeNullLiteral(typeFactory.createSqlType(SqlTypeName.BOOLEAN));
+    final RexLiteral nullLiteral =
+        rexBuilder.makeNullLiteral(typeFactory.createSqlType(SqlTypeName.NULL));
     for (int i = 0; i < whenList.size(); i++) {
       if (SqlUtil.isNullLiteral(whenList.get(i), false)) {
         exprList.add(unknownLiteral);
@@ -528,20 +603,10 @@ public RexNode convertMultisetQuery(
         cx.getRexBuilder().makeInputRef(
             msType,
             rr.getOffset());
-    assert msType.getComponentType() != null && msType.getComponentType().isStruct()
-        : "componentType of " + msType + " must be struct";
+    assert msType.getComponentType() != null
+        : "componentType of " + msType + " must not be null";
     assert originalType.getComponentType() != null
-        : "componentType of " + originalType + " must be struct";
-    if (!originalType.getComponentType().isStruct()) {
-      // If the type is not a struct, the multiset operator will have
-      // wrapped the type as a record. Add a call to the $SLICE operator
-      // to compensate. For example,
-      // if '<ms>' has type 'RECORD (INTEGER x) MULTISET',
-      // then '$SLICE(<ms>) has type 'INTEGER MULTISET'.
-      // This will be removed as the expression is translated.
-      expr =
-          cx.getRexBuilder().makeCall(SqlStdOperatorTable.SLICE, expr);
-    }
+        : "componentType of " + originalType + " must not be null";
     return expr;
   }
 
@@ -560,9 +625,13 @@ protected RexNode convertCast(
       SqlRexContext cx,
       final SqlCall call) {
     RelDataTypeFactory typeFactory = cx.getTypeFactory();
-    assert call.getKind() == SqlKind.CAST;
+    final SqlValidator validator = cx.getValidator();
+    final SqlKind kind = call.getKind();
+    checkArgument(kind == SqlKind.CAST || kind == SqlKind.SAFE_CAST, kind);
+    final boolean safe = kind == SqlKind.SAFE_CAST;
     final SqlNode left = call.operand(0);
     final SqlNode right = call.operand(1);
+    final RexBuilder rexBuilder = cx.getRexBuilder();
     if (right instanceof SqlIntervalQualifier) {
       final SqlIntervalQualifier intervalQualifier =
           (SqlIntervalQualifier) right;
@@ -572,65 +641,65 @@ protected RexNode convertCast(
         BigDecimal sourceValue =
             (BigDecimal) sourceInterval.getValue();
         RexLiteral castedInterval =
-            cx.getRexBuilder().makeIntervalLiteral(sourceValue,
+            rexBuilder.makeIntervalLiteral(sourceValue,
                 intervalQualifier);
-        return castToValidatedType(cx, call, castedInterval);
+        return castToValidatedType(call, castedInterval, validator, rexBuilder,
+            safe);
       } else if (left instanceof SqlNumericLiteral) {
         RexLiteral sourceInterval =
             (RexLiteral) cx.convertExpression(left);
         BigDecimal sourceValue =
-            (BigDecimal) sourceInterval.getValue();
+            requireNonNull(sourceInterval.getValueAs(BigDecimal.class),
+                "sourceValue");
         final BigDecimal multiplier = intervalQualifier.getUnit().multiplier;
-        sourceValue = SqlFunctions.multiply(sourceValue, multiplier);
         RexLiteral castedInterval =
-            cx.getRexBuilder().makeIntervalLiteral(
-                sourceValue,
+            rexBuilder.makeIntervalLiteral(
+                SqlFunctions.multiply(sourceValue, multiplier),
                 intervalQualifier);
-        return castToValidatedType(cx, call, castedInterval);
+        return castToValidatedType(call, castedInterval, validator, rexBuilder,
+            safe);
       }
-      return castToValidatedType(cx, call, cx.convertExpression(left));
-    }
-    SqlDataTypeSpec dataType = (SqlDataTypeSpec) right;
-    RelDataType type = dataType.deriveType(cx.getValidator());
-    if (type == null) {
-      type = cx.getValidator().getValidatedNodeType(dataType.getTypeName());
-    }
-    RexNode arg = cx.convertExpression(left);
-    if (arg.getType().isNullable()) {
-      type = typeFactory.createTypeWithNullability(type, true);
+      RexNode value = cx.convertExpression(left);
+      return castToValidatedType(call, value, validator, rexBuilder, safe);
     }
+
+    final RexNode arg = cx.convertExpression(left);
+    final SqlDataTypeSpec dataType = (SqlDataTypeSpec) right;
+    RelDataType type =
+        SqlCastFunction.deriveType(cx.getTypeFactory(), arg.getType(),
+            dataType.deriveType(validator), safe);
     if (SqlUtil.isNullLiteral(left, false)) {
-      final SqlValidatorImpl validator = (SqlValidatorImpl) cx.getValidator();
       validator.setValidatedNodeType(left, type);
       return cx.convertExpression(left);
     }
     if (null != dataType.getCollectionsTypeName()) {
-      final RelDataType argComponentType =
-          requireNonNull(
-              arg.getType().getComponentType(),
-              () -> "componentType of " + arg);
+      RelDataType argComponentType = arg.getType().getComponentType();
+
+      // arg.getType() may be ANY
+      if (argComponentType == null) {
+        argComponentType = dataType.getComponentTypeSpec().deriveType(validator);
+      }
+
+      requireNonNull(argComponentType, () -> "componentType of " + arg);
 
       RelDataType typeFinal = type;
-      final RelDataType componentType = requireNonNull(
-          type.getComponentType(),
-          () -> "componentType of " + typeFinal);
+      final RelDataType componentType =
+          requireNonNull(type.getComponentType(),
+              () -> "componentType of " + typeFinal);
       if (argComponentType.isStruct()
           && !componentType.isStruct()) {
         RelDataType tt =
             typeFactory.builder()
-                .add(
-                    argComponentType.getFieldList().get(0).getName(),
+                .add(argComponentType.getFieldList().get(0).getName(),
                     componentType)
                 .build();
-        tt = typeFactory.createTypeWithNullability(
-            tt,
-            componentType.isNullable());
+        tt = typeFactory.createTypeWithNullability(tt, componentType.isNullable());
         boolean isn = type.isNullable();
         type = typeFactory.createMultisetType(tt, -1);
         type = typeFactory.createTypeWithNullability(type, isn);
       }
     }
-    return cx.getRexBuilder().makeCast(type, arg);
+    return rexBuilder.makeCast(type, arg, safe, safe);
   }
 
   protected RexNode convertFloorCeil(SqlRexContext cx, SqlCall call) {
@@ -651,11 +720,12 @@ protected RexNode convertFloorCeil(SqlRexContext cx, SqlCall call) {
 
       RexNode pad =
           rexBuilder.makeExactLiteral(val.subtract(BigDecimal.ONE));
-      RexNode cast = rexBuilder.makeReinterpretCast(
-          rexInterval.getType(), pad, rexBuilder.makeLiteral(false));
-      RexNode sum = floor
-          ? minus(rexBuilder, rexInterval, cast)
-          : plus(rexBuilder, rexInterval, cast);
+      RexNode cast =
+          rexBuilder.makeReinterpretCast(rexInterval.getType(), pad,
+              rexBuilder.makeLiteral(false));
+      RexNode sum =
+          floor ? minus(rexBuilder, rexInterval, cast)
+              : plus(rexBuilder, rexInterval, cast);
 
       RexNode kase = floor
           ? case_(rexBuilder, rexInterval, cond, sum)
@@ -769,13 +839,8 @@ public RexNode convertJsonValueFunction(
     // For Expression with explicit return type:
     // i.e. json_value('{"foo":"bar"}', 'lax $.foo', returning varchar(2000))
     // use the specified type as the return type.
-    List<SqlNode> operands = call.getOperandList();
-    @SuppressWarnings("all")
-    boolean hasExplicitReturningType = SqlJsonValueFunction.hasExplicitTypeSpec(
-        operands.toArray(SqlNode.EMPTY_ARRAY));
-    if (hasExplicitReturningType) {
-      operands = SqlJsonValueFunction.removeTypeSpecOperands(call);
-    }
+    List<SqlNode> operands =
+        SqlJsonValueFunction.removeTypeSpecOperands(call);
     final List<RexNode> exprs =
         convertOperands(cx, call, operands,
             SqlOperandTypeChecker.Consistency.NONE);
@@ -882,8 +947,8 @@ private RexNode convertItem(
     final boolean isNumericIndex = SqlTypeUtil.isIntType(exprs.get(1).getType());
 
     if (isRowTypeField && isNumericIndex) {
-      final SqlOperatorBinding opBinding = new RexCallBinding(
-          cx.getTypeFactory(), op, exprs, ImmutableList.of());
+      final SqlOperatorBinding opBinding =
+          new RexCallBinding(cx.getTypeFactory(), op, exprs, ImmutableList.of());
       final RelDataType operandType = opBinding.getOperandType(0);
 
       final Integer index = opBinding.getOperandLiteralValue(1, Integer.class);
@@ -958,7 +1023,17 @@ private static List<Integer> elseArgs(int count) {
 
   private static List<RexNode> convertOperands(SqlRexContext cx,
       SqlCall call, SqlOperandTypeChecker.Consistency consistency) {
-    return convertOperands(cx, call, call.getOperandList(), consistency);
+    List<SqlNode> operandList;
+    if (call.getOperator() instanceof SqlTableFunction) {
+      // skip set semantic table node of table function
+      operandList =
+          call.getOperandList().stream().filter(
+              operand -> operand.getKind() != SqlKind.SET_SEMANTICS_TABLE)
+              .collect(Collectors.toList());
+    } else {
+      operandList = call.getOperandList();
+    }
+    return convertOperands(cx, call, operandList, consistency);
   }
 
   private static List<RexNode> convertOperands(SqlRexContext cx,
@@ -1288,18 +1363,20 @@ private static Pair<RexNode, RexNode> convertOverlapsOperand(SqlRexContext cx,
     return Pair.of(r0, r1);
   }
 
-  /**
-   * Casts a RexNode value to the validated type of a SqlCall. If the value
-   * was already of the validated type, then the value is returned without an
-   * additional cast.
-   */
+  @Deprecated // to be removed before 2.0
   public RexNode castToValidatedType(
       @UnknownInitialization StandardConvertletTable this,
       SqlRexContext cx,
       SqlCall call,
       RexNode value) {
     return castToValidatedType(call, value, cx.getValidator(),
-        cx.getRexBuilder());
+        cx.getRexBuilder(), false);
+  }
+
+  @Deprecated // to be removed before 2.0
+  public static RexNode castToValidatedType(SqlNode node, RexNode e,
+      SqlValidator validator, RexBuilder rexBuilder) {
+    return castToValidatedType(node, e, validator, rexBuilder, false);
   }
 
   /**
@@ -1308,12 +1385,12 @@ public RexNode castToValidatedType(
    * additional cast.
    */
   public static RexNode castToValidatedType(SqlNode node, RexNode e,
-      SqlValidator validator, RexBuilder rexBuilder) {
+      SqlValidator validator, RexBuilder rexBuilder, boolean safe) {
     final RelDataType type = validator.getValidatedNodeType(node);
     if (e.getType() == type) {
       return e;
     }
-    return rexBuilder.makeCast(type, e);
+    return rexBuilder.makeCast(type, e, safe, safe);
   }
 
   /** Convertlet that handles {@code COVAR_POP}, {@code COVAR_SAMP},
@@ -1401,12 +1478,15 @@ private static SqlNode expandCovariance(
         count = SqlStdOperatorTable.REGR_COUNT.createCall(pos, arg0, arg1);
       } else {
         sumArgSquared = SqlStdOperatorTable.SUM.createCall(pos, argSquared, dependent);
-        sum0 = SqlStdOperatorTable.SUM.createCall(
-            pos, arg0, Objects.equals(dependent, arg0Input) ? arg1 : dependent);
-        sum1 = SqlStdOperatorTable.SUM.createCall(
-            pos, arg1, Objects.equals(dependent, arg1Input) ? arg0 : dependent);
-        count = SqlStdOperatorTable.REGR_COUNT.createCall(
-            pos, arg0, Objects.equals(dependent, arg0Input) ? arg1 : dependent);
+        sum0 =
+            SqlStdOperatorTable.SUM.createCall(pos, arg0,
+                Objects.equals(dependent, arg0Input) ? arg1 : dependent);
+        sum1 =
+            SqlStdOperatorTable.SUM.createCall(pos, arg1,
+                Objects.equals(dependent, arg1Input) ? arg0 : dependent);
+        count =
+            SqlStdOperatorTable.REGR_COUNT.createCall(pos, arg0,
+                Objects.equals(dependent, arg0Input) ? arg1 : dependent);
       }
 
       final SqlNode sumSquared = SqlStdOperatorTable.MULTIPLY.createCall(pos, sum0, sum1);
@@ -1415,31 +1495,31 @@ private static SqlNode expandCovariance(
 
       final SqlNode avgSumSquared =
           SqlStdOperatorTable.DIVIDE.createCall(pos, sumSquared, countCasted);
-      final SqlNode diff = SqlStdOperatorTable.MINUS.createCall(pos, sumArgSquared, avgSumSquared);
+      final SqlNode diff =
+          SqlStdOperatorTable.MINUS.createCall(pos, sumArgSquared, avgSumSquared);
       SqlNode denominator;
       if (biased) {
         denominator = countCasted;
       } else {
         final SqlNumericLiteral one = SqlLiteral.createExactNumeric("1", pos);
-        denominator = new SqlCase(SqlParserPos.ZERO, countCasted,
-            SqlNodeList.of(SqlStdOperatorTable.EQUALS.createCall(pos, countCasted, one)),
-            SqlNodeList.of(getCastedSqlNode(nullLiteral, varType, pos, null)),
-            SqlStdOperatorTable.MINUS.createCall(pos, countCasted, one));
+        denominator =
+            new SqlCase(SqlParserPos.ZERO, countCasted,
+                SqlNodeList.of(
+                    SqlStdOperatorTable.EQUALS.createCall(pos, countCasted, one)),
+                SqlNodeList.of(getCastedSqlNode(nullLiteral, varType, pos, null)),
+                SqlStdOperatorTable.MINUS.createCall(pos, countCasted, one));
       }
 
       return SqlStdOperatorTable.DIVIDE.createCall(pos, diff, denominator);
     }
 
-    private static SqlNode getCastedSqlNode(SqlNode argInput, RelDataType varType,
-        SqlParserPos pos, @Nullable RexNode argRex) {
-      SqlNode arg;
-      if (argRex != null && !argRex.getType().equals(varType)) {
-        arg = SqlStdOperatorTable.CAST.createCall(
-            pos, argInput, SqlTypeUtil.convertTypeToSpec(varType));
-      } else {
-        arg = argInput;
+    private static SqlNode getCastedSqlNode(SqlNode argInput,
+        RelDataType varType, SqlParserPos pos, @Nullable RexNode argRex) {
+      if (argRex == null || argRex.getType().equals(varType)) {
+        return argInput;
       }
-      return arg;
+      return SqlStdOperatorTable.CAST.createCall(pos, argInput,
+          SqlTypeUtil.convertTypeToSpec(varType));
     }
   }
 
@@ -1522,29 +1602,40 @@ private static SqlNode expandVariance(
       //     / (count(x) - 1)
       final SqlParserPos pos = SqlParserPos.ZERO;
 
-      final SqlNode arg = getCastedSqlNode(argInput, varType, pos, cx.convertExpression(argInput));
+      final SqlNode arg =
+          getCastedSqlNode(argInput, varType, pos,
+              cx.convertExpression(argInput));
 
-      final SqlNode argSquared = SqlStdOperatorTable.MULTIPLY.createCall(pos, arg, arg);
+      final SqlNode argSquared =
+          SqlStdOperatorTable.MULTIPLY.createCall(pos, arg, arg);
       final SqlNode argSquaredCasted =
-          getCastedSqlNode(argSquared, varType, pos, cx.convertExpression(argSquared));
-      final SqlNode sumArgSquared = SqlStdOperatorTable.SUM.createCall(pos, argSquaredCasted);
+          getCastedSqlNode(argSquared, varType, pos,
+              cx.convertExpression(argSquared));
+      final SqlNode sumArgSquared =
+          SqlStdOperatorTable.SUM.createCall(pos, argSquaredCasted);
       final SqlNode sumArgSquaredCasted =
-          getCastedSqlNode(sumArgSquared, varType, pos, cx.convertExpression(sumArgSquared));
+          getCastedSqlNode(sumArgSquared, varType, pos,
+              cx.convertExpression(sumArgSquared));
       final SqlNode sum = SqlStdOperatorTable.SUM.createCall(pos, arg);
-      final SqlNode sumCasted = getCastedSqlNode(sum, varType, pos, cx.convertExpression(sum));
+      final SqlNode sumCasted =
+          getCastedSqlNode(sum, varType, pos, cx.convertExpression(sum));
       final SqlNode sumSquared =
           SqlStdOperatorTable.MULTIPLY.createCall(pos, sumCasted, sumCasted);
       final SqlNode sumSquaredCasted =
-          getCastedSqlNode(sumSquared, varType, pos, cx.convertExpression(sumSquared));
+          getCastedSqlNode(sumSquared, varType, pos,
+              cx.convertExpression(sumSquared));
       final SqlNode count = SqlStdOperatorTable.COUNT.createCall(pos, arg);
       final SqlNode countCasted =
           getCastedSqlNode(count, varType, pos, cx.convertExpression(count));
       final SqlNode avgSumSquared =
-          SqlStdOperatorTable.DIVIDE.createCall(pos, sumSquaredCasted, countCasted);
+          SqlStdOperatorTable.DIVIDE.createCall(pos, sumSquaredCasted,
+              countCasted);
       final SqlNode avgSumSquaredCasted =
-          getCastedSqlNode(avgSumSquared, varType, pos, cx.convertExpression(avgSumSquared));
+          getCastedSqlNode(avgSumSquared, varType, pos,
+              cx.convertExpression(avgSumSquared));
       final SqlNode diff =
-          SqlStdOperatorTable.MINUS.createCall(pos, sumArgSquaredCasted, avgSumSquaredCasted);
+          SqlStdOperatorTable.MINUS.createCall(pos, sumArgSquaredCasted,
+              avgSumSquaredCasted);
       final SqlNode diffCasted =
           getCastedSqlNode(diff, varType, pos, cx.convertExpression(diff));
       final SqlNode denominator;
@@ -1553,15 +1644,17 @@ private static SqlNode expandVariance(
       } else {
         final SqlNumericLiteral one = SqlLiteral.createExactNumeric("1", pos);
         final SqlLiteral nullLiteral = SqlLiteral.createNull(SqlParserPos.ZERO);
-        denominator = new SqlCase(SqlParserPos.ZERO,
-            count,
-            SqlNodeList.of(SqlStdOperatorTable.EQUALS.createCall(pos, count, one)),
-            SqlNodeList.of(getCastedSqlNode(nullLiteral, varType, pos, null)),
-            SqlStdOperatorTable.MINUS.createCall(pos, count, one));
+        denominator =
+            new SqlCase(SqlParserPos.ZERO, count,
+                SqlNodeList.of(
+                    SqlStdOperatorTable.EQUALS.createCall(pos, count, one)),
+                SqlNodeList.of(getCastedSqlNode(nullLiteral, varType, pos, null)),
+                SqlStdOperatorTable.MINUS.createCall(pos, count, one));
       }
       final SqlNode div =
           SqlStdOperatorTable.DIVIDE.createCall(pos, diffCasted, denominator);
-      final SqlNode divCasted = getCastedSqlNode(div, varType, pos, cx.convertExpression(div));
+      final SqlNode divCasted =
+          getCastedSqlNode(div, varType, pos, cx.convertExpression(div));
 
       SqlNode result = div;
       if (sqrt) {
@@ -1571,16 +1664,13 @@ private static SqlNode expandVariance(
       return result;
     }
 
-    private static SqlNode getCastedSqlNode(SqlNode argInput, RelDataType varType,
-            SqlParserPos pos, @Nullable RexNode argRex) {
-      SqlNode arg;
-      if (argRex != null && !argRex.getType().equals(varType)) {
-        arg = SqlStdOperatorTable.CAST.createCall(
-            pos, argInput, SqlTypeUtil.convertTypeToSpec(varType));
-      } else {
-        arg = argInput;
+    private static SqlNode getCastedSqlNode(SqlNode argInput,
+        RelDataType varType, SqlParserPos pos, @Nullable RexNode argRex) {
+      if (argRex == null || argRex.getType().equals(varType)) {
+        return argInput;
       }
-      return arg;
+      return SqlStdOperatorTable.CAST.createCall(pos, argInput,
+          SqlTypeUtil.convertTypeToSpec(varType));
     }
   }
 
@@ -1746,40 +1836,43 @@ private static class SubstrConvertlet implements SqlRexConvertlet {
       switch (library) {
       case POSTGRESQL:
         if (call.operandCount() == 2) {
-          newStart = rexBuilder.makeCall(SqlStdOperatorTable.CASE,
-              rexBuilder.makeCall(SqlStdOperatorTable.LESS_THAN, start,
-                  oneLiteral),
-              oneLiteral, start);
+          newStart =
+              rexBuilder.makeCall(SqlStdOperatorTable.CASE,
+                  rexBuilder.makeCall(SqlStdOperatorTable.LESS_THAN, start,
+                      oneLiteral),
+                  oneLiteral, start);
         } else {
           newStart = start;
         }
         break;
       case BIG_QUERY:
-        newStart = rexBuilder.makeCall(SqlStdOperatorTable.CASE,
-            rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, start,
-                zeroLiteral),
-            oneLiteral,
-            rexBuilder.makeCall(SqlStdOperatorTable.LESS_THAN, start,
-                zeroLiteral),
-            rexBuilder.makeCall(SqlStdOperatorTable.PLUS, start,
-                valueLengthPlusOne),
-            start);
+        newStart =
+            rexBuilder.makeCall(SqlStdOperatorTable.CASE,
+                rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, start,
+                    zeroLiteral),
+                oneLiteral,
+                rexBuilder.makeCall(SqlStdOperatorTable.LESS_THAN, start,
+                    zeroLiteral),
+                rexBuilder.makeCall(SqlStdOperatorTable.PLUS, start,
+                    valueLengthPlusOne),
+                start);
         break;
       default:
-        newStart = rexBuilder.makeCall(SqlStdOperatorTable.CASE,
-            rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, start,
-                zeroLiteral),
-            library == SqlLibrary.MYSQL ? valueLengthPlusOne : oneLiteral,
-            rexBuilder.makeCall(SqlStdOperatorTable.LESS_THAN,
+        newStart =
+            rexBuilder.makeCall(SqlStdOperatorTable.CASE,
+                rexBuilder.makeCall(SqlStdOperatorTable.EQUALS, start,
+                    zeroLiteral),
+                library == SqlLibrary.MYSQL ? valueLengthPlusOne : oneLiteral,
+                rexBuilder.makeCall(SqlStdOperatorTable.LESS_THAN,
+                    rexBuilder.makeCall(SqlStdOperatorTable.PLUS, start,
+                        valueLengthPlusOne),
+                    oneLiteral),
+                valueLengthPlusOne,
+                rexBuilder.makeCall(SqlStdOperatorTable.LESS_THAN, start,
+                    zeroLiteral),
                 rexBuilder.makeCall(SqlStdOperatorTable.PLUS, start,
                     valueLengthPlusOne),
-                oneLiteral),
-            valueLengthPlusOne,
-            rexBuilder.makeCall(SqlStdOperatorTable.LESS_THAN, start,
-                zeroLiteral),
-            rexBuilder.makeCall(SqlStdOperatorTable.PLUS, start,
-                valueLengthPlusOne),
-            start);
+                start);
         break;
       }
 
@@ -1818,18 +1911,58 @@ private static class SubstrConvertlet implements SqlRexConvertlet {
     }
   }
 
-  /** Convertlet that handles the {@code TIMESTAMPADD} function. */
+  /** Convertlet that handles the 3-argument {@code TIMESTAMPADD} function
+   * and the 2-argument BigQuery-style {@code TIMESTAMP_ADD} function. */
   private static class TimestampAddConvertlet implements SqlRexConvertlet {
     @Override public RexNode convertCall(SqlRexContext cx, SqlCall call) {
       // TIMESTAMPADD(unit, count, timestamp)
       //  => timestamp + count * INTERVAL '1' UNIT
+      // TIMESTAMP_ADD(timestamp, interval)
+      //  => timestamp + interval
+      // "timestamp" may be of type TIMESTAMP or TIMESTAMP WITH LOCAL TIME ZONE.
       final RexBuilder rexBuilder = cx.getRexBuilder();
-      final SqlLiteral unitLiteral = call.operand(0);
-      final TimeUnit unit = unitLiteral.getValueAs(TimeUnit.class);
+      SqlIntervalQualifier qualifier;
+      final RexNode op1;
+      final RexNode op2;
+      switch (call.operandCount()) {
+      case 2:
+        // BigQuery-style 'TIMESTAMP_ADD(timestamp, interval)'
+        final SqlBasicCall operandCall = call.operand(1);
+        qualifier  = operandCall.operand(1);
+        op1 = cx.convertExpression(operandCall.operand(0));
+        op2 = cx.convertExpression(call.operand(0));
+        break;
+      default:
+        // JDBC-style 'TIMESTAMPADD(unit, count, timestamp)'
+        qualifier = call.operand(0);
+        op1 = cx.convertExpression(call.operand(1));
+        op2 = cx.convertExpression(call.operand(2));
+      }
+
+      final TimeFrame timeFrame = cx.getValidator().validateTimeFrame(qualifier);
+      final TimeUnit unit = first(timeFrame.unit(), TimeUnit.EPOCH);
+      final RelDataType type = cx.getValidator().getValidatedNodeType(call);
+      if (unit == TimeUnit.EPOCH && qualifier.timeFrameName != null) {
+        // Custom time frames have a different path. They are kept as names,
+        // and then handled by Java functions such as
+        // SqlFunctions.customTimestampAdd.
+        final RexLiteral timeFrameName =
+            rexBuilder.makeLiteral(qualifier.timeFrameName);
+        // If the TIMESTAMPADD call has type TIMESTAMP and op2 has type DATE
+        // (which can happen for sub-day time frames such as HOUR), cast op2 to
+        // TIMESTAMP.
+        final RexNode op2b = rexBuilder.makeCast(type, op2);
+        return rexBuilder.makeCall(type, SqlStdOperatorTable.TIMESTAMP_ADD,
+            ImmutableList.of(timeFrameName, op1, op2b));
+      }
+
+      if (qualifier.getUnit() != unit) {
+        qualifier =
+            new SqlIntervalQualifier(unit, null,
+                qualifier.getParserPosition());
+      }
+
       RexNode interval2Add;
-      SqlIntervalQualifier qualifier =
-          new SqlIntervalQualifier(unit, null, unitLiteral.getParserPosition());
-      RexNode op1 = cx.convertExpression(call.operand(1));
       switch (unit) {
       case MICROSECOND:
       case NANOSECOND:
@@ -1841,23 +1974,125 @@ private static class TimestampAddConvertlet implements SqlRexConvertlet {
                     RoundingMode.UNNECESSARY));
         break;
       default:
-        interval2Add = multiply(rexBuilder,
-            rexBuilder.makeIntervalLiteral(unit.multiplier, qualifier), op1);
+        interval2Add =
+            multiply(rexBuilder,
+                rexBuilder.makeIntervalLiteral(unit.multiplier, qualifier), op1);
       }
 
       return rexBuilder.makeCall(SqlStdOperatorTable.DATETIME_PLUS,
-          cx.convertExpression(call.operand(2)), interval2Add);
+          op2, interval2Add);
+    }
+  }
+
+  /** Convertlet that handles the BigQuery {@code TIMESTAMP_SUB} function. */
+  private static class TimestampSubConvertlet implements SqlRexConvertlet {
+    @Override public RexNode convertCall(SqlRexContext cx, SqlCall call) {
+      // TIMESTAMP_SUB(timestamp, interval)
+      //  => timestamp - count * INTERVAL '1' UNIT
+      final RexBuilder rexBuilder = cx.getRexBuilder();
+      final SqlBasicCall operandCall = call.operand(1);
+      SqlIntervalQualifier qualifier = operandCall.operand(1);
+      final RexNode op1 = cx.convertExpression(operandCall.operand(0));
+      final RexNode op2 = cx.convertExpression(call.operand(0));
+      final TimeFrame timeFrame = cx.getValidator().validateTimeFrame(qualifier);
+      final TimeUnit unit = first(timeFrame.unit(), TimeUnit.EPOCH);
+      final RexNode interval2Sub;
+      switch (unit) {
+      //Fractional second units are converted to seconds using their associated multiplier.
+      case MICROSECOND:
+      case NANOSECOND:
+        interval2Sub =
+            divide(rexBuilder,
+                multiply(rexBuilder,
+                    rexBuilder.makeIntervalLiteral(BigDecimal.ONE, qualifier), op1),
+                BigDecimal.ONE.divide(unit.multiplier,
+                    RoundingMode.UNNECESSARY));
+        break;
+      default:
+        interval2Sub =
+            multiply(rexBuilder,
+                rexBuilder.makeIntervalLiteral(unit.multiplier, qualifier), op1);
+      }
+
+      return rexBuilder.makeCall(SqlInternalOperators.MINUS_DATE2,
+          op2, interval2Sub);
     }
   }
 
   /** Convertlet that handles the {@code TIMESTAMPDIFF} function. */
   private static class TimestampDiffConvertlet implements SqlRexConvertlet {
     @Override public RexNode convertCall(SqlRexContext cx, SqlCall call) {
+      // The standard TIMESTAMPDIFF and BigQuery's TIMESTAMP_DIFF have two key
+      // differences. The first being the order of the subtraction, outlined
+      // below. The second is that BigQuery truncates each timestamp to the
+      // specified time unit before the difference is computed.
+      //
+      // In fact, all BigQuery functions (TIMESTAMP_DIFF, DATETIME_DIFF,
+      // DATE_DIFF) truncate before subtracting when applied to date intervals
+      // (DAY, WEEK, ISOWEEK, MONTH, YEAR, etc.)
+      //
+      // For example, if computing the number of weeks between two timestamps,
+      // one occurring on a Saturday and the other occurring the next day on
+      // Sunday, their week difference is 1. This is because the first timestamp
+      // is truncated to the previous Sunday. This is done by making calls to
+      // TIMESTAMP_TRUNC and the difference is then computed using their
+      // results.
+      //
       // TIMESTAMPDIFF(unit, t1, t2)
       //    => (t2 - t1) UNIT
+      // TIMESTAMP_DIFF(t1, t2, unit)
+      //    => (t1 - t2) UNIT
+      SqlIntervalQualifier qualifier;
+      final boolean preTruncate;
+      final RexNode op1;
+      final RexNode op2;
+      if (call.operand(0).getKind() == SqlKind.INTERVAL_QUALIFIER) {
+        qualifier = call.operand(0);
+        preTruncate = false;
+        op1 = cx.convertExpression(call.operand(1));
+        op2 = cx.convertExpression(call.operand(2));
+      } else {
+        qualifier = call.operand(2);
+        preTruncate = qualifier.isDate();
+        op1 = cx.convertExpression(call.operand(1));
+        op2 = cx.convertExpression(call.operand(0));
+      }
       final RexBuilder rexBuilder = cx.getRexBuilder();
-      final SqlLiteral unitLiteral = call.operand(0);
-      TimeUnit unit = unitLiteral.getValueAs(TimeUnit.class);
+      final RelDataTypeFactory typeFactory = cx.getTypeFactory();
+      final TimeFrame timeFrame = cx.getValidator().validateTimeFrame(qualifier);
+      final TimeUnit unit = first(timeFrame.unit(), TimeUnit.EPOCH);
+      UnaryOperator<RexNode> truncateFn = UnaryOperator.identity();
+
+      if (unit == TimeUnit.EPOCH && qualifier.timeFrameName != null) {
+        // Custom time frames have a different path. They are kept as names, and
+        // then handled by Java functions.
+        final RexLiteral timeFrameName =
+            rexBuilder.makeLiteral(qualifier.timeFrameName);
+        // This additional logic accounts for BigQuery truncating prior to
+        // computing the difference.
+        if (preTruncate) {
+          truncateFn = e ->
+              rexBuilder.makeCall(e.getType(),
+                  SqlLibraryOperators.TIMESTAMP_TRUNC,
+                  ImmutableList.of(e, timeFrameName));
+        }
+        return rexBuilder.makeCall(cx.getValidator().getValidatedNodeType(call),
+            SqlStdOperatorTable.TIMESTAMP_DIFF,
+            ImmutableList.of(timeFrameName, truncateFn.apply(op1),
+                truncateFn.apply(op2)));
+      }
+
+      if (preTruncate) {
+        // The timestamps should be truncated unless the time unit is HOUR, in
+        // which case only the whole number of hours between the timestamps
+        // should be returned.
+        final RexNode timeUnit = cx.convertExpression(qualifier);
+        truncateFn = e ->
+            rexBuilder.makeCall(e.getType(),
+                SqlLibraryOperators.TIMESTAMP_TRUNC,
+                ImmutableList.of(e, timeUnit));
+      }
+
       BigDecimal multiplier = BigDecimal.ONE;
       BigDecimal divider = BigDecimal.ONE;
       SqlTypeName sqlTypeName = unit == TimeUnit.NANOSECOND
@@ -1870,31 +2105,38 @@ private static class TimestampDiffConvertlet implements SqlRexConvertlet {
       case WEEK:
         multiplier = BigDecimal.valueOf(DateTimeUtils.MILLIS_PER_SECOND);
         divider = unit.multiplier;
-        unit = TimeUnit.SECOND;
+        qualifier =
+            new SqlIntervalQualifier(TimeUnit.SECOND, null,
+                qualifier.getParserPosition());
         break;
       case QUARTER:
+      case CENTURY:
+      case MILLENNIUM:
         divider = unit.multiplier;
-        unit = TimeUnit.MONTH;
+        qualifier =
+            new SqlIntervalQualifier(TimeUnit.MONTH, null,
+                qualifier.getParserPosition());
         break;
       default:
+        qualifier =
+            new SqlIntervalQualifier(unit, null,
+                qualifier.getParserPosition());
         break;
       }
-      final SqlIntervalQualifier qualifier =
-          new SqlIntervalQualifier(unit, null, SqlParserPos.ZERO);
-      final RexNode op2 = cx.convertExpression(call.operand(2));
-      final RexNode op1 = cx.convertExpression(call.operand(1));
+
       final RelDataType intervalType =
-          cx.getTypeFactory().createTypeWithNullability(
-              cx.getTypeFactory().createSqlIntervalType(qualifier),
+          typeFactory.createTypeWithNullability(
+              typeFactory.createSqlIntervalType(qualifier),
               op1.getType().isNullable() || op2.getType().isNullable());
-      final RexCall rexCall = (RexCall) rexBuilder.makeCall(
-          intervalType, SqlStdOperatorTable.MINUS_DATE,
-          ImmutableList.of(op2, op1));
+      final RexNode call2 =
+          rexBuilder.makeCall(intervalType,
+              SqlStdOperatorTable.MINUS_DATE,
+              ImmutableList.of(truncateFn.apply(op2), truncateFn.apply(op1)));
       final RelDataType intType =
-          cx.getTypeFactory().createTypeWithNullability(
-              cx.getTypeFactory().createSqlType(sqlTypeName),
-              SqlTypeUtil.containsNullable(rexCall.getType()));
-      RexNode e = rexBuilder.makeCast(intType, rexCall);
+          typeFactory.createTypeWithNullability(
+              typeFactory.createSqlType(sqlTypeName),
+              SqlTypeUtil.containsNullable(call2.getType()));
+      RexNode e = rexBuilder.makeCast(intType, call2);
       return rexBuilder.multiplyDivide(e, multiplier, divider);
     }
   }
diff --git a/core/src/main/java/org/apache/calcite/tools/Hoist.java b/core/src/main/java/org/apache/calcite/tools/Hoist.java
index fad91ffe0b0..f2ac5dba04a 100644
--- a/core/src/main/java/org/apache/calcite/tools/Hoist.java
+++ b/core/src/main/java/org/apache/calcite/tools/Hoist.java
@@ -147,10 +147,12 @@ private Variable(String originalSql, int ordinal, SqlNode node) {
       this.ordinal = ordinal;
       this.node = Objects.requireNonNull(node, "node");
       final SqlParserPos pos = node.getParserPosition();
-      start = SqlParserUtil.lineColToIndex(originalSql,
-          pos.getLineNum(), pos.getColumnNum());
-      end = SqlParserUtil.lineColToIndex(originalSql,
-          pos.getEndLineNum(), pos.getEndColumnNum()) + 1;
+      start =
+          SqlParserUtil.lineColToIndex(originalSql,
+              pos.getLineNum(), pos.getColumnNum());
+      end =
+          SqlParserUtil.lineColToIndex(originalSql,
+              pos.getEndLineNum(), pos.getEndColumnNum()) + 1;
 
       Preconditions.checkArgument(ordinal >= 0);
       Preconditions.checkArgument(start >= 0);
diff --git a/core/src/main/java/org/apache/calcite/tools/Planner.java b/core/src/main/java/org/apache/calcite/tools/Planner.java
index 11de3da0d85..afaf160c741 100644
--- a/core/src/main/java/org/apache/calcite/tools/Planner.java
+++ b/core/src/main/java/org/apache/calcite/tools/Planner.java
@@ -78,6 +78,14 @@ default SqlNode parse(String sql) throws SqlParseException {
    */
   Pair<SqlNode, RelDataType> validateAndGetType(SqlNode sqlNode) throws ValidationException;
 
+  /**
+   * Returns a record type that contains the name and type of each parameter.
+   * Returns a record type with no fields if there are no parameters.
+   *
+   * @return Record type
+   */
+  RelDataType getParameterRowType();
+
   /**
    * Converts a SQL parse tree into a tree of relational expressions.
    *
diff --git a/core/src/main/java/org/apache/calcite/tools/Programs.java b/core/src/main/java/org/apache/calcite/tools/Programs.java
index 63bc8962f2e..e22f4c4dcf0 100644
--- a/core/src/main/java/org/apache/calcite/tools/Programs.java
+++ b/core/src/main/java/org/apache/calcite/tools/Programs.java
@@ -48,12 +48,13 @@
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Lists;
 
-import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 
 import static org.apache.calcite.linq4j.Nullness.castNonNull;
 
+import static java.util.Objects.requireNonNull;
+
 /**
  * Utilities for creating {@link Program}s.
  */
@@ -89,6 +90,7 @@ public class Programs {
           EnumerableRules.ENUMERABLE_WINDOW_RULE,
           EnumerableRules.ENUMERABLE_MATCH_RULE,
           CoreRules.PROJECT_TO_SEMI_JOIN,
+          CoreRules.JOIN_ON_UNIQUE_TO_SEMI_JOIN,
           CoreRules.JOIN_TO_SEMI_JOIN,
           CoreRules.MATCH,
           CalciteSystemProperty.COMMUTE.value()
@@ -154,14 +156,12 @@ public static Program hep(Iterable<? extends RelOptRule> rules,
   @SuppressWarnings("deprecation")
   public static Program of(final HepProgram hepProgram, final boolean noDag,
       final RelMetadataProvider metadataProvider) {
+    requireNonNull(metadataProvider, "metadataProvider");
     return (planner, rel, requiredOutputTraits, materializations, lattices) -> {
-      final HepPlanner hepPlanner = new HepPlanner(hepProgram,
-          null, noDag, null, RelOptCostImpl.FACTORY);
+      final HepPlanner hepPlanner =
+          new HepPlanner(hepProgram, null, noDag, null, RelOptCostImpl.FACTORY);
 
-      List<RelMetadataProvider> list = new ArrayList<>();
-      if (metadataProvider != null) {
-        list.add(metadataProvider);
-      }
+      List<RelMetadataProvider> list = Lists.newArrayList(metadataProvider);
       hepPlanner.registerMetadataProviders(list);
       for (RelOptMaterialization materialization : materializations) {
         hepPlanner.addMaterialization(materialization);
@@ -333,8 +333,9 @@ private static class SequenceProgram implements Program {
         List<RelOptMaterialization> materializations,
         List<RelOptLattice> lattices) {
       for (Program program : programs) {
-        rel = program.run(
-            planner, rel, requiredOutputTraits, materializations, lattices);
+        rel =
+            program.run(planner, rel, requiredOutputTraits, materializations,
+                lattices);
       }
       return rel;
     }
diff --git a/core/src/main/java/org/apache/calcite/tools/RelBuilder.java b/core/src/main/java/org/apache/calcite/tools/RelBuilder.java
index 968c8adf298..23ca4fdda88 100644
--- a/core/src/main/java/org/apache/calcite/tools/RelBuilder.java
+++ b/core/src/main/java/org/apache/calcite/tools/RelBuilder.java
@@ -99,6 +99,7 @@
 import org.apache.calcite.sql.type.TableFunctionReturnTypeInference;
 import org.apache.calcite.sql.validate.SqlValidatorUtil;
 import org.apache.calcite.sql2rel.SqlToRelConverter;
+import org.apache.calcite.util.DateString;
 import org.apache.calcite.util.Holder;
 import org.apache.calcite.util.ImmutableBitSet;
 import org.apache.calcite.util.ImmutableIntList;
@@ -143,6 +144,7 @@
 import java.util.Set;
 import java.util.SortedSet;
 import java.util.TreeSet;
+import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.function.UnaryOperator;
 import java.util.stream.Collectors;
@@ -175,7 +177,7 @@ public class RelBuilder {
   protected final RelOptCluster cluster;
   protected final @Nullable RelOptSchema relOptSchema;
   private final Deque<Frame> stack = new ArrayDeque<>();
-  private final RexSimplify simplifier;
+  private RexSimplify simplifier;
   private final Config config;
   private final RelOptTable.ViewExpander viewExpander;
   private RelFactories.Struct struct;
@@ -430,6 +432,27 @@ public <E> E with(RelNode r, Function<RelBuilder, E> fn) {
     }
   }
 
+  /** Performs an action with a temporary simplifier. */
+  public <E> E withSimplifier(
+      BiFunction<RelBuilder, RexSimplify, RexSimplify> simplifierTransform,
+      Function<RelBuilder, E> fn) {
+    final RexSimplify previousSimplifier = this.simplifier;
+    try {
+      this.simplifier = simplifierTransform.apply(this, previousSimplifier);
+      return fn.apply(this);
+    } finally {
+      this.simplifier = previousSimplifier;
+    }
+  }
+
+  /** Performs an action using predicates of
+   * the {@link #peek() current node} to simplify. */
+  public <E> E withPredicates(RelMetadataQuery mq,
+      Function<RelBuilder, E> fn) {
+    final RelOptPredicateList predicates = mq.getPulledUpPredicates(peek());
+    return withSimplifier((r, s) -> s.withPredicates(predicates), fn);
+  }
+
   // Methods that return scalar expressions
 
   /** Creates a literal (constant expression). */
@@ -453,6 +476,8 @@ public RexLiteral literal(@Nullable Object value) {
     } else if (value instanceof Enum) {
       return rexBuilder.makeLiteral(value,
           getTypeFactory().createSqlType(SqlTypeName.SYMBOL));
+    } else if (value instanceof DateString) {
+      return rexBuilder.makeDateLiteral((DateString) value);
     } else {
       throw new IllegalArgumentException("cannot convert " + value
           + " (" + value.getClass() + ") to a constant");
@@ -1127,7 +1152,7 @@ public RexNode cast(RexNode expr, SqlTypeName typeName, int precision,
    *
    * @see #project
    */
-  public RexNode alias(RexNode expr, @Nullable String alias) {
+  public RexNode alias(RexNode expr, String alias) {
     final RexNode aliasLiteral = literal(alias);
     switch (expr.getKind()) {
     case AS:
@@ -1795,7 +1820,24 @@ public RelBuilder project(Iterable<? extends RexNode> nodes,
    */
   public RelBuilder project(Iterable<? extends RexNode> nodes,
       Iterable<? extends @Nullable String> fieldNames, boolean force) {
-    return project_(nodes, fieldNames, ImmutableList.of(), force);
+    return project(nodes, fieldNames, force, ImmutableSet.of());
+  }
+
+  /**
+   * The same with {@link #project(Iterable, Iterable, boolean)}, with additional
+   * variablesSet param.
+   *
+   * @param nodes Expressions
+   * @param fieldNames Suggested field names
+   * @param force create project even if it is identity
+   * @param variablesSet Correlating variables that are set when reading a row
+   *                     from the input, and which may be referenced from the
+   *                     projection expressions
+   */
+  public RelBuilder project(Iterable<? extends RexNode> nodes,
+      Iterable<? extends @Nullable String> fieldNames, boolean force,
+      Iterable<CorrelationId> variablesSet) {
+    return project_(nodes, fieldNames, ImmutableList.of(), force, variablesSet);
   }
 
   /** Creates a {@link Project} of all original fields, plus the given
@@ -1806,7 +1848,7 @@ public RelBuilder projectPlus(RexNode... nodes) {
 
   /** Creates a {@link Project} of all original fields, plus the given list of
    * expressions. */
-  public RelBuilder projectPlus(Iterable<RexNode> nodes) {
+  public RelBuilder projectPlus(Iterable<? extends RexNode> nodes) {
     return project(Iterables.concat(fields(), nodes));
   }
 
@@ -1869,10 +1911,12 @@ private RelBuilder project_(
       Iterable<? extends RexNode> nodes,
       Iterable<? extends @Nullable String> fieldNames,
       Iterable<RelHint> hints,
-      boolean force) {
+      boolean force,
+      Iterable<CorrelationId> variablesSet) {
     final Frame frame = requireNonNull(peek_(), "frame stack is empty");
     final RelDataType inputRowType = frame.rel.getRowType();
     final List<RexNode> nodeList = Lists.newArrayList(nodes);
+    final Set<CorrelationId> variables = ImmutableSet.copyOf(variablesSet);
 
     // Perform a quick check for identity. We'll do a deeper check
     // later when we've derived column names.
@@ -1886,9 +1930,11 @@ private RelBuilder project_(
       fieldNameList.add(null);
     }
 
+    // Do not merge projection when top projection has correlation variables
     bloat:
     if (frame.rel instanceof Project
-        && config.bloat() >= 0) {
+        && config.bloat() >= 0
+        && variables.isEmpty()) {
       final Project project = (Project) frame.rel;
       // Populate field names. If the upper expression is an input ref and does
       // not have a recommended name, use the name of the underlying field.
@@ -1936,7 +1982,9 @@ private RelBuilder project_(
       final ImmutableSet.Builder<RelHint> mergedHints = ImmutableSet.builder();
       mergedHints.addAll(project.getHints());
       mergedHints.addAll(hints);
-      return project_(newNodes, fieldNameList, mergedHints.build(), force);
+      // Keep bottom projection's variablesSet.
+      return project_(newNodes, fieldNameList, mergedHints.build(), force,
+          ImmutableSet.copyOf(project.getVariablesSet()));
     }
 
     // Simplify expressions.
@@ -2021,7 +2069,8 @@ private RelBuilder project_(
         struct.projectFactory.createProject(frame.rel,
             ImmutableList.copyOf(hints),
             ImmutableList.copyOf(nodeList),
-            fieldNameList);
+            fieldNameList,
+            variables);
     stack.pop();
     stack.push(new Frame(project, fields.build()));
     return this;
@@ -2046,7 +2095,34 @@ private RelBuilder project_(
    */
   public RelBuilder projectNamed(Iterable<? extends RexNode> nodes,
       @Nullable Iterable<? extends @Nullable String> fieldNames, boolean force) {
-    @SuppressWarnings("unchecked") final List<? extends RexNode> nodeList =
+    return projectNamed(nodes, fieldNames, force, ImmutableSet.of());
+  }
+
+  /** Creates a {@link Project} of the given
+   * expressions and field names, and optionally optimizing.
+   *
+   * <p>If {@code fieldNames} is null, or if a particular entry in
+   * {@code fieldNames} is null, derives field names from the input
+   * expressions.
+   *
+   * <p>If {@code force} is false,
+   * and the input is a {@code Project},
+   * and the expressions  make the trivial projection ($0, $1, ...),
+   * modifies the input.
+   *
+   * @param nodes       Expressions
+   * @param fieldNames  Suggested field names, or null to generate
+   * @param force       Whether to create a renaming Project if the
+   *                    projections are trivial
+   * @param variablesSet Correlating variables that are set when reading a row
+   *                     from the input, and which may be referenced from the
+   *                     projection expressions
+   */
+  public RelBuilder projectNamed(Iterable<? extends RexNode> nodes,
+      @Nullable Iterable<? extends @Nullable String> fieldNames, boolean force,
+      Iterable<CorrelationId> variablesSet) {
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    final List<? extends RexNode> nodeList =
         nodes instanceof List ? (List) nodes : ImmutableList.copyOf(nodes);
     final List<@Nullable String> fieldNameList =
         fieldNames == null ? null
@@ -2062,8 +2138,9 @@ public RelBuilder projectNamed(Iterable<? extends RexNode> nodes,
         // Rename columns of child projection if desired field names are given.
         final Frame frame = stack.pop();
         final Project childProject = (Project) frame.rel;
-        final Project newInput = childProject.copy(childProject.getTraitSet(),
-            childProject.getInput(), childProject.getProjects(), rowType);
+        final Project newInput =
+            childProject.copy(childProject.getTraitSet(),
+                childProject.getInput(), childProject.getProjects(), rowType);
         stack.push(new Frame(newInput.attachHints(childProject.getHints()), frame.fields));
       }
       if (input instanceof Values && fieldNameList != null) {
@@ -2081,7 +2158,7 @@ public RelBuilder projectNamed(Iterable<? extends RexNode> nodes,
         stack.push(new Frame(newValues, frame.fields));
       }
     } else {
-      project(nodeList, rowType.getFieldNames(), force);
+      project(nodeList, rowType.getFieldNames(), force, variablesSet);
     }
     return this;
   }
@@ -2322,8 +2399,7 @@ public RelBuilder aggregate(GroupKey groupKey, Iterable<AggCall> aggCalls) {
           newProjects.add(project.getProjects().get(i));
           builder.add(project.getRowType().getFieldList().get(i));
         }
-        r = project.copy(cluster.traitSet(), project.getInput(), newProjects,
-            builder.build());
+        r = project.copy(cluster.traitSet(), project.getInput(), newProjects, builder.build());
       }
     }
 
@@ -2622,11 +2698,9 @@ public RelBuilder transientScan(String tableName) {
   public RelBuilder transientScan(String tableName, RelDataType rowType) {
     TransientTable transientTable = new ListTransientTable(tableName, rowType);
     requireNonNull(relOptSchema, "relOptSchema");
-    RelOptTable relOptTable = RelOptTableImpl.create(
-        relOptSchema,
-        rowType,
-        transientTable,
-        ImmutableList.of(tableName));
+    RelOptTable relOptTable =
+        RelOptTableImpl.create(relOptSchema, rowType, transientTable,
+            ImmutableList.of(tableName));
     RelNode scan =
         struct.scanFactory.createScan(
             ViewExpanders.toRelContext(viewExpander, cluster),
@@ -2761,8 +2835,9 @@ public RelBuilder join(JoinRelType joinType, RexNode condition,
       // Normalize expanded versions IS NOT DISTINCT FROM so that simplifier does not
       // transform the expression to something unrecognizable
       if (condition instanceof RexCall) {
-        condition = RelOptUtil.collapseExpandedIsNotDistinctFromExpr((RexCall) condition,
-            getRexBuilder());
+        condition =
+            RelOptUtil.collapseExpandedIsNotDistinctFromExpr((RexCall) condition,
+                getRexBuilder());
       }
       condition = simplifier.simplifyUnknownAsFalse(condition);
     }
@@ -2989,8 +3064,8 @@ private RelBuilder values(List<? extends List<RexLiteral>> tupleList,
     final RelDataTypeFactory typeFactory = cluster.getTypeFactory();
     final RelDataTypeFactory.Builder builder = typeFactory.builder();
     Ord.forEach(fieldNames, (fieldName, i) -> {
-      final RelDataType type = typeFactory.leastRestrictive(
-          new AbstractList<RelDataType>() {
+      final RelDataType type =
+          typeFactory.leastRestrictive(new AbstractList<RelDataType>() {
             @Override public RelDataType get(int index) {
               return tupleList.get(index).get(i).getType();
             }
@@ -3256,7 +3331,8 @@ public RelBuilder sortLimit(@Nullable RexNode offsetNode, @Nullable RexNode fetc
                 struct.projectFactory.createProject(sort,
                     project.getHints(),
                     project.getProjects(),
-                    Pair.right(project.getNamedProjects())));
+                    Pair.right(project.getNamedProjects()),
+                    project.getVariablesSet()));
             return this;
           }
         }
@@ -3813,11 +3889,14 @@ boolean isSimple() {
    * @throws IllegalArgumentException if the {@link CorrelationId} is used by left side or if the a
    *   {@link CorrelationId} is present and the {@link JoinRelType} is FULL or RIGHT.
    */
-  private static boolean checkIfCorrelated(Set<CorrelationId> variablesSet,
+  private boolean checkIfCorrelated(Set<CorrelationId> variablesSet,
       JoinRelType joinType, RelNode leftNode, RelNode rightRel) {
     if (variablesSet.size() != 1) {
       return false;
     }
+    if (!config.convertCorrelateToJoin()) {
+      return true;
+    }
     CorrelationId id = Iterables.getOnlyElement(variablesSet);
     if (!RelOptUtil.notContainsCorrelation(leftNode, id, Litmus.IGNORE)) {
       throw new IllegalArgumentException("variable " + id
@@ -4612,6 +4691,14 @@ public interface Config {
 
     /** Sets {@link #aggregateUnique()}. */
     Config withAggregateUnique(boolean aggregateUnique);
+
+    /** Whether to convert Correlate to Join if correlation variable is unused. */
+    @Value.Default default boolean convertCorrelateToJoin() {
+      return true;
+    }
+
+    /** Sets {@link #convertCorrelateToJoin()}. */
+    Config withConvertCorrelateToJoin(boolean convertCorrelateToJoin);
   }
 
 }
diff --git a/core/src/main/java/org/apache/calcite/util/BitSets.java b/core/src/main/java/org/apache/calcite/util/BitSets.java
index 197ac8365e0..0ae561c46ae 100644
--- a/core/src/main/java/org/apache/calcite/util/BitSets.java
+++ b/core/src/main/java/org/apache/calcite/util/BitSets.java
@@ -343,8 +343,9 @@ private BitSet computeClosure(int pos) {
       if (o != null) {
         return o;
       }
-      BitSet b = requireNonNull(equivalence.get(pos),
-          () -> "equivalence.get(pos) for " + pos);
+      BitSet b =
+          requireNonNull(equivalence.get(pos),
+              () -> "equivalence.get(pos) for " + pos);
       o = (BitSet) b.clone();
       int i = b.nextSetBit(pos + 1);
       for (; i >= 0; i = b.nextSetBit(i + 1)) {
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 602984c5cf1..7bfe470ea0e 100644
--- a/core/src/main/java/org/apache/calcite/util/Bug.java
+++ b/core/src/main/java/org/apache/calcite/util/Bug.java
@@ -25,14 +25,15 @@
  * incorrect row-count, and you want to disable unit tests. You might use the
  * constant in your code as follows:
  *
- * <blockquote>
- * <pre>Statement stmt = connection.createStatement();
- * int rowCount = stmt.execute(
- *     "INSERT INTO FemaleEmps SELECT * FROM Emps WHERE gender = 'F'");
- * if (Bug.CALCITE_123_FIXED) {
- *    assertEquals(rowCount, 5);
- * }</pre>
- * </blockquote>
+ * <blockquote><pre>{@code
+ *   Statement stmt = connection.createStatement();
+ *   int rowCount =
+ *       stmt.execute("INSERT INTO FemaleEmps\n"
+ *           + "SELECT * FROM Emps WHERE gender = 'F'");
+ *   if (Bug.CALCITE_123_FIXED) {
+ *      assertEquals(rowCount, 5);
+ *   }
+ * }</pre></blockquote>
  *
  * <p>The usage of the constant is a convenient way to identify the impact of
  * the bug. When someone fixes the bug, they will remove the constant and all
@@ -152,14 +153,6 @@ public abstract class Bug {
    * Decorrelate sub-queries in Project and Join</a> is fixed. */
   public static final boolean CALCITE_1045_FIXED = false;
 
-  /**
-   * Whether
-   * <a href="https://issues.apache.org/jira/browse/CALCITE-2223">[CALCITE-2223]
-   * ProjectMergeRule is infinitely matched when is applied after ProjectReduceExpressions Rule</a>
-   * is fixed.
-   */
-  public static final boolean CALCITE_2223_FIXED = false;
-
   /** Whether
    * <a href="https://issues.apache.org/jira/browse/CALCITE-2400">[CALCITE-2400]
    * Allow standards-compliant column ordering for NATURAL JOIN and JOIN USING
@@ -191,6 +184,7 @@ public abstract class Bug {
    * Intermittent precision in Druid results when using aggregation functions over columns of type
    * DOUBLE</a> is fixed. */
   public static final boolean CALCITE_4204_FIXED = false;
+
   /** Whether
    * <a href="https://issues.apache.org/jira/browse/CALCITE-4205">[CALCITE-4205]
    * DruidAdapterIT#testDruidTimeFloorAndTimeParseExpressions2 fails</a> is fixed. */
@@ -200,12 +194,18 @@ public abstract class Bug {
    * Druid plans with small intervals should be chosen over full interval scan plus filter</a> is
    * fixed. */
   public static final boolean CALCITE_4213_FIXED = false;
+
   /** Whether
    * <a href="https://issues.apache.org/jira/browse/CALCITE-4645">[CALCITE-4645]
    * In Elasticsearch adapter, a range predicate should be translated to a range query</a> is
    * fixed. */
   public static final boolean CALCITE_4645_FIXED = false;
 
+  /** Whether
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5422">[CALCITE-5422]
+   * MILLISECOND and MICROSECOND units in INTERVAL literal</a> is fixed. */
+  public static final boolean CALCITE_5422_FIXED = false;
+
   /**
    * Use this to flag temporary code.
    */
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 e1089a8fb0e..dae7fdc0c02 100644
--- a/core/src/main/java/org/apache/calcite/util/BuiltInMethod.java
+++ b/core/src/main/java/org/apache/calcite/util/BuiltInMethod.java
@@ -87,13 +87,13 @@
 import org.apache.calcite.runtime.Enumerables;
 import org.apache.calcite.runtime.FlatLists;
 import org.apache.calcite.runtime.FunctionContexts;
-import org.apache.calcite.runtime.GeoFunctions;
 import org.apache.calcite.runtime.JsonFunctions;
 import org.apache.calcite.runtime.Matcher;
 import org.apache.calcite.runtime.Pattern;
 import org.apache.calcite.runtime.RandomFunction;
 import org.apache.calcite.runtime.ResultSetEnumerable;
 import org.apache.calcite.runtime.SortedMultiMap;
+import org.apache.calcite.runtime.SpatialTypeFunctions;
 import org.apache.calcite.runtime.SqlFunctions;
 import org.apache.calcite.runtime.SqlFunctions.FlatProductInputType;
 import org.apache.calcite.runtime.Utilities;
@@ -303,11 +303,17 @@ public enum BuiltInMethod {
       Calendar.class),
   TIME_ZONE_GET_OFFSET(TimeZone.class, "getOffset", long.class),
   LONG_VALUE(Number.class, "longValue"),
+  STRING_TO_UPPER(String.class, "toUpperCase"),
   COMPARATOR_COMPARE(Comparator.class, "compare", Object.class, Object.class),
   COLLECTIONS_REVERSE_ORDER(Collections.class, "reverseOrder"),
   COLLECTIONS_EMPTY_LIST(Collections.class, "emptyList"),
   COLLECTIONS_SINGLETON_LIST(Collections.class, "singletonList", Object.class),
   COLLECTION_SIZE(Collection.class, "size"),
+  COLLECTION_EXISTS(Functions.class, "exists", List.class, Predicate1.class),
+  COLLECTION_ALL(Functions.class, "all", List.class, Predicate1.class),
+  COLLECTION_NULLABLE_EXISTS(SqlFunctions.class, "nullableExists",
+      List.class, Function1.class),
+  COLLECTION_NULLABLE_ALL(SqlFunctions.class, "nullableAll", List.class, Function1.class),
   MAP_CLEAR(Map.class, "clear"),
   MAP_GET(Map.class, "get", Object.class),
   MAP_GET_OR_DEFAULT(Map.class, "getOrDefault", Object.class, Object.class),
@@ -339,6 +345,8 @@ public enum BuiltInMethod {
   UPPER(SqlFunctions.class, "upper", String.class),
   LOWER(SqlFunctions.class, "lower", String.class),
   ASCII(SqlFunctions.class, "ascii", String.class),
+  CHAR_FROM_ASCII(SqlFunctions.class, "charFromAscii", int.class),
+  CHAR_FROM_UTF8(SqlFunctions.class, "charFromUtf8", int.class),
   REPEAT(SqlFunctions.class, "repeat", String.class, int.class),
   SPACE(SqlFunctions.class, "space", int.class),
   SOUNDEX(SqlFunctions.class, "soundex", String.class),
@@ -377,10 +385,13 @@ public enum BuiltInMethod {
   JSON_TYPE(JsonFunctions.class, "jsonType", String.class),
   JSON_DEPTH(JsonFunctions.class, "jsonDepth", String.class),
   JSON_KEYS(JsonFunctions.class, "jsonKeys", String.class),
+  JSON_INSERT(JsonFunctions.class, "jsonInsert", String.class, Object.class),
   JSON_PRETTY(JsonFunctions.class, "jsonPretty", String.class),
   JSON_LENGTH(JsonFunctions.class, "jsonLength", String.class),
+  JSON_REPLACE(JsonFunctions.class, "jsonReplace", String.class, Object.class),
   JSON_REMOVE(JsonFunctions.class, "jsonRemove", String.class),
   JSON_STORAGE_SIZE(JsonFunctions.class, "jsonStorageSize", String.class),
+  JSON_SET(JsonFunctions.class, "jsonSet", String.class, Object.class),
   JSON_OBJECTAGG_ADD(JsonFunctions.class, "jsonObjectAggAdd", Map.class,
       String.class, Object.class, SqlJsonConstructorNullClause.class),
   JSON_ARRAY(JsonFunctions.class, "jsonArray",
@@ -391,19 +402,23 @@ public enum BuiltInMethod {
   IS_JSON_OBJECT(JsonFunctions.class, "isJsonObject", String.class),
   IS_JSON_ARRAY(JsonFunctions.class, "isJsonArray", String.class),
   IS_JSON_SCALAR(JsonFunctions.class, "isJsonScalar", String.class),
-  ST_GEOM_FROM_TEXT(GeoFunctions.class, "ST_GeomFromText", String.class),
+  ST_GEOM_FROM_EWKT(SpatialTypeFunctions.class, "ST_GeomFromEWKT", String.class),
   INITCAP(SqlFunctions.class, "initcap", String.class),
   SUBSTRING(SqlFunctions.class, "substring", String.class, int.class,
       int.class),
+  LPAD(SqlFunctions.class, "lpad", String.class, int.class, String.class),
+  RPAD(SqlFunctions.class, "rpad", String.class, int.class, String.class),
+  STARTS_WITH(SqlFunctions.class, "startsWith", String.class, String.class),
+  ENDS_WITH(SqlFunctions.class, "endsWith", String.class, String.class),
   OCTET_LENGTH(SqlFunctions.class, "octetLength", ByteString.class),
   CHAR_LENGTH(SqlFunctions.class, "charLength", String.class),
   STRING_CONCAT(SqlFunctions.class, "concat", String.class, String.class),
   MULTI_STRING_CONCAT(SqlFunctions.class, "concatMulti", String[].class),
-  FLOOR_DIV(DateTimeUtils.class, "floorDiv", long.class, long.class),
-  FLOOR_MOD(DateTimeUtils.class, "floorMod", long.class, long.class),
-  ADD_MONTHS(SqlFunctions.class, "addMonths", long.class, int.class),
-  ADD_MONTHS_INT(SqlFunctions.class, "addMonths", int.class, int.class),
-  SUBTRACT_MONTHS(SqlFunctions.class, "subtractMonths", long.class,
+  FLOOR_DIV(Math.class, "floorDiv", long.class, long.class),
+  FLOOR_MOD(Math.class, "floorMod", long.class, long.class),
+  ADD_MONTHS(DateTimeUtils.class, "addMonths", long.class, int.class),
+  ADD_MONTHS_INT(DateTimeUtils.class, "addMonths", int.class, int.class),
+  SUBTRACT_MONTHS(DateTimeUtils.class, "subtractMonths", long.class,
       long.class),
   FLOOR(SqlFunctions.class, "floor", int.class, int.class),
   CEIL(SqlFunctions.class, "ceil", int.class, int.class),
@@ -417,6 +432,7 @@ public enum BuiltInMethod {
   RAND_INTEGER(RandomFunction.class, "randInteger", int.class),
   RAND_INTEGER_SEED(RandomFunction.class, "randIntegerSeed", int.class,
       int.class),
+  LOG(SqlFunctions.class, "log", long.class, long.class),
   TANH(SqlFunctions.class, "tanh", long.class),
   SINH(SqlFunctions.class, "sinh", long.class),
   TRUNCATE(SqlFunctions.class, "truncate", String.class, int.class),
@@ -446,6 +462,12 @@ public enum BuiltInMethod {
   NOT(SqlFunctions.class, "not", Boolean.class),
   LESSER(SqlFunctions.class, "lesser", Comparable.class, Comparable.class),
   GREATER(SqlFunctions.class, "greater", Comparable.class, Comparable.class),
+  LT_NULLABLE(SqlFunctions.class, "ltNullable", Comparable.class,
+      Comparable.class),
+  GT_NULLABLE(SqlFunctions.class, "gtNullable", Comparable.class,
+      Comparable.class),
+  LT(SqlFunctions.class, "lt", boolean.class, boolean.class),
+  GT(SqlFunctions.class, "gt", boolean.class, boolean.class),
   BIT_AND(SqlFunctions.class, "bitAnd", long.class, long.class),
   BIT_OR(SqlFunctions.class, "bitOr", long.class, long.class),
   BIT_XOR(SqlFunctions.class, "bitXor", long.class, long.class),
@@ -485,6 +507,12 @@ public enum BuiltInMethod {
       "timestampWithLocalTimeZoneToTimestamp", long.class, TimeZone.class),
   TIMESTAMP_WITH_LOCAL_TIME_ZONE_TO_STRING(SqlFunctions.class,
       "timestampWithLocalTimeZoneToString", long.class, TimeZone.class),
+  FORMAT_TIMESTAMP(SqlFunctions.class, "formatTimestamp", DataContext.class,
+      String.class, long.class),
+  FORMAT_DATE(SqlFunctions.class, "formatDate", DataContext.class, String.class,
+      int.class),
+  FORMAT_TIME(SqlFunctions.class, "formatTime", DataContext.class, String.class,
+      int.class),
   UNIX_DATE_TO_STRING(DateTimeUtils.class, "unixDateToString", int.class),
   UNIX_TIME_TO_STRING(DateTimeUtils.class, "unixTimeToString", int.class),
   UNIX_TIMESTAMP_TO_STRING(DateTimeUtils.class, "unixTimestampToString",
@@ -503,7 +531,24 @@ public enum BuiltInMethod {
       TimeUnitRange.class, long.class),
   UNIX_TIMESTAMP_CEIL(DateTimeUtils.class, "unixTimestampCeil",
       TimeUnitRange.class, long.class),
-  LAST_DAY(SqlFunctions.class, "lastDay", int.class),
+  CUSTOM_DATE_ADD(SqlFunctions.class, "customDateAdd",
+      DataContext.class, String.class, int.class, int.class),
+  CUSTOM_DATE_DIFF(SqlFunctions.class, "customDateDiff",
+      DataContext.class, String.class, int.class, int.class),
+  CUSTOM_DATE_FLOOR(SqlFunctions.class, "customDateFloor",
+      DataContext.class, String.class, int.class),
+  CUSTOM_DATE_CEIL(SqlFunctions.class, "customDateCeil",
+      DataContext.class, String.class, int.class),
+  CUSTOM_TIMESTAMP_ADD(SqlFunctions.class, "customTimestampAdd",
+      DataContext.class, String.class, long.class, long.class),
+  CUSTOM_TIMESTAMP_DIFF(SqlFunctions.class, "customTimestampDiff",
+      DataContext.class, String.class, long.class, long.class),
+  CUSTOM_TIMESTAMP_FLOOR(SqlFunctions.class, "customTimestampFloor",
+      DataContext.class, String.class, long.class),
+  CUSTOM_TIMESTAMP_CEIL(SqlFunctions.class, "customTimestampCeil",
+      DataContext.class, String.class, long.class),
+  TIMESTAMP_TO_DATE(SqlFunctions.class, "timestampToDate", long.class),
+  LAST_DAY(DateTimeUtils.class, "lastDay", int.class),
   DAYNAME_WITH_TIMESTAMP(SqlFunctions.class,
       "dayNameWithTimestamp", long.class, Locale.class),
   DAYNAME_WITH_DATE(SqlFunctions.class,
@@ -538,13 +583,17 @@ public enum BuiltInMethod {
       Comparable.class, Comparator.class),
   ROUND_LONG(SqlFunctions.class, "round", long.class, long.class),
   ROUND_INT(SqlFunctions.class, "round", int.class, int.class),
-  DATE_TO_INT(SqlFunctions.class, "toInt", java.util.Date.class),
+  DATE_TO_INT(SqlFunctions.class, "toInt", java.sql.Date.class),
+  DATE_TO_INT_OFFSET(SqlFunctions.class, "toInt", java.sql.Date.class,
+      TimeZone.class),
   DATE_TO_INT_OPTIONAL(SqlFunctions.class, "toIntOptional",
-      java.util.Date.class),
+      java.sql.Date.class),
+  DATE_TO_INT_OPTIONAL_OFFSET(SqlFunctions.class, "toIntOptional",
+      java.sql.Date.class, TimeZone.class),
   TIME_TO_INT(SqlFunctions.class, "toInt", Time.class),
   TIME_TO_INT_OPTIONAL(SqlFunctions.class, "toIntOptional", Time.class),
-  TIMESTAMP_TO_LONG(SqlFunctions.class, "toLong", java.util.Date.class),
-  TIMESTAMP_TO_LONG_OFFSET(SqlFunctions.class, "toLong", java.util.Date.class,
+  TIMESTAMP_TO_LONG(SqlFunctions.class, "toLong", Timestamp.class),
+  TIMESTAMP_TO_LONG_OFFSET(SqlFunctions.class, "toLong", Timestamp.class,
       TimeZone.class),
   TIMESTAMP_TO_LONG_OPTIONAL(SqlFunctions.class, "toLongOptional",
       Timestamp.class),
diff --git a/core/src/main/java/org/apache/calcite/util/ChunkList.java b/core/src/main/java/org/apache/calcite/util/ChunkList.java
index 7f3ef18be95..3d29197bb0b 100644
--- a/core/src/main/java/org/apache/calcite/util/ChunkList.java
+++ b/core/src/main/java/org/apache/calcite/util/ChunkList.java
@@ -258,8 +258,8 @@ private E[] currentChunk() {
         }
       }
       @SuppressWarnings("unchecked")
-      final E element = (E) element(currentChunk(),
-          HEADER_SIZE + (lastRet = cursor++) - start);
+      final E element =
+          (E) element(currentChunk(), HEADER_SIZE + (lastRet = cursor++) - start);
       return element;
     }
 
diff --git a/core/src/main/java/org/apache/calcite/util/Compatible.java b/core/src/main/java/org/apache/calcite/util/Compatible.java
index 924621d2f9a..3771080e31a 100644
--- a/core/src/main/java/org/apache/calcite/util/Compatible.java
+++ b/core/src/main/java/org/apache/calcite/util/Compatible.java
@@ -16,11 +16,14 @@
  */
 package org.apache.calcite.util;
 
+import com.google.common.collect.ImmutableMap;
+
 import java.lang.invoke.MethodHandles;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
+import java.util.Map;
 
 import static java.util.Objects.requireNonNull;
 
@@ -36,6 +39,15 @@ public interface Compatible {
    * (On JDK 8, only {@link MethodHandles#lookup()} is available. */
   <T> MethodHandles.Lookup lookupPrivate(Class<T> clazz);
 
+  /** Same behavior as {@link ImmutableMap#copyOf},
+   * available from Guava 19.0. */
+  static <K, V> ImmutableMap<K, V> copyOf(
+      Iterable<? extends Map.Entry<? extends K, ? extends V>> entries) {
+    final ImmutableMap.Builder<K, V> b = ImmutableMap.builder();
+    entries.forEach(b::put);
+    return b.build();
+  }
+
   /** Creates the implementation of Compatible suitable for the
    * current environment. */
   class Factory {
diff --git a/core/src/main/java/org/apache/calcite/util/DateTimeStringUtils.java b/core/src/main/java/org/apache/calcite/util/DateTimeStringUtils.java
index aff1229ca7d..d3cd99a9f1d 100644
--- a/core/src/main/java/org/apache/calcite/util/DateTimeStringUtils.java
+++ b/core/src/main/java/org/apache/calcite/util/DateTimeStringUtils.java
@@ -24,6 +24,8 @@
 
 /**
  * Utility methods to manipulate String representation of DateTime values.
+ *
+ * @see DateTimeUtils
  */
 public class DateTimeStringUtils {
 
@@ -113,8 +115,8 @@ public static SimpleDateFormat getDateFormatter(String format) {
    * Create a SimpleDateFormat with format string and time zone.
    */
   public static SimpleDateFormat getDateFormatter(String format, TimeZone timeZone) {
-    final SimpleDateFormat dateFormatter = new SimpleDateFormat(
-        format, Locale.ROOT);
+    final SimpleDateFormat dateFormatter =
+        new SimpleDateFormat(format, Locale.ROOT);
     dateFormatter.setTimeZone(timeZone);
     return dateFormatter;
   }
diff --git a/core/src/main/java/org/apache/calcite/util/DelegatingInvocationHandler.java b/core/src/main/java/org/apache/calcite/util/DelegatingInvocationHandler.java
index a2375d504b0..30e2db00dd7 100644
--- a/core/src/main/java/org/apache/calcite/util/DelegatingInvocationHandler.java
+++ b/core/src/main/java/org/apache/calcite/util/DelegatingInvocationHandler.java
@@ -29,26 +29,26 @@
  * must implement all of the interfaces which this proxy implements.
  *
  * <p>It is useful in creating a wrapper class around an interface which may
- * change over time.</p>
+ * change over time.
  *
- * <p>Example:</p>
+ * <p>Example:
  *
- * <blockquote>
- * <pre>import java.sql.Connection;
- * Connection connection = ...;
- * Connection tracingConnection = (Connection) Proxy.newProxyInstance(
- *     null,
- *     new Class[] {Connection.class},
- *     new DelegatingInvocationHandler() {
- *         protected Object getTarget() {
- *             return connection;
- *         }
- *         Statement createStatement() {
- *             System.out.println("statement created");
- *             return connection.createStatement();
- *         }
- *     });</pre>
- * </blockquote>
+ * <blockquote><pre>{@code
+ *   import java.sql.Connection;
+ *   Connection connection = ...;
+ *   Connection tracingConnection =
+ *       (Connection) Proxy.newProxyInstance(null,
+ *           new Class[] {Connection.class},
+ *           new DelegatingInvocationHandler() {
+ *             protected Object getTarget() {
+ *               return connection;
+ *             }
+ *             Statement createStatement() {
+ *               System.out.println("statement created");
+ *               return connection.createStatement();
+ *             }
+ *         });
+ * }</pre></blockquote>
  */
 public abstract class DelegatingInvocationHandler implements InvocationHandler {
   //~ Methods ----------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/util/ImmutableBitSet.java b/core/src/main/java/org/apache/calcite/util/ImmutableBitSet.java
index 256ac756a8d..c3ae4ca42e3 100644
--- a/core/src/main/java/org/apache/calcite/util/ImmutableBitSet.java
+++ b/core/src/main/java/org/apache/calcite/util/ImmutableBitSet.java
@@ -498,7 +498,7 @@ public int size() {
    * that occurs on or after the specified starting index. If no such
    * bit exists then {@code -1} is returned.
    *
-   * <p>Based upon {@link BitSet#nextSetBit}.
+   * <p>Based upon {@link BitSet#nextSetBit(int)}.
    *
    * @param  fromIndex the index to start checking from (inclusive)
    * @return the index of the next set bit, or {@code -1} if there
@@ -972,8 +972,7 @@ private static class Closure {
     @RequiresNonNull("equivalence")
     private ImmutableBitSet computeClosure(
         @UnderInitialization Closure this,
-        int pos
-    ) {
+        int pos) {
       ImmutableBitSet o = closure.get(pos);
       if (o != null) {
         return o;
diff --git a/core/src/main/java/org/apache/calcite/util/ImmutableNullableSet.java b/core/src/main/java/org/apache/calcite/util/ImmutableNullableSet.java
index cde22bf8bcb..3beaed7d68e 100644
--- a/core/src/main/java/org/apache/calcite/util/ImmutableNullableSet.java
+++ b/core/src/main/java/org/apache/calcite/util/ImmutableNullableSet.java
@@ -107,14 +107,16 @@ public static <E> Set<E> copyOf(Iterable<? extends E> elements) {
         E element = Iterables.getOnlyElement(collection);
         return element == null ? SINGLETON_NULL : ImmutableSet.of(element);
       default:
-        set = ImmutableSet.copyOf(
-            Collections2.transform(collection, e ->
-                e == null ? NullSentinel.INSTANCE : e));
+        set =
+            ImmutableSet.copyOf(
+                Collections2.transform(collection, e ->
+                    e == null ? NullSentinel.INSTANCE : e));
       }
     } else {
-      set = ImmutableSet.copyOf(
-          Util.transform(elements, e ->
-              e == null ? NullSentinel.INSTANCE : e));
+      set =
+          ImmutableSet.copyOf(
+              Util.transform(elements, e ->
+                  e == null ? NullSentinel.INSTANCE : e));
     }
     if (set.contains(NullSentinel.INSTANCE)) {
       return new ImmutableNullableSet<>(set);
diff --git a/core/src/main/java/org/apache/calcite/util/JsonBuilder.java b/core/src/main/java/org/apache/calcite/util/JsonBuilder.java
index 8c9cd77872d..68496fb161c 100644
--- a/core/src/main/java/org/apache/calcite/util/JsonBuilder.java
+++ b/core/src/main/java/org/apache/calcite/util/JsonBuilder.java
@@ -35,39 +35,39 @@ public class JsonBuilder {
   /** Maps control characters (0 .. 31) to JSON escaped strings.
    * Tab, newline, form feed and carriage return are mapped to '\t', '\n',
    * '\f', 'r' respectively; others are mapped to '\\u00xx' for some 'xx'. */
-  private static final ImmutableList<String> ESCAPED = ImmutableList.of(
-      "\\u0000",
-      "\\u0001",
-      "\\u0002",
-      "\\u0003",
-      "\\u0004",
-      "\\u0005",
-      "\\u0006",
-      "\\u0007",
-      "\\u0008",
-      "\\t", // tab, ASCII 9 x09
-      "\\n", // newline, ASCII 10 x0A
-      "\\u000B",
-      "\\f", // form feed, ASCII 12 x0C
-      "\\r", // carriage return, ASCII 13 x0D
-      "\\u000E",
-      "\\u000F",
-      "\\u0010",
-      "\\u0011",
-      "\\u0012",
-      "\\u0013",
-      "\\u0014",
-      "\\u0015",
-      "\\u0016",
-      "\\u0017",
-      "\\u0018",
-      "\\u0019",
-      "\\u001A",
-      "\\u001B",
-      "\\u001C",
-      "\\u001D",
-      "\\u001E",
-      "\\u001F");
+  private static final ImmutableList<String> ESCAPED =
+      ImmutableList.of("\\u0000",
+          "\\u0001",
+          "\\u0002",
+          "\\u0003",
+          "\\u0004",
+          "\\u0005",
+          "\\u0006",
+          "\\u0007",
+          "\\u0008",
+          "\\t", // tab, ASCII 9 x09
+          "\\n", // newline, ASCII 10 x0A
+          "\\u000B",
+          "\\f", // form feed, ASCII 12 x0C
+          "\\r", // carriage return, ASCII 13 x0D
+          "\\u000E",
+          "\\u000F",
+          "\\u0010",
+          "\\u0011",
+          "\\u0012",
+          "\\u0013",
+          "\\u0014",
+          "\\u0015",
+          "\\u0016",
+          "\\u0017",
+          "\\u0018",
+          "\\u0019",
+          "\\u001A",
+          "\\u001B",
+          "\\u001C",
+          "\\u001D",
+          "\\u001E",
+          "\\u001F");
 
   /**
    * Creates a JSON object (represented by a {@link Map}).
@@ -135,7 +135,7 @@ public void append(StringBuilder buf, int indent, @Nullable Object o) {
     }
   }
 
-  private void appendString(StringBuilder buf, String s) {
+  private static void appendString(StringBuilder buf, String s) {
     buf.append('"');
     final int n = s.length();
     for (int i = 0; i < n; i++) {
diff --git a/core/src/main/java/org/apache/calcite/util/Litmus.java b/core/src/main/java/org/apache/calcite/util/Litmus.java
index dd62f50e471..863e14964b6 100644
--- a/core/src/main/java/org/apache/calcite/util/Litmus.java
+++ b/core/src/main/java/org/apache/calcite/util/Litmus.java
@@ -25,25 +25,10 @@
 public interface Litmus {
   /** Implementation of {@link org.apache.calcite.util.Litmus} that throws
    * an {@link java.lang.AssertionError} on failure. */
-  Litmus THROW = new Litmus() {
-    @Override public boolean fail(@Nullable String message, @Nullable Object... args) {
-      final String s = message == null
-          ? null : MessageFormatter.arrayFormat(message, args).getMessage();
-      throw new AssertionError(s);
-    }
-
-    @Override public boolean succeed() {
-      return true;
-    }
-
-    @Override public boolean check(boolean condition, @Nullable String message,
-        @Nullable Object... args) {
-      if (condition) {
-        return succeed();
-      } else {
-        return fail(message, args);
-      }
-    }
+  Litmus THROW = (message, args) -> {
+    final String s = message == null
+        ? null : MessageFormatter.arrayFormat(message, args).getMessage();
+    throw new AssertionError(s);
   };
 
   /** Implementation of {@link org.apache.calcite.util.Litmus} that returns
@@ -53,14 +38,16 @@ public interface Litmus {
       return false;
     }
 
-    @Override public boolean succeed() {
-      return true;
-    }
-
     @Override public boolean check(boolean condition, @Nullable String message,
         @Nullable Object... args) {
       return condition;
     }
+
+    @Override public Litmus withMessageArgs(@Nullable String message,
+        @Nullable Object... args) {
+      // IGNORE never throws, so don't bother remembering message and args.
+      return this;
+    }
   };
 
   /** Called when test fails. Returns false or throws.
@@ -71,7 +58,9 @@ public interface Litmus {
   boolean fail(@Nullable String message, @Nullable Object... args);
 
   /** Called when test succeeds. Returns true. */
-  boolean succeed();
+  default boolean succeed() {
+    return true;
+  }
 
   /** Checks a condition.
    *
@@ -79,5 +68,19 @@ public interface Litmus {
    * if the condition is false, calls {@link #fail},
    * converting {@code info} into a string message.
    */
-  boolean check(boolean condition, @Nullable String message, @Nullable Object... args);
+  default boolean check(boolean condition, @Nullable String message,
+      @Nullable Object... args) {
+    if (condition) {
+      return succeed();
+    } else {
+      return fail(message, args);
+    }
+  }
+
+  /** Creates a Litmus that, if it fails, will use the given arguments. */
+  default Litmus withMessageArgs(@Nullable String message,
+      @Nullable Object... args) {
+    final Litmus delegate = this;
+    return (message1, args1) -> delegate.fail(message, args);
+  }
 }
diff --git a/core/src/main/java/org/apache/calcite/util/MonotonicSupplier.java b/core/src/main/java/org/apache/calcite/util/MonotonicSupplier.java
new file mode 100644
index 00000000000..cbeffbcf8ab
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/util/MonotonicSupplier.java
@@ -0,0 +1,55 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.util;
+
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Supplier that awaits a value and allows the value to be set, once,
+ * to a not-null value. The value supplied by {@link #get} is never null.
+ *
+ * <p>Not thread-safe.
+ *
+ * @param <E> Element type
+ */
+public class MonotonicSupplier<E> implements Consumer<E>, Supplier<E> {
+  private @Nullable E e;
+
+  /**
+   * {@inheritDoc}
+   *
+   * <p>Sets the value once and for all.
+   */
+  @Override public void accept(E e) {
+    if (this.e != null) {
+      throw new IllegalArgumentException("accept has been called already");
+    }
+    this.e = requireNonNull(e, "element must not be null");
+  }
+
+  @Override public E get() {
+    if (e == null) {
+      throw new IllegalArgumentException("accept has not been called");
+    }
+    return e;
+  }
+}
diff --git a/core/src/main/java/org/apache/calcite/util/NameMap.java b/core/src/main/java/org/apache/calcite/util/NameMap.java
index 0a63332e816..a41e3cdd3d2 100644
--- a/core/src/main/java/org/apache/calcite/util/NameMap.java
+++ b/core/src/main/java/org/apache/calcite/util/NameMap.java
@@ -62,7 +62,7 @@ public NameMap() {
   }
 
   /** Creates a NameMap that is an immutable copy of a given map. */
-  public static <V> NameMap immutableCopyOf(Map<String, V> names) {
+  public static <V> NameMap<V> immutableCopyOf(Map<String, V> names) {
     return new NameMap<>(ImmutableSortedMap.copyOf(names, COMPARATOR));
   }
 
diff --git a/core/src/main/java/org/apache/calcite/util/ReflectUtil.java b/core/src/main/java/org/apache/calcite/util/ReflectUtil.java
index 64e493576dc..79bc2fd49f6 100644
--- a/core/src/main/java/org/apache/calcite/util/ReflectUtil.java
+++ b/core/src/main/java/org/apache/calcite/util/ReflectUtil.java
@@ -375,8 +375,9 @@ private static boolean invokeVisitorInternal(
 
     Class<?>[] interfaces = visiteeClass.getInterfaces();
     for (Class<?> anInterface : interfaces) {
-      final Method method = lookupVisitMethod(visitorClass, anInterface,
-          visitMethodName, paramTypes, cache);
+      final Method method =
+          lookupVisitMethod(visitorClass, anInterface,
+              visitMethodName, paramTypes, cache);
       if (method != null) {
         if (candidateMethod != null) {
           if (!method.equals(candidateMethod)) {
diff --git a/core/src/main/java/org/apache/calcite/util/ReflectiveVisitor.java b/core/src/main/java/org/apache/calcite/util/ReflectiveVisitor.java
index 53a7cfbf78d..29f3c3d2100 100644
--- a/core/src/main/java/org/apache/calcite/util/ReflectiveVisitor.java
+++ b/core/src/main/java/org/apache/calcite/util/ReflectiveVisitor.java
@@ -22,7 +22,7 @@
  *
  * <p>This is a tagging interface: it has no methods, and is not even required
  * in order to use reflective visitation, but serves to advise users of the
- * class of the intended use of the class and refer them to auxilliary classes.
+ * class of the intended use of the class and refer them to auxiliary classes.
  */
 public interface ReflectiveVisitor {
 }
diff --git a/core/src/main/java/org/apache/calcite/util/RelToSqlConverterUtil.java b/core/src/main/java/org/apache/calcite/util/RelToSqlConverterUtil.java
index dd8f2379a2f..9943b2b0395 100644
--- a/core/src/main/java/org/apache/calcite/util/RelToSqlConverterUtil.java
+++ b/core/src/main/java/org/apache/calcite/util/RelToSqlConverterUtil.java
@@ -45,8 +45,9 @@ public static void unparseHiveTrim(
       int leftPrec,
       int rightPrec) {
     final SqlLiteral valueToTrim = call.operand(1);
-    String value = requireNonNull(valueToTrim.toValue(),
-        () -> "call.operand(1).toValue() for call " + call);
+    String value =
+        requireNonNull(valueToTrim.toValue(),
+            () -> "call.operand(1).toValue() for call " + call);
     if (value.matches("\\s+")) {
       unparseTrimWithSpace(writer, call, leftPrec, rightPrec);
     } else {
@@ -102,8 +103,9 @@ private static void unparseTrimWithSpace(
    * @return the regex pattern of the character to be trimmed
    */
   public static SqlCharStringLiteral createRegexPatternLiteral(SqlNode call, SqlLiteral trimFlag) {
-    final String regexPattern = requireNonNull(((SqlCharStringLiteral) call).toValue(),
-        () -> "null value for SqlNode " + call);
+    final String regexPattern =
+        requireNonNull(((SqlCharStringLiteral) call).toValue(),
+            () -> "null value for SqlNode " + call);
     String escaped = escapeSpecialChar(regexPattern);
     final StringBuilder builder = new StringBuilder();
     switch (trimFlag.getValueAs(SqlTrimFunction.Flag.class)) {
@@ -132,8 +134,9 @@ public static SqlCharStringLiteral createRegexPatternLiteral(SqlNode call, SqlLi
    * @return escape character if any special character is present in the string
    */
   private static String escapeSpecialChar(String inputString) {
-    final String[] specialCharacters = {"\\", "^", "$", "{", "}", "[", "]", "(", ")", ".",
-        "*", "+", "?", "|", "<", ">", "-", "&", "%", "@"};
+    final String[] specialCharacters =
+        {"\\", "^", "$", "{", "}", "[", "]", "(", ")", ".",
+            "*", "+", "?", "|", "<", ">", "-", "&", "%", "@"};
 
     for (String specialCharacter : specialCharacters) {
       if (inputString.contains(specialCharacter)) {
diff --git a/core/src/main/java/org/apache/calcite/util/SaffronProperties.java b/core/src/main/java/org/apache/calcite/util/SaffronProperties.java
index 4f5ec592541..c105338df7c 100644
--- a/core/src/main/java/org/apache/calcite/util/SaffronProperties.java
+++ b/core/src/main/java/org/apache/calcite/util/SaffronProperties.java
@@ -26,9 +26,10 @@
 import java.io.IOException;
 import java.io.InputStream;
 import java.util.Collections;
-import java.util.Objects;
 import java.util.Properties;
 
+import static java.util.Objects.requireNonNull;
+
 /**
  * Provides an environment for debugging information, et cetera, used by
  * saffron.
@@ -125,27 +126,28 @@ private Helper() {}
     static SaffronProperties instance() {
       Properties properties = new Properties();
 
-      // read properties from the file "saffron.properties", if it exists in classpath
-      try (InputStream stream = Objects.requireNonNull(Helper.class.getClassLoader(), "classLoader")
-          .getResourceAsStream("saffron.properties")) {
+      // Read properties from the file "saffron.properties", if it exists in
+      // classpath.
+      try (InputStream stream =
+               requireNonNull(Helper.class.getClassLoader(), "classLoader")
+                   .getResourceAsStream("saffron.properties")) {
         if (stream != null) {
           properties.load(stream);
         }
       } catch (IOException e) {
-        throw new RuntimeException("while reading from saffron.properties file", e);
-      } catch (RuntimeException e) {
-        if (!"java.security.AccessControlException".equals(e.getClass().getName())) {
-          throw e;
-        }
+        throw new RuntimeException("while reading saffron.properties file", e);
+      } catch (SecurityException ignore) {
+        // Ignore SecurityException on purpose because if
+        // we can't get to the file we fall through.
       }
 
       // copy in all system properties which start with "saffron."
       Properties source = System.getProperties();
       for (Object objectKey : Collections.list(source.keys())) {
         String key = (String) objectKey;
-        String value = Objects.requireNonNull(
-            source.getProperty(key),
-            () -> "value for " + key);
+        String value =
+            requireNonNull(source.getProperty(key),
+                () -> "value for " + key);
         if (key.startsWith("saffron.") || key.startsWith("net.sf.saffron.")) {
           properties.setProperty(key, value);
         }
diff --git a/core/src/main/java/org/apache/calcite/util/SerializableCharset.java b/core/src/main/java/org/apache/calcite/util/SerializableCharset.java
index 8138af8e23c..28a77861705 100644
--- a/core/src/main/java/org/apache/calcite/util/SerializableCharset.java
+++ b/core/src/main/java/org/apache/calcite/util/SerializableCharset.java
@@ -71,8 +71,9 @@ private void writeObject(ObjectOutputStream out) throws IOException {
   private void readObject(ObjectInputStream in)
       throws IOException, ClassNotFoundException {
     charsetName = (String) in.readObject();
-    charset = requireNonNull(Charset.availableCharsets().get(this.charsetName),
-        () -> "charset is not found: " + charsetName);
+    charset =
+        requireNonNull(Charset.availableCharsets().get(this.charsetName),
+            () -> "charset is not found: " + charsetName);
   }
 
   /**
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 888780383eb..86cd859ad17 100644
--- a/core/src/main/java/org/apache/calcite/util/Sources.java
+++ b/core/src/main/java/org/apache/calcite/util/Sources.java
@@ -327,7 +327,8 @@ private static URL fileToUrl(File file) {
       if (isFile(parent)) {
         if (isFile(this)
             && fileNonNull().getPath().startsWith(parent.file().getPath())) {
-          String rest = fileNonNull().getPath().substring(parent.file().getPath().length());
+          String rest =
+              fileNonNull().getPath().substring(parent.file().getPath().length());
           if (rest.startsWith(File.separator)) {
             return Sources.file(null, rest.substring(File.separator.length()));
           }
@@ -335,8 +336,9 @@ && fileNonNull().getPath().startsWith(parent.file().getPath())) {
         return this;
       } else {
         if (!isFile(this)) {
-          String rest = Sources.trimOrNull(url.toExternalForm(),
-              parent.url().toExternalForm());
+          String rest =
+              Sources.trimOrNull(url.toExternalForm(),
+                  parent.url().toExternalForm());
           if (rest != null
               && rest.startsWith("/")) {
             return Sources.file(null, rest.substring(1));
diff --git a/core/src/main/java/org/apache/calcite/util/TimeString.java b/core/src/main/java/org/apache/calcite/util/TimeString.java
index 1e8f8d56ff1..e0d46b837a9 100644
--- a/core/src/main/java/org/apache/calcite/util/TimeString.java
+++ b/core/src/main/java/org/apache/calcite/util/TimeString.java
@@ -26,6 +26,8 @@
 import java.util.Calendar;
 import java.util.regex.Pattern;
 
+import static java.lang.Math.floorMod;
+
 /**
  * Time literal.
  *
@@ -146,7 +148,7 @@ public static TimeString fromCalendarFields(Calendar calendar) {
 
   public static TimeString fromMillisOfDay(int i) {
     return new TimeString(DateTimeUtils.unixTimeToString(i))
-        .withMillis((int) DateTimeUtils.floorMod(i, 1000));
+        .withMillis((int) floorMod(i, 1000L));
   }
 
   public TimeString round(int precision) {
diff --git a/core/src/main/java/org/apache/calcite/util/TimeWithTimeZoneString.java b/core/src/main/java/org/apache/calcite/util/TimeWithTimeZoneString.java
index f651574e076..a533e2493d7 100644
--- a/core/src/main/java/org/apache/calcite/util/TimeWithTimeZoneString.java
+++ b/core/src/main/java/org/apache/calcite/util/TimeWithTimeZoneString.java
@@ -27,6 +27,8 @@
 import java.util.Locale;
 import java.util.TimeZone;
 
+import static java.lang.Math.floorMod;
+
 /**
  * Time with time-zone literal.
  *
@@ -171,7 +173,7 @@ public TimeWithTimeZoneString round(int precision) {
   public static TimeWithTimeZoneString fromMillisOfDay(int i) {
     return new TimeWithTimeZoneString(
         DateTimeUtils.unixTimeToString(i) + " " + DateTimeUtils.UTC_ZONE.getID())
-            .withMillis((int) DateTimeUtils.floorMod(i, 1000));
+            .withMillis((int) floorMod(i, 1000L));
   }
 
   /** Converts this TimeWithTimeZoneString to a string, truncated or padded with
diff --git a/core/src/main/java/org/apache/calcite/util/TimestampString.java b/core/src/main/java/org/apache/calcite/util/TimestampString.java
index 44ad844c72d..559df8805d8 100644
--- a/core/src/main/java/org/apache/calcite/util/TimestampString.java
+++ b/core/src/main/java/org/apache/calcite/util/TimestampString.java
@@ -18,7 +18,6 @@
 
 import org.apache.calcite.avatica.util.DateTimeUtils;
 
-import com.google.common.base.Preconditions;
 import com.google.common.base.Strings;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
@@ -26,6 +25,12 @@
 import java.util.Calendar;
 import java.util.regex.Pattern;
 
+import static com.google.common.base.Preconditions.checkArgument;
+
+import static org.apache.calcite.util.DateTimeStringUtils.ymdhms;
+
+import static java.lang.Math.floorMod;
+
 /**
  * Timestamp literal.
  *
@@ -38,18 +43,29 @@ public class TimestampString implements Comparable<TimestampString> {
           + " "
           + "[0-9][0-9]:[0-9][0-9]:[0-9][0-9](\\.[0-9]*[1-9])?");
 
+  /** The allowed format of input strings is slightly more flexible than
+   * normalized strings. Input strings can have trailing zeros in the fractional
+   * seconds. */
+  private static final Pattern INPUT_PATTERN =
+      Pattern.compile("[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]"
+          + " "
+          + "[0-9][0-9]:[0-9][0-9]:[0-9][0-9](\\.[0-9]+)?");
+
+  /** The Unix epoch. */
+  public static final TimestampString EPOCH =
+      new TimestampString(1970, 1, 1, 0, 0, 0);
+
   final String v;
 
   /** Creates a TimeString. */
   public TimestampString(String v) {
-    this.v = v;
-    Preconditions.checkArgument(PATTERN.matcher(v).matches(), v);
+    this.v = normalize(v);
   }
 
   /** Creates a TimestampString for year, month, day, hour, minute, second,
    *  millisecond values. */
   public TimestampString(int year, int month, int day, int h, int m, int s) {
-    this(DateTimeStringUtils.ymdhms(new StringBuilder(), year, month, day, h, m, s).toString());
+    this(ymdhms(new StringBuilder(), year, month, day, h, m, s).toString());
   }
 
   /** Sets the fraction field of a {@code TimestampString} to a given number
@@ -59,7 +75,7 @@ public TimestampString(int year, int month, int day, int h, int m, int s) {
    * {@code new TimestampString(1970, 1, 1, 2, 3, 4).withMillis(56)}
    * yields {@code TIMESTAMP '1970-01-01 02:03:04.056'}. */
   public TimestampString withMillis(int millis) {
-    Preconditions.checkArgument(millis >= 0 && millis < 1000);
+    checkArgument(millis >= 0 && millis < 1000);
     return withFraction(DateTimeStringUtils.pad(3, millis));
   }
 
@@ -70,7 +86,7 @@ public TimestampString withMillis(int millis) {
    * {@code new TimestampString(1970, 1, 1, 2, 3, 4).withNanos(56789)}
    * yields {@code TIMESTAMP '1970-01-01 02:03:04.000056789'}. */
   public TimestampString withNanos(int nanos) {
-    Preconditions.checkArgument(nanos >= 0 && nanos < 1000000000);
+    checkArgument(nanos >= 0 && nanos < 1000000000);
     return withFraction(DateTimeStringUtils.pad(9, nanos));
   }
 
@@ -96,6 +112,19 @@ public TimestampString withFraction(String fraction) {
     return new TimestampString(v);
   }
 
+  private static String normalize(String v) {
+    checkArgument(INPUT_PATTERN.matcher(v).matches(), v);
+
+    // Remove trailing zeros in the fractional seconds
+    if (v.indexOf('.') >= 0) {
+      while (v.endsWith("0")) {
+        v = v.substring(0, v.length() - 1);
+      }
+    }
+    checkArgument(PATTERN.matcher(v).matches(), v);
+    return v;
+  }
+
   @Override public String toString() {
     return v;
   }
@@ -127,8 +156,12 @@ public static TimestampString fromCalendarFields(Calendar calendar) {
         .withMillis(calendar.get(Calendar.MILLISECOND));
   }
 
+  /** Returns this value rounded to {@code precision} decimal digits after the
+   * point.
+   *
+   * <p>Uses rounding mode {@link java.math.RoundingMode#DOWN}. */
   public TimestampString round(int precision) {
-    Preconditions.checkArgument(precision >= 0);
+    checkArgument(precision >= 0);
     int targetLength = 20 + precision;
     if (v.length() <= targetLength) {
       return this;
@@ -175,7 +208,7 @@ private int getMillisInSecond() {
    * the epoch. */
   public static TimestampString fromMillisSinceEpoch(long millis) {
     return new TimestampString(DateTimeUtils.unixTimestampToString(millis))
-        .withMillis((int) DateTimeUtils.floorMod(millis, 1000));
+        .withMillis((int) floorMod(millis, 1000L));
   }
 
   public Calendar toCalendar() {
@@ -185,7 +218,7 @@ public Calendar toCalendar() {
   /** Converts this TimestampString to a string, truncated or padded with
    * zeros to a given precision. */
   public String toString(int precision) {
-    Preconditions.checkArgument(precision >= 0);
+    checkArgument(precision >= 0);
     final int p = precision();
     if (precision < p) {
       return round(precision).toString(precision);
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 eaabd0ae4a0..7a0baeec0c6 100644
--- a/core/src/main/java/org/apache/calcite/util/TimestampWithTimeZoneString.java
+++ b/core/src/main/java/org/apache/calcite/util/TimestampWithTimeZoneString.java
@@ -27,6 +27,8 @@
 import java.util.Locale;
 import java.util.TimeZone;
 
+import static java.lang.Math.floorMod;
+
 /**
  * Timestamp with time-zone literal.
  *
@@ -169,7 +171,7 @@ public TimestampWithTimeZoneString round(int precision) {
   public static TimestampWithTimeZoneString fromMillisSinceEpoch(long millis) {
     return new TimestampWithTimeZoneString(
         DateTimeUtils.unixTimestampToString(millis) + " " + DateTimeUtils.UTC_ZONE.getID())
-            .withMillis((int) DateTimeUtils.floorMod(millis, 1000));
+            .withMillis((int) floorMod(millis, 1000L));
   }
 
   /** Converts this TimestampWithTimeZoneString to a string, truncated or padded with
diff --git a/core/src/main/java/org/apache/calcite/util/TryThreadLocal.java b/core/src/main/java/org/apache/calcite/util/TryThreadLocal.java
index ac58e2bcf32..9b5ee2024e7 100644
--- a/core/src/main/java/org/apache/calcite/util/TryThreadLocal.java
+++ b/core/src/main/java/org/apache/calcite/util/TryThreadLocal.java
@@ -20,12 +20,14 @@
 
 import java.util.function.Supplier;
 
+import static org.apache.calcite.linq4j.Nullness.castNonNull;
+
 /**
  * Thread-local variable that returns a handle that can be closed.
  *
  * @param <T> Value type
  */
-public class TryThreadLocal<@Nullable T> extends ThreadLocal<T> {
+public class TryThreadLocal<T> extends ThreadLocal<@Nullable T> {
   private final T initialValue;
 
   /** Creates a TryThreadLocal.
@@ -48,6 +50,10 @@ private TryThreadLocal(T initialValue) {
     return initialValue;
   }
 
+  @Override public T get() {
+    return castNonNull(super.get());
+  }
+
   /** Assigns the value as {@code value} for the current thread.
    * Returns a {@link Memo} which, when closed, will assign the value
    * back to the previous value. */
diff --git a/core/src/main/java/org/apache/calcite/util/Util.java b/core/src/main/java/org/apache/calcite/util/Util.java
index fe771cb2c58..0d76d416bf5 100644
--- a/core/src/main/java/org/apache/calcite/util/Util.java
+++ b/core/src/main/java/org/apache/calcite/util/Util.java
@@ -40,6 +40,7 @@
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Sets;
+import com.google.errorprone.annotations.CanIgnoreReturnValue;
 
 import org.apiguardian.api.API;
 import org.checkerframework.checker.nullness.qual.Nullable;
@@ -114,6 +115,8 @@
 
 import static org.apache.calcite.linq4j.Nullness.castNonNull;
 
+import static java.util.Objects.requireNonNull;
+
 /**
  * Miscellaneous utility functions.
  */
@@ -919,12 +922,19 @@ public static Error newInternal(Throwable e, String s) {
     return new AssertionError("Internal error: " + s, e);
   }
 
+  /** Until we upgrade to Guava 19. */
+  @CanIgnoreReturnValue
+  public static <T> T verifyNotNull(@Nullable T reference) {
+    Bug.upgrade("Remove when minimum Guava version is 17");
+    return requireNonNull(reference, "expected a non-null reference");
+  }
+
   /** As {@link Throwables}{@code .throwIfUnchecked(Throwable)},
    * which was introduced in Guava 20,
    * but we don't require Guava version 20 yet. */
   public static void throwIfUnchecked(Throwable throwable) {
     Bug.upgrade("Remove when minimum Guava version is 20");
-    Objects.requireNonNull(throwable, "throwable");
+    requireNonNull(throwable, "throwable");
     if (throwable instanceof RuntimeException) {
       throw (RuntimeException) throwable;
     }
@@ -1560,9 +1570,9 @@ public static String toPosix(TimeZone tz, boolean verbose) {
   }
 
   private static int groupAsInt(Matcher matcher, int index) {
-    String value = Objects.requireNonNull(
-        matcher.group(index),
-        () -> "no group for index " + index + ", matcher " + matcher);
+    String value =
+        requireNonNull(matcher.group(index),
+            () -> "no group for index " + index + ", matcher " + matcher);
     return Integer.parseInt(value);
   }
 
@@ -1792,11 +1802,12 @@ public static <E> Iterable<E> cast(
    * <p>The returned object is an {@link Iterable},
    * which makes it ideal for use with the 'foreach' construct. For example,
    *
-   * <blockquote><code>List&lt;Number&gt; numbers = Arrays.asList(1, 2, 3.14,
-   * 4, null, 6E23);<br>
-   * for (int myInt : filter(numbers, Integer.class)) {<br>
-   * &nbsp;&nbsp;&nbsp;&nbsp;print(i);<br>
-   * }</code></blockquote>
+   * <blockquote><pre>{@code
+   *   List<Number> numbers = Arrays.asList(1, 2, 3.14, 4, null, 6E23);
+   *   for (int myInt : filter(numbers, Integer.class)) {
+   *     print(i);
+   *   }
+   * }</pre></blockquote>
    *
    * <p>will print 1, 2, 4.
    *
diff --git a/core/src/main/java/org/apache/calcite/util/XmlOutput.java b/core/src/main/java/org/apache/calcite/util/XmlOutput.java
index e20ea6a1962..8fef221e861 100644
--- a/core/src/main/java/org/apache/calcite/util/XmlOutput.java
+++ b/core/src/main/java/org/apache/calcite/util/XmlOutput.java
@@ -565,8 +565,8 @@ static class StringEscaper implements Cloneable {
      */
     public void defineEscape(char from, String to) {
       int i = (int) from;
-      List<@Nullable String> translationVector = requireNonNull(this.translationVector,
-          "translationVector");
+      List<@Nullable String> translationVector =
+          requireNonNull(this.translationVector, "translationVector");
       if (i >= translationVector.size()) {
         // Extend list by adding the requisite number of nulls.
         final int count = i + 1 - translationVector.size();
@@ -641,8 +641,9 @@ public String escapeString(String s) {
     public StringEscaper getMutableClone() {
       StringEscaper clone = clone();
       if (clone.translationVector == null) {
-        clone.translationVector = Lists.newArrayList(
-            requireNonNull(clone.translationTable, "clone.translationTable"));
+        clone.translationVector =
+            Lists.newArrayList(
+                requireNonNull(clone.translationTable, "clone.translationTable"));
         clone.translationTable = null;
       }
       return clone;
diff --git a/core/src/main/java/org/apache/calcite/util/format/FormatElement.java b/core/src/main/java/org/apache/calcite/util/format/FormatElement.java
new file mode 100644
index 00000000000..6670e23423a
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/util/format/FormatElement.java
@@ -0,0 +1,58 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.util.format;
+
+import org.apache.calcite.linq4j.function.Experimental;
+
+import java.util.function.Consumer;
+
+/**
+ * A format element in a format string. Knows how to parse and unparse itself.
+ */
+@Experimental
+public interface FormatElement {
+
+  /**
+   * Formats a date to its appropriate string representation for the element.
+   *
+   * <p>This API is subject to change. It might be more efficient if the
+   * signature was one of the following:
+   *
+   * <pre>
+   *   void format(StringBuilder, java.util.Date)
+   *   void format(StringBuilder, long)
+   * </pre>
+   */
+  String format(java.util.Date date);
+
+  /**
+   * Returns the description of an element.
+   *
+   * <p>For example, {@code %H} in MySQL represents the hour in 24-hour format
+   * (e.g., 00..23). This method returns the string "The hour (24-hour clock) as
+   * a decimal number (00-23)", which is the description of
+   * {@link FormatElementEnum#HH24}.
+   */
+  String getDescription();
+
+  /**
+   * Applies a consumer to a format element.
+   */
+  default void flatten(Consumer<FormatElement> consumer) {
+    consumer.accept(this);
+  }
+}
diff --git a/core/src/main/java/org/apache/calcite/util/format/FormatElementEnum.java b/core/src/main/java/org/apache/calcite/util/format/FormatElementEnum.java
new file mode 100644
index 00000000000..7aed1fc486f
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/util/format/FormatElementEnum.java
@@ -0,0 +1,234 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.util.format;
+
+import org.apache.calcite.avatica.util.DateTimeUtils;
+
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+import java.text.DateFormat;
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.Locale;
+
+import static org.apache.calcite.linq4j.Nullness.castNonNull;
+
+/**
+ * Implementation of {@link FormatElement} containing the standard format
+ * elements. These are based on Oracle's format model documentation.
+ *
+ * <p>See
+ * <a href="https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlqr/Format-Models.html">
+ * Oracle format model reference.</a>
+ *
+ * @see FormatModels#DEFAULT
+ */
+public enum FormatElementEnum implements FormatElement {
+  D("The weekday (Monday as the first day of the week) as a decimal number (1-7)") {
+    @Override public String format(Date date) {
+      final Calendar calendar = Work.get().calendar;
+      calendar.setTime(date);
+      return String.format(Locale.ROOT, "%d", calendar.get(Calendar.DAY_OF_WEEK));
+    }
+  },
+  DAY("The full weekday name") {
+    @Override public String format(Date date) {
+      final Work work = Work.get();
+      return work.eeeeFormat.format(date);
+    }
+  },
+  DD("The day of the month as a decimal number (01-31)") {
+    @Override public String format(Date date) {
+      final Calendar calendar = Work.get().calendar;
+      calendar.setTime(date);
+      return String.format(Locale.ROOT, "%02d", calendar.get(Calendar.DAY_OF_MONTH));
+    }
+  },
+  DDD("The day of the year as a decimal number (001-366)") {
+    @Override public String format(Date date) {
+      final Calendar calendar = Work.get().calendar;
+      calendar.setTime(date);
+      return String.format(Locale.ROOT, "%03d", calendar.get(Calendar.DAY_OF_YEAR));
+    }
+  },
+  DY("The abbreviated weekday name") {
+    @Override public String format(Date date) {
+      final Work work = Work.get();
+      return work.eeeFormat.format(date);
+    }
+  },
+  FF1("Fractional seconds to 1 digit") {
+    @Override public String format(Date date) {
+      final Work work = Work.get();
+      return work.sFormat.format(date);
+    }
+  },
+  FF2("Fractional seconds to 2 digits") {
+    @Override public String format(Date date) {
+      final Work work = Work.get();
+      return work.ssFormat.format(date);
+    }
+  },
+  FF3("Fractional seconds to 3 digits") {
+    @Override public String format(Date date) {
+      final Work work = Work.get();
+      return work.sssFormat.format(date);
+    }
+  },
+  FF4("Fractional seconds to 4 digits") {
+    @Override public String format(Date date) {
+      final Work work = Work.get();
+      return work.ssssFormat.format(date);
+    }
+  },
+  FF5("Fractional seconds to 5 digits") {
+    @Override public String format(Date date) {
+      final Work work = Work.get();
+      return work.sssssFormat.format(date);
+    }
+  },
+  FF6("Fractional seconds to 6 digits") {
+    @Override public String format(Date date) {
+      final Work work = Work.get();
+      return work.ssssssFormat.format(date);
+    }
+  },
+  HH24("The hour (24-hour clock) as a decimal number (00-23)") {
+    @Override public String format(Date date) {
+      final Calendar calendar = Work.get().calendar;
+      calendar.setTime(date);
+      return String.format(Locale.ROOT, "%02d", calendar.get(Calendar.HOUR_OF_DAY));
+    }
+  },
+  IW("The ISO 8601 week number of the year (Monday as the first day of the week) "
+      + "as a decimal number (01-53)") {
+    @Override public String format(Date date) {
+      // TODO: ensure this is isoweek
+      final Calendar calendar = Work.get().calendar;
+      calendar.setTime(date);
+      calendar.setFirstDayOfWeek(Calendar.MONDAY);
+      return String.format(Locale.ROOT, "%02d", calendar.get(Calendar.WEEK_OF_YEAR));
+    }
+  },
+  MI("The minute as a decimal number (00-59)") {
+    @Override public String format(Date date) {
+      final Calendar calendar = Work.get().calendar;
+      calendar.setTime(date);
+      return String.format(Locale.ROOT, "%02d", calendar.get(Calendar.MINUTE));
+    }
+  },
+  MM("The month as a decimal number (01-12)") {
+    @Override public String format(Date date) {
+      final Calendar calendar = Work.get().calendar;
+      calendar.setTime(date);
+      return String.format(Locale.ROOT, "%02d", calendar.get(Calendar.MONTH) + 1);
+    }
+  },
+  MON("The abbreviated month name") {
+    @Override public String format(Date date) {
+      final Work work = Work.get();
+      return work.mmmFormat.format(date);
+    }
+  },
+  MONTH("The full month name (English)") {
+    @Override public String format(Date date) {
+      final Work work = Work.get();
+      return work.mmmmFormat.format(date);
+    }
+  },
+  Q("The quarter as a decimal number (1-4)") {
+    @Override public String format(Date date) {
+      final Calendar calendar = Work.get().calendar;
+      calendar.setTime(date);
+      return String.format(Locale.ROOT, "%d", (calendar.get(Calendar.MONTH) / 3) + 1);
+    }
+  },
+  SS("The second as a decimal number (00-60)") {
+    @Override public String format(Date date) {
+      final Calendar calendar = Work.get().calendar;
+      calendar.setTime(date);
+      return String.format(Locale.ROOT, "%02d", calendar.get(Calendar.SECOND));
+    }
+  },
+  TZR("The time zone name") {
+    @Override public String format(Date date) {
+      // TODO: how to support timezones?
+      throw new UnsupportedOperationException();
+    }
+  },
+  WW("The week number of the year (Sunday as the first day of the week) as a decimal "
+      + "number (00-53)") {
+    @Override public String format(Date date) {
+      final Calendar calendar = Work.get().calendar;
+      calendar.setTime(date);
+      calendar.setFirstDayOfWeek(Calendar.SUNDAY);
+      return String.format(Locale.ROOT, "%02d", calendar.get(Calendar.WEEK_OF_YEAR));
+    }
+  },
+  YY("Last 2 digits of year") {
+    @Override public String format(Date date) {
+      final Work work = Work.get();
+      return work.yyFormat.format(date);
+    }
+  },
+  YYYY("The year with century as a decimal number") {
+    @Override public String format(Date date) {
+      final Calendar calendar = Work.get().calendar;
+      calendar.setTime(date);
+      return String.format(Locale.ROOT, "%d", calendar.get(Calendar.YEAR));
+    }
+  };
+
+  private final String description;
+
+  // TODO: be sure to deal with TZ
+
+  FormatElementEnum(String description) {
+    this.description = description;
+  }
+
+  @Override public String getDescription() {
+    return description;
+  }
+
+  /** Work space. Provides a value for each mutable data structure that might
+   * be needed by a format element. Ensures thread-safety. */
+  static class Work {
+    private static final ThreadLocal<@Nullable Work> THREAD_WORK =
+        ThreadLocal.withInitial(Work::new);
+
+    /** Returns an instance of Work for this thread. */
+    static Work get() {
+      return castNonNull(THREAD_WORK.get());
+    }
+
+    final Calendar calendar =
+        Calendar.getInstance(DateTimeUtils.DEFAULT_ZONE, Locale.ROOT);
+    final DateFormat eeeeFormat = new SimpleDateFormat("EEEE", Locale.ROOT);
+    final DateFormat eeeFormat = new SimpleDateFormat("EEE", Locale.ROOT);
+    final DateFormat mmmFormat = new SimpleDateFormat("MMM", Locale.ROOT);
+    final DateFormat mmmmFormat = new SimpleDateFormat("MMMM", Locale.ROOT);
+    final DateFormat sFormat = new SimpleDateFormat("S", Locale.ROOT);
+    final DateFormat ssFormat = new SimpleDateFormat("SS", Locale.ROOT);
+    final DateFormat sssFormat = new SimpleDateFormat("SSS", Locale.ROOT);
+    final DateFormat ssssFormat = new SimpleDateFormat("SSSS", Locale.ROOT);
+    final DateFormat sssssFormat = new SimpleDateFormat("SSSSS", Locale.ROOT);
+    final DateFormat ssssssFormat = new SimpleDateFormat("SSSSSS", Locale.ROOT);
+    final DateFormat yyFormat = new SimpleDateFormat("yy", Locale.ROOT);
+  }
+}
diff --git a/core/src/main/java/org/apache/calcite/util/format/FormatModel.java b/core/src/main/java/org/apache/calcite/util/format/FormatModel.java
new file mode 100644
index 00000000000..39bac2f0533
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/util/format/FormatModel.java
@@ -0,0 +1,37 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.util.format;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Describes the format strings used by a formatting function such as
+ * {@code FORMAT_TIMESTAMP} or {@code CAST(string AS DATE FORMAT formatString)}.
+ *
+ * <p>Can parse a format string to a list of format elements.
+ *
+ * @see FormatModels
+ */
+public interface FormatModel {
+  /** Returns the map used to create the {@link FormatModel} instance. */
+  Map<String, FormatElement> getElementMap();
+
+  /** Parses a format string using element identifiers supplied by
+   * {@code format}. */
+  List<FormatElement> parse(String format);
+}
diff --git a/core/src/main/java/org/apache/calcite/util/format/FormatModels.java b/core/src/main/java/org/apache/calcite/util/format/FormatModels.java
new file mode 100644
index 00000000000..be7a144b3aa
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/util/format/FormatModels.java
@@ -0,0 +1,278 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.util.format;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Consumer;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import static org.apache.calcite.util.format.FormatElementEnum.D;
+import static org.apache.calcite.util.format.FormatElementEnum.DAY;
+import static org.apache.calcite.util.format.FormatElementEnum.DD;
+import static org.apache.calcite.util.format.FormatElementEnum.DDD;
+import static org.apache.calcite.util.format.FormatElementEnum.DY;
+import static org.apache.calcite.util.format.FormatElementEnum.FF1;
+import static org.apache.calcite.util.format.FormatElementEnum.FF2;
+import static org.apache.calcite.util.format.FormatElementEnum.FF3;
+import static org.apache.calcite.util.format.FormatElementEnum.FF4;
+import static org.apache.calcite.util.format.FormatElementEnum.FF5;
+import static org.apache.calcite.util.format.FormatElementEnum.FF6;
+import static org.apache.calcite.util.format.FormatElementEnum.HH24;
+import static org.apache.calcite.util.format.FormatElementEnum.IW;
+import static org.apache.calcite.util.format.FormatElementEnum.MI;
+import static org.apache.calcite.util.format.FormatElementEnum.MM;
+import static org.apache.calcite.util.format.FormatElementEnum.MON;
+import static org.apache.calcite.util.format.FormatElementEnum.MONTH;
+import static org.apache.calcite.util.format.FormatElementEnum.Q;
+import static org.apache.calcite.util.format.FormatElementEnum.SS;
+import static org.apache.calcite.util.format.FormatElementEnum.TZR;
+import static org.apache.calcite.util.format.FormatElementEnum.WW;
+import static org.apache.calcite.util.format.FormatElementEnum.YY;
+import static org.apache.calcite.util.format.FormatElementEnum.YYYY;
+
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Utilities for {@link FormatModel}.
+ */
+public class FormatModels {
+  private FormatModels() {
+  }
+
+  /** The format model consisting of built-in format elements.
+   *
+   * <p>Due to the design of {@link FormatElementEnum}, it is similar to
+   * Oracle's format model.
+   */
+  public static final FormatModel DEFAULT;
+
+  /** Format model for BigQuery.
+   *
+   * <p>BigQuery format element reference:
+   * <a href="https://cloud.google.com/bigquery/docs/reference/standard-sql/format-elements">
+   * BigQuery Standard SQL Format Elements</a>.
+   */
+  public static final FormatModel BIG_QUERY;
+
+  static {
+    final Map<String, FormatElement> map = new HashMap<>();
+    for (FormatElementEnum fe : FormatElementEnum.values()) {
+      map.put(fe.toString(), fe);
+    }
+    DEFAULT = create(map);
+
+    map.clear();
+    map.put("%A", DAY);
+    map.put("%a", DY);
+    map.put("%B", MONTH);
+    map.put("%b", MON);
+    map.put("%c",
+        compositeElement("The date and time representation (English);",
+            DY, literalElement(" "), MON, literalElement(" "),
+            DD, literalElement(" "), HH24, literalElement(":"),
+            MI, literalElement(":"), SS, literalElement(" "),
+            YYYY));
+    map.put("%d", DD);
+    map.put("%E1S", FF1);
+    map.put("%E2S", FF2);
+    map.put("%E3S", FF3);
+    map.put("%E4S", FF4);
+    map.put("%E5S", FF5);
+    map.put("%E*S", FF6);
+    map.put("%H", HH24);
+    map.put("%j", DDD);
+    map.put("%M", MI);
+    map.put("%m", MM);
+    map.put("%Q", Q);
+    map.put("%R",
+        compositeElement("The time in the format %H:%M",
+            HH24, literalElement(":"), MI));
+    map.put("%S", SS);
+    map.put("%u", D);
+    map.put("%V", IW);
+    map.put("%W", WW);
+    map.put("%x",
+        compositeElement("The date representation in MM/DD/YY format",
+            MM, literalElement("/"), DD, literalElement("/"), YY));
+    map.put("%Y", YYYY);
+    map.put("%y", YY);
+    map.put("%Z", TZR);
+    BIG_QUERY = create(map);
+  }
+
+  /**
+   * Generates a {@link Pattern} using the keys of a {@link FormatModel} element
+   * map. This pattern is used in {@link FormatModel#parse(String)} to help
+   * locate known format elements in a string.
+   */
+  private static Pattern regexFromMap(Map<String, FormatElement> elementMap) {
+    StringBuilder regex = new StringBuilder();
+    for (String key : elementMap.keySet()) {
+      regex.append("(").append(Pattern.quote(key)).append(")|");
+    }
+    // remove the last '|'
+    regex.setLength(regex.length() - 1);
+    return Pattern.compile(regex.toString());
+  }
+
+  /**
+   * Creates a {@link FormatModel} that uses the provided map to identify
+   * {@link FormatElement}s while parsing a format string.
+   */
+  public static FormatModel create(Map<String, FormatElement> elementMap) {
+    final Pattern pattern = regexFromMap(elementMap);
+    return new FormatModelImpl(pattern, elementMap);
+  }
+
+  /**
+   * Creates a literal format element.
+   */
+  public static FormatElement literalElement(String literal) {
+    return new FormatModelElementLiteral(literal);
+  }
+
+  /**
+   * Creates a composite format element from the provided list of elements
+   * and description.
+   */
+  public static FormatElement compositeElement(String description,
+      FormatElement... fmtElements) {
+    return new CompositeFormatElement(ImmutableList.copyOf(fmtElements),
+        description);
+  }
+
+
+  /** Implementation of {@link FormatModel} based on a list of format
+   * elements. */
+  private static class FormatModelImpl implements FormatModel {
+    final Pattern pattern;
+    final Map<String, FormatElement> elementMap;
+
+    /** Cache of parsed format strings.
+     *
+     * <p>NOTE: The current implementation could grow without bounds.
+     * A per-thread cache would be better, or a cache tied to a statement
+     * execution (e.g. in DataContext). Also limit to a say 100 entries. */
+    final Map<String, List<FormatElement>> memoizedElements =
+        new ConcurrentHashMap<>();
+
+    FormatModelImpl(Pattern pattern, Map<String, FormatElement> elementMap) {
+      this.pattern = requireNonNull(pattern, "pattern");
+      this.elementMap = ImmutableMap.copyOf(elementMap);
+    }
+
+    @Override public Map<String, FormatElement> getElementMap() {
+      return elementMap;
+    }
+
+    private List<FormatElement> internalParse(String format) {
+      final ImmutableList.Builder<FormatElement> elements =
+          ImmutableList.builder();
+      final Matcher matcher = pattern.matcher(format);
+      int i = 0;
+      String literal;
+      while (matcher.find()) {
+        // Add any leading literal text before next element match
+        literal = format.substring(i, matcher.start());
+        if (!literal.isEmpty()) {
+          elements.add(literalElement(literal));
+        }
+        // add the element match - use literal as default to be safe.
+        String key = matcher.group();
+        elements.add(getElementMap().getOrDefault(key, literalElement(key)));
+        i = matcher.end();
+      }
+      // add any remaining literal text after last element match
+      literal = format.substring(i);
+      if (!literal.isEmpty()) {
+        elements.add(literalElement(literal));
+      }
+      return elements.build();
+    }
+
+    @Override public List<FormatElement> parse(String format) {
+      return memoizedElements.computeIfAbsent(format, this::internalParse);
+    }
+  }
+
+  /**
+   * A format element that is literal text.
+   */
+  private static class FormatModelElementLiteral implements FormatElement {
+    private final String literal;
+
+    FormatModelElementLiteral(String literal) {
+      this.literal = requireNonNull(literal, "literal");
+    }
+
+    @Override public String format(Date date) {
+      return literal;
+    }
+
+    @Override public String getDescription() {
+      return "Represents literal text in a format string";
+    }
+
+    @Override public String toString() {
+      return this.literal;
+    }
+  }
+
+  /**
+   * A format element comprised of one or more {@link FormatElement} entries.
+   */
+  private static class CompositeFormatElement implements FormatElement {
+    private final String description;
+    private final List<FormatElement> formatElements;
+
+    CompositeFormatElement(List<FormatElement> formatElements,
+        String description) {
+      this.formatElements = ImmutableList.copyOf(formatElements);
+      this.description = requireNonNull(description, "description");
+    }
+
+    @Override public String format(Date date) {
+      StringBuilder buf = new StringBuilder();
+      flatten(ele -> buf.append(ele.format(date)));
+      return buf.toString();
+    }
+
+    /**
+     * Applies a consumer to each format element that make up the composite
+     * element.
+     *
+     * <p>For example, {@code %R} in Google SQL represents the hour in 24-hour
+     * format (e.g., 00..23) followed by the minute as a decimal number.
+     * {@code flatten(i -> println(i.toString())); } would print "HH24:MI".
+     */
+    @Override public void flatten(Consumer<FormatElement> consumer) {
+      formatElements.forEach(consumer);
+    }
+
+    @Override public String getDescription() {
+      return this.description;
+    }
+  }
+}
diff --git a/core/src/main/java/org/apache/calcite/util/format/package-info.java b/core/src/main/java/org/apache/calcite/util/format/package-info.java
new file mode 100644
index 00000000000..88ed6b551c5
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/util/format/package-info.java
@@ -0,0 +1,21 @@
+/*
+ * 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.
+ */
+
+/**
+ * Utility classes for handling format strings.
+ */
+package org.apache.calcite.util.format;
diff --git a/core/src/main/java/org/apache/calcite/util/graph/Graphs.java b/core/src/main/java/org/apache/calcite/util/graph/Graphs.java
index e9727e3f96a..adf094c7dc4 100644
--- a/core/src/main/java/org/apache/calcite/util/graph/Graphs.java
+++ b/core/src/main/java/org/apache/calcite/util/graph/Graphs.java
@@ -77,8 +77,9 @@ public static <V, E extends DefaultEdge> FrozenGraph<V, E> makeImmutable(
           if (edge.target.equals(edge2.left)) {
             final Pair<V, V> key = Pair.of(graph1.source(edge), edge2.right);
             int[] bestDistance = shortestDistances.get(key);
-            int[] arc2Distance = requireNonNull(shortestDistances.get(edge2),
-                () -> "shortestDistances.get(edge2) for " + edge2);
+            int[] arc2Distance =
+                requireNonNull(shortestDistances.get(edge2),
+                    () -> "shortestDistances.get(edge2) for " + edge2);
             if ((bestDistance == null)
                 || (bestDistance[0] > (arc2Distance[0] + 1))) {
               shortestDistances.put(key, new int[] {arc2Distance[0] + 1});
diff --git a/core/src/main/java/org/apache/calcite/util/graph/TopologicalOrderIterator.java b/core/src/main/java/org/apache/calcite/util/graph/TopologicalOrderIterator.java
index aa561263e28..024eba39477 100644
--- a/core/src/main/java/org/apache/calcite/util/graph/TopologicalOrderIterator.java
+++ b/core/src/main/java/org/apache/calcite/util/graph/TopologicalOrderIterator.java
@@ -61,9 +61,9 @@ private void populate(
         : graph.vertexMap.values()) {
       for (E edge : info.outEdges) {
         //noinspection SuspiciousMethodCalls
-        final int[] ints = requireNonNull(
-            countMap.get(edge.target),
-            () -> "no value for " + edge.target);
+        final int[] ints =
+            requireNonNull(countMap.get(edge.target),
+                () -> "no value for " + edge.target);
         ++ints[0];
       }
     }
@@ -81,15 +81,15 @@ private void populate(
 
   @Override public V next() {
     V v = empties.remove(0);
-    DefaultDirectedGraph.VertexInfo<V, E> vertexInfo = requireNonNull(
-        graph.vertexMap.get(v),
-        () -> "no vertex " + v);
+    DefaultDirectedGraph.VertexInfo<V, E> vertexInfo =
+        requireNonNull(graph.vertexMap.get(v),
+            () -> "no vertex " + v);
     for (E o : vertexInfo.outEdges) {
       //noinspection unchecked
       final V target = (V) o.target;
-      int[] ints = requireNonNull(
-          countMap.get(target),
-          () -> "no counts found for target " + target);
+      int[] ints =
+          requireNonNull(countMap.get(target),
+              () -> "no counts found for target " + target);
       if (--ints[0] == 0) {
         countMap.remove(target);
         empties.add(target);
diff --git a/core/src/main/java/org/apache/calcite/util/javac/JavaCompilerArgs.java b/core/src/main/java/org/apache/calcite/util/javac/JavaCompilerArgs.java
index 6b93d7310f9..0127e2b246e 100644
--- a/core/src/main/java/org/apache/calcite/util/javac/JavaCompilerArgs.java
+++ b/core/src/main/java/org/apache/calcite/util/javac/JavaCompilerArgs.java
@@ -42,8 +42,9 @@ public class JavaCompilerArgs {
   //~ Constructors -----------------------------------------------------------
 
   public JavaCompilerArgs() {
-    classLoader = requireNonNull(getClass().getClassLoader(),
-        () -> "getClassLoader is null for " + getClass());
+    classLoader =
+        requireNonNull(getClass().getClassLoader(),
+            () -> "getClassLoader is null for " + getClass());
   }
 
   //~ Methods ----------------------------------------------------------------
diff --git a/core/src/main/java/org/apache/calcite/util/mapping/Mappings.java b/core/src/main/java/org/apache/calcite/util/mapping/Mappings.java
index ebad6bbed44..a9bf7d9b1a7 100644
--- a/core/src/main/java/org/apache/calcite/util/mapping/Mappings.java
+++ b/core/src/main/java/org/apache/calcite/util/mapping/Mappings.java
@@ -1348,8 +1348,7 @@ private class MappingItr implements Iterator<IntPair> {
       }
 
       private void advance(
-          @UnknownInitialization MappingItr this
-      ) {
+          @UnknownInitialization MappingItr this) {
         do {
           ++i;
         } while (i < targets.length && targets[i] == -1);
diff --git a/core/src/main/java/org/apache/calcite/util/trace/CalciteTrace.java b/core/src/main/java/org/apache/calcite/util/trace/CalciteTrace.java
index e2b0fcfbbd8..6a50dac5a67 100644
--- a/core/src/main/java/org/apache/calcite/util/trace/CalciteTrace.java
+++ b/core/src/main/java/org/apache/calcite/util/trace/CalciteTrace.java
@@ -129,8 +129,7 @@ public static Logger getSqlToRelTracer() {
 
   public static Logger getRuleAttemptsTracer() {
     return LoggerFactory.getLogger(
-        AbstractRelOptPlanner.class.getName() + ".rule_execution_summary"
-    );
+        AbstractRelOptPlanner.class.getName() + ".rule_execution_summary");
   }
 
   /**
diff --git a/core/src/main/resources/org/apache/calcite/runtime/CalciteResource.properties b/core/src/main/resources/org/apache/calcite/runtime/CalciteResource.properties
index c166ab4266f..ad0acc822bb 100644
--- a/core/src/main/resources/org/apache/calcite/runtime/CalciteResource.properties
+++ b/core/src/main/resources/org/apache/calcite/runtime/CalciteResource.properties
@@ -22,13 +22,15 @@ ParserContext=line {0,number,#}, column {1,number,#}
 BangEqualNotAllowed=Bang equal ''!='' is not allowed under the current SQL conformance level
 PercentRemainderNotAllowed=Percent remainder ''%'' is not allowed under the current SQL conformance level
 LimitStartCountNotAllowed=''LIMIT start, count'' is not allowed under the current SQL conformance level
+OffsetLimitNotAllowed=''OFFSET start LIMIT count'' is not allowed under the current SQL conformance level
 ApplyNotAllowed=APPLY operator is not allowed under the current SQL conformance level
-JsonPathMustBeSpecified=JSON path expression must be specified after the JSON value expression
-IllegalLiteral=Illegal {0} literal {1}: {2}
+ValueNotAllowed=VALUE is not allowed under the current SQL conformance level
+IllegalLiteral=Illegal {0} literal ''{1}'': {2}
 IdentifierTooLong=Length of identifier ''{0}'' must be less than or equal to {1,number,#} characters
 BadFormat=not in format ''{0}''
 BetweenWithoutAnd=BETWEEN operator has no terminating AND
 GeometryDisabled=Geo-spatial extensions and the GEOMETRY data type are not enabled
+Proj4jEpsgIsMissing=Proj4J EPSG is missing from the classpath; to resolve this problem, download the EPSG data set and agree to its terms of use
 IllegalIntervalLiteral=Illegal INTERVAL literal {0}; at {1}
 IllegalMinusDate=Illegal expression. Was expecting "(DATETIME - DATETIME) INTERVALQUALIFIER"
 IllegalOverlaps=Illegal overlaps expression. Was expecting expression on the form "(DATETIME, EXPRESSION) OVERLAPS (DATETIME, EXPRESSION)"
@@ -36,7 +38,10 @@ IllegalNonQueryExpression=Non-query expression encountered in illegal context
 IllegalQueryExpression=Query expression encountered in illegal context
 IllegalCursorExpression=CURSOR expression encountered in illegal context
 IllegalOrderBy=ORDER BY unexpected
+IllegalJoinExpression=Join expression encountered in illegal context
+ExpectedQueryOrJoinExpression=Expected query or join
 IllegalBinaryString=Illegal binary string {0}
+IllegalArrayExpression=Illegal array expression ''{0}''
 IllegalFromEmpty=''FROM'' without operands preceding it is illegal
 IllegalRowExpression=ROW expression encountered in illegal context
 IllegalColon=Illegal identifier '':''. Was expecting ''VALUE''
@@ -105,8 +110,9 @@ JoinRequiresCondition=INNER, LEFT, RIGHT or FULL join requires a condition (NATU
 DisallowsQualifyingCommonColumn=Cannot qualify common column ''{0}''
 CrossJoinDisallowsCondition=Cannot specify condition (NATURAL keyword, or ON or USING clause) following CROSS JOIN
 NaturalDisallowsOnOrUsing=Cannot specify NATURAL keyword with ON or USING clause
-ColumnInUsingNotUnique=Column name ''{0}'' in USING clause is not unique on one side of join
+ColumnInUsingNotUnique=Column name ''{0}'' in NATURAL join or USING clause is not unique on one side of join
 NaturalOrUsingColumnNotCompatible=Column ''{0}'' matched using NATURAL keyword or USING clause has incompatible types: cannot compare ''{1}'' to ''{2}''
+ArgumentMustBeMeasure=Argument to function ''{0}'' must be a measure
 WindowNotFound=Window ''{0}'' not found
 DisallowsNullTreatment=Cannot specify IGNORE NULLS or RESPECT NULLS following ''{0}''
 NotGroupExpr=Expression ''{0}'' is not being grouped
@@ -117,6 +123,8 @@ NotSelectDistinctExpr=Expression ''{0}'' is not in the select clause
 AggregateIllegalInClause=Aggregate expression is illegal in {0} clause
 WindowedAggregateIllegalInClause=Windowed aggregate expression is illegal in {0} clause
 NestedAggIllegal=Aggregate expressions cannot be nested
+MeasureIllegal=Measure expressions can only occur within AGGREGATE function
+MeasureMustBeInAggregateQuery=Measure expressions can only occur within a GROUP BY query
 AggregateInFilterIllegal=FILTER must not contain aggregate expression
 AggregateInWithinGroupIllegal=WITHIN GROUP must not contain aggregate expression
 AggregateInWithinDistinctIllegal=WITHIN DISTINCT must not contain aggregate expression
@@ -153,6 +161,7 @@ WindowNameMustBeSimple=Window name must be a simple identifier
 DuplicateWindowName=Duplicate window names not allowed
 EmptyWindowSpec=Empty window specification not allowed
 DupWindowSpec=Duplicate window specification not allowed in the same window clause
+QualifyExpressionMustContainWindowFunction=QUALIFY expression ''{0}'' must contain a window function
 RankWithFrame=ROW/RANGE not allowed with RANK, DENSE_RANK or ROW_NUMBER functions
 FuncNeedsOrderBy=RANK or DENSE_RANK functions require ORDER BY clause in window specification
 PartitionNotAllowed=PARTITION BY not allowed with existing window reference
@@ -190,9 +199,10 @@ NullIllegal=Illegal use of ''NULL''
 DynamicParamIllegal=Illegal use of dynamic parameter
 InvalidBoolean=''{0}'' is not a valid boolean value
 ArgumentMustBeValidPrecision=Argument to function ''{0}'' must be a valid precision between ''{1,number,#}'' and ''{2,number,#}''
+DelimiterIsRequired=Call to function ''{0}'' with argument of type ''{1}'' requires extra delimiter argument
 IllegalArgumentForTableFunctionCall=Wrong arguments for table function ''{0}'' call. Expected ''{1}'', actual ''{2}''
 CannotCallTableFunctionHere=Cannot call table function here: ''{0}''
-InvalidDatetimeFormat=''{0}'' is not a valid datetime format
+InvalidTimeFrame=''{0}'' is not a valid time frame
 InsertIntoAlwaysGenerated=Cannot INSERT into generated column ''{0}''
 ArgumentMustHaveScaleZero=Argument to function ''{0}'' must have a scale of 0
 PreparationAborted=Statement preparation aborted
@@ -276,6 +286,8 @@ ViewNotFound=View ''{0}'' not found
 TypeNotFound=Type ''{0}'' not found
 FunctionNotFound=Function ''{0}'' not found
 DialectDoesNotSupportFeature=Dialect does not support feature: ''{0}''
+IllegalNegativePadLength=Second argument for LPAD/RPAD must not be negative
+IllegalEmptyPadPattern=Third argument (pad pattern) for LPAD/RPAD must not be empty
 IllegalNegativeSubstringLength=Substring error: negative substring length not allowed
 TrimError=Trim error: trim character must be exactly 1 character
 InvalidTypesForArithmetic=Invalid types for arithmetic: {0} {1} {2}
@@ -302,19 +314,25 @@ NullKeyOfJsonObjectNotAllowed=Null key of JSON object is not allowed
 QueryExecutionTimeoutReached=Timeout of ''{0}'' ms for query execution is reached. Query execution started at ''{1}''
 AmbiguousSortOrderInJsonArrayAggFunc=Including both WITHIN GROUP(...) and inside ORDER BY in a single JSON_ARRAYAGG call is not allowed
 ExceptionWhilePerformingQueryOnJdbcSubSchema = While executing SQL [{0}] on JDBC sub-schema
-InvalidInputForJsonType=Not a valid input for JSON_TYPE: ''{0}''
-InvalidInputForJsonDepth=Not a valid input for JSON_DEPTH: ''{0}''
+InvalidInputForJsonType=Invalid input for JSON_TYPE: ''{0}''
+InvalidInputForJsonDepth=Invalid input for JSON_DEPTH: ''{0}''
 ExceptionWhileSerializingToJson=Cannot serialize object to JSON: ''{0}''
-InvalidInputForJsonLength=Not a valid input for JSON_LENGTH: ''{0}''
-InvalidInputForJsonKeys=Not a valid input for JSON_KEYS: ''{0}''
+InvalidInputForJsonLength=Invalid input for JSON_LENGTH: ''{0}''
+InvalidInputForJsonKeys=Invalid input for JSON_KEYS: ''{0}''
 InvalidInputForJsonRemove=Invalid input for JSON_REMOVE: document: ''{0}'', jsonpath expressions: ''{1}''
-InvalidInputForJsonStorageSize=Not a valid input for JSON_STORAGE_SIZE: ''{0}''
-InvalidInputForRegexpReplace=Not a valid input for REGEXP_REPLACE: ''{0}''
+InvalidInputForJsonStorageSize=Invalid input for JSON_STORAGE_SIZE: ''{0}''
+InvalidInputForRegexpReplace=Invalid input for REGEXP_REPLACE: ''{0}''
+InvalidInputForJsonInsert=Invalid input for JSON_INSERT: jsonDoc: ''{0}'', kvs: ''{1}''
+InvalidInputForJsonReplace=Invalid input for JSON_REPLACE: jsonDoc: ''{0}'', kvs: ''{1}''
+InvalidInputForJsonSet=Invalid input for JSON_SET: jsonDoc: ''{0}'', kvs: ''{1}''
 IllegalXslt=Illegal xslt specified : ''{0}''
 InvalidInputForXmlTransform=Invalid input for XMLTRANSFORM xml: ''{0}''
 InvalidInputForExtractValue=Invalid input for EXTRACTVALUE: xml: ''{0}'', xpath expression: ''{1}''
 InvalidInputForExtractXml=Invalid input for EXTRACT xpath: ''{0}'', namespace: ''{1}''
 InvalidInputForExistsNode=Invalid input for EXISTSNODE xpath: ''{0}'', namespace: ''{1}''
 DifferentLengthForBitwiseOperands=Different length for bitwise operands: the first: {0,number,#}, the second: {1,number,#}
+InvalidPartitionKeys=Only tables with set semantics may be partitioned. Invalid PARTITION BY clause in the {0,number,#}-th operand of table function ''{1}''
+InvalidOrderBy=Only tables with set semantics may be ordered. Invalid ORDER BY clause in the {0,number,#}-th operand of table function ''{1}''
+MultipleRowSemanticsTables=A table function at most has one input table with row semantics. Table function ''{0}'' has multiple input tables with row semantics
 NoOperator=No operator for ''{0}'' with kind: ''{1}'', syntax: ''{2}'' during JSON deserialization
 # End CalciteResource.properties
diff --git a/core/src/test/codegen/config.fmpp b/core/src/test/codegen/config.fmpp
index ee74320d574..99ecb93da96 100644
--- a/core/src/test/codegen/config.fmpp
+++ b/core/src/test/codegen/config.fmpp
@@ -28,7 +28,8 @@ data: {
     # Example: "org.apache.calcite.sql.*", "java.util.List".
     imports: [
       "org.apache.calcite.sql.SqlCreate",
-      "org.apache.calcite.sql.parser.parserextensiontesting.SqlCreateTable",
+      "org.apache.calcite.sql.ddl.SqlDdlNodes",
+      "org.apache.calcite.sql.parser.parserextensiontesting.ExtensionSqlCreateTable",
       "org.apache.calcite.sql.parser.parserextensiontesting.SqlUploadJarNode"
     ]
 
@@ -58,6 +59,7 @@ data: {
     # Example: "SqlCreateForeignSchema".
     createStatementParserMethods: [
       "SqlCreateTable"
+      "SqlCreateView"
     ]
 
     # List of files in @includes directory that have parser method
diff --git a/core/src/test/codegen/includes/parserImpls.ftl b/core/src/test/codegen/includes/parserImpls.ftl
index be718abc778..482867753ed 100644
--- a/core/src/test/codegen/includes/parserImpls.ftl
+++ b/core/src/test/codegen/includes/parserImpls.ftl
@@ -19,12 +19,12 @@
 SqlAlter SqlUploadJarNode(Span s, String scope) :
 {
     SqlNode jarPath;
-    final List<SqlNode> jarPathsList;
+    final List<SqlNode> jarPathsList = new ArrayList<SqlNode>();
 }
 {
     <UPLOAD> <JAR>
     jarPath = StringLiteral() {
-        jarPathsList = startList(jarPath);
+        jarPathsList.add(jarPath);
     }
     (
         <COMMA> jarPath = StringLiteral() {
@@ -53,7 +53,22 @@ SqlCreate SqlCreateTable(Span s, boolean replace) :
     |   { query = null; }
     )
     {
-        return new SqlCreateTable(s.end(this), id, columnList, query);
+        return new ExtensionSqlCreateTable(s.end(this), id, columnList, query);
+    }
+}
+
+SqlCreate SqlCreateView(Span s, boolean replace) :
+{
+    final SqlIdentifier id;
+    SqlNodeList columnList = null;
+    final SqlNode query;
+}
+{
+    <VIEW> id = CompoundIdentifier()
+    [ columnList = ParenthesizedSimpleIdentifierList() ]
+    <AS> query = OrderedQueryOrExpr(ExprContext.ACCEPT_QUERY) {
+        return SqlDdlNodes.createView(s.end(this), replace, id, columnList,
+            query);
     }
 }
 
diff --git a/core/src/test/java/org/apache/calcite/adapter/enumerable/EnumUtilsTest.java b/core/src/test/java/org/apache/calcite/adapter/enumerable/EnumUtilsTest.java
index 86943695424..267aa39ca16 100644
--- a/core/src/test/java/org/apache/calcite/adapter/enumerable/EnumUtilsTest.java
+++ b/core/src/test/java/org/apache/calcite/adapter/enumerable/EnumUtilsTest.java
@@ -21,7 +21,7 @@
 import org.apache.calcite.linq4j.tree.Expressions;
 import org.apache.calcite.linq4j.tree.MethodCallExpression;
 import org.apache.calcite.linq4j.tree.ParameterExpression;
-import org.apache.calcite.runtime.GeoFunctions;
+import org.apache.calcite.runtime.SpatialTypeFunctions;
 import org.apache.calcite.runtime.SqlFunctions;
 import org.apache.calcite.runtime.XmlFunctions;
 import org.apache.calcite.util.BuiltInMethod;
@@ -205,10 +205,10 @@ public final class EnumUtilsTest {
     final ConstantExpression arg4 = Expressions.constant(1, int.class);
     final ConstantExpression arg5 = Expressions.constant(2, int.class);
     final MethodCallExpression geoMethodCall =
-        EnumUtils.call(null, GeoFunctions.class, "ST_MakePoint",
+        EnumUtils.call(null, SpatialTypeFunctions.class, "ST_MakePoint",
             Arrays.asList(arg4, arg5));
     assertThat(Expressions.toString(geoMethodCall),
-        is("org.apache.calcite.runtime.GeoFunctions.ST_MakePoint("
+        is("org.apache.calcite.runtime.SpatialTypeFunctions.ST_MakePoint("
             + "new java.math.BigDecimal(\n  1), "
             + "new java.math.BigDecimal(\n  2))"));
   }
diff --git a/core/src/test/java/org/apache/calcite/adapter/enumerable/PhysTypeTest.java b/core/src/test/java/org/apache/calcite/adapter/enumerable/PhysTypeTest.java
index 0e23926c7ce..98dc6a9cd1e 100644
--- a/core/src/test/java/org/apache/calcite/adapter/enumerable/PhysTypeTest.java
+++ b/core/src/test/java/org/apache/calcite/adapter/enumerable/PhysTypeTest.java
@@ -40,14 +40,16 @@ public final class PhysTypeTest {
    * <a href="https://issues.apache.org/jira/browse/CALCITE-2677">[CALCITE-2677]
    * Struct types with one field are not mapped correctly to Java Classes</a>. */
   @Test void testFieldClassOnColumnOfOneFieldStructType() {
-    RelDataType columnType = TYPE_FACTORY.createStructType(
-        ImmutableList.of(TYPE_FACTORY.createSqlType(SqlTypeName.INTEGER)),
-        ImmutableList.of("intField"));
-    RelDataType rowType = TYPE_FACTORY.createStructType(
-        ImmutableList.of(columnType),
-        ImmutableList.of("structField"));
+    RelDataType columnType =
+        TYPE_FACTORY.createStructType(
+            ImmutableList.of(TYPE_FACTORY.createSqlType(SqlTypeName.INTEGER)),
+            ImmutableList.of("intField"));
+    RelDataType rowType =
+        TYPE_FACTORY.createStructType(ImmutableList.of(columnType),
+            ImmutableList.of("structField"));
 
-    PhysType rowPhysType = PhysTypeImpl.of(TYPE_FACTORY, rowType, JavaRowFormat.ARRAY);
+    PhysType rowPhysType =
+        PhysTypeImpl.of(TYPE_FACTORY, rowType, JavaRowFormat.ARRAY);
     assertEquals(Object[].class, rowPhysType.fieldClass(0));
   }
 
@@ -55,18 +57,17 @@ public final class PhysTypeTest {
    * <a href="https://issues.apache.org/jira/browse/CALCITE-2677">[CALCITE-2677]
    * Struct types with one field are not mapped correctly to Java Classes</a>. */
   @Test void testFieldClassOnColumnOfTwoFieldStructType() {
-    RelDataType columnType = TYPE_FACTORY.createStructType(
-        ImmutableList.of(
-            TYPE_FACTORY.createSqlType(SqlTypeName.INTEGER),
-            TYPE_FACTORY.createSqlType(SqlTypeName.VARCHAR)),
-        ImmutableList.of(
-            "intField",
-            "strField"));
-    RelDataType rowType = TYPE_FACTORY.createStructType(
-        ImmutableList.of(columnType),
-        ImmutableList.of("structField"));
+    RelDataType columnType =
+        TYPE_FACTORY.createStructType(
+            ImmutableList.of(TYPE_FACTORY.createSqlType(SqlTypeName.INTEGER),
+                TYPE_FACTORY.createSqlType(SqlTypeName.VARCHAR)),
+            ImmutableList.of("intField", "strField"));
+    RelDataType rowType =
+        TYPE_FACTORY.createStructType(ImmutableList.of(columnType),
+            ImmutableList.of("structField"));
 
-    PhysType rowPhysType = PhysTypeImpl.of(TYPE_FACTORY, rowType, JavaRowFormat.ARRAY);
+    PhysType rowPhysType =
+        PhysTypeImpl.of(TYPE_FACTORY, rowType, JavaRowFormat.ARRAY);
     assertEquals(Object[].class, rowPhysType.fieldClass(0));
   }
 
@@ -75,14 +76,15 @@ public final class PhysTypeTest {
    * Can't group table function result due to a type cast error if table function
    * returns a row with a single value</a>. */
   @Test void testOneColumnJavaRowFormatConversion() {
-    RelDataType rowType = TYPE_FACTORY.createStructType(
-        ImmutableList.of(TYPE_FACTORY.createSqlType(SqlTypeName.INTEGER)),
-        ImmutableList.of("intField"));
-    final PhysType rowPhysType = PhysTypeImpl.of(TYPE_FACTORY, rowType,
-        JavaRowFormat.ARRAY, false);
-    final Expression e = rowPhysType.convertTo(
-        Expressions.parameter(Enumerable.class, "input"),
-        JavaRowFormat.SCALAR);
+    RelDataType rowType =
+        TYPE_FACTORY.createStructType(
+            ImmutableList.of(TYPE_FACTORY.createSqlType(SqlTypeName.INTEGER)),
+            ImmutableList.of("intField"));
+    final PhysType rowPhysType =
+        PhysTypeImpl.of(TYPE_FACTORY, rowType, JavaRowFormat.ARRAY, false);
+    final Expression e =
+        rowPhysType.convertTo(Expressions.parameter(Enumerable.class, "input"),
+            JavaRowFormat.SCALAR);
     final String expected = "input.select(new org.apache.calcite.linq4j.function.Function1() {\n"
         + "  public int apply(Object[] o) {\n"
         + "    return org.apache.calcite.runtime.SqlFunctions.toInt(o[0]);\n"
diff --git a/core/src/test/java/org/apache/calcite/adapter/enumerable/TypeFinderTest.java b/core/src/test/java/org/apache/calcite/adapter/enumerable/TypeFinderTest.java
index ed91f2cb8c8..583bcd8d670 100644
--- a/core/src/test/java/org/apache/calcite/adapter/enumerable/TypeFinderTest.java
+++ b/core/src/test/java/org/apache/calcite/adapter/enumerable/TypeFinderTest.java
@@ -59,10 +59,10 @@ class TypeFinderTest {
 
   @Test void testFunctionExpression1() {
     ParameterExpression param = Expressions.parameter(String.class, "input");
-    FunctionExpression expr = Expressions.lambda(Function1.class,
-        Expressions.block(
-            Expressions.return_(null, param)),
-        param);
+    FunctionExpression expr =
+        Expressions.lambda(Function1.class,
+            Expressions.block(Expressions.return_(null, param)),
+            param);
     assertJavaCodeContains("new org.apache.calcite.linq4j.function.Function1() {\n"
         + "  public String apply(String input) {\n"
         + "    return input;\n"
@@ -76,9 +76,10 @@ class TypeFinderTest {
   }
 
   @Test void testFunctionExpression2() {
-    FunctionExpression expr = Expressions.lambda(Function1.class,
-        Expressions.block(
-            Expressions.return_(null, Expressions.constant(1L, Long.class))),
+    FunctionExpression expr =
+        Expressions.lambda(Function1.class,
+            Expressions.block(
+                Expressions.return_(null, Expressions.constant(1L, Long.class))),
         Expressions.parameter(String.class, "input"));
     assertJavaCodeContains("new org.apache.calcite.linq4j.function.Function1() {\n"
         + "  public Long apply(String input) {\n"
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 6e7a3d2883c..cf9f1d70587 100644
--- a/core/src/test/java/org/apache/calcite/jdbc/CalciteRemoteDriverTest.java
+++ b/core/src/test/java/org/apache/calcite/jdbc/CalciteRemoteDriverTest.java
@@ -88,8 +88,12 @@
 
 /**
  * Test for Calcite's remote JDBC driver.
- * Technically speaking, the test is thread safe, however Caclite/Avatica have thread-safety issues
- * see https://issues.apache.org/jira/browse/CALCITE-2853.
+ *
+ * <p>Technically, the test is thread-safe, however Calcite/Avatica have
+ * thread-safety issues; see
+ * <a href="https://issues.apache.org/jira/browse/CALCITE-2853">
+ * [CALCITE-2853] avatica.MetaImpl and calcite.jdbc.CalciteMetaImpl are not
+ * thread-safe</a>.
  */
 @Execution(ExecutionMode.SAME_THREAD)
 class CalciteRemoteDriverTest {
@@ -151,8 +155,8 @@ class CalciteRemoteDriverTest {
     localConnection = CalciteAssert.hr().connect();
 
     // Make sure we pick an ephemeral port for the server
-    start = Main.start(new String[]{Factory.class.getName()}, 0,
-        AvaticaJsonHandler::new);
+    final String[] args = {Factory.class.getName()};
+    start = Main.start(args, 0, AvaticaJsonHandler::new);
   }
 
   protected static Connection getRemoteConnection() throws SQLException {
@@ -173,8 +177,8 @@ protected static Connection getRemoteConnection() throws SQLException {
   }
 
   @Test void testCatalogsLocal() throws Exception {
-    final Connection connection = DriverManager.getConnection(
-        "jdbc:avatica:remote:factory=" + LJS);
+    final Connection connection =
+        DriverManager.getConnection("jdbc:avatica:remote:factory=" + LJS);
     assertThat(connection.isClosed(), is(false));
     final ResultSet resultSet = connection.getMetaData().getCatalogs();
     final ResultSetMetaData metaData = resultSet.getMetaData();
@@ -188,8 +192,8 @@ protected static Connection getRemoteConnection() throws SQLException {
   }
 
   @Test void testSchemasLocal() throws Exception {
-    final Connection connection = DriverManager.getConnection(
-        "jdbc:avatica:remote:factory=" + LJS);
+    final Connection connection =
+        DriverManager.getConnection("jdbc:avatica:remote:factory=" + LJS);
     assertThat(connection.isClosed(), is(false));
     final ResultSet resultSet = connection.getMetaData().getSchemas();
     final ResultSetMetaData metaData = resultSet.getMetaData();
@@ -508,8 +512,8 @@ private String pad(String x) {
     try (Connection remoteConnection = getRemoteConnection()) {
       Statement statement = remoteConnection.createStatement();
       statement.setMaxRows(2);
-      ResultSet resultSet = statement.executeQuery(
-          "select * from \"hr\".\"emps\"");
+      ResultSet resultSet =
+          statement.executeQuery("select * from \"hr\".\"emps\"");
       int count = 0;
       while (resultSet.next()) {
         ++count;
@@ -577,8 +581,9 @@ public static Connection makeConnection() throws Exception {
   }
 
   @Test void testRemoteStatementFetch() throws Exception {
-    final Connection connection = DriverManager.getConnection(
-        "jdbc:avatica:remote:factory=" + LocalServiceMoreFactory.class.getName());
+    final Connection connection =
+        DriverManager.getConnection("jdbc:avatica:remote:factory="
+            + LocalServiceMoreFactory.class.getName());
     String sql = "select * from \"foo\".\"bar\"";
     Statement statement = connection.createStatement();
     boolean status = statement.execute(sql);
@@ -592,8 +597,9 @@ public static Connection makeConnection() throws Exception {
   }
 
   @Test void testRemotePreparedStatementFetch() throws Exception {
-    final Connection connection = DriverManager.getConnection(
-        "jdbc:avatica:remote:factory=" + LocalServiceMoreFactory.class.getName());
+    final Connection connection =
+        DriverManager.getConnection("jdbc:avatica:remote:factory="
+            + LocalServiceMoreFactory.class.getName());
     assertThat(connection.isClosed(), is(false));
 
     String sql = "select * from \"foo\".\"bar\"";
@@ -814,8 +820,8 @@ public static class LocalServiceModifiableFactory implements Service.Factory {
 
   /** Test remote Statement insert. */
   @Test void testInsert() throws Exception {
-    final Connection connection = DriverManager.getConnection(
-        "jdbc:avatica:remote:factory="
+    final Connection connection =
+        DriverManager.getConnection("jdbc:avatica:remote:factory="
             + LocalServiceModifiableFactory.class.getName());
     assertThat(connection.isClosed(), is(false));
     Statement statement = connection.createStatement();
@@ -833,8 +839,8 @@ public static class LocalServiceModifiableFactory implements Service.Factory {
 
   /** Test remote Statement batched insert. */
   @Test void testInsertBatch() throws Exception {
-    final Connection connection = DriverManager.getConnection(
-        "jdbc:avatica:remote:factory="
+    final Connection connection =
+        DriverManager.getConnection("jdbc:avatica:remote:factory="
             + LocalServiceModifiableFactory.class.getName());
     assertThat(connection.getMetaData().supportsBatchUpdates(), is(true));
     assertThat(connection.isClosed(), is(false));
@@ -865,8 +871,8 @@ public static class LocalServiceModifiableFactory implements Service.Factory {
    * Remote PreparedStatement insert WITHOUT bind variables.
    */
   @Test void testRemotePreparedStatementInsert() throws Exception {
-    final Connection connection = DriverManager.getConnection(
-        "jdbc:avatica:remote:factory="
+    final Connection connection =
+        DriverManager.getConnection("jdbc:avatica:remote:factory="
             + LocalServiceModifiableFactory.class.getName());
     assertThat(connection.isClosed(), is(false));
 
@@ -886,12 +892,13 @@ public static class LocalServiceModifiableFactory implements Service.Factory {
    * <a href="https://issues.apache.org/jira/browse/CALCITE-3338">[CALCITE-3338]
    * Error with executeBatch and preparedStatement when using RemoteMeta</a>. */
   @Test void testInsertBatchWithPreparedStatement() throws Exception {
-    final Connection connection = DriverManager.getConnection(
-        "jdbc:avatica:remote:factory="
+    final Connection connection =
+        DriverManager.getConnection("jdbc:avatica:remote:factory="
             + LocalServiceModifiableFactory.class.getName());
 
-    PreparedStatement pst = connection.prepareStatement(
-        "insert into \"foo\".\"bar\" values (?, ?, ?, ?, ?)");
+    PreparedStatement pst =
+        connection.prepareStatement("insert into \"foo\".\"bar\"\n"
+            + "values (?, ?, ?, ?, ?)");
     pst.setInt(1, 1);
     pst.setInt(2, 1);
     pst.setString(3, "second");
diff --git a/core/src/test/java/org/apache/calcite/jdbc/JavaTypeFactoryTest.java b/core/src/test/java/org/apache/calcite/jdbc/JavaTypeFactoryTest.java
index ccda983fd19..10511ea267d 100644
--- a/core/src/test/java/org/apache/calcite/jdbc/JavaTypeFactoryTest.java
+++ b/core/src/test/java/org/apache/calcite/jdbc/JavaTypeFactoryTest.java
@@ -49,9 +49,10 @@ public final class JavaTypeFactoryTest {
    * <a href="https://issues.apache.org/jira/browse/CALCITE-2677">[CALCITE-2677]
    * Struct types with one field are not mapped correctly to Java Classes</a>. */
   @Test void testGetJavaClassWithOneFieldStructDataTypeV2() {
-    RelDataType structWithOneField = TYPE_FACTORY.createStructType(
-        ImmutableList.of(TYPE_FACTORY.createSqlType(SqlTypeName.INTEGER)),
-        ImmutableList.of("intField"));
+    RelDataType structWithOneField =
+        TYPE_FACTORY.createStructType(
+            ImmutableList.of(TYPE_FACTORY.createSqlType(SqlTypeName.INTEGER)),
+            ImmutableList.of("intField"));
     assertRecordType(TYPE_FACTORY.getJavaClass(structWithOneField));
   }
 
@@ -67,10 +68,10 @@ public final class JavaTypeFactoryTest {
    * <a href="https://issues.apache.org/jira/browse/CALCITE-2677">[CALCITE-2677]
    * Struct types with one field are not mapped correctly to Java Classes</a>. */
   @Test void testGetJavaClassWithTwoFieldsStructDataTypeV2() {
-    RelDataType structWithTwoFields = TYPE_FACTORY.createStructType(
-        ImmutableList.of(
-            TYPE_FACTORY.createSqlType(SqlTypeName.INTEGER),
-            TYPE_FACTORY.createSqlType(SqlTypeName.VARCHAR)),
+    RelDataType structWithTwoFields =
+        TYPE_FACTORY.createStructType(
+            ImmutableList.of(TYPE_FACTORY.createSqlType(SqlTypeName.INTEGER),
+                TYPE_FACTORY.createSqlType(SqlTypeName.VARCHAR)),
         ImmutableList.of("intField", "strField"));
     assertRecordType(TYPE_FACTORY.getJavaClass(structWithTwoFields));
   }
@@ -80,10 +81,10 @@ public final class JavaTypeFactoryTest {
    * Java-oriented field type is wrongly forced to be NOT NULL after being converted to
    * SQL-oriented</a>. */
   @Test void testFieldNullabilityAfterConvertingToSqlStructType() {
-    RelDataType javaStructType = TYPE_FACTORY.createStructType(
-        ImmutableList.of(
-            TYPE_FACTORY.createJavaType(Integer.class),
-            TYPE_FACTORY.createJavaType(int.class)),
+    RelDataType javaStructType =
+        TYPE_FACTORY.createStructType(
+            ImmutableList.of(TYPE_FACTORY.createJavaType(Integer.class),
+                TYPE_FACTORY.createJavaType(int.class)),
         ImmutableList.of("a", "b"));
     RelDataType sqlStructType = TYPE_FACTORY.toSql(javaStructType);
     assertEquals("RecordType(INTEGER a, INTEGER NOT NULL b) NOT NULL",
diff --git a/core/src/test/java/org/apache/calcite/materialize/LatticeSuggesterTest.java b/core/src/test/java/org/apache/calcite/materialize/LatticeSuggesterTest.java
index 5ff1e95ac3e..5d184330de6 100644
--- a/core/src/test/java/org/apache/calcite/materialize/LatticeSuggesterTest.java
+++ b/core/src/test/java/org/apache/calcite/materialize/LatticeSuggesterTest.java
@@ -26,6 +26,7 @@
 import org.apache.calcite.sql.fun.SqlLibraryOperatorTableFactory;
 import org.apache.calcite.sql.parser.SqlParseException;
 import org.apache.calcite.sql.parser.SqlParser;
+import org.apache.calcite.sql2rel.SqlToRelConverter;
 import org.apache.calcite.statistic.MapSqlStatisticProvider;
 import org.apache.calcite.statistic.QuerySqlStatisticProvider;
 import org.apache.calcite.test.CalciteAssert;
@@ -282,7 +283,9 @@ protected boolean matchesSafely(List<Lattice> lattices) {
   }
 
   private void checkFoodMartAll(boolean evolve) throws Exception {
-    final Tester t = new Tester().foodmart().withEvolve(evolve);
+    final Tester t = new Tester().sqlToRelConverter(config -> config.withExpand(true))
+        .foodmart()
+        .withEvolve(evolve);
     final FoodMartQuerySet set = FoodMartQuerySet.instance();
     for (FoodMartQuerySet.FoodmartQuery query : set.queries.values()) {
       if (query.sql.contains("\"agg_10_foo_fact\"")
@@ -815,6 +818,12 @@ Tester withConfig(FrameworkConfig config) {
       return new Tester(config);
     }
 
+    Tester sqlToRelConverter(UnaryOperator<SqlToRelConverter.Config> sqlToRelConverterConfig) {
+      return withConfig(
+          builder().sqlToRelConverterConfig(sqlToRelConverterConfig
+              .apply(config.getSqlToRelConverterConfig())).build());
+    }
+
     Tester foodmart() {
       return schema(CalciteAssert.SchemaSpec.JDBC_FOODMART);
     }
diff --git a/core/src/test/java/org/apache/calcite/materialize/NormalizationTrimFieldTest.java b/core/src/test/java/org/apache/calcite/materialize/NormalizationTrimFieldTest.java
index 9d4cc7722cc..9f8fb3db5a1 100644
--- a/core/src/test/java/org/apache/calcite/materialize/NormalizationTrimFieldTest.java
+++ b/core/src/test/java/org/apache/calcite/materialize/NormalizationTrimFieldTest.java
@@ -83,13 +83,15 @@ public static Frameworks.ConfigBuilder config() {
         .build();
     final ImmutableBitSet groupSet = ImmutableBitSet.of(4);
     final AggregateCall count = aggregate.getAggCallList().get(0);
-    final AggregateCall call = AggregateCall.create(count.getAggregation(),
-        count.isDistinct(), count.isApproximate(),
-        count.ignoreNulls(), ImmutableList.of(3),
-        count.filterArg, null, count.collation,
-        count.getType(), count.getName());
-    final RelNode query = LogicalAggregate.create(project, aggregate.getHints(),
-        groupSet, ImmutableList.of(groupSet), ImmutableList.of(call));
+    final AggregateCall call =
+        AggregateCall.create(count.getAggregation(),
+            count.isDistinct(), count.isApproximate(),
+            count.ignoreNulls(), ImmutableList.of(3),
+            count.filterArg, null, count.collation,
+            count.getType(), count.getName());
+    final RelNode query =
+        LogicalAggregate.create(project, aggregate.getHints(),
+            groupSet, ImmutableList.of(groupSet), ImmutableList.of(call));
     final RelNode target = aggregate;
     final RelNode replacement = relBuilder.scan("mv0").build();
     final RelOptMaterialization relOptMaterialization =
diff --git a/core/src/test/java/org/apache/calcite/plan/RelOptPlanReaderTest.java b/core/src/test/java/org/apache/calcite/plan/RelOptPlanReaderTest.java
index b1ff290ad3a..c274e3d1778 100644
--- a/core/src/test/java/org/apache/calcite/plan/RelOptPlanReaderTest.java
+++ b/core/src/test/java/org/apache/calcite/plan/RelOptPlanReaderTest.java
@@ -34,7 +34,7 @@
  */
 class RelOptPlanReaderTest {
   @Test void testTypeToClass() {
-    RelJson relJson = new RelJson(null);
+    RelJson relJson = RelJson.create();
 
     // in org.apache.calcite.rel package
     assertThat(relJson.classToTypeName(LogicalProject.class),
diff --git a/core/src/test/java/org/apache/calcite/plan/RelOptUtilTest.java b/core/src/test/java/org/apache/calcite/plan/RelOptUtilTest.java
index 2f22e78ee72..54611b0ad3c 100644
--- a/core/src/test/java/org/apache/calcite/plan/RelOptUtilTest.java
+++ b/core/src/test/java/org/apache/calcite/plan/RelOptUtilTest.java
@@ -49,6 +49,7 @@
 import org.apache.calcite.util.Util;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
 import com.google.common.collect.Lists;
 
@@ -274,9 +275,10 @@ private static Frameworks.ConfigBuilder config() {
     int leftJoinIndex = empScan.getRowType().getFieldNames().indexOf("DEPTNO");
     int rightJoinIndex = deptRow.getFieldNames().indexOf("DEPTNO");
 
-    RexNode joinCond = relBuilder.equals(
-        RexInputRef.of(leftJoinIndex, empDeptJoinRelFields),
-        RexInputRef.of(empRow.getFieldCount() + rightJoinIndex, empDeptJoinRelFields));
+    RexNode joinCond =
+        relBuilder.equals(RexInputRef.of(leftJoinIndex, empDeptJoinRelFields),
+            RexInputRef.of(empRow.getFieldCount() + rightJoinIndex,
+                empDeptJoinRelFields));
 
     splitJoinConditionHelper(
         joinCond,
@@ -288,21 +290,17 @@ private static Frameworks.ConfigBuilder config() {
 
   @Test void testSplitJoinConditionWithoutEqualCondition() {
     final List<RelDataTypeField> sysFieldList = Collections.emptyList();
-    final List<List<RexNode>> joinKeys = Arrays.asList(new ArrayList<>(), new ArrayList<>());
-    final RexNode joinCondition = relBuilder.equals(
-        RexInputRef.of(0, empDeptJoinRelFields),
-        relBuilder.literal(1));
-    final RexNode result = RelOptUtil.splitJoinCondition(
-        sysFieldList,
-        Arrays.asList(empScan, deptScan),
-        joinCondition,
-        joinKeys,
-        null,
-        null
-    );
-    final List<List<RexNode>> expectedJoinKeys = Arrays.asList(
-        Collections.emptyList(),
-        Collections.emptyList());
+    final List<List<RexNode>> joinKeys =
+        Arrays.asList(new ArrayList<>(), new ArrayList<>());
+    final RexNode joinCondition =
+        relBuilder.equals(RexInputRef.of(0, empDeptJoinRelFields),
+            relBuilder.literal(1));
+    final RexNode result =
+        RelOptUtil.splitJoinCondition(sysFieldList,
+            Arrays.asList(empScan, deptScan), joinCondition, joinKeys, null,
+            null);
+    final List<List<RexNode>> expectedJoinKeys =
+        Arrays.asList(Collections.emptyList(), Collections.emptyList());
     assertEquals(joinKeys, expectedJoinKeys);
     assertEquals(result, joinCondition);
   }
@@ -315,9 +313,11 @@ private static Frameworks.ConfigBuilder config() {
     int leftJoinIndex = empScan.getRowType().getFieldNames().indexOf("DEPTNO");
     int rightJoinIndex = deptRow.getFieldNames().indexOf("DEPTNO");
 
-    RexNode joinCond = relBuilder.isNotDistinctFrom(
-        RexInputRef.of(leftJoinIndex, empDeptJoinRelFields),
-        RexInputRef.of(empRow.getFieldCount() + rightJoinIndex, empDeptJoinRelFields));
+    RexNode joinCond =
+        relBuilder.isNotDistinctFrom(
+            RexInputRef.of(leftJoinIndex, empDeptJoinRelFields),
+            RexInputRef.of(empRow.getFieldCount() + rightJoinIndex,
+                empDeptJoinRelFields));
 
     splitJoinConditionHelper(
         joinCond,
@@ -338,11 +338,11 @@ private static Frameworks.ConfigBuilder config() {
     RexInputRef leftKeyInputRef = RexInputRef.of(leftJoinIndex, empDeptJoinRelFields);
     RexInputRef rightKeyInputRef =
         RexInputRef.of(empRow.getFieldCount() + rightJoinIndex, empDeptJoinRelFields);
-    RexNode joinCond = relBuilder.or(
-        relBuilder.equals(leftKeyInputRef, rightKeyInputRef),
-        relBuilder.call(SqlStdOperatorTable.AND,
-            relBuilder.isNull(leftKeyInputRef),
-            relBuilder.isNull(rightKeyInputRef)));
+    RexNode joinCond =
+        relBuilder.or(relBuilder.equals(leftKeyInputRef, rightKeyInputRef),
+            relBuilder.call(SqlStdOperatorTable.AND,
+                relBuilder.isNull(leftKeyInputRef),
+                relBuilder.isNull(rightKeyInputRef)));
 
     splitJoinConditionHelper(
         joinCond,
@@ -364,15 +364,11 @@ private static Frameworks.ConfigBuilder config() {
     RexInputRef leftKeyInputRef = RexInputRef.of(leftJoinIndex, empDeptJoinRelFields);
     RexInputRef rightKeyInputRef =
         RexInputRef.of(empRow.getFieldCount() + rightJoinIndex, empDeptJoinRelFields);
-    RexNode joinCond = RelOptUtil.isDistinctFrom(
-        relBuilder.getRexBuilder(),
-        leftKeyInputRef,
-        rightKeyInputRef,
-        true);
-
+    RexNode joinCond =
+        RelOptUtil.isDistinctFrom(relBuilder.getRexBuilder(),
+            leftKeyInputRef, rightKeyInputRef, true);
 
-    splitJoinConditionHelper(
-        joinCond,
+    splitJoinConditionHelper(joinCond,
         Collections.singletonList(leftJoinIndex),
         Collections.singletonList(rightJoinIndex),
         Collections.singletonList(false),
@@ -391,12 +387,13 @@ private static Frameworks.ConfigBuilder config() {
     RexInputRef leftKeyInputRef = RexInputRef.of(leftJoinIndex, empDeptJoinRelFields);
     RexInputRef rightKeyInputRef =
         RexInputRef.of(empRow.getFieldCount() + rightJoinIndex, empDeptJoinRelFields);
-    RexNode joinCond = relBuilder.call(SqlStdOperatorTable.CASE,
-        relBuilder.isNull(leftKeyInputRef),
-        relBuilder.isNull(rightKeyInputRef),
-        relBuilder.isNull(rightKeyInputRef),
-        relBuilder.isNull(leftKeyInputRef),
-        relBuilder.equals(leftKeyInputRef, rightKeyInputRef));
+    RexNode joinCond =
+        relBuilder.call(SqlStdOperatorTable.CASE,
+            relBuilder.isNull(leftKeyInputRef),
+            relBuilder.isNull(rightKeyInputRef),
+            relBuilder.isNull(rightKeyInputRef),
+            relBuilder.isNull(leftKeyInputRef),
+            relBuilder.equals(leftKeyInputRef, rightKeyInputRef));
 
     splitJoinConditionHelper(
         joinCond,
@@ -412,8 +409,9 @@ private void splitJoinConditionHelper(RexNode joinCond, List<Integer> expLeftKey
     List<Integer> actRightKeys = new ArrayList<>();
     List<Boolean> actFilterNulls = new ArrayList<>();
 
-    RexNode actRemaining = RelOptUtil.splitJoinCondition(empScan, deptScan, joinCond, actLeftKeys,
-        actRightKeys, actFilterNulls);
+    RexNode actRemaining =
+        RelOptUtil.splitJoinCondition(empScan, deptScan, joinCond, actLeftKeys,
+            actRightKeys, actFilterNulls);
 
     assertEquals(expRemaining, actRemaining);
     assertEquals(expFilterNulls, actFilterNulls);
@@ -432,11 +430,11 @@ private void splitJoinConditionHelper(RexNode joinCond, List<Integer> expLeftKey
     RexInputRef leftKeyInputRef = RexInputRef.of(leftJoinIndex, empDeptJoinRelFields);
     RexInputRef rightKeyInputRef =
         RexInputRef.of(empRow.getFieldCount() + rightJoinIndex, empDeptJoinRelFields);
-    RexNode joinCond = relBuilder.equals(
-        relBuilder.call(SqlStdOperatorTable.PLUS, leftKeyInputRef,
-            relBuilder.literal(1)),
-        rightKeyInputRef);
-
+    RexNode joinCond =
+        relBuilder.equals(
+            relBuilder.call(SqlStdOperatorTable.PLUS, leftKeyInputRef,
+                relBuilder.literal(1)),
+            rightKeyInputRef);
 
     // Build the join operator and push down join conditions
     relBuilder.push(empScan);
@@ -478,10 +476,11 @@ private void splitJoinConditionHelper(RexNode joinCond, List<Integer> expLeftKey
     RexInputRef leftKeyInputRef = RexInputRef.of(leftJoinIndex, empDeptJoinRelFields);
     RexInputRef rightKeyInputRef =
         RexInputRef.of(empRow.getFieldCount() + rightJoinIndex, empDeptJoinRelFields);
-    RexNode joinCond = relBuilder.call(SqlStdOperatorTable.IS_NOT_DISTINCT_FROM,
-        relBuilder.call(SqlStdOperatorTable.PLUS, leftKeyInputRef, relBuilder.literal(1)),
-        rightKeyInputRef);
-
+    RexNode joinCond =
+        relBuilder.call(SqlStdOperatorTable.IS_NOT_DISTINCT_FROM,
+            relBuilder.call(SqlStdOperatorTable.PLUS, leftKeyInputRef,
+                relBuilder.literal(1)),
+            rightKeyInputRef);
 
     // Build the join operator and push down join conditions
     relBuilder.push(empScan);
@@ -523,10 +522,12 @@ private void splitJoinConditionHelper(RexNode joinCond, List<Integer> expLeftKey
     RexInputRef leftKeyInputRef = RexInputRef.of(leftJoinIndex, empDeptJoinRelFields);
     RexInputRef rightKeyInputRef =
         RexInputRef.of(empRow.getFieldCount() + rightJoinIndex, empDeptJoinRelFields);
-    RexNode joinCond = relBuilder.or(
-        relBuilder.equals(
-            relBuilder.call(SqlStdOperatorTable.PLUS, leftKeyInputRef, relBuilder.literal(1)),
-            rightKeyInputRef),
+    RexNode joinCond =
+        relBuilder.or(
+            relBuilder.equals(
+                relBuilder.call(SqlStdOperatorTable.PLUS, leftKeyInputRef,
+                    relBuilder.literal(1)),
+                rightKeyInputRef),
         relBuilder.call(SqlStdOperatorTable.AND,
             relBuilder.isNull(
                 relBuilder.call(SqlStdOperatorTable.PLUS, leftKeyInputRef,
@@ -574,20 +575,20 @@ private void splitJoinConditionHelper(RexNode joinCond, List<Integer> expLeftKey
     RexInputRef leftKeyInputRef = RexInputRef.of(leftJoinIndex, empDeptJoinRelFields);
     RexInputRef rightKeyInputRef =
         RexInputRef.of(empRow.getFieldCount() + rightJoinIndex, empDeptJoinRelFields);
-    RexNode joinCond = relBuilder.call(SqlStdOperatorTable.CASE,
-        relBuilder.isNull(
-            relBuilder.call(SqlStdOperatorTable.PLUS, leftKeyInputRef,
-                relBuilder.literal(1))),
-        relBuilder.isNull(rightKeyInputRef),
-        relBuilder.isNull(rightKeyInputRef),
-        relBuilder.isNull(
-            relBuilder.call(SqlStdOperatorTable.PLUS, leftKeyInputRef,
-                relBuilder.literal(1))),
-        relBuilder.equals(
-            relBuilder.call(SqlStdOperatorTable.PLUS, leftKeyInputRef,
-                relBuilder.literal(1)),
-            rightKeyInputRef));
-
+    RexNode joinCond =
+        relBuilder.call(SqlStdOperatorTable.CASE,
+            relBuilder.isNull(
+                relBuilder.call(SqlStdOperatorTable.PLUS, leftKeyInputRef,
+                    relBuilder.literal(1))),
+            relBuilder.isNull(rightKeyInputRef),
+            relBuilder.isNull(rightKeyInputRef),
+            relBuilder.isNull(
+                relBuilder.call(SqlStdOperatorTable.PLUS, leftKeyInputRef,
+                    relBuilder.literal(1))),
+            relBuilder.equals(
+                relBuilder.call(SqlStdOperatorTable.PLUS, leftKeyInputRef,
+                    relBuilder.literal(1)),
+                rightKeyInputRef));
 
     // Build the join operator and push down join conditions
     relBuilder.push(empScan);
@@ -663,12 +664,12 @@ private void splitJoinConditionHelper(RexNode joinCond, List<Integer> expLeftKey
             rexBuilder.makeCast(
                 fieldTypeEmpnoNullable,
                 RexInputRef.of(0, agg.getRowType()),
-                true),
+                true, false),
             RexInputRef.of(1, agg.getRowType()),
             rexBuilder.makeCast(
                 fieldTypeJobCntNullable,
                 RexInputRef.of(2, agg.getRowType()),
-                true))
+                true, false))
         .build();
     assertThat(castNode.explain(), is(expectNode.explain()));
 
@@ -693,7 +694,8 @@ private void splitJoinConditionHelper(RexNode joinCond, List<Integer> expLeftKey
             ImmutableList.of(
                 fieldEmpno.getName(),
                 fieldEname.getName(),
-                "JOB_CNT"));
+                "JOB_CNT"),
+            ImmutableSet.of());
     assertThat(castNode1.explain(), is(expectNode1.explain()));
     // Change the field JOB_CNT field name again.
     // The projection expect to be merged.
@@ -716,7 +718,8 @@ private void splitJoinConditionHelper(RexNode joinCond, List<Integer> expLeftKey
             ImmutableList.of(
                 fieldEmpno.getName(),
                 fieldEname.getName(),
-                "JOB_CNT2"));
+                "JOB_CNT2"),
+            ImmutableSet.of());
     assertThat(castNode2.explain(), is(expectNode2.explain()));
   }
 
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 f2277fdc414..6c5275ec3fa 100644
--- a/core/src/test/java/org/apache/calcite/plan/RelWriterTest.java
+++ b/core/src/test/java/org/apache/calcite/plan/RelWriterTest.java
@@ -54,6 +54,7 @@
 import org.apache.calcite.sql.SqlExplainFormat;
 import org.apache.calcite.sql.SqlExplainLevel;
 import org.apache.calcite.sql.SqlIntervalQualifier;
+import org.apache.calcite.sql.fun.SqlLibraryOperators;
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
 import org.apache.calcite.sql.fun.SqlTrimFunction;
 import org.apache.calcite.sql.parser.SqlParserPos;
@@ -68,6 +69,7 @@
 import org.apache.calcite.util.ImmutableBitSet;
 import org.apache.calcite.util.JsonBuilder;
 import org.apache.calcite.util.TestUtil;
+import org.apache.calcite.util.TimestampString;
 
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.core.type.TypeReference;
@@ -461,7 +463,7 @@ private static Fixture relFn(Function<RelBuilder, RelNode> relFn) {
           .nullableRecord(false)
           .build();
       final JsonBuilder jsonBuilder = new JsonBuilder();
-      final RelJson json = new RelJson(jsonBuilder);
+      final RelJson json = RelJson.create().withJsonBuilder(jsonBuilder);
       final Object o = json.toJson(type);
       assertThat(o, notNullValue());
       final String s = jsonBuilder.toJsonString(o);
@@ -592,7 +594,8 @@ private static Fixture relFn(Function<RelBuilder, RelNode> relFn) {
                           RexWindowBounds.following(
                               rexBuilder.makeExactLiteral(BigDecimal.ONE)),
                           false, true, false, false, false)),
-                  ImmutableList.of("field0", "field1", "field2"));
+                  ImmutableList.of("field0", "field1", "field2"),
+                  ImmutableSet.of());
           final RelJsonWriter writer = new RelJsonWriter();
           project.explain(writer);
           return writer.asString();
@@ -766,7 +769,7 @@ private void assertThatReadExpressionResult(String json, Matcher<String> matcher
     final ObjectMapper mapper = new ObjectMapper();
     final TypeReference<LinkedHashMap<String, Object>> typeRef =
         new TypeReference<LinkedHashMap<String, Object>>() {
-    };
+        };
     final Map<String, Object> o;
     try {
       o = mapper
@@ -775,8 +778,9 @@ private void assertThatReadExpressionResult(String json, Matcher<String> matcher
     } catch (JsonProcessingException e) {
       throw TestUtil.rethrow(e);
     }
-    RexNode e =
-        RelJson.readExpression(cluster, RelWriterTest::translateInput, o);
+    final RelJson relJson = RelJson.create()
+        .withInputTranslator(RelWriterTest::translateInput);
+    final RexNode e = relJson.toRex(cluster, o);
     assertThat(e.toString(), is(matcher));
   }
 
@@ -866,6 +870,30 @@ void testAggregateWithAlias(SqlExplainFormat format) {
     assertThat(s, isLinux(expected));
   }
 
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-4804">[CALCITE-4804]
+   * Support Snapshot operator serialization and deserizalization</a>. */
+  @Test void testSnapshot() {
+    // Equivalent SQL:
+    //   SELECT *
+    //   FROM products_temporal FOR SYSTEM_TIME AS OF TIMESTAMP '2011-07-20 12:34:56'
+    final RelBuilder builder = RelBuilder.create(RelBuilderTest.config().build());
+    RelNode root =
+        builder.scan("products_temporal")
+            .snapshot(
+                builder.getRexBuilder().makeTimestampLiteral(
+                    new TimestampString("2011-07-20 12:34:56"), 0))
+            .build();
+
+    RelJsonWriter jsonWriter = new RelJsonWriter();
+    root.explain(jsonWriter);
+    String relJson = jsonWriter.asString();
+    String s = deserializeAndDumpToTextFormat(getSchema(root), relJson);
+    String expected = "LogicalSnapshot(period=[2011-07-20 12:34:56])\n"
+        + "  LogicalTableScan(table=[[scott, products_temporal]])\n";
+    assertThat(s, isLinux(expected));
+  }
+
   @Test void testDeserializeInvalidOperatorName() {
     final FrameworkConfig config = RelBuilderTest.config().build();
     final RelBuilder builder = RelBuilder.create(config);
@@ -892,6 +920,31 @@ void testAggregateWithAlias(SqlExplainFormat format) {
             + "No operator for 'MAXS' with kind: 'MAX', syntax: 'FUNCTION' during JSON deserialization");
   }
 
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5349">[CALCITE-5349]
+   * RelJson deserialization should support SqlLibraryOperators</a>. Before the
+   * fix, non-standard operators such as BigQuery's
+   * {@link SqlLibraryOperators#CURRENT_DATETIME} would throw during
+   * deserialization. */
+  @Test void testDeserializeNonStandardOperator() {
+    final FrameworkConfig config = RelBuilderTest.config().build();
+    final RelBuilder builder = RelBuilder.create(config);
+    final RelNode rel = builder
+        .scan("EMP")
+        .project(builder.field("JOB"),
+            builder.call(SqlLibraryOperators.CURRENT_DATETIME))
+        .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=[CURRENT_DATETIME()])\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);
@@ -998,6 +1051,21 @@ void testCorrelateQuery(SqlExplainFormat format) {
         .assertThatPlan(isLinux(expected));
   }
 
+  @Test void testProjectionWithCorrelationVariables() {
+    final Function<RelBuilder, RelNode> relFn = b -> b.scan("EMP")
+        .project(
+            ImmutableList.of(b.field("ENAME")),
+            ImmutableList.of("ename"),
+            true,
+            ImmutableSet.of(b.getCluster().createCorrel()))
+        .build();
+
+    final String expected = "LogicalProject(variablesSet=[[$cor0]], ename=[$1])\n"
+        + "  LogicalTableScan(table=[[scott, EMP]])\n";
+    relFn(relFn)
+        .assertThatPlan(isLinux(expected));
+  }
+
   @Test void testOverWithoutOrderKey() {
     // Equivalent SQL:
     //   SELECT count(*) OVER (PARTITION BY deptno) FROM emp
@@ -1126,7 +1194,8 @@ private static String deserializeAndDump(RelOptSchema schema, String relJson,
       SqlExplainFormat format) {
     return Frameworks.withPlanner((cluster, relOptSchema, rootSchema) -> {
       final RelJsonReader reader =
-          new RelJsonReader(cluster, schema, rootSchema);
+          new RelJsonReader(cluster, schema, rootSchema,
+              RelJson::withLibraryOperatorTable);
       RelNode node;
       try {
         node = reader.read(relJson);
@@ -1420,8 +1489,9 @@ Fixture assertThatJson(Matcher<String> matcher) {
       final FrameworkConfig config = RelBuilderTest.config().build();
       final RelBuilder b = RelBuilder.create(config);
       RelNode rel = relFn.apply(b);
-      final String relJson = RelOptUtil.dumpPlan("", rel,
-          SqlExplainFormat.JSON, SqlExplainLevel.EXPPLAN_ATTRIBUTES);
+      final String relJson =
+          RelOptUtil.dumpPlan("", rel, SqlExplainFormat.JSON,
+              SqlExplainLevel.EXPPLAN_ATTRIBUTES);
       assertThat(relJson, matcher);
       return this;
     }
@@ -1430,8 +1500,9 @@ Fixture assertThatPlan(Matcher<String> matcher) {
       final FrameworkConfig config = RelBuilderTest.config().build();
       final RelBuilder b = RelBuilder.create(config);
       RelNode rel = relFn.apply(b);
-      final String relJson = RelOptUtil.dumpPlan("", rel,
-          SqlExplainFormat.JSON, SqlExplainLevel.EXPPLAN_ATTRIBUTES);
+      final String relJson =
+          RelOptUtil.dumpPlan("", rel, SqlExplainFormat.JSON,
+              SqlExplainLevel.EXPPLAN_ATTRIBUTES);
       final String plan;
       if (distribution) {
         VolcanoPlanner planner = new VolcanoPlanner();
diff --git a/core/src/test/java/org/apache/calcite/plan/volcano/ComboRuleTest.java b/core/src/test/java/org/apache/calcite/plan/volcano/ComboRuleTest.java
index 0907924c118..b77b4212df8 100644
--- a/core/src/test/java/org/apache/calcite/plan/volcano/ComboRuleTest.java
+++ b/core/src/test/java/org/apache/calcite/plan/volcano/ComboRuleTest.java
@@ -164,8 +164,9 @@ public static class ComboRule extends RelRule<ComboRule.Config> {
       List<RelNode> newInputs = ImmutableList.of(call.rel(2));
       IntermediateNode oldInter = call.rel(1);
       RelNode physRel = call.rel(0).copy(call.rel(0).getTraitSet(), newInputs);
-      RelNode converted = new IntermediateNode(physRel.getCluster(), physRel,
-          oldInter.nodesBelowCount + 1);
+      RelNode converted =
+          new IntermediateNode(physRel.getCluster(), physRel,
+              oldInter.nodesBelowCount + 1);
       call.transformTo(converted);
     }
 
diff --git a/core/src/test/java/org/apache/calcite/plan/volcano/MultipleTraitConversionTest.java b/core/src/test/java/org/apache/calcite/plan/volcano/MultipleTraitConversionTest.java
index a39e97fb4b5..7d5853014d1 100644
--- a/core/src/test/java/org/apache/calcite/plan/volcano/MultipleTraitConversionTest.java
+++ b/core/src/test/java/org/apache/calcite/plan/volcano/MultipleTraitConversionTest.java
@@ -168,13 +168,11 @@ private static class CustomTraitDef extends RelTraitDef<CustomTrait> {
         RelOptPlanner planner,
         RelNode rel,
         CustomTrait toTrait,
-        boolean allowInfiniteCostConverters
-    ) {
+        boolean allowInfiniteCostConverters) {
       return new CustomTraitEnforcer(
           rel.getCluster(),
           rel.getTraitSet().replace(toTrait),
-          rel
-      );
+          rel);
     }
 
     @Override public boolean canConvert(RelOptPlanner planner, CustomTrait fromTrait,
diff --git a/core/src/test/java/org/apache/calcite/plan/volcano/RelSetTest.java b/core/src/test/java/org/apache/calcite/plan/volcano/RelSetTest.java
new file mode 100644
index 00000000000..62231e5fe83
--- /dev/null
+++ b/core/src/test/java/org/apache/calcite/plan/volcano/RelSetTest.java
@@ -0,0 +1,83 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.plan.volcano;
+
+import org.apache.calcite.plan.RelOptUtil;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.schema.SchemaPlus;
+import org.apache.calcite.sql.parser.SqlParser;
+import org.apache.calcite.test.CalciteAssert;
+import org.apache.calcite.tools.FrameworkConfig;
+import org.apache.calcite.tools.Frameworks;
+import org.apache.calcite.tools.RelBuilder;
+import org.apache.calcite.util.Util;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+/**
+ * Unit test for {@link RelSet}.
+ */
+public class RelSetTest {
+
+  /**
+   * Tests for adding RelNode with same RelDataType.
+   */
+  @Test void testAddRelNodeWithSameRowType() {
+    RelBuilder builder = createRelBuilder();
+    RelNode relNodeA =
+        builder.scan("myTable").project(builder.field("a")).build();
+    RelNode relNodeE =
+        builder.scan("myTable").project(builder.field("e")).build();
+    RelSet relSet =
+        new RelSet(1,
+            Util.minus(RelOptUtil.getVariablesSet(relNodeA),
+                relNodeA.getVariablesSet()),
+            RelOptUtil.getVariablesUsed(relNodeA));
+    relSet.add(relNodeA);
+    relSet.add(relNodeE);
+  }
+
+  /**
+   * Tests for adding RelNode with different RelDataType.
+   */
+  @Test void testAddRelNodeWithDifferentRowType() {
+    RelBuilder builder = createRelBuilder();
+    RelNode relNodeA =
+        builder.scan("myTable").project(builder.field("a")).build();
+    RelNode relNodeN =
+        builder.scan("myTable").project(builder.field("n1")).build();
+    RelSet relSet =
+        new RelSet(1,
+            Util.minus(RelOptUtil.getVariablesSet(relNodeA),
+                relNodeA.getVariablesSet()),
+            RelOptUtil.getVariablesUsed(relNodeA));
+    relSet.add(relNodeA);
+    assertThrows(AssertionError.class, () -> relSet.add(relNodeN));
+  }
+
+  private RelBuilder createRelBuilder() {
+    SchemaPlus rootSchema = Frameworks.createRootSchema(true);
+    SchemaPlus defaultSchema = CalciteAssert.addSchema(rootSchema, CalciteAssert.SchemaSpec.MY_DB);
+    FrameworkConfig config = Frameworks.newConfigBuilder()
+        .parserConfig(SqlParser.Config.DEFAULT)
+        .defaultSchema(defaultSchema)
+        .build();
+    return RelBuilder.create(config);
+  }
+}
diff --git a/core/src/test/java/org/apache/calcite/plan/volcano/TraitPropagationTest.java b/core/src/test/java/org/apache/calcite/plan/volcano/TraitPropagationTest.java
index 825e1434691..3b19d0421fd 100644
--- a/core/src/test/java/org/apache/calcite/plan/volcano/TraitPropagationTest.java
+++ b/core/src/test/java/org/apache/calcite/plan/volcano/TraitPropagationTest.java
@@ -72,6 +72,7 @@
 import org.apache.calcite.util.ImmutableBitSet;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.immutables.value.Value;
@@ -146,33 +147,36 @@ public RelDataType getRowType(RelDataTypeFactory typeFactory) {
         }
       };
 
-      final RelOptAbstractTable t1 = new RelOptAbstractTable(relOptSchema,
-          "t1", table.getRowType(typeFactory)) {
-        @Override public <T> T unwrap(Class<T> clazz) {
-          return clazz.isInstance(table)
-              ? clazz.cast(table)
-              : super.unwrap(clazz);
-        }
-      };
+      final RelOptAbstractTable t1 =
+          new RelOptAbstractTable(relOptSchema, "t1",
+              table.getRowType(typeFactory)) {
+            @Override public <T> T unwrap(Class<T> clazz) {
+              return clazz.isInstance(table)
+                  ? clazz.cast(table)
+                  : super.unwrap(clazz);
+            }
+          };
 
       final RelNode rt1 = LogicalTableScan.create(cluster, t1, ImmutableList.of());
 
       // project s column
-      RelNode project = LogicalProject.create(rt1,
-          ImmutableList.of(),
-          ImmutableList.of(
-              (RexNode) rexBuilder.makeInputRef(stringType, 0),
-              rexBuilder.makeInputRef(integerType, 1)),
-          typeFactory.builder().add("s", stringType).add("i", integerType)
-          .build());
+      RelNode project =
+          LogicalProject.create(rt1, ImmutableList.of(),
+              ImmutableList.of((RexNode) rexBuilder.makeInputRef(stringType, 0),
+                  rexBuilder.makeInputRef(integerType, 1)),
+              typeFactory.builder().add("s", stringType).add("i", integerType)
+                  .build(),
+              ImmutableSet.of());
 
       // aggregate on s, count
-      AggregateCall aggCall = AggregateCall.create(SqlStdOperatorTable.COUNT,
-          false, false, false, Collections.singletonList(1), -1,
-          null, RelCollations.EMPTY, sqlBigInt, "cnt");
-      RelNode agg = new LogicalAggregate(cluster,
-          cluster.traitSetOf(Convention.NONE), ImmutableList.of(), project,
-          ImmutableBitSet.of(0), null, Collections.singletonList(aggCall));
+      AggregateCall aggCall =
+          AggregateCall.create(SqlStdOperatorTable.COUNT,
+              false, false, false, Collections.singletonList(1), -1,
+              null, RelCollations.EMPTY, sqlBigInt, "cnt");
+      RelNode agg =
+          new LogicalAggregate(cluster,
+              cluster.traitSetOf(Convention.NONE), ImmutableList.of(), project,
+              ImmutableBitSet.of(0), null, Collections.singletonList(aggCall));
 
       final RelNode rootRel = agg;
 
@@ -207,10 +211,11 @@ public static class PhysAggRule extends RelRule<PhysAggRule.Config> {
       LogicalAggregate rel = call.rel(0);
       assert rel.getGroupSet().cardinality() == 1;
       int aggIndex = rel.getGroupSet().iterator().next();
-      RelTrait collation = RelCollations.of(
-          new RelFieldCollation(aggIndex,
-              RelFieldCollation.Direction.ASCENDING,
-              RelFieldCollation.NullDirection.FIRST));
+      RelTrait collation =
+          RelCollations.of(
+              new RelFieldCollation(aggIndex,
+                  RelFieldCollation.Direction.ASCENDING,
+                  RelFieldCollation.NullDirection.FIRST));
       RelTraitSet desiredTraits = empty.replace(PHYSICAL).replace(collation);
       RelNode convertedInput = convert(rel.getInput(), desiredTraits);
       call.transformTo(
@@ -300,10 +305,9 @@ private static class PhysSortRule extends ConverterRule {
 
     @Override public RelNode convert(RelNode rel) {
       final Sort sort = (Sort) rel;
-      final RelNode input = convert(sort.getInput(),
-          rel.getCluster().traitSetOf(PHYSICAL));
-      return new PhysSort(
-          rel.getCluster(),
+      final RelNode input =
+          convert(sort.getInput(), rel.getCluster().traitSetOf(PHYSICAL));
+      return new PhysSort(rel.getCluster(),
           input.getTraitSet().plus(sort.getCollation()),
           convert(input, input.getTraitSet().replace(PHYSICAL)),
           sort.getCollation(),
@@ -370,7 +374,7 @@ public Aggregate copy(RelTraitSet traitSet, RelNode input,
   private static class PhysProj extends Project implements Phys {
     PhysProj(RelOptCluster cluster, RelTraitSet traits, RelNode child,
         List<RexNode> exps, RelDataType rowType) {
-      super(cluster, traits, ImmutableList.of(), child, exps, rowType);
+      super(cluster, traits, ImmutableList.of(), child, exps, rowType, ImmutableSet.of());
     }
 
     public static PhysProj create(final RelNode input,
@@ -457,8 +461,8 @@ private static RelNode run(PropAction action, RuleSet rules)
               typeFactory,
               prepareContext.config());
     final RexBuilder rexBuilder = new RexBuilder(typeFactory);
-    final RelOptPlanner planner = new VolcanoPlanner(config.getCostFactory(),
-        config.getContext());
+    final RelOptPlanner planner =
+        new VolcanoPlanner(config.getCostFactory(), config.getContext());
 
     // set up rules before we generate cluster
     planner.clearRelTraitDefs();
diff --git a/core/src/test/java/org/apache/calcite/plan/volcano/VolcanoPlannerTest.java b/core/src/test/java/org/apache/calcite/plan/volcano/VolcanoPlannerTest.java
index 8aa2e1b9184..f0a2176ca98 100644
--- a/core/src/test/java/org/apache/calcite/plan/volcano/VolcanoPlannerTest.java
+++ b/core/src/test/java/org/apache/calcite/plan/volcano/VolcanoPlannerTest.java
@@ -139,6 +139,37 @@ class VolcanoPlannerTest {
     assertTrue(result instanceof PhysSingleRel);
   }
 
+  @Test void testMemoizeInputRelNodes() {
+    VolcanoPlanner planner = new VolcanoPlanner();
+    planner.addRelTraitDef(ConventionTraitDef.INSTANCE);
+    RelOptCluster cluster = newCluster(planner);
+
+    // The rule that triggers the assert rule
+    planner.addRule(PhysLeafRule.INSTANCE);
+    planner.addRule(GoodSingleRule.INSTANCE);
+
+    // Leaf RelNode
+    NoneLeafRel leafRel = new NoneLeafRel(cluster, "a");
+    RelNode leafPhy = planner
+        .changeTraits(leafRel, cluster.traitSetOf(PHYS_CALLING_CONVENTION));
+
+    // RelNode with leaf RelNode as single input
+    NoneSingleRel singleRel = new NoneSingleRel(cluster, leafPhy);
+    RelNode singlePhy = planner
+        .changeTraits(singleRel, cluster.traitSetOf(PHYS_CALLING_CONVENTION));
+
+    // Binary RelNode with identical input on either side
+    PhysBiRel parent =
+        new PhysBiRel(cluster, cluster.traitSetOf(PHYS_CALLING_CONVENTION),
+            singlePhy, singlePhy);
+    planner.setRoot(parent);
+
+    RelNode result = planner.chooseDelegate().findBestExp();
+
+    // Expect inputs to remain identical
+    assertEquals(result.getInput(0), result.getInput(1));
+  }
+
   @Test void testPlanToDot() {
     VolcanoPlanner planner = new VolcanoPlanner();
     planner.addRelTraitDef(ConventionTraitDef.INSTANCE);
diff --git a/core/src/test/java/org/apache/calcite/rel/RelDistributionTest.java b/core/src/test/java/org/apache/calcite/rel/RelDistributionTest.java
index 264fd434869..6bb59f50579 100644
--- a/core/src/test/java/org/apache/calcite/rel/RelDistributionTest.java
+++ b/core/src/test/java/org/apache/calcite/rel/RelDistributionTest.java
@@ -25,6 +25,8 @@
 
 import org.junit.jupiter.api.Test;
 
+import java.util.Arrays;
+
 import static org.apache.calcite.rel.RelDistributions.ANY;
 
 import static org.hamcrest.CoreMatchers.is;
@@ -94,4 +96,12 @@ private static Mapping mapping(int sourceCount, int... sources) {
   private static RelDistribution hash(int... keys) {
     return RelDistributions.hash(ImmutableIntList.of(keys));
   }
+
+  @Test void testRangeRelDistributionKeys() {
+    RelDistributions.range(Arrays.asList(0, 1));
+  }
+
+  @Test void testHashRelDistributionKeys() {
+    RelDistributions.hash(Arrays.asList(0, 1));
+  }
 }
diff --git a/core/src/test/java/org/apache/calcite/rel/logical/ToLogicalConverterTest.java b/core/src/test/java/org/apache/calcite/rel/logical/ToLogicalConverterTest.java
index b909946494e..4aa03d7b311 100644
--- a/core/src/test/java/org/apache/calcite/rel/logical/ToLogicalConverterTest.java
+++ b/core/src/test/java/org/apache/calcite/rel/logical/ToLogicalConverterTest.java
@@ -80,8 +80,9 @@ class ToLogicalConverterTest {
 
   private static FrameworkConfig frameworkConfig() {
     final SchemaPlus rootSchema = Frameworks.createRootSchema(true);
-    final SchemaPlus schema = CalciteAssert.addSchema(rootSchema,
-        CalciteAssert.SchemaSpec.JDBC_FOODMART);
+    final SchemaPlus schema =
+        CalciteAssert.addSchema(rootSchema,
+            CalciteAssert.SchemaSpec.JDBC_FOODMART);
     return Frameworks.newConfigBuilder()
         .defaultSchema(schema)
         .sqlToRelConverterConfig(DEFAULT_REL_CONFIG)
diff --git a/core/src/test/java/org/apache/calcite/rel/metadata/MetadataDefTest.java b/core/src/test/java/org/apache/calcite/rel/metadata/MetadataDefTest.java
index b1658ed3dfb..5a19a17ad58 100644
--- a/core/src/test/java/org/apache/calcite/rel/metadata/MetadataDefTest.java
+++ b/core/src/test/java/org/apache/calcite/rel/metadata/MetadataDefTest.java
@@ -25,15 +25,14 @@
  */
 class MetadataDefTest {
   @Test void staticMethodInHandlerIsIgnored() {
-    assertDoesNotThrow(
-        () -> MetadataDef.of(TestMetadata.class, MetadataHandlerWithStaticMethod.class)
-    );
+    assertDoesNotThrow(() ->
+        MetadataDef.of(TestMetadata.class,
+            MetadataHandlerWithStaticMethod.class));
   }
 
   @Test void synthenticMethodInHandlerIsIgnored() {
-    assertDoesNotThrow(
-        () -> MetadataDef.of(TestMetadata.class,
-            TestMetadataHandlers.handlerClassWithSyntheticMethod())
-    );
+    assertDoesNotThrow(() ->
+        MetadataDef.of(TestMetadata.class,
+            TestMetadataHandlers.handlerClassWithSyntheticMethod()));
   }
 }
diff --git a/core/src/test/java/org/apache/calcite/rel/metadata/MetadataHandlerTest.java b/core/src/test/java/org/apache/calcite/rel/metadata/MetadataHandlerTest.java
index 9c87a5937b1..e69ba62731d 100644
--- a/core/src/test/java/org/apache/calcite/rel/metadata/MetadataHandlerTest.java
+++ b/core/src/test/java/org/apache/calcite/rel/metadata/MetadataHandlerTest.java
@@ -36,21 +36,24 @@ class MetadataHandlerTest {
   }
 
   @Test void getDefMethodInHandlerIsIgnored() {
-    Method[] methods = MetadataHandler.handlerMethods(
-        MetadataHandlerWithGetDefMethodOnly.class);
+    Method[] methods =
+        MetadataHandler.handlerMethods(
+            MetadataHandlerWithGetDefMethodOnly.class);
 
     assertThat(methods, is(emptyArray()));
   }
 
   @Test void staticMethodInHandlerIsIgnored() {
-    Method[] methods = MetadataHandler.handlerMethods(MetadataHandlerWithStaticMethod.class);
+    Method[] methods =
+        MetadataHandler.handlerMethods(MetadataHandlerWithStaticMethod.class);
 
     assertThat(methods, is(emptyArray()));
   }
 
   @Test void synthenticMethodInHandlerIsIgnored() {
-    Method[] methods = MetadataHandler.handlerMethods(
-        TestMetadataHandlers.handlerClassWithSyntheticMethod());
+    Method[] methods =
+        MetadataHandler.handlerMethods(
+            TestMetadataHandlers.handlerClassWithSyntheticMethod());
 
     assertThat(methods, is(emptyArray()));
   }
diff --git a/core/src/test/java/org/apache/calcite/rel/metadata/RelMdUtilTest.java b/core/src/test/java/org/apache/calcite/rel/metadata/RelMdUtilTest.java
index dcfa6ecb82f..b7191089310 100644
--- a/core/src/test/java/org/apache/calcite/rel/metadata/RelMdUtilTest.java
+++ b/core/src/test/java/org/apache/calcite/rel/metadata/RelMdUtilTest.java
@@ -24,9 +24,13 @@
 
 import org.junit.jupiter.api.Test;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.apache.calcite.rel.metadata.RelMdUtil.numDistinctVals;
+import static org.apache.calcite.test.Matchers.within;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.lessThanOrEqualTo;
+import static org.hamcrest.Matchers.not;
 import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertTrue;
 
 /**
  * Test cases for {@link RelMdUtil}.
@@ -42,29 +46,55 @@ final RelMetadataFixture sql(String sql) {
     return fixture().withSql(sql);
   }
 
+  private static final double EPSILON = 1e-5;
+
   @Test void testNumDistinctVals() {
     // the first element must be distinct, the second one has half chance of being distinct
-    assertEquals(1.5, RelMdUtil.numDistinctVals(2.0, 2.0), 1e-5);
+    assertThat(numDistinctVals(2.0, 2.0), within(1.5, EPSILON));
 
     // when no selection is made, we get no distinct value
     double domainSize = 100;
-    assertEquals(0, RelMdUtil.numDistinctVals(domainSize, 0.0), 1e-5);
+    assertThat(numDistinctVals(domainSize, 0.0), within(0, EPSILON));
 
     // when we perform one selection, we always have 1 distinct value,
     // regardless of the domain size
     for (double dSize = 1; dSize < 100; dSize += 1) {
-      assertEquals(1.0, RelMdUtil.numDistinctVals(dSize, 1.0), 1e-5);
+      assertThat(numDistinctVals(dSize, 1.0), within(1.0, EPSILON));
     }
 
     // when we select n objects from a set with n values
     // we get no more than n distinct values
     for (double dSize = 1; dSize < 100; dSize += 1) {
-      assertTrue(RelMdUtil.numDistinctVals(dSize, dSize) <= dSize);
+      assertThat(numDistinctVals(dSize, dSize), lessThanOrEqualTo(dSize));
     }
 
     // when the number of selections is large enough
     // we get all distinct values, w.h.p.
-    assertEquals(domainSize, RelMdUtil.numDistinctVals(domainSize, domainSize * 100), 1e-5);
+    assertThat(numDistinctVals(domainSize, domainSize * 100), within(domainSize, EPSILON));
+
+    assertThat(numDistinctVals(100.0, 2.0), within(1.99, EPSILON));
+    assertThat(numDistinctVals(1000.0, 2.0), within(1.999, EPSILON));
+    assertThat(numDistinctVals(10000.0, 2.0), within(1.9999, EPSILON));
+  }
+
+  @Test void testNumDistinctValsWithLargeDomain() {
+    double[] domainSizes = {1e18, 1e20};
+    double[] numSels = {1e2, 1e4, 1e6, 1e8, 1e10, 1e12};
+    double res;
+    for (double domainSize : domainSizes) {
+      for (double numSel : numSels) {
+        res = numDistinctVals(domainSize, numSel);
+        assertThat(res, not(0));
+        // due to the possible duplicate selections, the distinct values
+        // must be smaller than or equal to the number of selections
+        assertThat(res, lessThanOrEqualTo(numSel));
+      }
+      res = numDistinctVals(domainSize, 1.0);
+      assertThat(res, within(1.0, EPSILON));
+
+      res = numDistinctVals(domainSize, 2.0);
+      assertThat(res, within(2.0, EPSILON));
+    }
   }
 
   @Test void testDynamicParameterInLimitOffset() {
@@ -73,9 +103,8 @@ final RelMetadataFixture sql(String sql) {
       RelNode rel = sql("select * from emp limit ? offset ?").toRel();
       Sort sort = (Sort) rel;
       assertFalse(
-          RelMdUtil.checkInputForCollationAndLimit(mq, sort.getInput(), RelCollations.EMPTY,
-              sort.offset, sort.fetch)
-      );
+          RelMdUtil.checkInputForCollationAndLimit(mq, sort.getInput(),
+              RelCollations.EMPTY, sort.offset, sort.fetch));
       return null;
     });
   }
diff --git a/core/src/test/java/org/apache/calcite/rel/metadata/janino/RelMetadataHandlerGeneratorUtilTest.java b/core/src/test/java/org/apache/calcite/rel/metadata/janino/RelMetadataHandlerGeneratorUtilTest.java
index d8fd5deba71..4e908e42c9b 100644
--- a/core/src/test/java/org/apache/calcite/rel/metadata/janino/RelMetadataHandlerGeneratorUtilTest.java
+++ b/core/src/test/java/org/apache/calcite/rel/metadata/janino/RelMetadataHandlerGeneratorUtilTest.java
@@ -158,8 +158,10 @@ private void checkGenerateHandler(Class<? extends MetadataHandler<?>> handlerCla
   }
 
   private static String readResource(String resourceName) {
-    URL url = castNonNull(
-        RelMetadataHandlerGeneratorUtilTest.class.getClassLoader().getResource(resourceName));
+    URL url =
+        castNonNull(
+            RelMetadataHandlerGeneratorUtilTest.class.getClassLoader()
+                .getResource(resourceName));
     try (Reader reader = Sources.of(url).reader()) {
       return CharStreams.toString(reader).replace("\r\n", "\n");
     } catch (IOException e) {
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 c2d235c1322..cfebf54b1b8 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
@@ -61,13 +61,12 @@
 import org.apache.calcite.sql.dialect.MysqlSqlDialect;
 import org.apache.calcite.sql.dialect.OracleSqlDialect;
 import org.apache.calcite.sql.dialect.PostgresqlSqlDialect;
+import org.apache.calcite.sql.dialect.PrestoSqlDialect;
 import org.apache.calcite.sql.fun.SqlLibrary;
-import org.apache.calcite.sql.fun.SqlLibraryOperatorTableFactory;
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
 import org.apache.calcite.sql.parser.SqlParser;
 import org.apache.calcite.sql.type.SqlTypeFactoryImpl;
 import org.apache.calcite.sql.type.SqlTypeName;
-import org.apache.calcite.sql.util.SqlOperatorTables;
 import org.apache.calcite.sql.util.SqlShuttle;
 import org.apache.calcite.sql.validate.SqlConformance;
 import org.apache.calcite.sql.validate.SqlConformanceEnum;
@@ -94,6 +93,7 @@
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.junit.jupiter.api.Test;
 
+import java.math.BigDecimal;
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
@@ -141,19 +141,15 @@ private static Planner getPlanner(List<RelTraitDef> traitDefs,
       SqlParser.Config parserConfig, SchemaPlus schema,
       SqlToRelConverter.Config sqlToRelConf, Collection<SqlLibrary> librarySet,
       RelDataTypeSystem typeSystem, Program... programs) {
-    final MockSqlOperatorTable operatorTable =
-        new MockSqlOperatorTable(
-            SqlOperatorTables.chain(SqlStdOperatorTable.instance(),
-                SqlLibraryOperatorTableFactory.INSTANCE
-                    .getOperatorTable(librarySet)));
-    MockSqlOperatorTable.addRamp(operatorTable);
     final FrameworkConfig config = Frameworks.newConfigBuilder()
         .parserConfig(parserConfig)
         .defaultSchema(schema)
         .traitDefs(traitDefs)
         .sqlToRelConverterConfig(sqlToRelConf)
         .programs(programs)
-        .operatorTable(operatorTable)
+        .operatorTable(MockSqlOperatorTable.standard()
+            .plus(librarySet)
+            .extend())
         .typeSystem(typeSystem)
         .build();
     return Frameworks.getPlanner(config);
@@ -272,36 +268,42 @@ private static String toSql(RelNode root, SqlDialect dialect,
     sql(query).ok(expected);
   }
 
-  @Test void testAggregateFilterWhereToSqlFromProductTable() {
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-4321">[CALCITE-4321]
+   * JDBC adapter omits FILTER (WHERE ...) expressions when generating SQL</a>
+   * and
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5270">[CALCITE-5270]
+   * JDBC adapter should not generate FILTER (WHERE) in Firebolt dialect</a>. */
+  @Test void testAggregateFilterWhere() {
     String query = "select\n"
         + "  sum(\"shelf_width\") filter (where \"net_weight\" > 0),\n"
         + "  sum(\"shelf_width\")\n"
         + "from \"foodmart\".\"product\"\n"
         + "where \"product_id\" > 0\n"
         + "group by \"product_id\"";
-    final String expected = "SELECT"
+    final String expectedDefault = "SELECT"
         + " SUM(\"shelf_width\") FILTER (WHERE \"net_weight\" > 0 IS TRUE),"
         + " SUM(\"shelf_width\")\n"
         + "FROM \"foodmart\".\"product\"\n"
         + "WHERE \"product_id\" > 0\n"
         + "GROUP BY \"product_id\"";
-    sql(query).ok(expected);
-  }
-
-  @Test void testAggregateFilterWhereToBigQuerySqlFromProductTable() {
-    String query = "select\n"
-        + "  sum(\"shelf_width\") filter (where \"net_weight\" > 0),\n"
-        + "  sum(\"shelf_width\")\n"
-        + "from \"foodmart\".\"product\"\n"
-        + "where \"product_id\" > 0\n"
-        + "group by \"product_id\"";
-    final String expected = "SELECT SUM(CASE WHEN net_weight > 0 IS TRUE"
+    final String expectedBigQuery = "SELECT"
+        + " SUM(CASE WHEN net_weight > 0 IS TRUE"
         + " THEN shelf_width ELSE NULL END), "
         + "SUM(shelf_width)\n"
         + "FROM foodmart.product\n"
         + "WHERE product_id > 0\n"
         + "GROUP BY product_id";
-    sql(query).withBigQuery().ok(expected);
+    final String expectedFirebolt = "SELECT"
+        + " SUM(CASE WHEN \"net_weight\" > 0 IS TRUE"
+        + " THEN \"shelf_width\" ELSE NULL END), "
+        + "SUM(\"shelf_width\")\n"
+        + "FROM \"foodmart\".\"product\"\n"
+        + "WHERE \"product_id\" > 0\n"
+        + "GROUP BY \"product_id\"";
+    sql(query).ok(expectedDefault)
+        .withBigQuery().ok(expectedBigQuery)
+        .withFirebolt().ok(expectedFirebolt);
   }
 
   @Test void testPivotToSqlFromProductTable() {
@@ -625,7 +627,7 @@ private static String toSql(RelNode root, SqlDialect dialect,
         + "GROUP BY GROUPING SETS((\"EMPNO\", \"ENAME\", \"JOB\"),"
         + " (\"EMPNO\", \"ENAME\"), \"EMPNO\")\n"
         + "HAVING GROUPING(\"EMPNO\", \"ENAME\", \"JOB\") <> 0\n"
-        + "ORDER BY COUNT(*)";
+        + "ORDER BY 4";
     relFn(relFn).ok(expectedSql);
   }
 
@@ -695,14 +697,44 @@ private static String toSql(RelNode root, SqlDialect dialect,
         + "FROM \"foodmart\".\"product\"\n"
         + "GROUP BY ROLLUP(\"product_class_id\", \"brand_name\")\n"
         + "ORDER BY \"brand_name\", \"product_class_id\"";
-    final String expectedMysql = "SELECT `product_class_id`, `brand_name`\n"
+    final String expectedMysql = "SELECT *\n"
+        + "FROM (SELECT `product_class_id`, `brand_name`\n"
         + "FROM `foodmart`.`product`\n"
-        + "GROUP BY `brand_name`, `product_class_id` WITH ROLLUP";
+        + "GROUP BY `product_class_id`, `brand_name` WITH ROLLUP) AS `t0`\n"
+        + "ORDER BY `brand_name`, `product_class_id`";
     sql(query)
         .ok(expected)
         .withMysql().ok(expectedMysql);
   }
 
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5518">[CALCITE-5518]
+   * RelToSql converter generates invalid order of ROLLUP fields</a>.
+   */
+  @Test void testGroupingSetsRollupNonNaturalOrder() {
+    final String query1 = "select \"product_class_id\", \"brand_name\"\n"
+        + "from \"product\"\n"
+        + "group by GROUPING SETS ((\"product_class_id\", \"brand_name\"),"
+        + " (\"brand_name\"), ())\n";
+    final String expected1 = "SELECT \"product_class_id\", \"brand_name\"\n"
+        + "FROM \"foodmart\".\"product\"\n"
+        + "GROUP BY ROLLUP(\"brand_name\", \"product_class_id\")";
+    sql(query1)
+        .withPostgresql().ok(expected1);
+
+    final String query2 = "select \"product_class_id\", \"brand_name\", \"product_id\"\n"
+        + "from \"product\"\n"
+        + "group by GROUPING SETS ("
+        + " (\"product_class_id\", \"brand_name\", \"product_id\"),"
+        + " (\"product_class_id\", \"brand_name\"),"
+        + " (\"brand_name\"), ())\n";
+    final String expected2 = "SELECT \"product_class_id\", \"brand_name\", \"product_id\"\n"
+        + "FROM \"foodmart\".\"product\"\n"
+        + "GROUP BY ROLLUP(\"brand_name\", \"product_class_id\", \"product_id\")";
+    sql(query2)
+        .withPostgresql().ok(expected2);
+  }
+
   /** Tests a query with GROUP BY and a sub-query which is also with GROUP BY.
    * If we flatten sub-queries, the number of rows going into AVG becomes
    * incorrect. */
@@ -758,17 +790,17 @@ private static String toSql(RelNode root, SqlDialect dialect,
     final String expected = "SELECT \"product_class_id\", COUNT(*) AS \"C\"\n"
         + "FROM \"foodmart\".\"product\"\n"
         + "GROUP BY ROLLUP(\"product_class_id\")\n"
-        + "ORDER BY \"product_class_id\", COUNT(*)";
+        + "ORDER BY \"product_class_id\", 2";
     final String expectedMysql = "SELECT `product_class_id`, COUNT(*) AS `C`\n"
         + "FROM `foodmart`.`product`\n"
         + "GROUP BY `product_class_id` WITH ROLLUP\n"
         + "ORDER BY `product_class_id` IS NULL, `product_class_id`,"
-        + " COUNT(*) IS NULL, COUNT(*)";
+        + " COUNT(*) IS NULL, 2";
     final String expectedPresto = "SELECT \"product_class_id\", COUNT(*) AS \"C\"\n"
         + "FROM \"foodmart\".\"product\"\n"
         + "GROUP BY ROLLUP(\"product_class_id\")\n"
         + "ORDER BY \"product_class_id\" IS NULL, \"product_class_id\", "
-        + "COUNT(*) IS NULL, COUNT(*)";
+        + "COUNT(*) IS NULL, 2";
     sql(query)
         .ok(expected)
         .withMysql().ok(expectedMysql)
@@ -808,14 +840,14 @@ private static String toSql(RelNode root, SqlDialect dialect,
         + " COUNT(*) AS \"C\"\n"
         + "FROM \"foodmart\".\"product\"\n"
         + "GROUP BY ROLLUP(\"product_class_id\", \"brand_name\")\n"
-        + "ORDER BY \"product_class_id\", \"brand_name\", COUNT(*)";
+        + "ORDER BY \"product_class_id\", \"brand_name\", 3";
     final String expectedMysql = "SELECT `product_class_id`, `brand_name`,"
         + " COUNT(*) AS `C`\n"
         + "FROM `foodmart`.`product`\n"
         + "GROUP BY `product_class_id`, `brand_name` WITH ROLLUP\n"
         + "ORDER BY `product_class_id` IS NULL, `product_class_id`,"
         + " `brand_name` IS NULL, `brand_name`,"
-        + " COUNT(*) IS NULL, COUNT(*)";
+        + " COUNT(*) IS NULL, 3";
     sql(query)
         .ok(expected)
         .withMysql().ok(expectedMysql);
@@ -1188,6 +1220,38 @@ private static String toSql(RelNode root, SqlDialect dialect,
     assertThat(toSql(root), isLinux(expectedSql));
   }
 
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5395">[CALCITE-5395]
+   * RelToSql converter fails when SELECT * is under a semi-join node</a>. */
+  @Test void testUnionUnderSemiJoinNode() {
+    final RelBuilder builder = relBuilder();
+    final RelNode base = builder
+        .scan("EMP")
+        .scan("EMP")
+        .union(true)
+        .build();
+    final RelNode root = builder
+        .push(base)
+        .scan("DEPT")
+        .join(
+            JoinRelType.SEMI, builder.equals(
+                builder.field(2, 1, "DEPTNO"),
+                builder.field(2, 0, "DEPTNO")))
+        .project(builder.field("DEPTNO"))
+        .build();
+    final String expectedSql = "SELECT \"DEPTNO\"\n"
+        + "FROM (SELECT *\n"
+        + "FROM (SELECT *\n"
+        + "FROM \"scott\".\"EMP\"\n"
+        + "UNION ALL\n"
+        + "SELECT *\n"
+        + "FROM \"scott\".\"EMP\")\n"
+        + "WHERE EXISTS (SELECT 1\n"
+        + "FROM \"scott\".\"DEPT\"\n"
+        + "WHERE \"t\".\"DEPTNO\" = \"DEPT\".\"DEPTNO\")) AS \"t\"";
+    assertThat(toSql(root), isLinux(expectedSql));
+  }
+
   @Test void testSemiNestedJoin() {
     final RelBuilder builder = relBuilder();
     final RelNode base = builder
@@ -1216,6 +1280,39 @@ private static String toSql(RelNode root, SqlDialect dialect,
     assertThat(toSql(root), isLinux(expectedSql));
   }
 
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5394">[CALCITE-5394]
+   * RelToSql converter fails when semi-join is under a join node</a>. */
+  @Test void testSemiJoinUnderJoin() {
+    final RelBuilder builder = relBuilder();
+    final RelNode base = builder
+        .scan("EMP")
+        .scan("EMP")
+        .join(
+            JoinRelType.SEMI, builder.equals(
+                builder.field(2, 0, "EMPNO"),
+                builder.field(2, 1, "EMPNO")))
+        .build();
+    final RelNode root = builder
+        .scan("DEPT")
+        .push(base)
+        .join(
+            JoinRelType.INNER, builder.equals(
+                builder.field(2, 1, "DEPTNO"),
+                builder.field(2, 0, "DEPTNO")))
+        .project(builder.field("DEPTNO"))
+        .build();
+    final String expectedSql = "SELECT \"DEPT\".\"DEPTNO\"\n"
+        + "FROM \"scott\".\"DEPT\"\n"
+        + "INNER JOIN (SELECT *\n"
+        + "FROM \"scott\".\"EMP\"\n"
+        + "WHERE EXISTS (SELECT 1\n"
+        + "FROM \"scott\".\"EMP\" AS \"EMP0\"\n"
+        + "WHERE \"EMP\".\"EMPNO\" = \"EMP0\".\"EMPNO\")) AS \"t\" ON \"DEPT\".\"DEPTNO\" = \"t\""
+        + ".\"DEPTNO\"";
+    assertThat(toSql(root), isLinux(expectedSql));
+  }
+
   /** Test case for
    * <a href="https://issues.apache.org/jira/browse/CALCITE-2792">[CALCITE-2792]
    * StackOverflowError while evaluating filter with large number of OR
@@ -1258,6 +1355,46 @@ private static String toSql(RelNode root, SqlDialect dialect,
     relFn(relFn).optimize(rules, null).ok(expected);
   }
 
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-4632">[CALCITE-4632]
+   * Find the least restrictive datatype for SARG</a>. */
+  @Test void testLeastRestrictiveTypeForSargMakeIn() {
+    final Function<RelBuilder, RelNode> relFn = b -> b
+        .scan("EMP")
+        .filter(
+            b.or(b.isNull(b.field("COMM")),
+                  b.in(
+                  b.field("COMM"),
+                  b.literal(new BigDecimal("1.0")), b.literal(new BigDecimal("20000.0")))))
+        .build();
+
+    final String expected = "SELECT *\n"
+        + "FROM \"scott\".\"EMP\"\n"
+        + "WHERE \"COMM\" IS NULL OR \"COMM\" IN (1.0, 20000.0)";
+    relFn(relFn).ok(expected);
+  }
+
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-4632">[CALCITE-4632]
+   * Find the least restrictive datatype for SARG</a>. */
+  @Test void testLeastRestrictiveTypeForSargMakeBetween() {
+    final Function<RelBuilder, RelNode> relFn = b -> b
+        .scan("EMP")
+        .filter(
+            b.or(b.isNull(b.field("COMM")),
+                b.between(
+                    b.field("COMM"),
+                    b.literal(
+                        new BigDecimal("1.0")), b.literal(new BigDecimal("20000.0")))))
+        .build();
+
+    final String expected = "SELECT *\n"
+        + "FROM \"scott\".\"EMP\"\n"
+        + "WHERE \"COMM\" IS NULL OR \"COMM\" >= 1.0 AND \"COMM\" <= 20000.0";
+
+    relFn(relFn).ok(expected);
+  }
+
   /** Test case for
    * <a href="https://issues.apache.org/jira/browse/CALCITE-1946">[CALCITE-1946]
    * JDBC adapter should generate sub-SELECT if dialect does not support nested
@@ -1650,6 +1787,35 @@ private SqlDialect nonOrdinalDialect() {
         + "FROM \"foodmart\".\"employee\"");
   }
 
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5510">[CALCITE-5510]
+   * RelToSqlConverter don't support sort by ordinal when sort by column is an expression</a>.
+   */
+  @Test void testOrderByOrdinalWithExpression() {
+    final String query = "select \"product_id\", count(*) as \"c\"\n"
+        + "from \"product\"\n"
+        + "group by \"product_id\"\n"
+        + "order by 2";
+    final String ordinalExpected = "SELECT \"product_id\", COUNT(*) AS \"c\"\n"
+        + "FROM \"foodmart\".\"product\"\n"
+        + "GROUP BY \"product_id\"\n"
+        + "ORDER BY 2";
+    final String nonOrdinalExpected = "SELECT product_id, COUNT(*) AS c\n"
+        + "FROM foodmart.product\n"
+        + "GROUP BY product_id\n"
+        + "ORDER BY COUNT(*)";
+    final String prestoExpected = "SELECT \"product_id\", COUNT(*) AS \"c\"\n"
+        + "FROM \"foodmart\".\"product\"\n"
+        + "GROUP BY \"product_id\"\n"
+        + "ORDER BY COUNT(*) IS NULL, 2";
+    sql(query)
+        .ok(ordinalExpected)
+        .dialect(nonOrdinalDialect())
+        .ok(nonOrdinalExpected)
+        .dialect(PrestoSqlDialect.DEFAULT)
+        .ok(prestoExpected);
+  }
+
   /** Test case for
    * <a href="https://issues.apache.org/jira/browse/CALCITE-3440">[CALCITE-3440]
    * RelToSqlConverter does not properly alias ambiguous ORDER BY</a>. */
@@ -1738,6 +1904,56 @@ private SqlDialect nonOrdinalDialect() {
     sql(query).withBigQuery().ok(expected);
   }
 
+  @Test void testBigQueryTimeTruncFunctions() {
+    String timestampTrunc = "select timestamp_trunc(timestamp '2012-02-03 15:30:00', month)\n"
+        + "from \"foodmart\".\"product\"\n";
+    final String expectedTimestampTrunc =
+        "SELECT TIMESTAMP_TRUNC(TIMESTAMP '2012-02-03 15:30:00', MONTH)\n"
+        + "FROM \"foodmart\".\"product\"";
+    sql(timestampTrunc).withLibrary(SqlLibrary.BIG_QUERY).ok(expectedTimestampTrunc);
+
+    String timeTrunc = "select time_trunc(time '15:30:00', minute)\n"
+        + "from \"foodmart\".\"product\"\n";
+    final String expectedTimeTrunc = "SELECT TIME_TRUNC(TIME '15:30:00', MINUTE)\n"
+        + "FROM \"foodmart\".\"product\"";
+    sql(timeTrunc).withLibrary(SqlLibrary.BIG_QUERY).ok(expectedTimeTrunc);
+  }
+
+  @Test void testBigQueryDatetimeFormatFunctions() {
+    final String formatTime = "select format_time('%H', time '12:45:30')\n"
+        + "from \"foodmart\".\"product\"\n";
+    final String formatDate = "select format_date('%b-%d-%Y', date '2012-02-03')\n"
+        + "from \"foodmart\".\"product\"\n";
+    final String formatTimestamp = "select format_timestamp('%b-%d-%Y',\n"
+        + "    timestamp with local time zone '2012-02-03 12:30:40')\n"
+        + "from \"foodmart\".\"product\"\n";
+    final String formatDatetime = "select format_datetime('%R',\n"
+        + "    timestamp '2012-02-03 12:34:34')\n"
+        + "from \"foodmart\".\"product\"\n";
+
+    final String expectedBqFormatTime =
+        "SELECT FORMAT_TIME('%H', TIME '12:45:30')\n"
+            + "FROM foodmart.product";
+    final String expectedBqFormatDate =
+        "SELECT FORMAT_DATE('%b-%d-%Y', DATE '2012-02-03')\n"
+            + "FROM foodmart.product";
+    final String expectedBqFormatTimestamp =
+        "SELECT FORMAT_TIMESTAMP('%b-%d-%Y', TIMESTAMP_WITH_LOCAL_TIME_ZONE '2012-02-03 12:30:40')\n"
+            + "FROM foodmart.product";
+    final String expectedBqFormatDatetime =
+        "SELECT FORMAT_DATETIME('%R', TIMESTAMP '2012-02-03 12:34:34')\n"
+            + "FROM foodmart.product";
+    final Sql sql = fixture().withBigQuery().withLibrary(SqlLibrary.BIG_QUERY);
+    sql.withSql(formatTime)
+        .ok(expectedBqFormatTime);
+    sql.withSql(formatDate)
+        .ok(expectedBqFormatDate);
+    sql.withSql(formatTimestamp)
+        .ok(expectedBqFormatTimestamp);
+    sql.withSql(formatDatetime)
+        .ok(expectedBqFormatDatetime);
+  }
+
   /** Test case for
    * <a href="https://issues.apache.org/jira/browse/CALCITE-3220">[CALCITE-3220]
    * HiveSqlDialect should transform the SQL-standard TRIM function to TRIM,
@@ -2457,6 +2673,30 @@ private SqlDialect nonOrdinalDialect() {
     sql(query).withMysql().ok(expected);
   }
 
+  @Test void testMySqlUnparseListAggCall() {
+    final String query = "select\n"
+        + "listagg(distinct \"product_name\", ',') within group(order by \"cases_per_pallet\"),\n"
+        + "listagg(\"product_name\", ',') within group(order by \"cases_per_pallet\"),\n"
+        + "listagg(distinct \"product_name\") within group(order by \"cases_per_pallet\" desc),\n"
+        + "listagg(distinct \"product_name\", ',') within group(order by \"cases_per_pallet\"),\n"
+        + "listagg(\"product_name\"),\n"
+        + "listagg(\"product_name\", ',')\n"
+        + "from \"product\"\n"
+        + "group by \"product_id\"\n";
+    final String expected = "SELECT GROUP_CONCAT(DISTINCT `product_name` "
+        + "ORDER BY `cases_per_pallet` IS NULL, `cases_per_pallet` SEPARATOR ','), "
+        + "GROUP_CONCAT(`product_name` "
+        + "ORDER BY `cases_per_pallet` IS NULL, `cases_per_pallet` SEPARATOR ','), "
+        + "GROUP_CONCAT(DISTINCT `product_name` "
+        + "ORDER BY `cases_per_pallet` IS NULL DESC, `cases_per_pallet` DESC), "
+        + "GROUP_CONCAT(DISTINCT `product_name` "
+        + "ORDER BY `cases_per_pallet` IS NULL, `cases_per_pallet` SEPARATOR ','), "
+        + "GROUP_CONCAT(`product_name`), GROUP_CONCAT(`product_name` SEPARATOR ',')\n"
+        + "FROM `foodmart`.`product`\n"
+        + "GROUP BY `product_id`";
+    sql(query).withMysql().ok(expected);
+  }
+
   @Test void testMySqlWithHighNullsSelectWithOrderByAscNullsLastAndNoEmulation() {
     final String query = "select \"product_id\" from \"product\"\n"
         + "order by \"product_id\" nulls last";
@@ -2998,7 +3238,7 @@ private SqlDialect nonOrdinalDialect() {
         + "WHERE \"store_id\" < 150\n"
         + "GROUP BY \"department_id\") AS \"t1\" "
         + "ON \"department\".\"department_id\" = \"t1\".\"department_id\"";
-    sql(query).ok(expected);
+    sql(query).withConfig(c -> c.withExpand(true)).ok(expected);
   }
 
   /** Test case for
@@ -3356,6 +3596,104 @@ private SqlDialect nonOrdinalDialect() {
     sql(query).ok(expected);
   }
 
+
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5013">[CALCITE-5013]
+   * Unparse SqlSetOperator should be retained parentheses
+   * when the operand has limit or offset</a>. */
+  @Test void testSetOpRetainParentheses() {
+    // Parentheses will be discarded, because semantics not be affected.
+    final String discardedParenthesesQuery = "SELECT \"product_id\" FROM \"product\""
+        + "UNION ALL\n"
+        + "(SELECT \"product_id\" FROM \"product\" WHERE \"product_id\" > 10)\n"
+        + "INTERSECT ALL\n"
+        + "(SELECT \"product_id\" FROM \"product\" )";
+    final String discardedParenthesesRes = "SELECT \"product_id\"\n"
+        + "FROM \"foodmart\".\"product\"\n"
+        + "UNION ALL\n"
+        + "SELECT *\n"
+        + "FROM (SELECT \"product_id\"\n"
+        + "FROM \"foodmart\".\"product\"\n"
+        + "WHERE \"product_id\" > 10\n"
+        + "INTERSECT ALL\n"
+        + "SELECT \"product_id\"\n"
+        + "FROM \"foodmart\".\"product\")";
+    sql(discardedParenthesesQuery).ok(discardedParenthesesRes);
+
+    // Parentheses will be retained because sub-query has LIMIT or OFFSET.
+    // If parentheses are discarded the semantics of parsing will be affected.
+    final String allSetOpQuery = "SELECT \"product_id\" FROM \"product\""
+        + "UNION ALL\n"
+        + "(SELECT \"product_id\" FROM \"product\" LIMIT 10)\n"
+        + "INTERSECT ALL\n"
+        + "(SELECT \"product_id\" FROM \"product\" OFFSET 10)\n"
+        + "EXCEPT ALL\n"
+        + "(SELECT \"product_id\" FROM \"product\" LIMIT 5 OFFSET 5)";
+    final String allSetOpRes = "SELECT *\n"
+        + "FROM (SELECT \"product_id\"\n"
+        + "FROM \"foodmart\".\"product\"\n"
+        + "UNION ALL\n"
+        + "SELECT *\n"
+        + "FROM ((SELECT \"product_id\"\n"
+        + "FROM \"foodmart\".\"product\"\n"
+        + "FETCH NEXT 10 ROWS ONLY)\n"
+        + "INTERSECT ALL\n"
+        + "(SELECT \"product_id\"\n"
+        + "FROM \"foodmart\".\"product\"\n"
+        + "OFFSET 10 ROWS)))\n"
+        + "EXCEPT ALL\n"
+        + "(SELECT \"product_id\"\n"
+        + "FROM \"foodmart\".\"product\"\n"
+        + "OFFSET 5 ROWS\n"
+        + "FETCH NEXT 5 ROWS ONLY)";
+    sql(allSetOpQuery).ok(allSetOpRes);
+
+    // After the config is enabled, order by will be retained, so parentheses are required.
+    final String retainOrderQuery = "SELECT \"product_id\" FROM \"product\""
+        + "UNION ALL\n"
+        + "(SELECT \"product_id\" FROM \"product\" ORDER BY \"product_id\")";
+    final String retainOrderResult = "SELECT \"product_id\"\n"
+        + "FROM \"foodmart\".\"product\"\n"
+        + "UNION ALL\n"
+        + "(SELECT \"product_id\"\n"
+        + "FROM \"foodmart\".\"product\"\n"
+        + "ORDER BY \"product_id\")";
+    sql(retainOrderQuery).withConfig(c -> c.withRemoveSortInSubQuery(false)).ok(retainOrderResult);
+
+    // Parentheses are required to keep ORDER and LIMIT on the sub-query.
+    final String retainLimitQuery = "SELECT \"product_id\" FROM \"product\""
+        + "UNION ALL\n"
+        + "(SELECT \"product_id\" FROM \"product\" ORDER BY \"product_id\" LIMIT 2)";
+    final String retainLimitResult = "SELECT \"product_id\"\n"
+        + "FROM \"foodmart\".\"product\"\n"
+        + "UNION ALL\n"
+        + "(SELECT \"product_id\"\n"
+        + "FROM \"foodmart\".\"product\"\n"
+        + "ORDER BY \"product_id\"\n"
+        + "FETCH NEXT 2 ROWS ONLY)";
+    sql(retainLimitQuery).ok(retainLimitResult);
+  }
+
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5504">[CALCITE-5504]
+   * Array literals are unparsed incorrectly for the spark dialect</a>.*/
+  @Test void testArrayValueConstructorSpark() {
+    final String query = "SELECT ARRAY[1, 2, 3]";
+    final String expected = "SELECT ARRAY (1, 2, 3)\n"
+        + "FROM (VALUES (0)) t (ZERO)";
+    sql(query).withSpark().ok(expected);
+  }
+
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5577">[CALCITE-5577]
+   * Map value constructor is unparsed incorrectly for SparkSqlDialect</a>.*/
+  @Test void testMapValueConstructorSpark() {
+    final String query = "SELECT MAP['k1', 'v1', 'k2', 'v2']";
+    final String expected = "SELECT MAP ('k1', 'v1', 'k2', 'v2')\n"
+        + "FROM (VALUES (0)) t (ZERO)";
+    sql(query).withSpark().ok(expected);
+  }
+
   /** Test case for
    * <a href="https://issues.apache.org/jira/browse/CALCITE-4674">[CALCITE-4674]
    * Excess quotes in generated SQL when STAR is a column alias</a>. */
@@ -3570,10 +3908,11 @@ private void checkLiteral2(String expression, String expected) {
     builder.addRuleClass(AggregateProjectMergeRule.class);
     builder.addRuleClass(AggregateJoinTransposeRule.class);
     HepPlanner hepPlanner = new HepPlanner(builder.build());
-    RuleSet rules = RuleSets.ofList(
-        CoreRules.FILTER_INTO_JOIN,
-        CoreRules.JOIN_CONDITION_PUSH,
-        CoreRules.AGGREGATE_PROJECT_MERGE, CoreRules.AGGREGATE_JOIN_TRANSPOSE_EXTENDED);
+    RuleSet rules =
+        RuleSets.ofList(CoreRules.FILTER_INTO_JOIN,
+            CoreRules.JOIN_CONDITION_PUSH,
+            CoreRules.AGGREGATE_PROJECT_MERGE,
+            CoreRules.AGGREGATE_JOIN_TRANSPOSE_EXTENDED);
     sql(query).withPostgresql().optimize(rules, hepPlanner).ok(expect);
   }
 
@@ -3679,15 +4018,6 @@ private void checkLiteral2(String expression, String expected) {
         .withPresto().ok(expectedPresto);
   }
 
-  @Test void testFloorMssqlWeek() {
-    String query = "SELECT floor(\"hire_date\" TO WEEK) FROM \"employee\"";
-    String expected = "SELECT CONVERT(DATETIME, CONVERT(VARCHAR(10), "
-        + "DATEADD(day, - (6 + DATEPART(weekday, [hire_date] )) % 7, [hire_date] ), 126))\n"
-        + "FROM [foodmart].[employee]";
-    sql(query)
-        .withMssql().ok(expected);
-  }
-
   @Test void testFetchMssql() {
     String query = "SELECT * FROM \"employee\" LIMIT 1";
     String expected = "SELECT TOP (1) *\nFROM [foodmart].[employee]";
@@ -3697,12 +4027,20 @@ private void checkLiteral2(String expression, String expected) {
 
   @Test void testFetchOffset() {
     String query = "SELECT * FROM \"employee\" LIMIT 1 OFFSET 1";
-    String expectedMssql = "SELECT *\nFROM [foodmart].[employee]\nOFFSET 1 ROWS\n"
+    String expectedMssql = "SELECT *\n"
+        + "FROM [foodmart].[employee]\n"
+        + "OFFSET 1 ROWS\n"
         + "FETCH NEXT 1 ROWS ONLY";
-    String expectedSybase = "SELECT TOP (1) START AT 1 *\nFROM foodmart.employee";
+    String expectedSybase = "SELECT TOP (1) START AT 1 *\n"
+        + "FROM foodmart.employee";
+    final String expectedPresto = "SELECT *\n"
+        + "FROM \"foodmart\".\"employee\"\n"
+        + "OFFSET 1\n"
+        + "LIMIT 1";
     sql(query)
         .withMssql().ok(expectedMssql)
-        .withSybase().ok(expectedSybase);
+        .withSybase().ok(expectedSybase)
+        .withPresto().ok(expectedPresto);
   }
 
   @Test void testFloorMssqlMonth() {
@@ -3726,7 +4064,8 @@ private void checkLiteral2(String expression, String expected) {
     final String expectedClickHouse = "SELECT toMonday(`hire_date`)\n"
         + "FROM `foodmart`.`employee`";
     final String expectedMssql = "SELECT CONVERT(DATETIME, CONVERT(VARCHAR(10), "
-        + "DATEADD(day, - (6 + DATEPART(weekday, [hire_date] )) % 7, [hire_date] ), 126))\n"
+        + "DATEADD(day, - (6 + DATEPART(weekday, [hire_date] )) % 7, [hire_date] "
+        + "), 126))\n"
         + "FROM [foodmart].[employee]";
     final String expectedMysql = "SELECT STR_TO_DATE(DATE_FORMAT(`hire_date` , '%x%v-1'), "
         + "'%x%v-%w')\n"
@@ -3846,6 +4185,28 @@ private void checkLiteral2(String expression, String expected) {
     sql(sql2).withBigQuery().throws_("Only INT64 is supported as the interval value for BigQuery.");
   }
 
+  @Test void testUnparseSqlIntervalQualifierFirebolt() {
+    final String sql0 = "select  * from \"employee\" where  \"hire_date\" - "
+        + "INTERVAL '19800' SECOND(5) > TIMESTAMP '2005-10-17 00:00:00' ";
+    final String expect0 = "SELECT *\n"
+        + "FROM \"foodmart\".\"employee\"\n"
+        + "WHERE (\"hire_date\" - INTERVAL '19800 SECOND ')"
+        + " > TIMESTAMP '2005-10-17 00:00:00'";
+    sql(sql0).withFirebolt().ok(expect0);
+
+    final String sql1 = "select  * from \"employee\" where  \"hire_date\" + "
+        + "INTERVAL '10' HOUR > TIMESTAMP '2005-10-17 00:00:00' ";
+    final String expect1 = "SELECT *\n"
+        + "FROM \"foodmart\".\"employee\"\n"
+        + "WHERE (\"hire_date\" + INTERVAL '10 HOUR ')"
+        + " > TIMESTAMP '2005-10-17 00:00:00'";
+    sql(sql1).withFirebolt().ok(expect1);
+
+    final String sql2 = "select  * from \"employee\" where  \"hire_date\" + "
+        + "INTERVAL '1 2:34:56.78' DAY TO SECOND > TIMESTAMP '2005-10-17 00:00:00' ";
+    sql(sql2).withFirebolt().throws_("Only INT64 is supported as the interval value for Firebolt.");
+  }
+
   @Test void testFloorMysqlWeek() {
     String query = "SELECT floor(\"hire_date\" TO WEEK) FROM \"employee\"";
     String expected = "SELECT STR_TO_DATE(DATE_FORMAT(`hire_date` , '%x%v-1'), '%x%v-%w')\n"
@@ -4550,7 +4911,7 @@ private void checkLiteral2(String expression, String expected) {
         + "FROM \"foodmart\".\"product\") "
         + "MATCH_RECOGNIZE(\n"
         + "MEASURES "
-        + "FINAL MATCH_NUMBER () AS \"MATCH_NUM\", "
+        + "FINAL MATCH_NUMBER() AS \"MATCH_NUM\", "
         + "FINAL CLASSIFIER() AS \"VAR_MATCH\", "
         + "FINAL \"STRT\".\"net_weight\" AS \"START_NW\", "
         + "FINAL LAST(\"DOWN\".\"net_weight\", 0) AS \"BOTTOM_NW\", "
@@ -5187,6 +5548,23 @@ private void checkLiteral2(String expression, String expected) {
         .withSnowflake().ok(expectedSnowflake);
   }
 
+  /**
+   * Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5179">[CALCITE-5179]
+   * In RelToSqlConverter, AssertionError for values with more than two items
+   * when SqlDialect#supportsAliasedValues is false</a>.
+   */
+  @Test void testThreeValues() {
+    final String sql = "select * from (values (1), (2), (3)) as t(\"a\")\n";
+    sql(sql)
+        .withRedshift().ok("SELECT *\n"
+            + "FROM (SELECT 1 AS \"a\"\n"
+            + "UNION ALL\n"
+            + "SELECT 2 AS \"a\"\n"
+            + "UNION ALL\n"
+            + "SELECT 3 AS \"a\")");
+  }
+
   @Test void testValuesEmpty() {
     final String sql = "select *\n"
         + "from (values (1, 'a'), (2, 'bb')) as t(x, y)\n"
@@ -5775,16 +6153,13 @@ private void checkLiteral2(String expression, String expected) {
     final String expected = "SELECT COUNT(*)\n"
         + "FROM \"foodmart\".\"product\"\n"
         + "GROUP BY CUBE(\"product_id\", \"product_class_id\")";
-    final String expectedInSpark = "SELECT COUNT(*)\n"
+    final String expectedSpark = "SELECT COUNT(*)\n"
         + "FROM foodmart.product\n"
-        + "GROUP BY product_id, product_class_id WITH CUBE";
-    final String expectedPresto = "SELECT COUNT(*)\n"
-        + "FROM \"foodmart\".\"product\"\n"
-        + "GROUP BY CUBE(\"product_id\", \"product_class_id\")";
+        + "GROUP BY CUBE(product_id, product_class_id)";
     sql(query)
         .ok(expected)
-        .withPresto().ok(expectedPresto)
-        .withSpark().ok(expectedInSpark);
+        .withPresto().ok(expected)
+        .withSpark().ok(expectedSpark);
   }
 
   @Test void testRollupWithGroupBy() {
@@ -5796,13 +6171,10 @@ private void checkLiteral2(String expression, String expected) {
         + "GROUP BY ROLLUP(\"product_id\", \"product_class_id\")";
     final String expectedSpark = "SELECT COUNT(*)\n"
         + "FROM foodmart.product\n"
-        + "GROUP BY product_id, product_class_id WITH ROLLUP";
-    final String expectedPresto = "SELECT COUNT(*)\n"
-        + "FROM \"foodmart\".\"product\"\n"
-        + "GROUP BY ROLLUP(\"product_id\", \"product_class_id\")";
+        + "GROUP BY ROLLUP(product_id, product_class_id)";
     sql(query)
         .ok(expected)
-        .withPresto().ok(expectedPresto)
+        .withPresto().ok(expected)
         .withSpark().ok(expectedSpark);
   }
 
@@ -5845,11 +6217,47 @@ private void checkLiteral2(String expression, String expected) {
     sql(query).ok(expected);
   }
 
-  @Test void testUnionAllWithNoOperandsUsingOracleDialect() {
+  @Test public void testJsonInsert() {
+    String query0 = "select json_insert(\"product_name\", '$', 10) from \"product\"";
+    String query1 = "select json_insert(cast(null as varchar), '$', 10, '$', null, '$',"
+        + " '\n\t\n') from \"product\"";
+    final String expected0 = "SELECT JSON_INSERT(\"product_name\", '$', 10)\n"
+        + "FROM \"foodmart\".\"product\"";
+    final String expected1 = "SELECT JSON_INSERT(NULL, '$', 10, '$', NULL, '$', "
+        + "u&'\\000a\\0009\\000a')\nFROM \"foodmart\".\"product\"";
+    sql(query0).ok(expected0);
+    sql(query1).ok(expected1);
+  }
+
+  @Test public void testJsonReplace() {
+    String query = "select json_replace(\"product_name\", '$', 10) from \"product\"";
+    String query1 = "select json_replace(cast(null as varchar), '$', 10, '$', null, '$',"
+        + " '\n\t\n') from \"product\"";
+    final String expected = "SELECT JSON_REPLACE(\"product_name\", '$', 10)\n"
+        + "FROM \"foodmart\".\"product\"";
+    final String expected1 = "SELECT JSON_REPLACE(NULL, '$', 10, '$', NULL, '$', "
+        + "u&'\\000a\\0009\\000a')\nFROM \"foodmart\".\"product\"";
+    sql(query).ok(expected);
+    sql(query1).ok(expected1);
+  }
+
+  @Test public void testJsonSet() {
+    String query = "select json_set(\"product_name\", '$', 10) from \"product\"";
+    String query1 = "select json_set(cast(null as varchar), '$', 10, '$', null, '$',"
+        + " '\n\t\n') from \"product\"";
+    final String expected = "SELECT JSON_SET(\"product_name\", '$', 10)\n"
+        + "FROM \"foodmart\".\"product\"";
+    final String expected1 = "SELECT JSON_SET(NULL, '$', 10, '$', NULL, '$', "
+        + "u&'\\000a\\0009\\000a')\nFROM \"foodmart\".\"product\"";
+    sql(query).ok(expected);
+    sql(query1).ok(expected1);
+  }
+
+  @Test void testUnionAll() {
     String query = "select A.\"department_id\" "
         + "from \"foodmart\".\"employee\" A "
         + " where A.\"department_id\" = ( select min( A.\"department_id\") from \"foodmart\".\"department\" B where 1=2 )";
-    final String expected = "SELECT \"employee\".\"department_id\"\n"
+    final String expectedOracle = "SELECT \"employee\".\"department_id\"\n"
         + "FROM \"foodmart\".\"employee\"\n"
         + "INNER JOIN (SELECT \"t1\".\"department_id\" \"department_id0\", MIN(\"t1\".\"department_id\") \"EXPR$0\"\n"
         + "FROM (SELECT NULL \"department_id\", NULL \"department_description\"\n"
@@ -5858,30 +6266,28 @@ private void checkLiteral2(String expression, String expected) {
         + "(SELECT \"department_id\"\n"
         + "FROM \"foodmart\".\"employee\"\n"
         + "GROUP BY \"department_id\") \"t1\"\n"
-        + "GROUP BY \"t1\".\"department_id\") \"t3\" ON \"employee\".\"department_id\" = \"t3\".\"department_id0\""
-        + " AND \"employee\".\"department_id\" = \"t3\".\"EXPR$0\"";
-    sql(query).withOracle().ok(expected);
-  }
-
-  @Test void testUnionAllWithNoOperands() {
-    String query = "select A.\"department_id\" "
-        + "from \"foodmart\".\"employee\" A "
-        + " where A.\"department_id\" = ( select min( A.\"department_id\") from \"foodmart\".\"department\" B where 1=2 )";
+        + "GROUP BY \"t1\".\"department_id\"\n"
+        + "HAVING \"t1\".\"department_id\" = MIN(\"t1\".\"department_id\")) \"t4\" ON \"employee\".\"department_id\" = \"t4\".\"department_id0\"";
+    final String expectedNoExpand = "SELECT \"department_id\"\n"
+        + "FROM \"foodmart\".\"employee\"\n"
+        + "WHERE \"department_id\" = (((SELECT MIN(\"employee\".\"department_id\")\n"
+        + "FROM \"foodmart\".\"department\"\n"
+        + "WHERE 1 = 2)))";
     final String expected = "SELECT \"employee\".\"department_id\"\n"
         + "FROM \"foodmart\".\"employee\"\n"
-        + "INNER JOIN (SELECT \"t1\".\"department_id\" AS \"department_id0\","
-        + " MIN(\"t1\".\"department_id\") AS \"EXPR$0\"\n"
+        + "INNER JOIN (SELECT \"t1\".\"department_id\" AS \"department_id0\", MIN(\"t1\".\"department_id\") AS \"EXPR$0\"\n"
         + "FROM (SELECT *\n"
-        + "FROM (VALUES (NULL, NULL))"
-        + " AS \"t\" (\"department_id\", \"department_description\")\n"
+        + "FROM (VALUES (NULL, NULL)) AS \"t\" (\"department_id\", \"department_description\")\n"
         + "WHERE 1 = 0) AS \"t\",\n"
         + "(SELECT \"department_id\"\n"
         + "FROM \"foodmart\".\"employee\"\n"
         + "GROUP BY \"department_id\") AS \"t1\"\n"
-        + "GROUP BY \"t1\".\"department_id\") AS \"t3\" "
-        + "ON \"employee\".\"department_id\" = \"t3\".\"department_id0\""
-        + " AND \"employee\".\"department_id\" = \"t3\".\"EXPR$0\"";
-    sql(query).ok(expected);
+        + "GROUP BY \"t1\".\"department_id\"\n"
+        + "HAVING \"t1\".\"department_id\" = MIN(\"t1\".\"department_id\")) AS \"t4\" ON \"employee\".\"department_id\" = \"t4\".\"department_id0\"";
+    sql(query)
+        .ok(expectedNoExpand)
+        .withConfig(c -> c.withExpand(true)).ok(expected)
+        .withOracle().ok(expectedOracle);
   }
 
   @Test void testSmallintOracle() {
@@ -6029,7 +6435,7 @@ private void checkLiteral2(String expression, String expected) {
     final String expected = "INSERT INTO \"foodmart\".\"account\" ("
         + "\"account_id\", \"account_parent\", \"account_description\", "
         + "\"account_type\", \"account_rollup\", \"Custom_Members\")\n"
-        + "(SELECT \"EXPR$0\" AS \"account_id\","
+        + "SELECT \"EXPR$0\" AS \"account_id\","
         + " \"EXPR$1\" AS \"account_parent\","
         + " CAST(NULL AS VARCHAR(30) CHARACTER SET \"ISO-8859-1\") "
         + "AS \"account_description\","
@@ -6038,7 +6444,7 @@ private void checkLiteral2(String expression, String expected) {
         + " CAST(NULL AS VARCHAR(255) CHARACTER SET \"ISO-8859-1\") "
         + "AS \"Custom_Members\"\n"
         + "FROM (VALUES (1, NULL, '123', '123')) "
-        + "AS \"t\" (\"EXPR$0\", \"EXPR$1\", \"EXPR$2\", \"EXPR$3\"))";
+        + "AS \"t\" (\"EXPR$0\", \"EXPR$1\", \"EXPR$2\", \"EXPR$3\")";
     sql(query).ok(expected);
     // validate
     sql(expected).exec();
@@ -6058,7 +6464,7 @@ private void checkLiteral2(String expression, String expected) {
     final String expected = "INSERT INTO \"foodmart\".\"account\" "
         + "(\"account_id\", \"account_parent\", \"account_description\", "
         + "\"account_type\", \"account_rollup\", \"Custom_Members\")\n"
-        + "(SELECT \"product\".\"product_id\" AS \"account_id\", "
+        + "SELECT \"product\".\"product_id\" AS \"account_id\", "
         + "CAST(NULL AS INTEGER) AS \"account_parent\", CAST(NULL AS VARCHAR"
         + "(30) CHARACTER SET \"ISO-8859-1\") AS \"account_description\", "
         + "CAST(\"product\".\"product_id\" AS VARCHAR CHARACTER SET "
@@ -6068,7 +6474,7 @@ private void checkLiteral2(String expression, String expected) {
         + "CAST(NULL AS VARCHAR(255) CHARACTER SET \"ISO-8859-1\") AS \"Custom_Members\"\n"
         + "FROM \"foodmart\".\"product\"\n"
         + "INNER JOIN \"foodmart\".\"sales_fact_1997\" "
-        + "ON \"product\".\"product_id\" = \"sales_fact_1997\".\"product_id\")";
+        + "ON \"product\".\"product_id\" = \"sales_fact_1997\".\"product_id\"";
     sql(query).ok(expected);
     // validate
     sql(expected).exec();
@@ -6236,6 +6642,44 @@ private void checkLiteral2(String expression, String expected) {
         .withCalcite().ok(expectedCalciteX);
   }
 
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5265">[CALCITE-5265]
+   * JDBC adapter sometimes adds unnecessary parentheses around SELECT in INSERT</a>. */
+  @Test void testInsertSelect() {
+    final String sql = "insert into \"DEPT\" select * from \"DEPT\"";
+    final String expected = ""
+        + "INSERT INTO \"SCOTT\".\"DEPT\" (\"DEPTNO\", \"DNAME\", \"LOC\")\n"
+        + "SELECT *\n"
+        + "FROM \"SCOTT\".\"DEPT\"";
+    sql(sql)
+        .schema(CalciteAssert.SchemaSpec.JDBC_SCOTT)
+        .ok(expected);
+  }
+
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5265">[CALCITE-5265]
+   * JDBC adapter sometimes adds unnecessary parentheses around SELECT in INSERT</a>. */
+  @Test void testInsertUnionThenIntersect() {
+    final String sql = ""
+        + "insert into \"DEPT\"\n"
+        + "(select * from \"DEPT\" union select * from \"DEPT\")\n"
+        + "intersect select * from \"DEPT\"";
+    final String expected = ""
+        + "INSERT INTO \"SCOTT\".\"DEPT\" (\"DEPTNO\", \"DNAME\", \"LOC\")\n"
+        + "SELECT *\n"
+        + "FROM (SELECT *\n"
+        + "FROM \"SCOTT\".\"DEPT\"\n"
+        + "UNION\n"
+        + "SELECT *\n"
+        + "FROM \"SCOTT\".\"DEPT\")\n"
+        + "INTERSECT\n"
+        + "SELECT *\n"
+        + "FROM \"SCOTT\".\"DEPT\"";
+    sql(sql)
+        .schema(CalciteAssert.SchemaSpec.JDBC_SCOTT)
+        .ok(expected);
+  }
+
   @Test void testInsertValuesWithDynamicParams() {
     final String sql = "insert into \"DEPT\" values (?,?,?), (?,?,?)";
     final String expected = ""
@@ -6347,7 +6791,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, COUNT(DISTINCT EMPNO) DESC";
+        + "ORDER BY COUNT(DISTINCT EMPNO) IS NULL DESC, 2 DESC";
 
     // Convert rel node to SQL with BigQuery dialect,
     // in which "isHavingAlias" is true.
diff --git a/core/src/test/java/org/apache/calcite/rel/rules/DateRangeRulesTest.java b/core/src/test/java/org/apache/calcite/rel/rules/DateRangeRulesTest.java
index a2dee174aaf..0be9524ec3e 100644
--- a/core/src/test/java/org/apache/calcite/rel/rules/DateRangeRulesTest.java
+++ b/core/src/test/java/org/apache/calcite/rel/rules/DateRangeRulesTest.java
@@ -723,44 +723,56 @@ private static class Fixture2 extends Fixture {
     private final RexNode ceilMinute;
 
     Fixture2() {
-      exYearTs = rexBuilder.makeCall(SqlStdOperatorTable.EXTRACT,
-          ImmutableList.of(rexBuilder.makeFlag(TimeUnitRange.YEAR), ts));
-      exMonthTs = rexBuilder.makeCall(intRelDataType,
-          SqlStdOperatorTable.EXTRACT,
-          ImmutableList.of(rexBuilder.makeFlag(TimeUnitRange.MONTH), ts));
-      exDayTs = rexBuilder.makeCall(intRelDataType,
-          SqlStdOperatorTable.EXTRACT,
-          ImmutableList.of(rexBuilder.makeFlag(TimeUnitRange.DAY), ts));
-      exYearD = rexBuilder.makeCall(SqlStdOperatorTable.EXTRACT,
-          ImmutableList.of(rexBuilder.makeFlag(TimeUnitRange.YEAR), d));
-      exMonthD = rexBuilder.makeCall(intRelDataType,
-          SqlStdOperatorTable.EXTRACT,
-          ImmutableList.of(rexBuilder.makeFlag(TimeUnitRange.MONTH), d));
-      exDayD = rexBuilder.makeCall(intRelDataType,
-          SqlStdOperatorTable.EXTRACT,
-          ImmutableList.of(rexBuilder.makeFlag(TimeUnitRange.DAY), d));
-
-      floorYear = rexBuilder.makeCall(intRelDataType, SqlStdOperatorTable.FLOOR,
-          ImmutableList.of(ts, rexBuilder.makeFlag(TimeUnitRange.YEAR)));
-      floorMonth = rexBuilder.makeCall(intRelDataType, SqlStdOperatorTable.FLOOR,
-          ImmutableList.of(ts, rexBuilder.makeFlag(TimeUnitRange.MONTH)));
-      floorDay = rexBuilder.makeCall(intRelDataType, SqlStdOperatorTable.FLOOR,
-          ImmutableList.of(ts, rexBuilder.makeFlag(TimeUnitRange.DAY)));
-      floorHour = rexBuilder.makeCall(intRelDataType, SqlStdOperatorTable.FLOOR,
-          ImmutableList.of(ts, rexBuilder.makeFlag(TimeUnitRange.HOUR)));
-      floorMinute = rexBuilder.makeCall(intRelDataType, SqlStdOperatorTable.FLOOR,
-          ImmutableList.of(ts, rexBuilder.makeFlag(TimeUnitRange.MINUTE)));
-
-      ceilYear = rexBuilder.makeCall(intRelDataType, SqlStdOperatorTable.CEIL,
-          ImmutableList.of(ts, rexBuilder.makeFlag(TimeUnitRange.YEAR)));
-      ceilMonth = rexBuilder.makeCall(intRelDataType, SqlStdOperatorTable.CEIL,
-          ImmutableList.of(ts, rexBuilder.makeFlag(TimeUnitRange.MONTH)));
-      ceilDay = rexBuilder.makeCall(intRelDataType, SqlStdOperatorTable.CEIL,
-          ImmutableList.of(ts, rexBuilder.makeFlag(TimeUnitRange.DAY)));
-      ceilHour = rexBuilder.makeCall(intRelDataType, SqlStdOperatorTable.CEIL,
-          ImmutableList.of(ts, rexBuilder.makeFlag(TimeUnitRange.HOUR)));
-      ceilMinute = rexBuilder.makeCall(intRelDataType, SqlStdOperatorTable.CEIL,
-          ImmutableList.of(ts, rexBuilder.makeFlag(TimeUnitRange.MINUTE)));
+      exYearTs =
+          rexBuilder.makeCall(SqlStdOperatorTable.EXTRACT,
+              ImmutableList.of(rexBuilder.makeFlag(TimeUnitRange.YEAR), ts));
+      exMonthTs =
+          rexBuilder.makeCall(intRelDataType, SqlStdOperatorTable.EXTRACT,
+              ImmutableList.of(rexBuilder.makeFlag(TimeUnitRange.MONTH), ts));
+      exDayTs =
+          rexBuilder.makeCall(intRelDataType, SqlStdOperatorTable.EXTRACT,
+              ImmutableList.of(rexBuilder.makeFlag(TimeUnitRange.DAY), ts));
+      exYearD =
+          rexBuilder.makeCall(SqlStdOperatorTable.EXTRACT,
+              ImmutableList.of(rexBuilder.makeFlag(TimeUnitRange.YEAR), d));
+      exMonthD =
+          rexBuilder.makeCall(intRelDataType, SqlStdOperatorTable.EXTRACT,
+              ImmutableList.of(rexBuilder.makeFlag(TimeUnitRange.MONTH), d));
+      exDayD =
+          rexBuilder.makeCall(intRelDataType, SqlStdOperatorTable.EXTRACT,
+              ImmutableList.of(rexBuilder.makeFlag(TimeUnitRange.DAY), d));
+
+      floorYear =
+          rexBuilder.makeCall(intRelDataType, SqlStdOperatorTable.FLOOR,
+              ImmutableList.of(ts, rexBuilder.makeFlag(TimeUnitRange.YEAR)));
+      floorMonth =
+          rexBuilder.makeCall(intRelDataType, SqlStdOperatorTable.FLOOR,
+              ImmutableList.of(ts, rexBuilder.makeFlag(TimeUnitRange.MONTH)));
+      floorDay =
+          rexBuilder.makeCall(intRelDataType, SqlStdOperatorTable.FLOOR,
+              ImmutableList.of(ts, rexBuilder.makeFlag(TimeUnitRange.DAY)));
+      floorHour =
+          rexBuilder.makeCall(intRelDataType, SqlStdOperatorTable.FLOOR,
+              ImmutableList.of(ts, rexBuilder.makeFlag(TimeUnitRange.HOUR)));
+      floorMinute =
+          rexBuilder.makeCall(intRelDataType, SqlStdOperatorTable.FLOOR,
+              ImmutableList.of(ts, rexBuilder.makeFlag(TimeUnitRange.MINUTE)));
+
+      ceilYear =
+          rexBuilder.makeCall(intRelDataType, SqlStdOperatorTable.CEIL,
+              ImmutableList.of(ts, rexBuilder.makeFlag(TimeUnitRange.YEAR)));
+      ceilMonth =
+          rexBuilder.makeCall(intRelDataType, SqlStdOperatorTable.CEIL,
+              ImmutableList.of(ts, rexBuilder.makeFlag(TimeUnitRange.MONTH)));
+      ceilDay =
+          rexBuilder.makeCall(intRelDataType, SqlStdOperatorTable.CEIL,
+              ImmutableList.of(ts, rexBuilder.makeFlag(TimeUnitRange.DAY)));
+      ceilHour =
+          rexBuilder.makeCall(intRelDataType, SqlStdOperatorTable.CEIL,
+              ImmutableList.of(ts, rexBuilder.makeFlag(TimeUnitRange.HOUR)));
+      ceilMinute =
+          rexBuilder.makeCall(intRelDataType, SqlStdOperatorTable.CEIL,
+              ImmutableList.of(ts, rexBuilder.makeFlag(TimeUnitRange.MINUTE)));
     }
   }
 }
diff --git a/core/src/test/java/org/apache/calcite/rel/rules/EnumerableLimitRuleTest.java b/core/src/test/java/org/apache/calcite/rel/rules/EnumerableLimitRuleTest.java
index e3b2ac30b97..ad6464771af 100644
--- a/core/src/test/java/org/apache/calcite/rel/rules/EnumerableLimitRuleTest.java
+++ b/core/src/test/java/org/apache/calcite/rel/rules/EnumerableLimitRuleTest.java
@@ -57,8 +57,7 @@ class EnumerableLimitRuleTest {
    */
   @Test void enumerableLimitOnEmptySort() throws Exception {
     RuleSet prepareRules =
-        RuleSets.ofList(
-            EnumerableRules.ENUMERABLE_FILTER_RULE,
+        RuleSets.ofList(EnumerableRules.ENUMERABLE_FILTER_RULE,
             EnumerableRules.ENUMERABLE_SORT_RULE,
             EnumerableRules.ENUMERABLE_LIMIT_RULE,
             EnumerableRules.ENUMERABLE_TABLE_SCAN_RULE);
@@ -85,8 +84,9 @@ class EnumerableLimitRuleTest {
     RelTraitSet desiredTraits = planBefore.getTraitSet()
         .replace(EnumerableConvention.INSTANCE);
     Program program = Programs.of(prepareRules);
-    RelNode planAfter = program.run(planBefore.getCluster().getPlanner(), planBefore,
-        desiredTraits, ImmutableList.of(), ImmutableList.of());
+    RelNode planAfter =
+        program.run(planBefore.getCluster().getPlanner(), planBefore,
+            desiredTraits, ImmutableList.of(), ImmutableList.of());
 
     // verify that the collation [0] is not lost in the final plan
     final RelCollation collation =
diff --git a/core/src/test/java/org/apache/calcite/rel/rules/SortRemoveRuleTest.java b/core/src/test/java/org/apache/calcite/rel/rules/SortRemoveRuleTest.java
index 20a6e43078f..fbea518b232 100644
--- a/core/src/test/java/org/apache/calcite/rel/rules/SortRemoveRuleTest.java
+++ b/core/src/test/java/org/apache/calcite/rel/rules/SortRemoveRuleTest.java
@@ -30,6 +30,7 @@
 import org.apache.calcite.sql.SqlExplainLevel;
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.sql.parser.SqlParser;
+import org.apache.calcite.sql2rel.SqlToRelConverter;
 import org.apache.calcite.tools.FrameworkConfig;
 import org.apache.calcite.tools.Frameworks;
 import org.apache.calcite.tools.Planner;
@@ -38,9 +39,11 @@
 import org.apache.calcite.tools.RuleSets;
 import org.apache.calcite.util.Util;
 
+import org.hamcrest.Matcher;
 import org.junit.jupiter.api.Test;
 
 import java.util.Arrays;
+import java.util.function.UnaryOperator;
 
 import static org.hamcrest.CoreMatchers.allOf;
 import static org.hamcrest.CoreMatchers.containsString;
@@ -52,32 +55,6 @@
  */
 public final class SortRemoveRuleTest {
 
-  /**
-   * The default schema that is used in these tests provides tables sorted on the primary key. Due
-   * to this scan operators always come with a {@link org.apache.calcite.rel.RelCollation} trait.
-   */
-  private RelNode transform(String sql, RuleSet prepareRules) throws Exception {
-    final SchemaPlus rootSchema = Frameworks.createRootSchema(true);
-    final SchemaPlus defSchema = rootSchema.add("hr", new HrClusteredSchema());
-    final FrameworkConfig config = Frameworks.newConfigBuilder()
-        .parserConfig(SqlParser.Config.DEFAULT)
-        .defaultSchema(defSchema)
-        .traitDefs(ConventionTraitDef.INSTANCE, RelCollationTraitDef.INSTANCE)
-        .programs(
-            Programs.of(prepareRules),
-            Programs.ofRules(CoreRules.SORT_REMOVE))
-        .build();
-    Planner planner = Frameworks.getPlanner(config);
-    SqlNode parse = planner.parse(sql);
-    SqlNode validate = planner.validate(parse);
-    RelRoot planRoot = planner.rel(validate);
-    RelNode planBefore = planRoot.rel;
-    RelTraitSet desiredTraits = planBefore.getTraitSet()
-        .replace(EnumerableConvention.INSTANCE);
-    RelNode planAfter = planner.transform(0, desiredTraits, planBefore);
-    return planner.transform(1, desiredTraits, planAfter);
-  }
-
   /** Test case for
    * <a href="https://issues.apache.org/jira/browse/CALCITE-2554">[CALCITE-2554]
    * Enrich enumerable join operators with order preserving information</a>.
@@ -87,8 +64,7 @@ private RelNode transform(String sql, RuleSet prepareRules) throws Exception {
    */
   @Test void removeSortOverEnumerableHashJoin() throws Exception {
     RuleSet prepareRules =
-        RuleSets.ofList(
-            CoreRules.SORT_PROJECT_TRANSPOSE,
+        RuleSets.ofList(CoreRules.SORT_PROJECT_TRANSPOSE,
             EnumerableRules.ENUMERABLE_JOIN_RULE,
             EnumerableRules.ENUMERABLE_PROJECT_RULE,
             EnumerableRules.ENUMERABLE_SORT_RULE,
@@ -99,12 +75,10 @@ private RelNode transform(String sql, RuleSet prepareRules) throws Exception {
               + joinType + " join \"hr\".\"depts\" d "
               + " on e.\"deptno\" = d.\"deptno\" "
               + "order by e.\"empid\" ";
-      RelNode actualPlan = transform(sql, prepareRules);
-      assertThat(
-          toString(actualPlan),
-          allOf(
-              containsString("EnumerableHashJoin"),
-              not(containsString("EnumerableSort"))));
+      new Fixture(sql, prepareRules)
+          .assertThatPlan(
+              allOf(containsString("EnumerableHashJoin"),
+                  not(containsString("EnumerableSort"))));
     }
   }
 
@@ -118,8 +92,7 @@ private RelNode transform(String sql, RuleSet prepareRules) throws Exception {
    */
   @Test void removeSortOverEnumerableNestedLoopJoin() throws Exception {
     RuleSet prepareRules =
-        RuleSets.ofList(
-            CoreRules.SORT_PROJECT_TRANSPOSE,
+        RuleSets.ofList(CoreRules.SORT_PROJECT_TRANSPOSE,
             EnumerableRules.ENUMERABLE_JOIN_RULE,
             EnumerableRules.ENUMERABLE_PROJECT_RULE,
             EnumerableRules.ENUMERABLE_SORT_RULE,
@@ -132,12 +105,10 @@ private RelNode transform(String sql, RuleSet prepareRules) throws Exception {
               + joinType + " join \"hr\".\"depts\" d "
               + " on e.\"deptno\" > d.\"deptno\" "
               + "order by e.\"empid\" ";
-      RelNode actualPlan = transform(sql, prepareRules);
-      assertThat(
-          toString(actualPlan),
-          allOf(
-              containsString("EnumerableNestedLoopJoin"),
-              not(containsString("EnumerableSort"))));
+      new Fixture(sql, prepareRules)
+          .assertThatPlan(
+              allOf(containsString("EnumerableNestedLoopJoin"),
+                  not(containsString("EnumerableSort"))));
     }
   }
 
@@ -152,8 +123,7 @@ private RelNode transform(String sql, RuleSet prepareRules) throws Exception {
    */
   @Test void removeSortOverEnumerableCorrelate() throws Exception {
     RuleSet prepareRules =
-        RuleSets.ofList(
-            CoreRules.SORT_PROJECT_TRANSPOSE,
+        RuleSets.ofList(CoreRules.SORT_PROJECT_TRANSPOSE,
             CoreRules.JOIN_TO_CORRELATE,
             EnumerableRules.ENUMERABLE_PROJECT_RULE,
             EnumerableRules.ENUMERABLE_CORRELATE_RULE,
@@ -165,7 +135,7 @@ private RelNode transform(String sql, RuleSet prepareRules) throws Exception {
               + joinType + " join \"hr\".\"depts\" d "
               + " on e.\"deptno\" = d.\"deptno\" "
               + "order by e.\"empid\" ";
-      RelNode actualPlan = transform(sql, prepareRules);
+      RelNode actualPlan = new Fixture(sql, prepareRules).plan();
       assertThat(
           toString(actualPlan),
           allOf(
@@ -183,8 +153,7 @@ private RelNode transform(String sql, RuleSet prepareRules) throws Exception {
    */
   @Test void removeSortOverEnumerableSemiJoin() throws Exception {
     RuleSet prepareRules =
-        RuleSets.ofList(
-            CoreRules.SORT_PROJECT_TRANSPOSE,
+        RuleSets.ofList(CoreRules.SORT_PROJECT_TRANSPOSE,
             CoreRules.PROJECT_TO_SEMI_JOIN,
             CoreRules.JOIN_TO_SEMI_JOIN,
             EnumerableRules.ENUMERABLE_PROJECT_RULE,
@@ -196,7 +165,9 @@ private RelNode transform(String sql, RuleSet prepareRules) throws Exception {
         "select e.\"deptno\" from \"hr\".\"emps\" e\n"
             + " where e.\"deptno\" in (select d.\"deptno\" from \"hr\".\"depts\" d)\n"
             + " order by e.\"empid\"";
-    RelNode actualPlan = transform(sql, prepareRules);
+    RelNode actualPlan = new Fixture(sql, prepareRules)
+        .withSqlToRel(c -> c.withExpand(true))
+        .plan();
     assertThat(
         toString(actualPlan),
         allOf(
@@ -204,9 +175,73 @@ private RelNode transform(String sql, RuleSet prepareRules) throws Exception {
             not(containsString("EnumerableSort"))));
   }
 
-  private String toString(RelNode rel) {
+  private static String toString(RelNode rel) {
     return Util.toLinux(
         RelOptUtil.dumpPlan("", rel, SqlExplainFormat.TEXT,
             SqlExplainLevel.DIGEST_ATTRIBUTES));
   }
+
+  /** Test fixture. */
+  private static class Fixture {
+    final RuleSet prepareRules;
+    final String sql;
+    final UnaryOperator<SqlToRelConverter.Config> sqlToRelConfigTransform;
+
+    Fixture(String sql, RuleSet prepareRules,
+        UnaryOperator<SqlToRelConverter.Config> sqlToRelConfigTransform) {
+      this.prepareRules = prepareRules;
+      this.sql = sql;
+      this.sqlToRelConfigTransform = sqlToRelConfigTransform;
+    }
+
+    Fixture(String sql, RuleSet prepareRules) {
+      this(sql, prepareRules, UnaryOperator.identity());
+    }
+
+    Fixture withSqlToRel(UnaryOperator<SqlToRelConverter.Config> transform) {
+      final UnaryOperator<SqlToRelConverter.Config> newTransform = c ->
+          transform.apply(this.sqlToRelConfigTransform.apply(c));
+      return new Fixture(sql, prepareRules, newTransform);
+    }
+
+    /**
+     * The default schema that is used in these tests provides tables sorted on the primary key. Due
+     * to this scan operators always come with a {@link org.apache.calcite.rel.RelCollation} trait.
+     */
+    RelNode plan() throws Exception {
+      final SchemaPlus rootSchema = Frameworks.createRootSchema(true);
+      final SchemaPlus defSchema = rootSchema.add("hr", new HrClusteredSchema());
+      final FrameworkConfig config = Frameworks.newConfigBuilder()
+          .parserConfig(SqlParser.Config.DEFAULT)
+          .sqlToRelConverterConfig(
+              sqlToRelConfigTransform.apply(SqlToRelConverter.config()))
+          .defaultSchema(defSchema)
+          .traitDefs(ConventionTraitDef.INSTANCE, RelCollationTraitDef.INSTANCE)
+          .programs(
+              Programs.of(prepareRules),
+              Programs.ofRules(CoreRules.SORT_REMOVE))
+          .build();
+      Planner planner = Frameworks.getPlanner(config);
+      SqlNode parse = planner.parse(sql);
+      SqlNode validate = planner.validate(parse);
+      RelRoot planRoot = planner.rel(validate);
+      RelNode planBefore = planRoot.rel;
+      RelTraitSet desiredTraits = planBefore.getTraitSet()
+          .replace(EnumerableConvention.INSTANCE);
+      RelNode planAfter = planner.transform(0, desiredTraits, planBefore);
+      return planner.transform(1, desiredTraits, planAfter);
+    }
+
+    Fixture assertThatPlan(Matcher<String> matcher) {
+      try {
+        RelNode actualPlan = plan();
+        assertThat(
+            SortRemoveRuleTest.toString(actualPlan),
+            matcher);
+      } catch (Exception e) {
+        throw new RuntimeException(e);
+      }
+      return this;
+    }
+  }
 }
diff --git a/core/src/test/java/org/apache/calcite/rex/RexBuilderTest.java b/core/src/test/java/org/apache/calcite/rex/RexBuilderTest.java
index 5b0ee198c95..41e52b185ea 100644
--- a/core/src/test/java/org/apache/calcite/rex/RexBuilderTest.java
+++ b/core/src/test/java/org/apache/calcite/rex/RexBuilderTest.java
@@ -17,6 +17,7 @@
 package org.apache.calcite.rex;
 
 import org.apache.calcite.avatica.util.ByteString;
+import org.apache.calcite.avatica.util.TimeUnit;
 import org.apache.calcite.rel.core.CorrelationId;
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeFactory;
@@ -27,10 +28,12 @@
 import org.apache.calcite.rel.type.RelDataTypeSystemImpl;
 import org.apache.calcite.sql.SqlCollation;
 import org.apache.calcite.sql.SqlKind;
+import org.apache.calcite.sql.fun.SqlLibraryOperators;
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
 import org.apache.calcite.sql.type.BasicSqlType;
 import org.apache.calcite.sql.type.SqlTypeFactoryImpl;
 import org.apache.calcite.sql.type.SqlTypeName;
+import org.apache.calcite.test.RexImplicationCheckerFixtures;
 import org.apache.calcite.util.DateString;
 import org.apache.calcite.util.Litmus;
 import org.apache.calcite.util.NlsString;
@@ -97,10 +100,12 @@ private static class MySqlTypeFactoryImpl extends SqlTypeFactoryImpl {
     final RelDataTypeFactory typeFactory = new SqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT);
     RexBuilder builder = new RexBuilder(typeFactory);
 
-    RexNode node =  new RexLiteral(
-            Boolean.TRUE, typeFactory.createSqlType(SqlTypeName.BOOLEAN), SqlTypeName.BOOLEAN);
-    RexNode ensuredNode = builder.ensureType(
-            typeFactory.createSqlType(SqlTypeName.ANY), node, true);
+    RexNode node =
+        new RexLiteral(Boolean.TRUE,
+            typeFactory.createSqlType(SqlTypeName.BOOLEAN), SqlTypeName.BOOLEAN);
+    RexNode ensuredNode =
+        builder.ensureType(typeFactory.createSqlType(SqlTypeName.ANY), node,
+            true);
 
     assertEquals(node, ensuredNode);
   }
@@ -112,10 +117,12 @@ private static class MySqlTypeFactoryImpl extends SqlTypeFactoryImpl {
     final RelDataTypeFactory typeFactory = new SqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT);
     RexBuilder builder = new RexBuilder(typeFactory);
 
-    RexNode node =  new RexLiteral(
-            Boolean.TRUE, typeFactory.createSqlType(SqlTypeName.BOOLEAN), SqlTypeName.BOOLEAN);
-    RexNode ensuredNode = builder.ensureType(
-            typeFactory.createSqlType(SqlTypeName.BOOLEAN), node, true);
+    RexNode node =
+        new RexLiteral(Boolean.TRUE,
+            typeFactory.createSqlType(SqlTypeName.BOOLEAN), SqlTypeName.BOOLEAN);
+    RexNode ensuredNode =
+        builder.ensureType(typeFactory.createSqlType(SqlTypeName.BOOLEAN), node,
+            true);
 
     assertEquals(node, ensuredNode);
   }
@@ -127,10 +134,12 @@ private static class MySqlTypeFactoryImpl extends SqlTypeFactoryImpl {
     final RelDataTypeFactory typeFactory = new SqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT);
     RexBuilder builder = new RexBuilder(typeFactory);
 
-    RexNode node =  new RexLiteral(
-            Boolean.TRUE, typeFactory.createSqlType(SqlTypeName.BOOLEAN), SqlTypeName.BOOLEAN);
-    RexNode ensuredNode = builder.ensureType(
-            typeFactory.createSqlType(SqlTypeName.INTEGER), node, true);
+    RexNode node =
+        new RexLiteral(Boolean.TRUE,
+            typeFactory.createSqlType(SqlTypeName.BOOLEAN), SqlTypeName.BOOLEAN);
+    RexNode ensuredNode =
+        builder.ensureType(typeFactory.createSqlType(SqlTypeName.INTEGER), node,
+            true);
 
     assertNotEquals(node, ensuredNode);
     assertEquals(ensuredNode.getType(), typeFactory.createSqlType(SqlTypeName.INTEGER));
@@ -191,6 +200,16 @@ private static class MySqlTypeFactoryImpl extends SqlTypeFactoryImpl {
     final RexLiteral literal4 = builder.makeLiteral(ts4, timestampType18);
     assertThat(literal4.getValueAs(TimestampString.class).toString(),
         is("1969-07-21 02:56:15.102"));
+  }
+
+  @Test void testTimestampString() {
+    final TimestampString ts = new TimestampString(1969, 7, 21, 2, 56, 15);
+    assertThat(ts.toString(), is("1969-07-21 02:56:15"));
+    assertThat(ts.round(1), is(ts));
+
+    // Now with milliseconds
+    final TimestampString ts2 = ts.withMillis(56);
+    assertThat(ts2.toString(), is("1969-07-21 02:56:15.056"));
 
     // toString
     assertThat(ts2.round(1).toString(), is("1969-07-21 02:56:15"));
@@ -207,8 +226,67 @@ private static class MySqlTypeFactoryImpl extends SqlTypeFactoryImpl {
     assertThat(ts2.round(0).toString(1), is("1969-07-21 02:56:15.0"));
     assertThat(ts2.round(0).toString(2), is("1969-07-21 02:56:15.00"));
 
-    assertThat(TimestampString.fromMillisSinceEpoch(1456513560123L).toString(),
-        is("2016-02-26 19:06:00.123"));
+    // Now with milliseconds ending in zero (3 equivalent strings).
+    final TimestampString ts3 = ts.withMillis(10);
+    assertThat(ts3.toString(), is("1969-07-21 02:56:15.01"));
+
+    final TimestampString ts3b = new TimestampString("1969-07-21 02:56:15.01");
+    assertThat(ts3b.toString(), is("1969-07-21 02:56:15.01"));
+    assertThat(ts3b, is(ts3));
+
+    final TimestampString ts3c = new TimestampString("1969-07-21 02:56:15.010");
+    assertThat(ts3c.toString(), is("1969-07-21 02:56:15.01"));
+    assertThat(ts3c, is(ts3));
+
+    // Now with nanoseconds
+    final TimestampString ts4 = ts.withNanos(56);
+    assertThat(ts4.toString(), is("1969-07-21 02:56:15.000000056"));
+
+    // Check rounding; uses RoundingMode.DOWN
+    final TimestampString ts5 = ts.withNanos(2345670);
+    assertThat(ts5.toString(), is("1969-07-21 02:56:15.00234567"));
+    assertThat(ts5.round(0).toString(), is("1969-07-21 02:56:15"));
+    assertThat(ts5.round(1).toString(), is("1969-07-21 02:56:15"));
+    assertThat(ts5.round(2).toString(), is("1969-07-21 02:56:15"));
+    assertThat(ts5.round(3).toString(), is("1969-07-21 02:56:15.002"));
+    assertThat(ts5.round(4).toString(), is("1969-07-21 02:56:15.0023"));
+    assertThat(ts5.round(5).toString(), is("1969-07-21 02:56:15.00234"));
+    assertThat(ts5.round(6).toString(), is("1969-07-21 02:56:15.002345"));
+    assertThat(ts5.round(600).toString(), is("1969-07-21 02:56:15.00234567"));
+
+    // Now with a very long fraction
+    final TimestampString ts6 = ts.withFraction("102030405060708090102");
+    assertThat(ts6.toString(), is("1969-07-21 02:56:15.102030405060708090102"));
+
+    // From milliseconds
+    final TimestampString ts7 =
+        TimestampString.fromMillisSinceEpoch(1456513560123L);
+    assertThat(ts7.toString(), is("2016-02-26 19:06:00.123"));
+
+    final TimestampString ts8 =
+        TimestampString.fromMillisSinceEpoch(1456513560120L);
+    assertThat(ts8.toString(), is("2016-02-26 19:06:00.12"));
+
+    final TimestampString ts9 = ts8.withFraction("9876543210");
+    assertThat(ts9.toString(), is("2016-02-26 19:06:00.987654321"));
+
+    // TimestampString.toCalendar
+    final Calendar c = ts9.toCalendar();
+    assertThat(c.get(Calendar.ERA), is(1)); // CE
+    assertThat(c.get(Calendar.YEAR), is(2016));
+    assertThat(c.get(Calendar.MONTH), is(1)); // February
+    assertThat(c.get(Calendar.DATE), is(26));
+    assertThat(c.get(Calendar.HOUR_OF_DAY), is(19));
+    assertThat(c.get(Calendar.MINUTE), is(6));
+    assertThat(c.get(Calendar.SECOND), is(0));
+    assertThat(c.get(Calendar.MILLISECOND), is(987)); // RoundingMode.DOWN
+    assertThat(ts9.getMillisSinceEpoch(), is(c.getTimeInMillis()));
+
+    // TimestampString.fromCalendarFields
+    c.set(Calendar.YEAR, 1969);
+    final TimestampString ts10 = TimestampString.fromCalendarFields(c);
+    assertThat(ts10.toString(), is("1969-02-26 19:06:00.987"));
+    assertThat(ts10.getMillisSinceEpoch(), is(c.getTimeInMillis()));
   }
 
   private void checkTimestamp(RexLiteral literal) {
@@ -237,8 +315,9 @@ private void checkTimestamp(RexLiteral literal) {
     final RexBuilder builder = new RexBuilder(typeFactory);
 
     // The new way
-    final TimestampWithTimeZoneString ts = new TimestampWithTimeZoneString(
-        1969, 7, 21, 2, 56, 15, TimeZone.getTimeZone("PST").getID());
+    final TimestampWithTimeZoneString ts =
+        new TimestampWithTimeZoneString(1969, 7, 21, 2, 56, 15,
+            TimeZone.getTimeZone("PST").getID());
     checkTimestampWithLocalTimeZone(
         builder.makeLiteral(ts.getLocalTimestampString(), timestampType));
 
@@ -560,29 +639,29 @@ private void checkDate(RexLiteral literal) {
 
     RexLiteral literal = builder.makePreciseStringLiteral("foobar");
     assertEquals("'foobar'", literal.toString());
-    literal = builder.makePreciseStringLiteral(
-        new ByteString(new byte[] { 'f', 'o', 'o', 'b', 'a', 'r'}),
-        "UTF8",
-        SqlCollation.IMPLICIT);
+    literal =
+        builder.makePreciseStringLiteral(
+            new ByteString(new byte[] { 'f', 'o', 'o', 'b', 'a', 'r'}),
+            "UTF8", SqlCollation.IMPLICIT);
     assertEquals("_UTF8'foobar'", literal.toString());
     assertEquals("_UTF8'foobar':CHAR(6) CHARACTER SET \"UTF-8\"",
         literal.computeDigest(RexDigestIncludeType.ALWAYS));
-    literal = builder.makePreciseStringLiteral(
-        new ByteString("\u82f1\u56fd".getBytes(StandardCharsets.UTF_8)),
-        "UTF8",
-        SqlCollation.IMPLICIT);
+    literal =
+        builder.makePreciseStringLiteral(
+            new ByteString("\u82f1\u56fd".getBytes(StandardCharsets.UTF_8)),
+            "UTF8", SqlCollation.IMPLICIT);
     assertEquals("_UTF8'\u82f1\u56fd'", literal.toString());
     // Test again to check decode cache.
-    literal = builder.makePreciseStringLiteral(
-        new ByteString("\u82f1".getBytes(StandardCharsets.UTF_8)),
-        "UTF8",
-        SqlCollation.IMPLICIT);
+    literal =
+        builder.makePreciseStringLiteral(
+            new ByteString("\u82f1".getBytes(StandardCharsets.UTF_8)),
+            "UTF8", SqlCollation.IMPLICIT);
     assertEquals("_UTF8'\u82f1'", literal.toString());
     try {
-      literal = builder.makePreciseStringLiteral(
-          new ByteString("\u82f1\u56fd".getBytes(StandardCharsets.UTF_8)),
-          "GB2312",
-          SqlCollation.IMPLICIT);
+      literal =
+          builder.makePreciseStringLiteral(
+              new ByteString("\u82f1\u56fd".getBytes(StandardCharsets.UTF_8)),
+              "GB2312", SqlCollation.IMPLICIT);
       fail("expected exception, got " + literal);
     } catch (RuntimeException e) {
       assertThat(e.getMessage(), containsString("Failed to encode"));
@@ -624,6 +703,44 @@ private void checkDate(RexLiteral literal) {
     assertThat(inCall.getKind(), is(SqlKind.SEARCH));
   }
 
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-4632">[CALCITE-4632]
+   * Find the least restrictive datatype for SARG</a>. */
+  @Test void testLeastRestrictiveTypeForSargMakeIn() {
+    final RelDataTypeFactory typeFactory = new SqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT);
+    final RexBuilder rexBuilder = new RexBuilder(typeFactory);
+    final RelDataType decimalType = typeFactory.createSqlType(SqlTypeName.DECIMAL);
+    RexNode left = rexBuilder.makeInputRef(decimalType, 0);
+    final RexNode literal1 = rexBuilder.makeExactLiteral(new BigDecimal("1.0"));
+    final RexNode literal2 = rexBuilder.makeExactLiteral(new BigDecimal("20000.0"));
+
+    RexNode inCall = rexBuilder.makeIn(left, ImmutableList.of(literal1, literal2));
+    assertThat(inCall.getKind(), is(SqlKind.SEARCH));
+
+    final RexNode sarg = ((RexCall) inCall).operands.get(1);
+    RelDataType expected = typeFactory.createSqlType(SqlTypeName.DECIMAL, 6, 1);
+    assertEquals(sarg.getType(), expected);
+  }
+
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-4632">[CALCITE-4632]
+   * Find the least restrictive datatype for SARG</a>. */
+  @Test void testLeastRestrictiveTypeForSargMakeBetween() {
+    final RelDataTypeFactory typeFactory = new SqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT);
+    final RexBuilder rexBuilder = new RexBuilder(typeFactory);
+    final RelDataType decimalType = typeFactory.createSqlType(SqlTypeName.DECIMAL);
+    RexNode left = rexBuilder.makeInputRef(decimalType, 0);
+    final RexNode literal1 = rexBuilder.makeExactLiteral(new BigDecimal("1.0"));
+    final RexNode literal2 = rexBuilder.makeExactLiteral(new BigDecimal("20000.0"));
+
+    RexNode betweenCall = rexBuilder.makeBetween(left, literal1, literal2);
+    assertThat(betweenCall.getKind(), is(SqlKind.SEARCH));
+
+    final RexNode sarg = ((RexCall) betweenCall).operands.get(1);
+    RelDataType expected = typeFactory.createSqlType(SqlTypeName.DECIMAL, 6, 1);
+    assertEquals(sarg.getType(), expected);
+  }
+
   /** Tests {@link RexCopier#visitOver(RexOver)}. */
   @Test void testCopyOver() {
     final RelDataTypeFactory sourceTypeFactory =
@@ -634,16 +751,16 @@ private void checkDate(RexLiteral literal) {
         new MySqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT);
     final RexBuilder builder = new RexBuilder(targetTypeFactory);
 
-    final RexOver node = (RexOver) builder.makeOver(type,
-        SqlStdOperatorTable.COUNT,
-        ImmutableList.of(builder.makeInputRef(type, 0)),
-        ImmutableList.of(builder.makeInputRef(type, 1)),
-        ImmutableList.of(
-            new RexFieldCollation(
-                builder.makeInputRef(type, 2), ImmutableSet.of())),
-        RexWindowBounds.UNBOUNDED_PRECEDING,
-        RexWindowBounds.CURRENT_ROW,
-        true, true, false, false, false);
+    final RexOver node =
+        (RexOver) builder.makeOver(type, SqlStdOperatorTable.COUNT,
+            ImmutableList.of(builder.makeInputRef(type, 0)),
+            ImmutableList.of(builder.makeInputRef(type, 1)),
+            ImmutableList.of(
+                new RexFieldCollation(builder.makeInputRef(type, 2),
+                    ImmutableSet.of())),
+            RexWindowBounds.UNBOUNDED_PRECEDING,
+            RexWindowBounds.CURRENT_ROW,
+            true, true, false, false, false);
     final RexNode copy = builder.copy(node);
     assertTrue(copy instanceof RexOver);
 
@@ -759,8 +876,9 @@ private void checkBigDecimalLiteral(RexBuilder builder, String val) {
     RelDataType intType = typeFactory.createSqlType(SqlTypeName.INTEGER);
     RelDataType longType = typeFactory.createSqlType(SqlTypeName.BIGINT);
 
-    RelDataType structType = typeFactory.createStructType(
-        Arrays.asList(intType, longType), Arrays.asList("x", "y"));
+    RelDataType structType =
+        typeFactory.createStructType(Arrays.asList(intType, longType),
+            Arrays.asList("x", "y"));
     RexInputRef inputRef = builder.makeInputRef(structType, 0);
 
     // construct RexFieldAccess fails because of negative index
@@ -812,4 +930,34 @@ private static class UDT extends RelDataTypeImpl {
     // and the suffix should not be removed.
     assertThat(literal.digest, is("0L:(udt)NOT NULL"));
   }
+
+
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5489">[CALCITE-5489]
+   * RexCall to TIMESTAMP_DIFF function fails to convert a TIMESTAMP literal to
+   * a org.apache.calcite.avatica.util.TimeUnit</a>. */
+  @Test void testTimestampDiffCall() {
+    final RexImplicationCheckerFixtures.Fixture f =
+        new RexImplicationCheckerFixtures.Fixture();
+    final TimestampString ts =
+        TimestampString.fromCalendarFields(Util.calendar());
+    final RexNode literal = f.timestampLiteral(ts);
+    final RexLiteral flag = f.rexBuilder.makeFlag(TimeUnit.QUARTER);
+    assertThat(
+        f.rexBuilder.makeCall(SqlLibraryOperators.DATEDIFF,
+            flag, literal, literal),
+        notNullValue());
+    assertThat(
+        f.rexBuilder.makeCall(SqlStdOperatorTable.TIMESTAMP_DIFF,
+            flag, literal, literal),
+        notNullValue());
+    assertThat(
+        f.rexBuilder.makeCall(SqlLibraryOperators.TIMESTAMP_DIFF3,
+            literal, literal, flag),
+        notNullValue());
+    assertThat(
+        f.rexBuilder.makeCall(SqlLibraryOperators.TIME_DIFF,
+            literal, literal, flag),
+        notNullValue());
+  }
 }
diff --git a/core/src/test/java/org/apache/calcite/rex/RexExecutorTest.java b/core/src/test/java/org/apache/calcite/rex/RexExecutorTest.java
index 942d76351fb..ee77ac126ee 100644
--- a/core/src/test/java/org/apache/calcite/rex/RexExecutorTest.java
+++ b/core/src/test/java/org/apache/calcite/rex/RexExecutorTest.java
@@ -98,8 +98,8 @@ protected void check(final Action action) {
           .add("someStr", varchar)
           .build();
 
-      final RexExecutable exec = executor.getExecutable(rexBuilder,
-          constExps, rowType);
+      final RexExecutable exec =
+          executor.getExecutable(rexBuilder, constExps, rowType);
       exec.setDataContext(testContext);
       values[0] = "Hello World";
       Object[] result = exec.execute();
diff --git a/core/src/test/java/org/apache/calcite/rex/RexProgramBuilderBase.java b/core/src/test/java/org/apache/calcite/rex/RexProgramBuilderBase.java
index b6a1470d300..dfa1269addc 100644
--- a/core/src/test/java/org/apache/calcite/rex/RexProgramBuilderBase.java
+++ b/core/src/test/java/org/apache/calcite/rex/RexProgramBuilderBase.java
@@ -241,7 +241,7 @@ protected RexNode case_(Iterable<? extends RexNode> nodes) {
    * @return call to CAST operator
    */
   protected RexNode abstractCast(RexNode e, RelDataType type) {
-    return rexBuilder.makeAbstractCast(type, e);
+    return rexBuilder.makeAbstractCast(type, e, false);
   }
 
   /**
@@ -321,11 +321,7 @@ protected RexNode add(RexNode n1, RexNode n2) {
   }
 
   protected RexNode item(RexNode inputRef, RexNode literal) {
-    RexNode rexNode = rexBuilder.makeCall(
-        SqlStdOperatorTable.ITEM,
-        inputRef,
-        literal);
-    return rexNode;
+    return rexBuilder.makeCall(SqlStdOperatorTable.ITEM, inputRef, literal);
   }
 
   /**
diff --git a/core/src/test/java/org/apache/calcite/rex/RexProgramTest.java b/core/src/test/java/org/apache/calcite/rex/RexProgramTest.java
index 081d18696d6..6b094e1f542 100644
--- a/core/src/test/java/org/apache/calcite/rex/RexProgramTest.java
+++ b/core/src/test/java/org/apache/calcite/rex/RexProgramTest.java
@@ -24,10 +24,12 @@
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeFactory;
 import org.apache.calcite.rel.type.RelDataTypeImpl;
+import org.apache.calcite.sql.SqlBasicFunction;
 import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.SqlOperator;
 import org.apache.calcite.sql.SqlSpecialOperator;
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
+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;
@@ -231,37 +233,26 @@ private RexProgramBuilder createProg(int variant) {
     // $t0 = x
     // $t1 = y
     // $t2 = $t0 + 1 (i.e. x + 1)
-    final RexNode i0 = rexBuilder.makeInputRef(
-        types.get(0), 0);
+    final RexNode i0 = rexBuilder.makeInputRef(types.get(0), 0);
     RexLocalRef t2 =
         builder.addExpr(
-            rexBuilder.makeCall(
-                SqlStdOperatorTable.PLUS,
-                i0, literal(1)));
+            rexBuilder.makeCall(SqlStdOperatorTable.PLUS, i0, literal(1)));
     // $t3 = 77 (not used)
-    RexLocalRef t3 =
-        builder.addExpr(literal(77));
+    RexLocalRef t3 = builder.addExpr(literal(77));
     Util.discard(t3);
     // $t4 = $t0 + $t1 (i.e. x + y)
-    final RexNode i1 = rexBuilder.makeInputRef(
-        types.get(1), 1);
+    final RexNode i1 = rexBuilder.makeInputRef(types.get(1), 1);
     RexLocalRef t4 =
-        builder.addExpr(
-            rexBuilder.makeCall(
-                SqlStdOperatorTable.PLUS,
-                i0,
-                i1));
+        builder.addExpr(rexBuilder.makeCall(SqlStdOperatorTable.PLUS, i0, i1));
     RexLocalRef t5;
     final RexLocalRef t1;
     switch (variant) {
     case 0:
     case 2:
       // $t5 = $t0 + $t0 (i.e. x + x)
-      t5 = builder.addExpr(
-          rexBuilder.makeCall(
-              SqlStdOperatorTable.PLUS,
-              i0,
-              i0));
+      t5 =
+          builder.addExpr(
+              rexBuilder.makeCall(SqlStdOperatorTable.PLUS, i0, i0));
       t1 = null;
       break;
     case 1:
@@ -405,8 +396,11 @@ private RexProgramBuilder createProg(int variant) {
 
     // If i0 is null, then "i0 is not null" is false
     RexNode i0NotNull = isNotNull(i0);
+    RexNode i1NotNull = isNotNull(i1);
     assertThat(Strong.isNull(i0NotNull, c0), is(false));
     assertThat(Strong.isNotTrue(i0NotNull, c0), is(true));
+    assertThat(Strong.isNotTrue(or(i0NotNull, i1NotNull), c01), is(true));
+    assertThat(Strong.isNotTrue(and(i0NotNull, i1NotNull), c1), is(true));
 
     // If i0 is null, then "not(i0 is not null)" is true.
     // Join-strengthening relies on this.
@@ -1240,6 +1234,20 @@ private void checkExponentialCnf(int n) {
         RelOptPredicateList.of(rexBuilder,
             ImmutableList.of(le(aRef, literal(5)), le(bRef, literal(5)))),
         "false");
+
+    // condition "(a >= 1 and a <= 3) or (a >= 2 and a <= 4)"
+    // yelds "a >= 1 and a <= 4"
+    checkSimplifyFilter(
+        or(and(ge(aRef, literal(1)), le(aRef, literal(3))),
+            and(ge(aRef, literal(2)), le(aRef, literal(4)))),
+        "SEARCH(?0.a, Sarg[[1..4]])");
+
+    // condition "(a >= 1 and a <= 3) or (a >= 0 and a <= 2)"
+    // yelds "a >= 0 and a <= 3"
+    checkSimplifyFilter(
+        or(and(ge(aRef, literal(1)), le(aRef, literal(3))),
+            and(ge(aRef, literal(0)), le(aRef, literal(2)))),
+        "SEARCH(?0.a, Sarg[[0..3]])");
   }
 
   /** Test case for
@@ -1443,11 +1451,16 @@ private void checkExponentialCnf(int n) {
         "true");
 
     // "a = 1 or a <> 2" could (and should) be simplified to "a <> 2"
-    // but can't do that right now
     checkSimplifyFilter(
         or(eq(aRef, literal1),
             ne(aRef, literal2)),
-        "OR(=(?0.a, 1), <>(?0.a, 2))");
+        "<>(?0.a, 2)");
+
+    // "a < 1 or a > 1" ==> "a <> 1"
+    checkSimplifyFilter(
+        or(lt(aRef, literal1),
+            gt(aRef, literal1)),
+        "<>(?0.a, 1)");
 
     // "(a >= 1 and a <= 3) or a <> 2", or equivalently
     // "a between 1 and 3 or a <> 2" ==> "true"
@@ -1593,13 +1606,14 @@ private void checkExponentialCnf(int n) {
   @Test void testSimplifyRange() {
     final RexNode aRef = input(tInt(), 0);
     // ((0 < a and a <= 10) or a >= 15) and a <> 6 and a <> 12
-    RexNode expr = and(
-        or(
-            and(lt(literal(0), aRef),
-                le(aRef, literal(10))),
-            ge(aRef, literal(15))),
-        ne(aRef, literal(6)),
-        ne(aRef, literal(12)));
+    RexNode expr =
+        and(
+            or(
+                and(lt(literal(0), aRef),
+                    le(aRef, literal(10))),
+                ge(aRef, literal(15))),
+            ne(aRef, literal(6)),
+            ne(aRef, literal(12)));
     final String simplified =
         "SEARCH($0, Sarg[(0..6), (6..10], [15..+\u221e)])";
     final String expanded = "OR(AND(>($0, 0), <($0, 6)), AND(>($0, 6),"
@@ -1611,8 +1625,9 @@ private void checkExponentialCnf(int n) {
   @Test void testSimplifyRange2() {
     final RexNode aRef = input(tInt(true), 0);
     // a is null or a >= 15
-    RexNode expr = or(isNull(aRef),
-        ge(aRef, literal(15)));
+    RexNode expr =
+        or(isNull(aRef),
+            ge(aRef, literal(15)));
     checkSimplify(expr, "SEARCH($0, Sarg[[15..+\u221e); NULL AS TRUE])")
         .expandedSearch("OR(IS NULL($0), >=($0, 15))");
   }
@@ -1623,13 +1638,14 @@ private void checkExponentialCnf(int n) {
   @Test void testSimplifyRange3() {
     final RexNode aRef = input(tInt(true), 0);
     // (0 < a and a <= 10) or a is null or (8 < a and a < 12) or a >= 15
-    RexNode expr = or(
-        and(lt(literal(0), aRef),
-            le(aRef, literal(10))),
-        isNull(aRef),
-        and(lt(literal(8), aRef),
-            lt(aRef, literal(12))),
-        ge(aRef, literal(15)));
+    RexNode expr =
+        or(
+            and(lt(literal(0), aRef),
+                le(aRef, literal(10))),
+            isNull(aRef),
+            and(lt(literal(8), aRef),
+                lt(aRef, literal(12))),
+            ge(aRef, literal(15)));
     // [CALCITE-4190] causes "or a >= 15" to disappear from the simplified form.
     final String simplified =
         "SEARCH($0, Sarg[(0..12), [15..+\u221e); NULL AS TRUE])";
@@ -1642,9 +1658,10 @@ private void checkExponentialCnf(int n) {
   @Test void testSimplifyRange4() {
     final RexNode aRef = input(tInt(true), 0);
     // not (a = 3 or a = 5)
-    RexNode expr = not(
-        or(eq(aRef, literal(3)),
-            eq(aRef, literal(5))));
+    RexNode expr =
+        not(
+            or(eq(aRef, literal(3)),
+                eq(aRef, literal(5))));
     final String expected =
         "SEARCH($0, Sarg[(-\u221e..3), (3..5), (5..+\u221e)])";
     final String expanded = "AND(<>($0, 3), <>($0, 5))";
@@ -1655,11 +1672,12 @@ private void checkExponentialCnf(int n) {
   @Test void testSimplifyRange5() {
     final RexNode aRef = input(tInt(true), 0);
     // not (a = 3 or a = 5) or a is null
-    RexNode expr = or(
-        not(
-            or(eq(aRef, literal(3)),
-                eq(aRef, literal(5)))),
-        isNull(aRef));
+    RexNode expr =
+        or(
+            not(
+                or(eq(aRef, literal(3)),
+                    eq(aRef, literal(5)))),
+            isNull(aRef));
     final String simplified =
         "SEARCH($0, Sarg[(-\u221e..3), (3..5), (5..+\u221e); NULL AS TRUE])";
     final String expanded = "OR(IS NULL($0), AND(<>($0, 3), <>($0, 5)))";
@@ -1685,10 +1703,10 @@ private void checkExponentialCnf(int n) {
   @Test void testSimplifyRange7() {
     final RexNode aRef = input(tInt(true), 0);
     // a is not null and a > 3 and a < 10
-    RexNode expr = and(
-        isNotNull(aRef),
-        gt(aRef, literal(3)),
-        lt(aRef, literal(10)));
+    RexNode expr =
+        and(isNotNull(aRef),
+            gt(aRef, literal(3)),
+            lt(aRef, literal(10)));
     final String simplified = "SEARCH($0, Sarg[(3..10); NULL AS FALSE])";
     final String expanded = "AND(IS NOT NULL($0), AND(>($0, 3), <($0, 10)))";
     checkSimplify(expr, simplified)
@@ -1702,10 +1720,11 @@ private void checkExponentialCnf(int n) {
     final RexNode aRef = input(tInt(true), 0);
     final RexNode bRef = input(tInt(true), 1);
     // (0 < a and a < 10) and b is not null
-    RexNode expr = and(
-        and(lt(literal(0), aRef),
-            lt(aRef, literal(10))),
-        isNotNull(bRef));
+    RexNode expr =
+        and(
+            and(lt(literal(0), aRef),
+                lt(aRef, literal(10))),
+            isNotNull(bRef));
     // [CALCITE-4352] causes "and b is not null" to disappear from the expanded
     // form.
     final String simplified = "AND(SEARCH($0, Sarg[(0..10)]), IS NOT NULL($1))";
@@ -1740,31 +1759,35 @@ private void checkExponentialCnf(int n) {
     // =>
     // "=(CAST(?0.int0):INTEGER NOT NULL, 5)"
     checkSimplify(
-        and(ne(rexBuilder.makeCast(intType, intExpr, true), literal3),
-                    eq(rexBuilder.makeCast(intType, intExpr, true), literal5)),
+        and(ne(rexBuilder.makeCast(intType, intExpr, true, false), literal3),
+                    eq(rexBuilder.makeCast(intType, intExpr, true, false), literal5)),
             "=(CAST(?0.int0):INTEGER NOT NULL, 5)");
     // "AND(<>(CAST(?0.int0):INTEGER NOT NULL, 3), =(CAST(?0.int0):INTEGER NOT NULL, 5))"
     // =>
     // "=(CAST(?0.int0):INTEGER NOT NULL, 5)"
     checkSimplify(
-        and(ne(rexBuilder.makeCast(intType, intExpr, true), literal3),
-                    eq(rexBuilder.makeCast(intType, intExpr, true), literal5)),
+        and(ne(rexBuilder.makeCast(intType, intExpr, true, false), literal3),
+                    eq(rexBuilder.makeCast(intType, intExpr, true, false), literal5)),
             "=(CAST(?0.int0):INTEGER NOT NULL, 5)");
     // "AND(<>(CAST(?0.int0):INTEGER NOT NULL, 3), =(?0.int0, 5))"
     // =>
     // "AND(<>(CAST(?0.int0):INTEGER NOT NULL, 3), =(?0.int0, 5))"
     checkSimplifyUnchanged(
-        and(ne(rexBuilder.makeCast(intType, intExpr, true), literal3), eq(intExpr, literal5)));
+        and(
+            ne(
+            rexBuilder.makeCast(intType, intExpr, true, false),
+            literal3), eq(intExpr, literal5)));
   }
 
   @Test void testSimplifyAndIsNull() {
     final RexNode aRef = input(tInt(true), 0);
     final RexNode bRef = input(tInt(true), 1);
     // (0 < a and a < 10) and b is null
-    RexNode expr = and(
-        and(lt(literal(0), aRef),
-            lt(aRef, literal(10))),
-        isNull(bRef));
+    RexNode expr =
+        and(
+            and(lt(literal(0), aRef),
+                lt(aRef, literal(10))),
+            isNull(bRef));
     // [CALCITE-4352] causes "and b is null" to disappear from the expanded
     // form.
     final String simplified = "AND(SEARCH($0, Sarg[(0..10)]), IS NULL($1))";
@@ -1789,13 +1812,11 @@ private void checkExponentialCnf(int n) {
   }
 
   @Test void testSimplifyNotAnd() {
-    final RexNode e = or(
-        le(
-            vBool(1),
-            literal(true)),
-        eq(
-            literal(false),
-            eq(literal(false), vBool(1))));
+    final RexNode e =
+        or(
+            le(vBool(1), literal(true)),
+            eq(literal(false),
+                eq(literal(false), vBool(1))));
     checkSimplify(e, "OR(<=(?0.bool1, true), ?0.bool1)");
   }
 
@@ -2056,10 +2077,10 @@ trueLiteral, literal(1),
   }
 
   @Test void testSimplifyCaseAndNotSimplificationIsInAction() {
-    RexNode caseNode = case_(
-        eq(vIntNotNull(), literal(0)), falseLiteral,
-        eq(vIntNotNull(), literal(1)), trueLiteral,
-        falseLiteral);
+    RexNode caseNode =
+        case_(eq(vIntNotNull(), literal(0)), falseLiteral,
+            eq(vIntNotNull(), literal(1)), trueLiteral,
+            falseLiteral);
     checkSimplify(caseNode, "=(?0.notNullInt0, 1)");
   }
 
@@ -2087,9 +2108,10 @@ trueLiteral, literal(1),
   @Test void testSimplifyCaseCompactionDiv() {
     // FIXME: RexInterpreter currently evaluates children beforehand.
     simplify = simplify.withParanoid(false);
-    RexNode caseNode = case_(vBool(0), vInt(0),
-        eq(div(literal(3), vIntNotNull()), literal(11)), vInt(0),
-        vInt(1));
+    RexNode caseNode =
+        case_(vBool(0), vInt(0),
+            eq(div(literal(3), vIntNotNull()), literal(11)), vInt(0),
+            vInt(1));
     // expectation here is that the 2 branches are not merged.
     checkSimplifyUnchanged(caseNode);
   }
@@ -2098,10 +2120,10 @@ trueLiteral, literal(1),
   @Test void testSimplifyCaseDiv1() {
     // FIXME: RexInterpreter currently evaluates children beforehand.
     simplify = simplify.withParanoid(false);
-    RexNode caseNode = case_(
-        ne(vIntNotNull(), literal(0)),
-        eq(div(literal(3), vIntNotNull()), literal(11)),
-        falseLiteral);
+    RexNode caseNode =
+        case_(ne(vIntNotNull(), literal(0)),
+            eq(div(literal(3), vIntNotNull()), literal(11)),
+            falseLiteral);
     checkSimplifyUnchanged(caseNode);
   }
 
@@ -2109,17 +2131,17 @@ trueLiteral, literal(1),
   @Test void testSimplifyCaseDiv2() {
     // FIXME: RexInterpreter currently evaluates children beforehand.
     simplify = simplify.withParanoid(false);
-    RexNode caseNode = case_(
-        eq(vIntNotNull(), literal(0)), trueLiteral,
-        gt(div(literal(3), vIntNotNull()), literal(1)), trueLiteral,
-        falseLiteral);
+    RexNode caseNode =
+        case_(eq(vIntNotNull(), literal(0)), trueLiteral,
+            gt(div(literal(3), vIntNotNull()), literal(1)), trueLiteral,
+            falseLiteral);
     checkSimplifyUnchanged(caseNode);
   }
 
   @Test void testSimplifyCaseFirstBranchIsSafe() {
-    RexNode caseNode = case_(
-        gt(div(vIntNotNull(), literal(1)), literal(1)), falseLiteral,
-        trueLiteral);
+    RexNode caseNode =
+        case_(gt(div(vIntNotNull(), literal(1)), literal(1)), falseLiteral,
+            trueLiteral);
     checkSimplify(caseNode, "<=(?0.notNullInt0, 1)");
   }
 
@@ -2241,31 +2263,13 @@ trueLiteral, literal(1),
   }
 
   private SqlOperator getDeterministicOperator() {
-    return new SqlSpecialOperator(
-            "DC",
-            SqlKind.OTHER_FUNCTION,
-            0,
-            false,
-            ReturnTypes.BOOLEAN_FORCE_NULLABLE,
-            null, null) {
-      @Override public boolean isDeterministic() {
-        return true;
-      }
-    };
+    return SqlBasicFunction.create("DC", ReturnTypes.BOOLEAN_FORCE_NULLABLE,
+        OperandTypes.VARIADIC).withDeterministic(true);
   }
 
   private SqlOperator getNoDeterministicOperator() {
-    return new SqlSpecialOperator(
-            "NDC",
-            SqlKind.OTHER_FUNCTION,
-            0,
-            false,
-            ReturnTypes.BOOLEAN_FORCE_NULLABLE,
-            null, null) {
-      @Override public boolean isDeterministic() {
-        return false;
-      }
-    };
+    return SqlBasicFunction.create("NDC", ReturnTypes.BOOLEAN_FORCE_NULLABLE,
+        OperandTypes.VARIADIC).withDeterministic(false);
   }
 
   /** Unit test for
@@ -2432,11 +2436,10 @@ private SqlOperator getNoDeterministicOperator() {
     // Default TimeZone is "America/Los_Angeles" (DummyDataContext)
     final RexLiteral literalDate = rexBuilder.makeDateLiteral(new DateString("2011-07-20"));
     final RexLiteral literalTime = rexBuilder.makeTimeLiteral(new TimeString("12:34:56"), 0);
-    final RexLiteral literalTimestamp = rexBuilder.makeTimestampLiteral(
-        new TimestampString("2011-07-20 12:34:56"), 0);
+    final RexLiteral literalTimestamp =
+        rexBuilder.makeTimestampLiteral(new TimestampString("2011-07-20 12:34:56"), 0);
     final RexLiteral literalTimeLTZ =
-        rexBuilder.makeTimeWithLocalTimeZoneLiteral(
-            new TimeString(1, 23, 45), 0);
+        rexBuilder.makeTimeWithLocalTimeZoneLiteral(new TimeString(1, 23, 45), 0);
     final RexLiteral timeLTZChar1 = rexBuilder.makeLiteral("12:34:45 America/Los_Angeles");
     final RexLiteral timeLTZChar2 = rexBuilder.makeLiteral("12:34:45 UTC");
     final RexLiteral timeLTZChar3 = rexBuilder.makeLiteral("12:34:45 GMT+01");
@@ -2653,17 +2656,9 @@ private void assertTypeAndToString(
   }
 
   @Test void testIsDeterministic() {
-    SqlOperator ndc = new SqlSpecialOperator(
-            "NDC",
-            SqlKind.OTHER_FUNCTION,
-            0,
-            false,
-            ReturnTypes.BOOLEAN,
-            null, null) {
-      @Override public boolean isDeterministic() {
-        return false;
-      }
-    };
+    SqlOperator ndc =
+        SqlBasicFunction.create("NDC", ReturnTypes.BOOLEAN,
+            OperandTypes.VARIADIC).withDeterministic(false);
     RexNode n = rexBuilder.makeCall(ndc);
     assertFalse(RexUtil.isDeterministic(n));
     assertEquals(0,
@@ -2757,6 +2752,30 @@ private void assertTypeAndToString(
     assertThat(getString(map7), is("{1=CAST(?0.a):BIGINT NOT NULL, ?0.a=1}"));
   }
 
+  /** Unit test for {@link RexUtil#predicateConstants(Class, RexBuilder, List)}
+   * applied to a predicate with {@code IS NOT DISTINCT FROM}. */
+  @Test void testConstantMapIsNotDistinctFrom() {
+    final RelDataType dateColumnType =
+        typeFactory.createTypeWithNullability(
+            typeFactory.createSqlType(SqlTypeName.DATE), true);
+
+    final RexNode dateLiteral =
+        rexBuilder.makeLiteral(new DateString(2020, 12, 11), dateColumnType,
+            false);
+    final RexNode dateColumn = rexBuilder.makeInputRef(dateColumnType, 0);
+
+    final RexNode call =
+        rexBuilder.makeCall(SqlStdOperatorTable.IS_NOT_DISTINCT_FROM,
+            dateColumn, dateLiteral);
+    final Map<RexNode, RexNode> map =
+        RexUtil.predicateConstants(RexNode.class, rexBuilder,
+            ImmutableList.of(call));
+
+    assertThat(map.isEmpty(), is(false));
+    assertThat(dateLiteral, is(map.get(dateColumn)));
+    assertThat(getString(map), is("{$0=2020-12-11}"));
+  }
+
   @Test void notDistinct() {
     checkSimplify(
         isFalse(isNotDistinctFrom(vBool(0), vBool(1))),
@@ -2828,7 +2847,7 @@ private void assertTypeAndToString(
 
   /** Converts a map to a string, sorting on the string representation of its
    * keys. */
-  private static String getString(ImmutableMap<RexNode, RexNode> map) {
+  private static String getString(Map<RexNode, RexNode> map) {
     final TreeMap<String, RexNode> map2 = new TreeMap<>();
     for (Map.Entry<RexNode, RexNode> entry : map.entrySet()) {
       map2.put(entry.getKey().toString(), entry.getValue());
@@ -3196,15 +3215,17 @@ private void checkSarg(String message, Sarg sarg,
 
   @Test void testSimplifyRangeWithMultiPredicates() {
     final RexNode ref = input(tInt(), 0);
-    RelOptPredicateList relOptPredicateList = RelOptPredicateList.of(rexBuilder,
-        ImmutableList.of(gt(ref, literal(1)), le(ref, literal(5))));
+    RelOptPredicateList relOptPredicateList =
+        RelOptPredicateList.of(rexBuilder,
+            ImmutableList.of(gt(ref, literal(1)), le(ref, literal(5))));
     checkSimplifyFilter(gt(ref, literal(9)), relOptPredicateList, "false");
   }
 
   @Test void testSimplifyNotEqual() {
     final RexNode ref = input(tInt(), 0);
-    RelOptPredicateList relOptPredicateList = RelOptPredicateList.of(rexBuilder,
-        ImmutableList.of(eq(ref, literal(9))));
+    RelOptPredicateList relOptPredicateList =
+        RelOptPredicateList.of(rexBuilder,
+            ImmutableList.of(eq(ref, literal(9))));
     checkSimplifyFilter(ne(ref, literal(9)), relOptPredicateList, "false");
     checkSimplifyFilter(ne(ref, literal(5)), relOptPredicateList, "true");
 
@@ -3268,17 +3289,9 @@ private void checkSarg(String message, Sarg sarg,
   }
 
   @Test void testSimplifyNonDeterministicFunction() {
-    final SqlOperator ndc = new SqlSpecialOperator(
-        "NDC",
-        SqlKind.OTHER_FUNCTION,
-        0,
-        false,
-        ReturnTypes.BOOLEAN,
-        null, null) {
-      @Override public boolean isDeterministic() {
-        return false;
-      }
-    };
+    final SqlOperator ndc =
+        SqlBasicFunction.create("NDC", ReturnTypes.BOOLEAN,
+            OperandTypes.VARIADIC).withDeterministic(false);
     final RexNode call1 = rexBuilder.makeCall(ndc);
     final RexNode call2 = rexBuilder.makeCall(ndc);
     final RexNode expr = eq(call1, call2);
@@ -3305,49 +3318,33 @@ private SqlSpecialOperatorWithPolicy(String name, SqlKind kind, int prec, boolea
    * <a href="https://issues.apache.org/jira/browse/CALCITE-4094">[CALCITE-4094]
    * Allow SqlUserDefinedFunction to define an optional Strong.Policy</a>. */
   @Test void testSimplifyFunctionWithStrongPolicy() {
-    final SqlOperator op = new SqlSpecialOperator(
-        "OP1",
-        SqlKind.OTHER_FUNCTION,
-        0,
-        false,
-        ReturnTypes.BOOLEAN,
-        null,
-        null) {
-    };
+    final SqlOperator op =
+        new SqlSpecialOperator("OP1", SqlKind.OTHER_FUNCTION, 0, false,
+            ReturnTypes.BOOLEAN, null, null) {
+        };
     // Operator with no Strong.Policy defined: no simplification can be made
     checkSimplifyUnchanged(rexBuilder.makeCall(op, vInt()));
     checkSimplifyUnchanged(rexBuilder.makeCall(op, vIntNotNull()));
     checkSimplifyUnchanged(rexBuilder.makeCall(op, nullInt));
 
-    final SqlOperator opPolicyAsIs = new SqlSpecialOperatorWithPolicy(
-        "OP2",
-        SqlKind.OTHER_FUNCTION,
-        0,
-        false,
-        ReturnTypes.BOOLEAN,
-        null,
-        null,
-        Strong.Policy.AS_IS) {
-    };
+    final SqlOperator opPolicyAsIs =
+        new SqlSpecialOperatorWithPolicy("OP2", SqlKind.OTHER_FUNCTION, 0,
+            false, ReturnTypes.BOOLEAN, null, null, Strong.Policy.AS_IS) {
+        };
     // Operator with Strong.Policy.AS_IS: no simplification can be made
     checkSimplifyUnchanged(rexBuilder.makeCall(opPolicyAsIs, vInt()));
     checkSimplifyUnchanged(rexBuilder.makeCall(opPolicyAsIs, vIntNotNull()));
     checkSimplifyUnchanged(rexBuilder.makeCall(opPolicyAsIs, nullInt));
 
-    final SqlOperator opPolicyAny = new SqlSpecialOperatorWithPolicy(
-        "OP3",
-        SqlKind.OTHER_FUNCTION,
-        0,
-        false,
-        ReturnTypes.BOOLEAN,
-        null,
-        null,
-        Strong.Policy.ANY) {
-    };
+    final SqlOperator opPolicyAny =
+        new SqlSpecialOperatorWithPolicy("OP3", SqlKind.OTHER_FUNCTION, 0,
+            false, ReturnTypes.BOOLEAN, null, null, Strong.Policy.ANY) {
+        };
     // Operator with Strong.Policy.ANY: simplification possible with null parameter
     checkSimplifyUnchanged(rexBuilder.makeCall(opPolicyAny, vInt()));
     checkSimplifyUnchanged(rexBuilder.makeCall(opPolicyAny, vIntNotNull()));
-    checkSimplify3(rexBuilder.makeCall(opPolicyAny, nullInt), "null:BOOLEAN", "false", "true");
+    checkSimplify3(rexBuilder.makeCall(opPolicyAny, nullInt),
+        "null:BOOLEAN", "false", "true");
   }
 
   @Test void testSimplifyVarbinary() {
@@ -3382,4 +3379,5 @@ private SqlSpecialOperatorWithPolicy(String name, SqlKind kind, int prec, boolea
 
     checkSimplify(add(zero, sub(nullInt, nullInt)), "null:INTEGER");
   }
+
 }
diff --git a/core/src/test/java/org/apache/calcite/rex/RexSqlStandardConvertletTableTest.java b/core/src/test/java/org/apache/calcite/rex/RexSqlStandardConvertletTableTest.java
index 998a9925f1f..212d3886a13 100644
--- a/core/src/test/java/org/apache/calcite/rex/RexSqlStandardConvertletTableTest.java
+++ b/core/src/test/java/org/apache/calcite/rex/RexSqlStandardConvertletTableTest.java
@@ -34,7 +34,8 @@
 
 import org.junit.jupiter.api.Test;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.hasToString;
 
 /**
  * Unit test for {@link org.apache.calcite.rex.RexSqlStandardConvertletTable}.
@@ -42,14 +43,13 @@
 class RexSqlStandardConvertletTableTest extends SqlToRelTestBase {
 
   @Test void testCoalesce() {
-    final Project project = (Project) convertSqlToRel(
-            "SELECT COALESCE(NULL, 'a')", false);
+    final Project project =
+        (Project) convertSqlToRel("SELECT COALESCE(NULL, 'a')", false);
     final RexNode rex = project.getProjects().get(0);
     final RexToSqlNodeConverter rexToSqlNodeConverter = rexToSqlNodeConverter();
     final SqlNode convertedSql = rexToSqlNodeConverter.convertNode(rex);
-    assertEquals(
-            "CASE WHEN NULL IS NOT NULL THEN NULL ELSE 'a' END",
-            convertedSql.toString());
+    assertThat(convertedSql,
+        hasToString("CASE WHEN NULL IS NOT NULL THEN NULL ELSE 'a' END"));
   }
 
   @Test void testCaseWithValue() {
@@ -59,24 +59,23 @@ class RexSqlStandardConvertletTableTest extends SqlToRelTestBase {
     final RexNode rex = project.getProjects().get(0);
     final RexToSqlNodeConverter rexToSqlNodeConverter = rexToSqlNodeConverter();
     final SqlNode convertedSql = rexToSqlNodeConverter.convertNode(rex);
-    assertEquals(
-            "CASE WHEN NULL = NULL THEN NULL ELSE 'a' END",
-            convertedSql.toString());
+    assertThat(convertedSql,
+        hasToString("CASE WHEN NULL = NULL THEN NULL ELSE 'a' END"));
   }
 
   @Test void testCaseNoValue() {
-    final Project project = (Project) convertSqlToRel(
-            "SELECT CASE WHEN NULL IS NULL THEN NULL ELSE 'a' END", false);
+    final String sql = "SELECT CASE WHEN NULL IS NULL THEN NULL ELSE 'a' END";
+    final Project project = (Project) convertSqlToRel(sql, false);
     final RexNode rex = project.getProjects().get(0);
     final RexToSqlNodeConverter rexToSqlNodeConverter = rexToSqlNodeConverter();
     final SqlNode convertedSql = rexToSqlNodeConverter.convertNode(rex);
-    assertEquals(
-            "CASE WHEN NULL IS NULL THEN NULL ELSE 'a' END",
-            convertedSql.toString());
+    assertThat(convertedSql,
+        hasToString("CASE WHEN NULL IS NULL THEN NULL ELSE 'a' END"));
   }
 
   private RelNode convertSqlToRel(String sql, boolean simplifyRex) {
-    final FrameworkConfig config = Frameworks.newConfigBuilder()
+    final FrameworkConfig config =
+        Frameworks.newConfigBuilder()
             .defaultSchema(CalciteSchema.createRootSchema(false).plus())
             .parserConfig(SqlParser.config())
             .build();
@@ -92,7 +91,8 @@ private RelNode convertSqlToRel(String sql, boolean simplifyRex) {
   }
 
   private static RexToSqlNodeConverter rexToSqlNodeConverter() {
-    final RexSqlStandardConvertletTable convertletTable = new RexSqlStandardConvertletTable();
+    final RexSqlStandardConvertletTable convertletTable =
+        new RexSqlStandardConvertletTable();
     return new RexToSqlNodeConverterImpl(convertletTable);
   }
 
diff --git a/core/src/test/java/org/apache/calcite/runtime/EnumerablesTest.java b/core/src/test/java/org/apache/calcite/runtime/EnumerablesTest.java
index 80d1a510c4a..058717bbd30 100644
--- a/core/src/test/java/org/apache/calcite/runtime/EnumerablesTest.java
+++ b/core/src/test/java/org/apache/calcite/runtime/EnumerablesTest.java
@@ -46,17 +46,17 @@
  * Unit tests for {@link org.apache.calcite.runtime.Enumerables}.
  */
 class EnumerablesTest {
-  private static final Enumerable<Emp> EMPS = Linq4j.asEnumerable(
-      Arrays.asList(
-          new Emp(10, "Fred"),
-          new Emp(20, "Theodore"),
-          new Emp(20, "Sebastian"),
-          new Emp(30, "Joe")));
-
-  private static final Enumerable<Dept> DEPTS = Linq4j.asEnumerable(
-      Arrays.asList(
-          new Dept(20, "Sales"),
-          new Dept(15, "Marketing")));
+  private static final Enumerable<Emp> EMPS =
+      Linq4j.asEnumerable(
+          Arrays.asList(new Emp(10, "Fred"),
+              new Emp(20, "Theodore"),
+              new Emp(20, "Sebastian"),
+              new Emp(30, "Joe")));
+
+  private static final Enumerable<Dept> DEPTS =
+      Linq4j.asEnumerable(
+          Arrays.asList(new Dept(20, "Sales"),
+              new Dept(15, "Marketing")));
 
   private static final Function2<Emp, Dept, String> EMP_DEPT_TO_STRING =
       (v0, v1) -> "{" + (v0 == null ? null : v0.name)
@@ -397,18 +397,18 @@ private static <T extends Comparable<T>> Enumerable<String> intersect(
   }
 
   @Test void testMergeJoinWithPredicate() {
-    final List<Emp> listEmp1 = Arrays.asList(
-        new Emp(1, "Fred"),
-        new Emp(2, "Fred"),
-        new Emp(3, "Joe"),
-        new Emp(4, "Joe"),
-        new Emp(5, "Peter"));
-    final List<Emp> listEmp2 = Arrays.asList(
-        new Emp(2, "Fred"),
-        new Emp(3, "Fred"),
-        new Emp(3, "Joe"),
-        new Emp(5, "Joe"),
-        new Emp(6, "Peter"));
+    final List<Emp> listEmp1 =
+        Arrays.asList(new Emp(1, "Fred"),
+            new Emp(2, "Fred"),
+            new Emp(3, "Joe"),
+            new Emp(4, "Joe"),
+            new Emp(5, "Peter"));
+    final List<Emp> listEmp2 =
+        Arrays.asList(new Emp(2, "Fred"),
+            new Emp(3, "Fred"),
+            new Emp(3, "Joe"),
+            new Emp(5, "Joe"),
+            new Emp(6, "Peter"));
 
     assertThat(
         EnumerableDefaults.mergeJoin(
@@ -816,12 +816,12 @@ private static <T extends Comparable<T>> Enumerable<String> intersect(
 
   @Test @Disabled // TODO fix this
   public void testMatch() {
-    final Enumerable<Emp> emps = Linq4j.asEnumerable(
-        Arrays.asList(
-            new Emp(20, "Theodore"),
-            new Emp(10, "Fred"),
-            new Emp(20, "Sebastian"),
-            new Emp(30, "Joe")));
+    final Enumerable<Emp> emps =
+        Linq4j.asEnumerable(
+            Arrays.asList(new Emp(20, "Theodore"),
+                new Emp(10, "Fred"),
+                new Emp(20, "Sebastian"),
+                new Emp(30, "Joe")));
 
     final Pattern p =
         Pattern.builder()
diff --git a/core/src/test/java/org/apache/calcite/runtime/SpatialTypeUtilsTest.java b/core/src/test/java/org/apache/calcite/runtime/SpatialTypeUtilsTest.java
new file mode 100644
index 00000000000..1d0099fde29
--- /dev/null
+++ b/core/src/test/java/org/apache/calcite/runtime/SpatialTypeUtilsTest.java
@@ -0,0 +1,55 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.runtime;
+
+import org.junit.jupiter.api.Test;
+import org.locationtech.jts.geom.Coordinate;
+import org.locationtech.jts.geom.Geometry;
+import org.locationtech.jts.geom.GeometryFactory;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/**
+ * Tests {@link org.apache.calcite.runtime.SpatialTypeUtilsTest}.
+ */
+class SpatialTypeUtilsTest {
+
+  @Test void testFromEwkt() {
+    Geometry g1 = SpatialTypeUtils.fromEwkt("POINT(1 2)");
+    assertEquals(1, g1.getCoordinate().getX());
+    assertEquals(2, g1.getCoordinate().getY());
+
+    Geometry g2 = SpatialTypeUtils.fromEwkt("srid:1234;POINT(1 2)");
+    assertEquals(1234, g2.getSRID());
+    assertEquals(1, g2.getCoordinate().getX());
+    assertEquals(2, g2.getCoordinate().getY());
+
+    Geometry g3 = SpatialTypeUtils.fromEwkt("GEOMETRYCOLLECTION(\n"
+        + "  POLYGON((0 0, 3 -1, 1.5 2, 0 0)),\n"
+        + "  POLYGON((2 0, 3 3, 4 2, 2 0)),\n"
+        + "  POINT(5 6),\n"
+        + "  LINESTRING(1 1, 1 6))");
+    assertEquals(g3.getSRID(), 0);
+  }
+
+  @Test void testAsEwkt() {
+    GeometryFactory gf = new GeometryFactory();
+    Geometry g1 = gf.createPoint(new Coordinate(1, 2));
+    g1.setSRID(1234);
+    assertEquals("srid:1234;POINT (1 2)", SpatialTypeUtils.asEwkt(g1));
+  }
+}
diff --git a/core/src/test/java/org/apache/calcite/sql/SqlSetOptionOperatorTest.java b/core/src/test/java/org/apache/calcite/sql/SqlSetOptionOperatorTest.java
index f0abda9f6da..e007de350a4 100644
--- a/core/src/test/java/org/apache/calcite/sql/SqlSetOptionOperatorTest.java
+++ b/core/src/test/java/org/apache/calcite/sql/SqlSetOptionOperatorTest.java
@@ -56,10 +56,10 @@ public SqlNode parse(String s) throws SqlParseException {
 
   private static void checkSqlSetOptionSame(SqlNode node) {
     SqlSetOption opt = (SqlSetOption) node;
-    SqlCall returned = opt.getOperator().createCall(
-        opt.getFunctionQuantifier(),
-        opt.getParserPosition(),
-        opt.getOperandList());
+    SqlCall returned =
+        opt.getOperator().createCall(opt.getFunctionQuantifier(),
+            opt.getParserPosition(),
+            opt.getOperandList());
     assertThat(opt.getClass(), equalTo(returned.getClass()));
     SqlSetOption optRet = (SqlSetOption) returned;
     assertThat(optRet.getScope(), is(opt.getScope()));
diff --git a/core/src/test/java/org/apache/calcite/sql/parser/parserextensiontesting/SqlCreateTable.java b/core/src/test/java/org/apache/calcite/sql/parser/parserextensiontesting/ExtensionSqlCreateTable.java
similarity index 78%
rename from core/src/test/java/org/apache/calcite/sql/parser/parserextensiontesting/SqlCreateTable.java
rename to core/src/test/java/org/apache/calcite/sql/parser/parserextensiontesting/ExtensionSqlCreateTable.java
index f97ba0f079c..24148655e5c 100644
--- a/core/src/test/java/org/apache/calcite/sql/parser/parserextensiontesting/SqlCreateTable.java
+++ b/core/src/test/java/org/apache/calcite/sql/parser/parserextensiontesting/ExtensionSqlCreateTable.java
@@ -16,42 +16,28 @@
  */
 package org.apache.calcite.sql.parser.parserextensiontesting;
 
-import org.apache.calcite.sql.SqlCreate;
 import org.apache.calcite.sql.SqlDataTypeSpec;
 import org.apache.calcite.sql.SqlIdentifier;
-import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.sql.SqlNodeList;
-import org.apache.calcite.sql.SqlOperator;
-import org.apache.calcite.sql.SqlSpecialOperator;
 import org.apache.calcite.sql.SqlWriter;
+import org.apache.calcite.sql.ddl.SqlCreateTable;
 import org.apache.calcite.sql.parser.SqlParserPos;
 import org.apache.calcite.util.ImmutableNullableList;
 import org.apache.calcite.util.Pair;
 import org.apache.calcite.util.Util;
 
 import java.util.List;
-import java.util.Objects;
 import java.util.function.BiConsumer;
 
 /**
  * Simple test example of a CREATE TABLE statement.
  */
-public class SqlCreateTable extends SqlCreate {
-  public final SqlIdentifier name;
-  public final SqlNodeList columnList;
-  public final SqlNode query;
-
-  private static final SqlOperator OPERATOR =
-      new SqlSpecialOperator("CREATE TABLE", SqlKind.CREATE_TABLE);
-
+public class ExtensionSqlCreateTable extends SqlCreateTable {
   /** Creates a SqlCreateTable. */
-  public SqlCreateTable(SqlParserPos pos, SqlIdentifier name,
+  public ExtensionSqlCreateTable(SqlParserPos pos, SqlIdentifier name,
       SqlNodeList columnList, SqlNode query) {
-    super(OPERATOR, pos, false, false);
-    this.name = Objects.requireNonNull(name, "name");
-    this.columnList = columnList; // may be null
-    this.query = query; // for "CREATE TABLE ... AS query"; may be null
+    super(pos, false, false, name, columnList, query);
   }
 
   @Override public List<SqlNode> getOperandList() {
diff --git a/core/src/test/java/org/apache/calcite/sql/test/SqlAdvisorTest.java b/core/src/test/java/org/apache/calcite/sql/test/SqlAdvisorTest.java
index 82075d2ae11..2d62211df01 100644
--- a/core/src/test/java/org/apache/calcite/sql/test/SqlAdvisorTest.java
+++ b/core/src/test/java/org/apache/calcite/sql/test/SqlAdvisorTest.java
@@ -87,8 +87,10 @@ class SqlAdvisorTest extends SqlValidatorTestCase {
           "TABLE(CATALOG.SALES.EMP_B)",
           "TABLE(CATALOG.SALES.EMP_20)",
           "TABLE(CATALOG.SALES.EMPNULLABLES_20)",
+          "TABLE(CATALOG.SALES.EMPTY_PRODUCTS)",
           "TABLE(CATALOG.SALES.EMP_ADDRESS)",
           "TABLE(CATALOG.SALES.DEPT)",
+          "TABLE(CATALOG.SALES.DEPT_SINGLE)",
           "TABLE(CATALOG.SALES.DEPT_NESTED)",
           "TABLE(CATALOG.SALES.DEPT_NESTED_EXPANDED)",
           "TABLE(CATALOG.SALES.BONUS)",
@@ -138,6 +140,7 @@ class SqlAdvisorTest extends SqlValidatorTestCase {
           "KEYWORD(CAST)",
           "KEYWORD(CEIL)",
           "KEYWORD(CEILING)",
+          "KEYWORD(CHAR)",
           "KEYWORD(CHARACTER_LENGTH)",
           "KEYWORD(CHAR_LENGTH)",
           "KEYWORD(CLASSIFIER)",
@@ -160,6 +163,7 @@ class SqlAdvisorTest extends SqlValidatorTestCase {
           "KEYWORD(CURRENT_USER)",
           "KEYWORD(CURSOR)",
           "KEYWORD(DATE)",
+          "KEYWORD(DATETIME)",
           "KEYWORD(DENSE_RANK)",
           "KEYWORD(ELEMENT)",
           "KEYWORD(EVERY)",
@@ -220,6 +224,7 @@ class SqlAdvisorTest extends SqlValidatorTestCase {
           "KEYWORD(ROW)",
           "KEYWORD(ROW_NUMBER)",
           "KEYWORD(RUNNING)",
+          "KEYWORD(SAFE_CAST)",
           "KEYWORD(SECOND)",
           "KEYWORD(SESSION_USER)",
           "KEYWORD(SOME)",
@@ -335,6 +340,7 @@ class SqlAdvisorTest extends SqlValidatorTestCase {
           "KEYWORD(LIMIT)",
           "KEYWORD(GROUP)",
           "KEYWORD(HAVING)",
+          "KEYWORD(QUALIFY)",
           "KEYWORD(INTERSECT)",
           "KEYWORD(ORDER)",
           "KEYWORD(UNION)",
@@ -360,6 +366,7 @@ class SqlAdvisorTest extends SqlValidatorTestCase {
           "KEYWORD(USING)",
           "KEYWORD(OUTER)",
           "KEYWORD(RIGHT)",
+          "KEYWORD(QUALIFY)",
           "KEYWORD(GROUP)",
           "KEYWORD(CROSS)",
           "KEYWORD(,)",
@@ -1136,21 +1143,21 @@ private void checkSimpleParserQuotedIdImpl(Fixture fixture) {
 
     // closed double-quote
     sql = replaceQuotes(parserConfig, "select * from t where [^] and x = y");
-    expected = replaceQuotes(parserConfig,
-        "SELECT * FROM t WHERE _suggest_ and x = y");
+    expected =
+        replaceQuotes(parserConfig, "SELECT * FROM t WHERE _suggest_ and x = y");
     fixture.withSql(sql).assertSimplify(expected);
 
     // closed double-quote containing extra stuff
     sql = replaceQuotes(parserConfig, "select * from t where [^foo] and x = y");
-    expected = replaceQuotes(parserConfig,
-        "SELECT * FROM t WHERE _suggest_ and x = y");
+    expected =
+        replaceQuotes(parserConfig, "SELECT * FROM t WHERE _suggest_ and x = y");
     fixture.withSql(sql).assertSimplify(expected);
 
     // escaped double-quote containing extra stuff
-    sql = replaceQuotes(parserConfig,
-        "select * from t where [^f]]oo] and x = y");
-    expected = replaceQuotes(parserConfig,
-        "SELECT * FROM t WHERE _suggest_ and x = y");
+    sql =
+        replaceQuotes(parserConfig, "select * from t where [^f]]oo] and x = y");
+    expected =
+        replaceQuotes(parserConfig, "SELECT * FROM t WHERE _suggest_ and x = y");
     fixture.withSql(sql).assertSimplify(expected);
   }
 
diff --git a/core/src/test/java/org/apache/calcite/sql/test/SqlPrettyWriterTest.java b/core/src/test/java/org/apache/calcite/sql/test/SqlPrettyWriterTest.java
index 4891edd7086..621e33da2d2 100644
--- a/core/src/test/java/org/apache/calcite/sql/test/SqlPrettyWriterTest.java
+++ b/core/src/test/java/org/apache/calcite/sql/test/SqlPrettyWriterTest.java
@@ -25,6 +25,8 @@
 import org.apache.calcite.sql.pretty.SqlPrettyWriter;
 import org.apache.calcite.test.DiffRepository;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 
@@ -49,8 +51,19 @@ class SqlPrettyWriterTest {
   private static final SqlPrettyWriterFixture LOCAL_FIXTURE =
       FIXTURE.withDiffRepos(DiffRepository.lookup(SqlPrettyWriterTest.class));
 
+  @Nullable
+  private static DiffRepository diffRepos = null;
+
+  @AfterAll
+  public static void checkActualAndReferenceFiles() {
+    if (diffRepos != null) {
+      diffRepos.checkActualAndReferenceFiles();
+    }
+  }
+
   /** Returns the default fixture for tests. Sub-classes may override. */
   protected SqlPrettyWriterFixture fixture() {
+    diffRepos = LOCAL_FIXTURE.diffRepos();
     return LOCAL_FIXTURE;
   }
 
diff --git a/core/src/test/java/org/apache/calcite/sql/type/RelDataTypeSystemTest.java b/core/src/test/java/org/apache/calcite/sql/type/RelDataTypeSystemTest.java
index 8eec8e85ac7..9a9513fceae 100644
--- a/core/src/test/java/org/apache/calcite/sql/type/RelDataTypeSystemTest.java
+++ b/core/src/test/java/org/apache/calcite/sql/type/RelDataTypeSystemTest.java
@@ -53,8 +53,11 @@ private static final class CustomTypeSystem extends RelDataTypeSystemImpl {
       }
 
       int resultScale = Math.max(type1.getScale(), type2.getScale());
-      int resultPrecision = resultScale + Math.max(type1.getPrecision() - type1.getScale(),
-              type2.getPrecision() - type2.getScale()) + 1;
+      int resultPrecision =
+          resultScale
+              + Math.max(type1.getPrecision() - type1.getScale(),
+                  type2.getPrecision() - type2.getScale())
+              + 1;
       if (resultPrecision > 38) {
         int minScale = Math.min(resultScale, 6);
         int delta = resultPrecision - 38;
@@ -124,7 +127,8 @@ private static final class CustomTypeSystem extends RelDataTypeSystemImpl {
     RelDataType operand1 = TYPE_FACTORY.createSqlType(SqlTypeName.DECIMAL, 10, 1);
     RelDataType operand2 = TYPE_FACTORY.createSqlType(SqlTypeName.DECIMAL, 10, 2);
 
-    RelDataType dataType = SqlStdOperatorTable.MINUS.inferReturnType(TYPE_FACTORY,
+    RelDataType dataType =
+        SqlStdOperatorTable.MINUS.inferReturnType(TYPE_FACTORY,
             Lists.newArrayList(operand1, operand2));
     assertEquals(12, dataType.getPrecision());
     assertEquals(2, dataType.getScale());
diff --git a/core/src/test/java/org/apache/calcite/sql/type/SqlTypeFactoryTest.java b/core/src/test/java/org/apache/calcite/sql/type/SqlTypeFactoryTest.java
index 9f7ec0a530b..a4921233b93 100644
--- a/core/src/test/java/org/apache/calcite/sql/type/SqlTypeFactoryTest.java
+++ b/core/src/test/java/org/apache/calcite/sql/type/SqlTypeFactoryTest.java
@@ -150,6 +150,34 @@ class SqlTypeFactoryTest {
     assertThat(leastRestrictive.getValueType().getPrecision(), is(10));
   }
 
+  @Test void testLeastRestrictiveForTimestamps() {
+    SqlTypeFixture f = new SqlTypeFixture();
+    RelDataType leastRestrictive =
+        f.typeFactory.leastRestrictive(
+            Lists.newArrayList(f.sqlTimestampPrec0, f.sqlTimestampPrec3));
+    assertThat(leastRestrictive.getSqlTypeName(), is(SqlTypeName.TIMESTAMP));
+    assertThat(leastRestrictive.isNullable(), is(false));
+    assertThat(leastRestrictive.getPrecision(), is(3));
+  }
+
+  @Test void testLeastRestrictiveForTimestamps2() {
+    SqlTypeFixture f = new SqlTypeFixture();
+    RelDataType leastRestrictive =
+        f.typeFactory.leastRestrictive(
+            Lists.newArrayList(f.sqlTimestampPrec3, f.sqlTimestampPrec0));
+    assertThat(leastRestrictive.getSqlTypeName(), is(SqlTypeName.TIMESTAMP));
+    assertThat(leastRestrictive.isNullable(), is(false));
+    assertThat(leastRestrictive.getPrecision(), is(3));
+  }
+
+  @Test void testLeastRestrictiveForTimestampAndDate() {
+    SqlTypeFixture f = new SqlTypeFixture();
+    RelDataType leastRestrictive =
+        f.typeFactory.leastRestrictive(
+            Lists.newArrayList(f.sqlTimestampPrec3, f.sqlDate));
+    assertNull(leastRestrictive);
+  }
+
   @Test void testLeastRestrictiveForImpossibleWithMaps() {
     SqlTypeFixture f = new SqlTypeFixture();
     RelDataType leastRestrictive =
@@ -216,14 +244,17 @@ private void checkPrecision(int p0, int p1, int expectedMax,
     SqlTypeFixture f = new SqlTypeFixture();
     RelDataTypeFactory typeFactory = f.typeFactory;
     List<RelDataTypeField> fields = new ArrayList<>();
-    RelDataTypeField field0 = new RelDataTypeFieldImpl(
-            "i", 0, typeFactory.createSqlType(SqlTypeName.INTEGER));
-    RelDataTypeField field1 = new RelDataTypeFieldImpl(
-            "s", 1, typeFactory.createSqlType(SqlTypeName.VARCHAR));
+    RelDataTypeField field0 =
+        new RelDataTypeFieldImpl("i", 0,
+            typeFactory.createSqlType(SqlTypeName.INTEGER));
+    RelDataTypeField field1 =
+        new RelDataTypeFieldImpl("s", 1,
+            typeFactory.createSqlType(SqlTypeName.VARCHAR));
     fields.add(field0);
     fields.add(field1);
     final RelDataType recordType = new RelRecordType(fields); // nullable false by default
-    final RelDataType copyRecordType = typeFactory.createTypeWithNullability(recordType, true);
+    final RelDataType copyRecordType =
+        typeFactory.createTypeWithNullability(recordType, true);
     assertFalse(recordType.isNullable());
     assertTrue(copyRecordType.isNullable());
   }
diff --git a/core/src/test/java/org/apache/calcite/sql/type/SqlTypeFixture.java b/core/src/test/java/org/apache/calcite/sql/type/SqlTypeFixture.java
index 05fa8fed58a..01f6fb122ba 100644
--- a/core/src/test/java/org/apache/calcite/sql/type/SqlTypeFixture.java
+++ b/core/src/test/java/org/apache/calcite/sql/type/SqlTypeFixture.java
@@ -25,75 +25,80 @@
  * Reusable {@link RelDataType} fixtures for tests.
  */
 class SqlTypeFixture {
-  SqlTypeFactoryImpl typeFactory = new SqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT);
-  final RelDataType sqlBoolean = typeFactory.createTypeWithNullability(
-      typeFactory.createSqlType(SqlTypeName.BOOLEAN), false);
-  final RelDataType sqlBigInt = typeFactory.createTypeWithNullability(
-      typeFactory.createSqlType(SqlTypeName.BIGINT), false);
-  final RelDataType sqlBigIntNullable = typeFactory.createTypeWithNullability(
-      typeFactory.createSqlType(SqlTypeName.BIGINT), true);
-  final RelDataType sqlInt = typeFactory.createTypeWithNullability(
-      typeFactory.createSqlType(SqlTypeName.INTEGER), false);
-  final RelDataType sqlDate = typeFactory.createTypeWithNullability(
-      typeFactory.createSqlType(SqlTypeName.DATE), false);
-  final RelDataType sqlVarchar = typeFactory.createTypeWithNullability(
-      typeFactory.createSqlType(SqlTypeName.VARCHAR), false);
-  final RelDataType sqlChar = typeFactory.createTypeWithNullability(
-      typeFactory.createSqlType(SqlTypeName.CHAR), false);
-  final RelDataType sqlVarcharNullable = typeFactory.createTypeWithNullability(
-      typeFactory.createSqlType(SqlTypeName.VARCHAR), true);
-  final RelDataType sqlNull = typeFactory.createTypeWithNullability(
-      typeFactory.createSqlType(SqlTypeName.NULL), false);
-  final RelDataType sqlUnknown = typeFactory.createTypeWithNullability(
-      typeFactory.createSqlType(SqlTypeName.UNKNOWN), false);
-  final RelDataType sqlAny = typeFactory.createTypeWithNullability(
-      typeFactory.createSqlType(SqlTypeName.ANY), false);
-  final RelDataType sqlFloat = typeFactory.createTypeWithNullability(
-      typeFactory.createSqlType(SqlTypeName.FLOAT), false);
-  final RelDataType sqlTimestamp = typeFactory.createTypeWithNullability(
-      typeFactory.createSqlType(SqlTypeName.TIMESTAMP, 3), false);
-  final RelDataType arrayFloat = typeFactory.createTypeWithNullability(
-      typeFactory.createArrayType(sqlFloat, -1), false);
-  final RelDataType arrayBigInt = typeFactory.createTypeWithNullability(
-      typeFactory.createArrayType(sqlBigIntNullable, -1), false);
-  final RelDataType multisetFloat = typeFactory.createTypeWithNullability(
-      typeFactory.createMultisetType(sqlFloat, -1), false);
-  final RelDataType multisetBigInt = typeFactory.createTypeWithNullability(
-      typeFactory.createMultisetType(sqlBigIntNullable, -1), false);
-  final RelDataType multisetBigIntNullable = typeFactory.createTypeWithNullability(
-      typeFactory.createMultisetType(sqlBigIntNullable, -1), true);
-  final RelDataType arrayBigIntNullable = typeFactory.createTypeWithNullability(
-      typeFactory.createArrayType(sqlBigIntNullable, -1), true);
-  final RelDataType arrayOfArrayBigInt = typeFactory.createTypeWithNullability(
-      typeFactory.createArrayType(arrayBigInt, -1), false);
-  final RelDataType arrayOfArrayFloat = typeFactory.createTypeWithNullability(
-      typeFactory.createArrayType(arrayFloat, -1), false);
-  final RelDataType structOfInt = typeFactory.createTypeWithNullability(
-      typeFactory.createStructType(
-          ImmutableList.of(sqlInt, sqlInt),
-          ImmutableList.of("i", "j")), false);
-  final RelDataType structOfIntNullable = typeFactory.createTypeWithNullability(
-      typeFactory.createStructType(
-          ImmutableList.of(sqlInt, sqlInt),
-          ImmutableList.of("i", "j")), true);
-  final RelDataType mapOfInt = typeFactory.createTypeWithNullability(
-      typeFactory.createMapType(sqlInt, sqlInt), false);
-  final RelDataType mapOfIntNullable = typeFactory.createTypeWithNullability(
-      typeFactory.createMapType(sqlInt, sqlInt), true);
-  final RelDataType sqlChar1 = typeFactory.createTypeWithNullability(
-      typeFactory.createSqlType(SqlTypeName.CHAR, 1), false);
-  final RelDataType sqlChar10 = typeFactory.createTypeWithNullability(
-      typeFactory.createSqlType(SqlTypeName.CHAR, 10), false);
-  final RelDataType arraySqlChar10 = typeFactory.createTypeWithNullability(
-      typeFactory.createArrayType(sqlChar10, -1), false);
-  final RelDataType arraySqlChar1 = typeFactory.createTypeWithNullability(
-      typeFactory.createArrayType(sqlChar1, -1), false);
-  final RelDataType multisetSqlChar10Nullable = typeFactory.createTypeWithNullability(
-      typeFactory.createMultisetType(sqlChar10, -1), true);
-  final RelDataType multisetSqlChar1 = typeFactory.createTypeWithNullability(
-      typeFactory.createMultisetType(sqlChar1, -1), false);
-  final RelDataType mapSqlChar10Nullable = typeFactory.createTypeWithNullability(
-      typeFactory.createMapType(sqlChar10, sqlChar10), true);
-  final RelDataType mapSqlChar1 = typeFactory.createTypeWithNullability(
-      typeFactory.createMapType(sqlChar1, sqlChar1), false);
+  final SqlTypeFactoryImpl typeFactory =
+      new SqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT);
+  final RelDataType sqlBoolean = type(SqlTypeName.BOOLEAN, false);
+  final RelDataType sqlBigInt = type(SqlTypeName.BIGINT, false);
+  final RelDataType sqlBigIntNullable = type(SqlTypeName.BIGINT, true);
+  final RelDataType sqlInt = type(SqlTypeName.INTEGER, false);
+  final RelDataType sqlDate = type(SqlTypeName.DATE, false);
+  final RelDataType sqlVarchar = type(SqlTypeName.VARCHAR, false);
+  final RelDataType sqlChar = type(SqlTypeName.CHAR, false);
+  final RelDataType sqlVarcharNullable = type(SqlTypeName.VARCHAR, true);
+  final RelDataType sqlNull = type(SqlTypeName.NULL, false);
+  final RelDataType sqlUnknown = type(SqlTypeName.UNKNOWN, false);
+  final RelDataType sqlAny = type(SqlTypeName.ANY, false);
+  final RelDataType sqlFloat = type(SqlTypeName.FLOAT, false);
+  final RelDataType sqlTimestampPrec0 = type(SqlTypeName.TIMESTAMP, 0);
+  final RelDataType sqlTimestampPrec3 = type(SqlTypeName.TIMESTAMP, 3);
+  final RelDataType sqlGeometry = type(SqlTypeName.GEOMETRY, false);
+  final RelDataType arrayFloat =
+      notNullable(typeFactory.createArrayType(sqlFloat, -1));
+  final RelDataType arrayBigInt =
+      notNullable(typeFactory.createArrayType(sqlBigIntNullable, -1));
+  final RelDataType multisetFloat =
+      notNullable(typeFactory.createMultisetType(sqlFloat, -1));
+  final RelDataType multisetBigInt =
+      notNullable(typeFactory.createMultisetType(sqlBigIntNullable, -1));
+  final RelDataType multisetBigIntNullable =
+      nullable(typeFactory.createMultisetType(sqlBigIntNullable, -1));
+  final RelDataType arrayBigIntNullable =
+      nullable(typeFactory.createArrayType(sqlBigIntNullable, -1));
+  final RelDataType arrayOfArrayBigInt =
+      notNullable(typeFactory.createArrayType(arrayBigInt, -1));
+  final RelDataType arrayOfArrayFloat =
+      notNullable(typeFactory.createArrayType(arrayFloat, -1));
+  final RelDataType structOfInt =
+      notNullable(
+          typeFactory.createStructType(
+              ImmutableList.of(sqlInt, sqlInt), ImmutableList.of("i", "j")));
+  final RelDataType structOfIntNullable =
+      nullable(
+          typeFactory.createStructType(
+              ImmutableList.of(sqlInt, sqlInt), ImmutableList.of("i", "j")));
+  final RelDataType mapOfInt =
+      notNullable(typeFactory.createMapType(sqlInt, sqlInt));
+  final RelDataType mapOfIntNullable =
+      nullable(typeFactory.createMapType(sqlInt, sqlInt));
+  final RelDataType sqlChar1 = type(SqlTypeName.CHAR, 1);
+  final RelDataType sqlChar10 = type(SqlTypeName.CHAR, 10);
+  final RelDataType arraySqlChar10 =
+      notNullable(typeFactory.createArrayType(sqlChar10, -1));
+  final RelDataType arraySqlChar1 =
+      notNullable(typeFactory.createArrayType(sqlChar1, -1));
+  final RelDataType multisetSqlChar10Nullable =
+      nullable(typeFactory.createMultisetType(sqlChar10, -1));
+  final RelDataType multisetSqlChar1 =
+      notNullable(typeFactory.createMultisetType(sqlChar1, -1));
+  final RelDataType mapSqlChar10Nullable =
+      nullable(typeFactory.createMapType(sqlChar10, sqlChar10));
+  final RelDataType mapSqlChar1 =
+      notNullable(typeFactory.createMapType(sqlChar1, sqlChar1));
+
+  private RelDataType type(SqlTypeName typeName, int precision) {
+    return notNullable(typeFactory.createSqlType(typeName, precision));
+  }
+
+  private RelDataType type(SqlTypeName typeName, boolean nullable) {
+    RelDataType type = typeFactory.createSqlType(typeName);
+    return typeFactory.createTypeWithNullability(type, nullable);
+  }
+
+  private RelDataType notNullable(RelDataType type) {
+    return typeFactory.createTypeWithNullability(type, false);
+  }
+
+  private RelDataType nullable(RelDataType type) {
+    return typeFactory.createTypeWithNullability(type, true);
+  }
 }
diff --git a/core/src/test/java/org/apache/calcite/sql/type/SqlTypeUtilTest.java b/core/src/test/java/org/apache/calcite/sql/type/SqlTypeUtilTest.java
index b6bddfa267f..a2c3fe1ad97 100644
--- a/core/src/test/java/org/apache/calcite/sql/type/SqlTypeUtilTest.java
+++ b/core/src/test/java/org/apache/calcite/sql/type/SqlTypeUtilTest.java
@@ -120,10 +120,10 @@ class SqlTypeUtilTest {
 
     // Initialize a SqlTypeCoercionRules with the new builder mappings.
     SqlTypeCoercionRule typeCoercionRules = SqlTypeCoercionRule.instance(builder.map);
-    assertThat(SqlTypeUtil.canCastFrom(f.sqlTimestamp, f.sqlBoolean, true),
+    assertThat(SqlTypeUtil.canCastFrom(f.sqlTimestampPrec3, f.sqlBoolean, true),
         is(false));
     SqlTypeCoercionRule.THREAD_PROVIDERS.set(typeCoercionRules);
-    assertThat(SqlTypeUtil.canCastFrom(f.sqlTimestamp, f.sqlBoolean, true),
+    assertThat(SqlTypeUtil.canCastFrom(f.sqlTimestampPrec3, f.sqlBoolean, true),
         is(true));
     // Recover the mappings to default.
     SqlTypeCoercionRule.THREAD_PROVIDERS.set(defaultRules);
diff --git a/core/src/test/java/org/apache/calcite/sql/validate/LexCaseSensitiveTest.java b/core/src/test/java/org/apache/calcite/sql/validate/LexCaseSensitiveTest.java
index 0c9d82aaa74..68937790ae2 100644
--- a/core/src/test/java/org/apache/calcite/sql/validate/LexCaseSensitiveTest.java
+++ b/core/src/test/java/org/apache/calcite/sql/validate/LexCaseSensitiveTest.java
@@ -24,7 +24,6 @@
 import org.apache.calcite.rel.RelNode;
 import org.apache.calcite.schema.SchemaPlus;
 import org.apache.calcite.sql.SqlNode;
-import org.apache.calcite.sql.parser.SqlParseException;
 import org.apache.calcite.sql.parser.SqlParser;
 import org.apache.calcite.sql.parser.SqlParser.Config;
 import org.apache.calcite.test.CalciteAssert;
@@ -33,7 +32,6 @@
 import org.apache.calcite.tools.Planner;
 import org.apache.calcite.tools.Program;
 import org.apache.calcite.tools.Programs;
-import org.apache.calcite.tools.RelConversionException;
 import org.apache.calcite.tools.ValidationException;
 
 import org.junit.jupiter.api.Test;
@@ -64,7 +62,7 @@ private static Planner getPlanner(List<RelTraitDef> traitDefs,
   }
 
   private static void runProjectQueryWithLex(Lex lex, String sql)
-      throws SqlParseException, ValidationException, RelConversionException {
+      throws Exception {
     Config javaLex = SqlParser.config().withLex(lex);
     Planner planner = getPlanner(null, javaLex, Programs.ofRules(Programs.RULE_SET));
     SqlNode parse = planner.parse(sql);
@@ -85,8 +83,7 @@ private static void runProjectQueryWithLex(Lex lex, String sql)
     }
   }
 
-  @Test void testCalciteCaseOracle()
-      throws SqlParseException, ValidationException, RelConversionException {
+  @Test void testCalciteCaseOracle() throws Exception {
     String sql = "select \"empid\" as EMPID, \"empid\" from\n"
         + " (select \"empid\" from \"emps\" order by \"emps\".\"deptno\")";
     runProjectQueryWithLex(Lex.ORACLE, sql);
@@ -101,50 +98,43 @@ private static void runProjectQueryWithLex(Lex lex, String sql)
     });
   }
 
-  @Test void testCalciteCaseMySql()
-      throws SqlParseException, ValidationException, RelConversionException {
+  @Test void testCalciteCaseMySql() throws Exception {
     String sql = "select empid as EMPID, empid from (\n"
         + "  select empid from emps order by `EMPS`.DEPTNO)";
     runProjectQueryWithLex(Lex.MYSQL, sql);
   }
 
-  @Test void testCalciteCaseMySqlNoException()
-      throws SqlParseException, ValidationException, RelConversionException {
+  @Test void testCalciteCaseMySqlNoException() throws Exception {
     String sql = "select EMPID, empid from\n"
         + " (select empid from emps order by emps.deptno)";
     runProjectQueryWithLex(Lex.MYSQL, sql);
   }
 
-  @Test void testCalciteCaseMySqlAnsi()
-      throws SqlParseException, ValidationException, RelConversionException {
+  @Test void testCalciteCaseMySqlAnsi() throws Exception {
     String sql = "select empid as EMPID, empid from (\n"
         + "  select empid from emps order by EMPS.DEPTNO)";
     runProjectQueryWithLex(Lex.MYSQL_ANSI, sql);
   }
 
-  @Test void testCalciteCaseMySqlAnsiNoException()
-      throws SqlParseException, ValidationException, RelConversionException {
+  @Test void testCalciteCaseMySqlAnsiNoException() throws Exception {
     String sql = "select EMPID, empid from\n"
         + " (select empid from emps order by emps.deptno)";
     runProjectQueryWithLex(Lex.MYSQL_ANSI, sql);
   }
 
-  @Test void testCalciteCaseSqlServer()
-      throws SqlParseException, ValidationException, RelConversionException {
+  @Test void testCalciteCaseSqlServer() throws Exception {
     String sql = "select empid as EMPID, empid from (\n"
         + "  select empid from emps order by EMPS.DEPTNO)";
     runProjectQueryWithLex(Lex.SQL_SERVER, sql);
   }
 
-  @Test void testCalciteCaseSqlServerNoException()
-      throws SqlParseException, ValidationException, RelConversionException {
+  @Test void testCalciteCaseSqlServerNoException() throws Exception {
     String sql = "select EMPID, empid from\n"
         + " (select empid from emps order by emps.deptno)";
     runProjectQueryWithLex(Lex.SQL_SERVER, sql);
   }
 
-  @Test void testCalciteCaseJava()
-      throws SqlParseException, ValidationException, RelConversionException {
+  @Test void testCalciteCaseJava() throws Exception {
     String sql = "select empid as EMPID, empid from (\n"
         + "  select empid from emps order by emps.deptno)";
     runProjectQueryWithLex(Lex.JAVA, sql);
@@ -159,8 +149,7 @@ private static void runProjectQueryWithLex(Lex lex, String sql)
     });
   }
 
-  @Test void testCalciteCaseJoinOracle()
-      throws SqlParseException, ValidationException, RelConversionException {
+  @Test void testCalciteCaseJoinOracle() throws Exception {
     String sql = "select t.\"empid\" as EMPID, s.\"empid\" from\n"
         + "(select * from \"emps\" where \"emps\".\"deptno\" > 100) t join\n"
         + "(select * from \"emps\" where \"emps\".\"deptno\" < 200) s\n"
@@ -168,35 +157,57 @@ private static void runProjectQueryWithLex(Lex lex, String sql)
     runProjectQueryWithLex(Lex.ORACLE, sql);
   }
 
-  @Test void testCalciteCaseJoinMySql()
-      throws SqlParseException, ValidationException, RelConversionException {
+  @Test void testCalciteCaseJoinMySql() throws Exception {
     String sql = "select t.empid as EMPID, s.empid from\n"
         + "(select * from emps where emps.deptno > 100) t join\n"
         + "(select * from emps where emps.deptno < 200) s on t.empid = s.empid";
     runProjectQueryWithLex(Lex.MYSQL, sql);
   }
 
-  @Test void testCalciteCaseJoinMySqlAnsi()
-      throws SqlParseException, ValidationException, RelConversionException {
+  @Test void testCalciteCaseJoinMySqlAnsi() throws Exception {
     String sql = "select t.empid as EMPID, s.empid from\n"
         + "(select * from emps where emps.deptno > 100) t join\n"
         + "(select * from emps where emps.deptno < 200) s on t.empid = s.empid";
     runProjectQueryWithLex(Lex.MYSQL_ANSI, sql);
   }
 
-  @Test void testCalciteCaseJoinSqlServer()
-      throws SqlParseException, ValidationException, RelConversionException {
+  @Test void testCalciteCaseJoinSqlServer() throws Exception {
     String sql = "select t.empid as EMPID, s.empid from\n"
         + "(select * from emps where emps.deptno > 100) t join\n"
         + "(select * from emps where emps.deptno < 200) s on t.empid = s.empid";
     runProjectQueryWithLex(Lex.SQL_SERVER, sql);
   }
 
-  @Test void testCalciteCaseJoinJava()
-      throws SqlParseException, ValidationException, RelConversionException {
+  @Test void testCalciteCaseJoinJava() throws Exception {
     String sql = "select t.empid as EMPID, s.empid from\n"
         + "(select * from emps where emps.deptno > 100) t join\n"
         + "(select * from emps where emps.deptno < 200) s on t.empid = s.empid";
     runProjectQueryWithLex(Lex.JAVA, sql);
   }
+
+  @Test void testCalciteCaseBigQuery() throws Exception {
+    String sql = "select empid as EMPID, empid from (\n"
+        + "  select empid from emps order by EMPS.DEPTNO)";
+    runProjectQueryWithLex(Lex.BIG_QUERY, sql);
+  }
+
+  @Test void testCalciteCaseBigQueryNoException() throws Exception {
+    String sql = "select EMPID, empid from\n"
+        + " (select empid from emps order by emps.deptno)";
+    runProjectQueryWithLex(Lex.BIG_QUERY, sql);
+  }
+
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5291">[CALCITE-5291]
+   * Make BigQuery lexical policy case insensitive</a>.
+   *
+   * <p>In reality, BigQuery treats table names as case-sensitive, column names
+   * and aliases as case-insensitive. Calcite cannot currently support a hybrid
+   * policy, so it treats table names as case-insensitive. */
+  @Test void testCalciteCaseJoinBigQuery() throws Exception {
+    String sql = "select t.empid as EMPID, s.empid from\n"
+        + "(select * from emps where emps.deptno > 100) t join\n"
+        + "(select * from emps where emps.deptno < 200) s on t.empid = s.empid";
+    runProjectQueryWithLex(Lex.BIG_QUERY, sql);
+  }
 }
diff --git a/core/src/test/java/org/apache/calcite/sql/validate/SqlValidatorUtilTest.java b/core/src/test/java/org/apache/calcite/sql/validate/SqlValidatorUtilTest.java
index 0eff1895981..38f5a586ede 100644
--- a/core/src/test/java/org/apache/calcite/sql/validate/SqlValidatorUtilTest.java
+++ b/core/src/test/java/org/apache/calcite/sql/validate/SqlValidatorUtilTest.java
@@ -75,46 +75,46 @@ private static void checkChangedFieldList(
 
   @Test void testUniquifyCaseSensitive() {
     List<String> nameList = Lists.newArrayList("col1", "COL1", "col_ABC", "col_abC");
-    List<String> resultList = SqlValidatorUtil.uniquify(
-        nameList, SqlValidatorUtil.EXPR_SUGGESTER, true);
+    List<String> resultList =
+        SqlValidatorUtil.uniquify(nameList, SqlValidatorUtil.EXPR_SUGGESTER, true);
     assertThat(nameList, sameInstance(resultList));
   }
 
   @Test void testUniquifyNotCaseSensitive() {
     List<String> nameList = Lists.newArrayList("col1", "COL1", "col_ABC", "col_abC");
-    List<String> resultList = SqlValidatorUtil.uniquify(
-        nameList, SqlValidatorUtil.EXPR_SUGGESTER, false);
+    List<String> resultList =
+        SqlValidatorUtil.uniquify(nameList, SqlValidatorUtil.EXPR_SUGGESTER, false);
     assertThat(resultList, not(nameList));
     checkChangedFieldList(nameList, resultList, false);
   }
 
   @Test void testUniquifyOrderingCaseSensitive() {
     List<String> nameList = Lists.newArrayList("k68s", "def", "col1", "COL1", "abc", "123");
-    List<String> resultList = SqlValidatorUtil.uniquify(
-        nameList, SqlValidatorUtil.EXPR_SUGGESTER, true);
+    List<String> resultList =
+        SqlValidatorUtil.uniquify(nameList, SqlValidatorUtil.EXPR_SUGGESTER, true);
     assertThat(nameList, sameInstance(resultList));
   }
 
   @Test void testUniquifyOrderingRepeatedCaseSensitive() {
     List<String> nameList = Lists.newArrayList("k68s", "def", "col1", "COL1", "def", "123");
-    List<String> resultList = SqlValidatorUtil.uniquify(
-        nameList, SqlValidatorUtil.EXPR_SUGGESTER, true);
+    List<String> resultList =
+        SqlValidatorUtil.uniquify(nameList, SqlValidatorUtil.EXPR_SUGGESTER, true);
     assertThat(nameList, not(resultList));
     checkChangedFieldList(nameList, resultList, true);
   }
 
   @Test void testUniquifyOrderingNotCaseSensitive() {
     List<String> nameList = Lists.newArrayList("k68s", "def", "col1", "COL1", "abc", "123");
-    List<String> resultList = SqlValidatorUtil.uniquify(
-        nameList, SqlValidatorUtil.EXPR_SUGGESTER, false);
+    List<String> resultList =
+        SqlValidatorUtil.uniquify(nameList, SqlValidatorUtil.EXPR_SUGGESTER, false);
     assertThat(resultList, not(nameList));
     checkChangedFieldList(nameList, resultList, false);
   }
 
   @Test void testUniquifyOrderingRepeatedNotCaseSensitive() {
     List<String> nameList = Lists.newArrayList("k68s", "def", "col1", "COL1", "def", "123");
-    List<String> resultList = SqlValidatorUtil.uniquify(
-        nameList, SqlValidatorUtil.EXPR_SUGGESTER, false);
+    List<String> resultList =
+        SqlValidatorUtil.uniquify(nameList, SqlValidatorUtil.EXPR_SUGGESTER, false);
     assertThat(resultList, not(nameList));
     checkChangedFieldList(nameList, resultList, false);
   }
diff --git a/core/src/test/java/org/apache/calcite/sql2rel/RelDecorrelatorTest.java b/core/src/test/java/org/apache/calcite/sql2rel/RelDecorrelatorTest.java
new file mode 100644
index 00000000000..8a242ba7387
--- /dev/null
+++ b/core/src/test/java/org/apache/calcite/sql2rel/RelDecorrelatorTest.java
@@ -0,0 +1,89 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.sql2rel;
+
+import org.apache.calcite.plan.RelTraitDef;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.core.JoinRelType;
+import org.apache.calcite.rex.RexCorrelVariable;
+import org.apache.calcite.schema.SchemaPlus;
+import org.apache.calcite.sql.fun.SqlStdOperatorTable;
+import org.apache.calcite.sql.parser.SqlParser;
+import org.apache.calcite.test.CalciteAssert;
+import org.apache.calcite.tools.Frameworks;
+import org.apache.calcite.tools.RelBuilder;
+import org.apache.calcite.util.Holder;
+
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.apache.calcite.test.Matchers.hasTree;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+
+/**
+ * Tests for {@link RelDecorrelator}.
+ */
+public class RelDecorrelatorTest {
+  public static Frameworks.ConfigBuilder config() {
+    final SchemaPlus rootSchema = Frameworks.createRootSchema(true);
+    return Frameworks.newConfigBuilder()
+        .parserConfig(SqlParser.Config.DEFAULT)
+        .defaultSchema(
+            CalciteAssert.addSchema(rootSchema, CalciteAssert.SchemaSpec.SCOTT_WITH_TEMPORAL))
+        .traitDefs((List<RelTraitDef>) null);
+  }
+
+  @Test void testGroupKeyNotInFrontWhenDecorrelate() {
+    final RelBuilder builder = RelBuilder.create(config().build());
+    final Holder<@Nullable RexCorrelVariable> v = Holder.empty();
+    RelNode before = builder.scan("EMP")
+        .variable(v)
+        .scan("DEPT")
+        .filter(
+            builder.equals(builder.field(0),
+                builder.call(
+                    SqlStdOperatorTable.PLUS,
+                    builder.literal(10),
+                    builder.field(v.get(), "DEPTNO"))))
+        .correlate(JoinRelType.LEFT, v.get().id, builder.field(2, 0, "DEPTNO"))
+        .aggregate(builder.groupKey("ENAME"), builder.max(builder.field("EMPNO")))
+        .build();
+
+    final String planBefore = ""
+        + "LogicalAggregate(group=[{1}], agg#0=[MAX($0)])\n"
+        + "  LogicalCorrelate(correlation=[$cor0], joinType=[left], requiredColumns=[{7}])\n"
+        + "    LogicalTableScan(table=[[scott, EMP]])\n"
+        + "    LogicalFilter(condition=[=($0, +(10, $cor0.DEPTNO))])\n"
+        + "      LogicalTableScan(table=[[scott, DEPT]])\n";
+    assertThat(before, hasTree(planBefore));
+
+    RelNode after = RelDecorrelator.decorrelateQuery(before, builder);
+
+    final String planAfter = ""
+        + "LogicalAggregate(group=[{0}], agg#0=[MAX($1)])\n"
+        + "  LogicalProject(ENAME=[$1], EMPNO=[$0])\n"
+        + "    LogicalJoin(condition=[=($8, $9)], joinType=[left])\n"
+        + "      LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], "
+        + "SAL=[$5], COMM=[$6], DEPTNO=[$7], $f8=[+(10, $7)])\n"
+        + "        LogicalTableScan(table=[[scott, EMP]])\n"
+        + "      LogicalTableScan(table=[[scott, DEPT]])\n";
+    assertThat(after, hasTree(planAfter));
+  }
+}
diff --git a/core/src/test/java/org/apache/calcite/sql2rel/RelFieldTrimmerTest.java b/core/src/test/java/org/apache/calcite/sql2rel/RelFieldTrimmerTest.java
index 81d3620ce6a..8f10a2cef73 100644
--- a/core/src/test/java/org/apache/calcite/sql2rel/RelFieldTrimmerTest.java
+++ b/core/src/test/java/org/apache/calcite/sql2rel/RelFieldTrimmerTest.java
@@ -516,4 +516,33 @@ public static Frameworks.ConfigBuilder config() {
       assertThat(trimmed, hasTree(expected));
     }
   }
+
+  @Test void testUnionFieldTrimmer() {
+    final RelBuilder builder = RelBuilder.create(config().build());
+    final RelNode root =
+        builder.scan("EMP").as("t1")
+            .project(builder.field("EMPNO"))
+            .scan("EMP").as("t2")
+            .scan("EMP").as("t3")
+            .join(JoinRelType.INNER,
+                builder.equals(
+                    builder.field(2, "t2", "EMPNO"),
+                    builder.field(2, "t3", "EMPNO")))
+            .project(builder.field("t2", "EMPNO"))
+            .union(false)
+            .build();
+    final RelFieldTrimmer fieldTrimmer = new RelFieldTrimmer(null, builder);
+    final RelNode trimmed = fieldTrimmer.trim(root);
+    final String expected = ""
+        + "LogicalUnion(all=[false])\n"
+        + "  LogicalProject(EMPNO=[$0])\n"
+        + "    LogicalTableScan(table=[[scott, EMP]])\n"
+        + "  LogicalProject(EMPNO=[$0])\n"
+        + "    LogicalJoin(condition=[=($0, $1)], joinType=[inner])\n"
+        + "      LogicalProject(EMPNO=[$0])\n"
+        + "        LogicalTableScan(table=[[scott, EMP]])\n"
+        + "      LogicalProject(EMPNO=[$0])\n"
+        + "        LogicalTableScan(table=[[scott, EMP]])\n";
+    assertThat(trimmed, hasTree(expected));
+  }
 }
diff --git a/core/src/test/java/org/apache/calcite/test/CoreQuidemTest.java b/core/src/test/java/org/apache/calcite/test/CoreQuidemTest.java
index f4410b7c5e7..6814907db48 100644
--- a/core/src/test/java/org/apache/calcite/test/CoreQuidemTest.java
+++ b/core/src/test/java/org/apache/calcite/test/CoreQuidemTest.java
@@ -17,8 +17,6 @@
 package org.apache.calcite.test;
 
 import org.apache.calcite.config.CalciteConnectionProperty;
-import org.apache.calcite.prepare.Prepare;
-import org.apache.calcite.util.TryThreadLocal;
 
 import net.hydromatic.quidem.Quidem;
 
@@ -43,7 +41,7 @@ public static void main(String[] args) throws Exception {
   }
 
   /** For {@link QuidemTest#test(String)} parameters. */
-  public static Collection<Object[]> data() {
+  @Override public Collection<String> getPath() {
     // Start with a test file we know exists, then find the directory and list
     // its files.
     final String first = "sql/agg.iq";
@@ -60,9 +58,15 @@ public static Collection<Object[]> data() {
                   ExtensionDdlExecutor.class.getName() + "#PARSER_FACTORY")
               .with(CalciteAssert.SchemaSpec.BLANK)
               .connect();
+        case "scott":
+          return CalciteAssert.that()
+              .with(CalciteConnectionProperty.PARSER_FACTORY,
+                  ExtensionDdlExecutor.class.getName() + "#PARSER_FACTORY")
+              .with(CalciteAssert.Config.SCOTT)
+              .connect();
         default:
+          return super.connect(name, reference);
         }
-        return super.connect(name, reference);
       }
     };
   }
@@ -75,26 +79,6 @@ public void testSqlMisc(String path) throws Exception {
       // Oracle as the JDBC data source.
       return;
     }
-    try (TryThreadLocal.Memo ignored = Prepare.THREAD_EXPAND.push(true)) {
-      checkRun(path);
-    }
+    checkRun(path);
   }
-
-  /** Override settings for "sql/scalar.iq". */
-  public void testSqlScalar(String path) throws Exception {
-    try (TryThreadLocal.Memo ignored = Prepare.THREAD_EXPAND.push(true)) {
-      checkRun(path);
-    }
-  }
-
-  /** Runs the dummy script "sql/dummy.iq", which is checked in empty but
-   * which you may use as scratch space during development. */
-
-  // Do not disable this test; just remember not to commit changes to dummy.iq
-  public void testSqlDummy(String path) throws Exception {
-    try (TryThreadLocal.Memo ignored = Prepare.THREAD_EXPAND.push(true)) {
-      checkRun(path);
-    }
-  }
-
 }
diff --git a/core/src/test/java/org/apache/calcite/test/ExtensionDdlExecutor.java b/core/src/test/java/org/apache/calcite/test/ExtensionDdlExecutor.java
index 9ff12c0e0e3..1466663cb94 100644
--- a/core/src/test/java/org/apache/calcite/test/ExtensionDdlExecutor.java
+++ b/core/src/test/java/org/apache/calcite/test/ExtensionDdlExecutor.java
@@ -16,62 +16,21 @@
  */
 package org.apache.calcite.test;
 
-import org.apache.calcite.adapter.java.JavaTypeFactory;
-import org.apache.calcite.jdbc.CalcitePrepare;
-import org.apache.calcite.jdbc.CalciteSchema;
-import org.apache.calcite.jdbc.ContextSqlValidator;
-import org.apache.calcite.linq4j.Enumerator;
-import org.apache.calcite.linq4j.Linq4j;
-import org.apache.calcite.linq4j.QueryProvider;
-import org.apache.calcite.linq4j.Queryable;
-import org.apache.calcite.linq4j.tree.Expression;
-import org.apache.calcite.rel.RelRoot;
-import org.apache.calcite.rel.type.RelDataType;
-import org.apache.calcite.rel.type.RelDataTypeFactory;
-import org.apache.calcite.rel.type.RelDataTypeImpl;
-import org.apache.calcite.rel.type.RelProtoDataType;
-import org.apache.calcite.schema.SchemaPlus;
-import org.apache.calcite.schema.Schemas;
-import org.apache.calcite.schema.TranslatableTable;
-import org.apache.calcite.schema.impl.AbstractTableQueryable;
-import org.apache.calcite.schema.impl.ViewTable;
-import org.apache.calcite.schema.impl.ViewTableMacro;
 import org.apache.calcite.server.DdlExecutor;
-import org.apache.calcite.server.DdlExecutorImpl;
+import org.apache.calcite.sql.SqlDataTypeSpec;
 import org.apache.calcite.sql.SqlIdentifier;
-import org.apache.calcite.sql.SqlNode;
-import org.apache.calcite.sql.SqlUtil;
-import org.apache.calcite.sql.dialect.CalciteSqlDialect;
+import org.apache.calcite.sql.ddl.SqlCreateTable;
 import org.apache.calcite.sql.parser.SqlAbstractParserImpl;
-import org.apache.calcite.sql.parser.SqlParseException;
 import org.apache.calcite.sql.parser.SqlParserImplFactory;
+import org.apache.calcite.sql.parser.parserextensiontesting.ExtensionSqlCreateTable;
 import org.apache.calcite.sql.parser.parserextensiontesting.ExtensionSqlParserImpl;
-import org.apache.calcite.sql.parser.parserextensiontesting.SqlCreateTable;
-import org.apache.calcite.sql.pretty.SqlPrettyWriter;
-import org.apache.calcite.sql.validate.SqlValidator;
-import org.apache.calcite.tools.FrameworkConfig;
-import org.apache.calcite.tools.Frameworks;
-import org.apache.calcite.tools.Planner;
-import org.apache.calcite.tools.RelConversionException;
-import org.apache.calcite.tools.ValidationException;
-import org.apache.calcite.util.Util;
-
-import com.google.common.collect.ImmutableList;
 
 import java.io.Reader;
-import java.lang.reflect.Type;
-import java.sql.PreparedStatement;
-import java.sql.SQLException;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.List;
-import java.util.Objects;
-
-import static org.apache.calcite.util.Static.RESOURCE;
+import java.util.function.BiConsumer;
 
 /** Executes the few DDL commands supported by
  * {@link ExtensionSqlParserImpl}. */
-public class ExtensionDdlExecutor extends DdlExecutorImpl {
+public class ExtensionDdlExecutor extends MockDdlExecutor {
   static final ExtensionDdlExecutor INSTANCE = new ExtensionDdlExecutor();
 
   /** Parser factory. */
@@ -87,132 +46,8 @@ public class ExtensionDdlExecutor extends DdlExecutorImpl {
         }
       };
 
-  /** Executes a {@code CREATE TABLE} command. Called via reflection. */
-  public void execute(SqlCreateTable create, CalcitePrepare.Context context) {
-    final CalciteSchema schema =
-        Schemas.subSchema(context.getRootSchema(),
-            context.getDefaultSchemaPath());
-    final JavaTypeFactory typeFactory = context.getTypeFactory();
-    final RelDataType queryRowType;
-    if (create.query != null) {
-      // A bit of a hack: pretend it's a view, to get its row type
-      final String sql =
-          create.query.toSqlString(CalciteSqlDialect.DEFAULT).getSql();
-      final ViewTableMacro viewTableMacro =
-          ViewTable.viewMacro(schema.plus(), sql, schema.path(null),
-              context.getObjectPath(), false);
-      final TranslatableTable x = viewTableMacro.apply(ImmutableList.of());
-      queryRowType = x.getRowType(typeFactory);
-
-      if (create.columnList != null
-          && queryRowType.getFieldCount() != create.columnList.size()) {
-        throw SqlUtil.newContextException(create.columnList.getParserPosition(),
-            RESOURCE.columnCountMismatch());
-      }
-    } else {
-      queryRowType = null;
-    }
-    final RelDataTypeFactory.Builder builder = typeFactory.builder();
-    if (create.columnList != null) {
-      final SqlValidator validator = new ContextSqlValidator(context, false);
-      create.forEachNameType((name, typeSpec) ->
-          builder.add(name.getSimple(), typeSpec.deriveType(validator, true)));
-    } else {
-      if (queryRowType == null) {
-        // "CREATE TABLE t" is invalid; because there is no "AS query" we need
-        // a list of column names and types, "CREATE TABLE t (INT c)".
-        throw SqlUtil.newContextException(create.name.getParserPosition(),
-            RESOURCE.createTableRequiresColumnList());
-      }
-      builder.addAll(queryRowType.getFieldList());
-    }
-    final RelDataType rowType = builder.build();
-    schema.add(create.name.getSimple(),
-        new MutableArrayTable(create.name.getSimple(),
-            RelDataTypeImpl.proto(rowType)));
-    if (create.query != null) {
-      populate(create.name, create.query, context);
-    }
-  }
-
-  /** Populates the table called {@code name} by executing {@code query}. */
-  protected static void populate(SqlIdentifier name, SqlNode query,
-      CalcitePrepare.Context context) {
-    // Generate, prepare and execute an "INSERT INTO table query" statement.
-    // (It's a bit inefficient that we convert from SqlNode to SQL and back
-    // again.)
-    final FrameworkConfig config = Frameworks.newConfigBuilder()
-        .defaultSchema(
-            Objects.requireNonNull(
-                Schemas.subSchema(context.getRootSchema(),
-                    context.getDefaultSchemaPath())).plus())
-        .build();
-    final Planner planner = Frameworks.getPlanner(config);
-    try {
-      final StringBuilder buf = new StringBuilder();
-      final SqlPrettyWriter w =
-          new SqlPrettyWriter(
-              SqlPrettyWriter.config()
-                  .withDialect(CalciteSqlDialect.DEFAULT)
-                  .withAlwaysUseParentheses(false),
-              buf);
-      buf.append("INSERT INTO ");
-      name.unparse(w, 0, 0);
-      buf.append(" ");
-      query.unparse(w, 0, 0);
-      final String sql = buf.toString();
-      final SqlNode query1 = planner.parse(sql);
-      final SqlNode query2 = planner.validate(query1);
-      final RelRoot r = planner.rel(query2);
-      final PreparedStatement prepare =
-          context.getRelRunner().prepareStatement(r.rel);
-      int rowCount = prepare.executeUpdate();
-      Util.discard(rowCount);
-      prepare.close();
-    } catch (SqlParseException | ValidationException
-        | RelConversionException | SQLException e) {
-      throw Util.throwAsRuntime(e);
-    }
-  }
-
-  /** Table backed by a Java list. */
-  private static class MutableArrayTable
-      extends AbstractModifiableTable {
-    final List list = new ArrayList();
-    private final RelProtoDataType protoRowType;
-
-    MutableArrayTable(String name, RelProtoDataType protoRowType) {
-      super(name);
-      this.protoRowType = protoRowType;
-    }
-
-    public Collection getModifiableCollection() {
-      return list;
-    }
-
-    public <T> Queryable<T> asQueryable(QueryProvider queryProvider,
-        SchemaPlus schema, String tableName) {
-      return new AbstractTableQueryable<T>(queryProvider, schema, this,
-          tableName) {
-        public Enumerator<T> enumerator() {
-          //noinspection unchecked
-          return (Enumerator<T>) Linq4j.enumerator(list);
-        }
-      };
-    }
-
-    public Type getElementType() {
-      return Object[].class;
-    }
-
-    public Expression getExpression(SchemaPlus schema, String tableName,
-        Class clazz) {
-      return Schemas.tableExpression(schema, getElementType(),
-          tableName, clazz);
-    }
-
-    public RelDataType getRowType(RelDataTypeFactory typeFactory) {
-      return protoRowType.apply(typeFactory);
-    }
+  @Override protected void forEachNameType(SqlCreateTable createTable, BiConsumer<SqlIdentifier,
+      SqlDataTypeSpec> consumer) {
+    ((ExtensionSqlCreateTable) createTable).forEachNameType(consumer);
   }
 }
diff --git a/core/src/test/java/org/apache/calcite/test/HepPlannerTest.java b/core/src/test/java/org/apache/calcite/test/HepPlannerTest.java
index 8e0ae1c1e10..1b30b20f046 100644
--- a/core/src/test/java/org/apache/calcite/test/HepPlannerTest.java
+++ b/core/src/test/java/org/apache/calcite/test/HepPlannerTest.java
@@ -32,6 +32,8 @@
 
 import com.google.common.collect.ImmutableList;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.Test;
 
 import java.io.PrintWriter;
@@ -81,11 +83,21 @@ class HepPlannerTest {
       + "  select ENAME, 50022371 as cat_id, '100' as cat_name, 0 as require_free_postage, 0 as require_15return, 0 as require_48hour,0 as require_insurance from emp where EMPNO = 20171216 and MGR = 0 and ENAME = 'Y' and SAL = 50022371\n"
       + ") a";
 
+  @Nullable
+  private static DiffRepository diffRepos = null;
+
   //~ Methods ----------------------------------------------------------------
 
+  @AfterAll
+  public static void checkActualAndReferenceFiles() {
+    diffRepos.checkActualAndReferenceFiles();
+  }
+
   public RelOptFixture fixture() {
-    return RelOptFixture.DEFAULT
+    RelOptFixture fixture = RelOptFixture.DEFAULT
         .withDiffRepos(DiffRepository.lookup(HepPlannerTest.class));
+    diffRepos = fixture.diffRepos();
+    return fixture;
   }
 
   /** Sets the SQL statement for a test. */
@@ -355,8 +367,9 @@ private void assertIncludesExactlyOnce(String message, String digest, String sub
     HepPlanner planner = new HepPlanner(HepProgram.builder().build());
     RelNode tableRel = sql("select * from dept").toRel();
     RelNode queryRel = tableRel;
-    RelOptMaterialization mat1 = new RelOptMaterialization(
-        tableRel, queryRel, null, ImmutableList.of("default", "mv"));
+    RelOptMaterialization mat1 =
+        new RelOptMaterialization(tableRel, queryRel, null,
+            ImmutableList.of("default", "mv"));
     planner.addMaterialization(mat1);
     assertEquals(planner.getMaterializations().size(), 1);
     assertEquals(planner.getMaterializations().get(0), mat1);
diff --git a/core/src/test/java/org/apache/calcite/test/InterpreterTest.java b/core/src/test/java/org/apache/calcite/test/InterpreterTest.java
index 21942b3f44c..77b486c614f 100644
--- a/core/src/test/java/org/apache/calcite/test/InterpreterTest.java
+++ b/core/src/test/java/org/apache/calcite/test/InterpreterTest.java
@@ -40,6 +40,7 @@
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.sql.parser.SqlParseException;
 import org.apache.calcite.sql.parser.SqlParser;
+import org.apache.calcite.sql2rel.SqlToRelConverter;
 import org.apache.calcite.tools.FrameworkConfig;
 import org.apache.calcite.tools.Frameworks;
 import org.apache.calcite.tools.Planner;
@@ -62,6 +63,7 @@
 import java.util.List;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Function;
+import java.util.function.UnaryOperator;
 
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.MatcherAssert.assertThat;
@@ -108,27 +110,36 @@ private static class Sql {
     private final String sql;
     private final SchemaPlus rootSchema;
     private final boolean project;
-    private final Function<RelBuilder, RelNode> relFn;
+    private final @Nullable Function<RelBuilder, RelNode> relFn;
+    private final UnaryOperator<SqlToRelConverter.Config> sqlToRelTransform;
 
     Sql(String sql, SchemaPlus rootSchema, boolean project,
-        @Nullable Function<RelBuilder, RelNode> relFn) {
+        @Nullable Function<RelBuilder, RelNode> relFn,
+        UnaryOperator<SqlToRelConverter.Config> sqlToRelTransform) {
       this.sql = sql;
       this.rootSchema = rootSchema;
       this.project = project;
       this.relFn = relFn;
+      this.sqlToRelTransform = sqlToRelTransform;
     }
 
     Sql withSql(String sql) {
-      return new Sql(sql, rootSchema, project, relFn);
+      return new Sql(sql, rootSchema, project, relFn, sqlToRelTransform);
     }
 
     @SuppressWarnings("SameParameterValue")
     Sql withProject(boolean project) {
-      return new Sql(sql, rootSchema, project, relFn);
+      return new Sql(sql, rootSchema, project, relFn, sqlToRelTransform);
     }
 
     Sql withRel(Function<RelBuilder, RelNode> relFn) {
-      return new Sql(sql, rootSchema, project, relFn);
+      return new Sql(sql, rootSchema, project, relFn, sqlToRelTransform);
+    }
+
+    Sql withSqlToRel(UnaryOperator<SqlToRelConverter.Config> transform) {
+      final UnaryOperator<SqlToRelConverter.Config> newTransform = c ->
+          transform.apply(this.sqlToRelTransform.apply(c));
+      return new Sql(sql, rootSchema, project, relFn, newTransform);
     }
 
     /** Interprets the sql and checks result with specified rows, ordered. */
@@ -146,6 +157,8 @@ Sql returnsRowsUnordered(String... rows) {
     private Planner createPlanner() {
       final FrameworkConfig config = Frameworks.newConfigBuilder()
           .parserConfig(SqlParser.Config.DEFAULT)
+          .sqlToRelConverterConfig(
+              sqlToRelTransform.apply(SqlToRelConverter.config()))
           .defaultSchema(
               CalciteAssert.addSchema(rootSchema,
                   CalciteAssert.SchemaSpec.JDBC_SCOTT,
@@ -190,7 +203,7 @@ private Sql returnsRows(boolean unordered, String[] rows) {
 
   /** Creates a {@link Sql}. */
   private Sql fixture() {
-    return new Sql("?", rootSchema, false, null);
+    return new Sql("?", rootSchema, false, null, UnaryOperator.identity());
   }
 
   private Sql sql(String sql) {
@@ -496,14 +509,16 @@ private static void assertRows(Interpreter interpreter,
     final String sql = "select x, y from (values (1, 'a'), (2, 'b'), (3, 'c')) as t(x, y)\n"
         + "where x in\n"
         + "(select x from (values (1, 'd'), (3, 'g')) as t2(x, y))";
-    sql(sql).returnsRows("[1, a]", "[3, c]");
+    sql(sql).withSqlToRel(c -> c.withExpand(true))
+        .returnsRows("[1, a]", "[3, c]");
   }
 
   @Test void testInterpretSemiJoin() {
     final String sql = "select x, y from (values (1, 'a'), (2, 'b'), (3, 'c')) as t(x, y)\n"
         + "where x in\n"
         + "(select x from (values (1, 'd'), (3, 'g')) as t2(x, y))";
-    try (Planner planner = sql(sql).createPlanner()) {
+    try (Planner planner =
+             sql(sql).withSqlToRel(c -> c.withExpand(true)).createPlanner()) {
       SqlNode validate = planner.validate(planner.parse(sql));
       RelNode convert = planner.rel(validate).rel;
       final HepProgram program = new HepProgramBuilder()
@@ -526,7 +541,8 @@ private static void assertRows(Interpreter interpreter,
     final String sql = "select x, y from (values (1, 'a'), (2, 'b'), (3, 'c')) as t(x, y)\n"
         + "where x not in\n"
         + "(select x from (values (1, 'd')) as t2(x, y))";
-    sql(sql).returnsRows("[2, b]", "[3, c]");
+    sql(sql).withSqlToRel(c -> c.withExpand(true))
+        .returnsRows("[2, b]", "[3, c]");
   }
 
   @Test void testInterpretFullJoin() {
diff --git a/core/src/test/java/org/apache/calcite/test/JdbcAdapterTest.java b/core/src/test/java/org/apache/calcite/test/JdbcAdapterTest.java
index d4bd9dc9c57..564fe6dab9b 100644
--- a/core/src/test/java/org/apache/calcite/test/JdbcAdapterTest.java
+++ b/core/src/test/java/org/apache/calcite/test/JdbcAdapterTest.java
@@ -50,23 +50,25 @@ class JdbcAdapterTest {
    * same time. */
   private static final ReentrantLock LOCK = new ReentrantLock();
 
-  /** VALUES is not pushed down, currently. */
+  /** VALUES is pushed down. */
   @Test void testValuesPlan() {
     final String sql = "select * from \"days\", (values 1, 2) as t(c)";
-    final String explain = "PLAN="
-        + "EnumerableNestedLoopJoin(condition=[true], joinType=[inner])\n"
-        + "  JdbcToEnumerableConverter\n"
+    final String explain = "PLAN=JdbcToEnumerableConverter\n"
+        + "  JdbcJoin(condition=[true], joinType=[inner])\n"
         + "    JdbcTableScan(table=[[foodmart, days]])\n"
-        + "  EnumerableValues(tuples=[[{ 1 }, { 2 }]])";
+        + "    JdbcValues(tuples=[[{ 1 }, { 2 }]])";
     final String jdbcSql = "SELECT *\n"
-        + "FROM \"foodmart\".\"days\"";
+        + "FROM \"foodmart\".\"days\",\n"
+        + "(VALUES (1),\n"
+        + "(2)) AS \"t\" (\"C\")";
     CalciteAssert.model(FoodmartSchema.FOODMART_MODEL)
         .query(sql)
         .explainContains(explain)
         .runs()
         .enable(CalciteAssert.DB == CalciteAssert.DatabaseInstance.HSQLDB
             || CalciteAssert.DB == DatabaseInstance.POSTGRESQL)
-        .planHasSql(jdbcSql);
+        .planHasSql(jdbcSql)
+        .returnsCount(14);
   }
 
   @Test void testUnionPlan() {
@@ -360,17 +362,14 @@ class JdbcAdapterTest {
             + "FROM \"SCOTT\".\"DEPT\") AS \"t0\" ON \"t\".\"DEPTNO\" = \"t0\".\"DEPTNO\"");
   }
 
-  // JdbcJoin not used for this
   @Test void testCartesianJoinWithoutKeyPlan() {
     CalciteAssert.model(JdbcTest.SCOTT_MODEL)
         .query("select empno, ename, d.deptno, dname\n"
             + "from scott.emp e,scott.dept d")
-        .explainContains("PLAN=EnumerableNestedLoopJoin(condition=[true], "
-            + "joinType=[inner])\n"
-            + "  JdbcToEnumerableConverter\n"
+        .explainContains("PLAN=JdbcToEnumerableConverter\n"
+            + "  JdbcJoin(condition=[true], joinType=[inner])\n"
             + "    JdbcProject(EMPNO=[$0], ENAME=[$1])\n"
             + "      JdbcTableScan(table=[[SCOTT, EMP]])\n"
-            + "  JdbcToEnumerableConverter\n"
             + "    JdbcProject(DEPTNO=[$0], DNAME=[$1])\n"
             + "      JdbcTableScan(table=[[SCOTT, DEPT]])")
         .runs()
@@ -402,6 +401,26 @@ class JdbcAdapterTest {
             + "FROM \"SCOTT\".\"DEPT\") AS \"t1\" ON \"t0\".\"DEPTNO\" = \"t1\".\"DEPTNO\"");
   }
 
+  @Test void testJoinConditionAlwaysTruePushDown() {
+    CalciteAssert.model(JdbcTest.SCOTT_MODEL)
+        .query("select empno, ename, d.deptno, dname\n"
+                + "from scott.emp e,scott.dept d\n"
+                + "where true")
+        .explainContains("PLAN=JdbcToEnumerableConverter\n"
+                + "  JdbcJoin(condition=[true], joinType=[inner])\n"
+                + "    JdbcProject(EMPNO=[$0], ENAME=[$1])\n"
+                + "      JdbcTableScan(table=[[SCOTT, EMP]])\n"
+                + "    JdbcProject(DEPTNO=[$0], DNAME=[$1])\n"
+                + "      JdbcTableScan(table=[[SCOTT, DEPT]])")
+        .runs()
+        .enable(CalciteAssert.DB == CalciteAssert.DatabaseInstance.HSQLDB)
+        .planHasSql("SELECT *\n"
+                + "FROM (SELECT \"EMPNO\", \"ENAME\"\n"
+                + "FROM \"SCOTT\".\"EMP\") AS \"t\",\n"
+                + "(SELECT \"DEPTNO\", \"DNAME\"\n"
+                + "FROM \"SCOTT\".\"DEPT\") AS \"t0\"");
+  }
+
   /** Test case for
    * <a href="https://issues.apache.org/jira/browse/CALCITE-893">[CALCITE-893]
    * Theta join in JdbcAdapter</a>. */
@@ -963,11 +982,11 @@ private LockWrapper exclusiveCleanDb(Connection c) throws SQLException {
         final String jdbcSql = "INSERT INTO \"foodmart\".\"expense_fact\""
             + " (\"store_id\", \"account_id\", \"exp_date\", \"time_id\","
             + " \"category_id\", \"currency_id\", \"amount\")\n"
-            + "(SELECT \"store_id\", \"account_id\", \"exp_date\","
+            + "SELECT \"store_id\", \"account_id\", \"exp_date\","
             + " \"time_id\" + 1 AS \"time_id\", \"category_id\","
             + " \"currency_id\", \"amount\"\n"
             + "FROM \"foodmart\".\"expense_fact\"\n"
-            + "WHERE \"store_id\" = 666)";
+            + "WHERE \"store_id\" = 666";
         that.query(sql)
             .explainContains(explain)
             .planUpdateHasSql(jdbcSql, 1);
@@ -1074,6 +1093,19 @@ private LockWrapper exclusiveCleanDb(Connection c) throws SQLException {
         .runs();
   }
 
+  /**
+   * Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5243">[CALCITE-5243]
+   * "SELECT NULL AS C causes NoSuchMethodException: java.sql.ResultSet.getVoid(int)</a>. */
+  @Test void testNullSelect() {
+    final String sql = "select NULL AS C from \"days\"";
+    CalciteAssert.model(FoodmartSchema.FOODMART_MODEL)
+        .query(sql)
+        .runs()
+        .returnsCount(7)
+        .returns("C=null\nC=null\nC=null\nC=null\nC=null\nC=null\nC=null\n");
+  }
+
   /** Acquires a lock, and releases it when closed. */
   static class LockWrapper implements AutoCloseable {
     private final Lock lock;
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 3edb668637f..1d2c7763eb8 100644
--- a/core/src/test/java/org/apache/calcite/test/JdbcFrontJdbcBackTest.java
+++ b/core/src/test/java/org/apache/calcite/test/JdbcFrontJdbcBackTest.java
@@ -84,8 +84,9 @@ private void checkTablesByType(final String tableType,
     that()
         .with(CalciteAssert.Config.REGULAR_PLUS_METADATA)
         .doWithConnection(connection -> {
-          try (ResultSet rset = connection.getMetaData().getTables(null, null,
-              null, new String[] {tableType})) {
+          try (ResultSet rset =
+                   connection.getMetaData().getTables(null, null, null,
+                       new String[] {tableType})) {
             StringBuilder buf = new StringBuilder();
             while (rset.next()) {
               buf.append(rset.getString(3)).append(';');
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 ddd35fa1a3d..e62d4552773 100644
--- a/core/src/test/java/org/apache/calcite/test/JdbcTest.java
+++ b/core/src/test/java/org/apache/calcite/test/JdbcTest.java
@@ -140,6 +140,7 @@
 import java.util.Properties;
 import java.util.Set;
 import java.util.TimeZone;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Consumer;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
@@ -151,7 +152,6 @@
 import static org.apache.calcite.util.Static.RESOURCE;
 
 import static org.hamcrest.CoreMatchers.containsString;
-import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.CoreMatchers.hasItem;
 import static org.hamcrest.CoreMatchers.instanceOf;
 import static org.hamcrest.CoreMatchers.is;
@@ -164,6 +164,7 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
 
@@ -262,10 +263,10 @@ static void forEachExpand(Runnable r) {
     employees.add(new Employee(135, 10, "Simon", 56.7f, null));
     try (TryThreadLocal.Memo ignore =
              EmpDeptTableFactory.THREAD_COLLECTION.push(employees)) {
-      final CalciteAssert.AssertThat with = modelWithView(
-          "select \"name\", \"empid\" as e, \"salary\" "
-              + "from \"MUTABLE_EMPLOYEES\" where \"deptno\" = 10",
-          null);
+      final CalciteAssert.AssertThat with =
+          modelWithView("select \"name\", \"empid\" as e, \"salary\" "
+                  + "from \"MUTABLE_EMPLOYEES\" where \"deptno\" = 10",
+              null);
       with.query("select \"name\" from \"adhoc\".V order by \"name\"")
           .returns("name=Simon\n");
       with.doWithConnection(connection -> {
@@ -447,7 +448,7 @@ private void addTableMacro(Connection connection, Method method) throws SQLExcep
         + "where n < 15");
     // The call to "View('(10), (2)')" expands to 'values (1), (3), (10), (20)'.
     assertThat(CalciteAssert.toString(resultSet),
-        equalTo("N=1\n"
+        is("N=1\n"
             + "N=3\n"
             + "N=10\n"));
     connection.close();
@@ -468,7 +469,7 @@ private void addTableMacro(Connection connection, Method method) throws SQLExcep
         + "                         ARRAY[3, 4, CAST(null AS INTEGER)])) as t(n)");
     // The call to "View('(10), (2)')" expands to 'values (1), (3), (10), (20)'.
     assertThat(CalciteAssert.toString(resultSet),
-        equalTo("N={'a'=1, 'baz'=2}\n"
+        is("N={'a'=1, 'baz'=2}\n"
             + "N=[3, 4, null]    \n"));
     connection.close();
   }
@@ -482,38 +483,43 @@ private void addTableMacro(Connection connection, Method method) throws SQLExcep
         DriverManager.getConnection("jdbc:calcite:");
     addTableMacro(connection, Smalls.STR_METHOD);
     // check for cast
-    ResultSet resultSet = connection.createStatement().executeQuery(
-        "select * from table(\"s\".\"str\"(MAP['a', 1, 'baz', 2], cast(1 as bigint))) as t(n)");
+    ResultSet resultSet =
+        connection.createStatement().executeQuery("select *\n"
+            + "from table(\"s\".\"str\"(MAP['a', 1, 'baz', 2], cast(1 as bigint))) as t(n)");
     assertThat(CalciteAssert.toString(resultSet),
-        equalTo("N={'a'=1, 'baz'=2}\n"
+        is("N={'a'=1, 'baz'=2}\n"
             + "N=1               \n"));
     // check for Boolean type
-    resultSet = connection.createStatement().executeQuery(
-        "select * from table(\"s\".\"str\"(MAP['a', 1, 'baz', 2], true)) as t(n)");
+    resultSet =
+        connection.createStatement().executeQuery("select *\n"
+            + "from table(\"s\".\"str\"(MAP['a', 1, 'baz', 2], true)) as t(n)");
     assertThat(CalciteAssert.toString(resultSet),
-        equalTo("N={'a'=1, 'baz'=2}\n"
+        is("N={'a'=1, 'baz'=2}\n"
             + "N=true            \n"));
     // check for nested cast
-    resultSet = connection.createStatement().executeQuery(
-        "select * from table(\"s\".\"str\"(MAP['a', 1, 'baz', 2],"
+    resultSet =
+        connection.createStatement().executeQuery("select *\n"
+            + "from table(\"s\".\"str\"(MAP['a', 1, 'baz', 2],"
             + "cast(cast(1 as int) as varchar(1)))) as t(n)");
     assertThat(CalciteAssert.toString(resultSet),
-        equalTo("N={'a'=1, 'baz'=2}\n"
+        is("N={'a'=1, 'baz'=2}\n"
             + "N=1               \n"));
 
-    resultSet = connection.createStatement().executeQuery(
-        "select * from table(\"s\".\"str\"(MAP['a', 1, 'baz', 2],"
+    resultSet =
+        connection.createStatement().executeQuery("select *\n"
+            + "from table(\"s\".\"str\"(MAP['a', 1, 'baz', 2],"
             + "cast(cast(cast('2019-10-18 10:35:23' as TIMESTAMP) as BIGINT) as VARCHAR))) as t(n)");
     assertThat(CalciteAssert.toString(resultSet),
-        equalTo("N={'a'=1, 'baz'=2}     \n"
+        is("N={'a'=1, 'baz'=2}     \n"
             + "N='2019-10-18 10:35:23'\n"));
 
     // check for implicit type coercion
     addTableMacro(connection, Smalls.VIEW_METHOD);
-    resultSet = connection.createStatement().executeQuery(
-        "select * from table(\"s\".\"view\"(5)) as t(n)");
+    resultSet =
+        connection.createStatement().executeQuery("select *\n"
+            + "from table(\"s\".\"view\"(5)) as t(n)");
     assertThat(CalciteAssert.toString(resultSet),
-        equalTo("N=1\n"
+        is("N=1\n"
             + "N=3\n"
             + "N=5\n"));
     connection.close();
@@ -760,17 +766,71 @@ private void checkTableFunctionInModel(Class<?> clazz) {
 
   /** Tests that a driver can be extended with its own parser and can execute
    * its own flavor of DDL. */
-  @Test void testMockDdl() throws Exception {
-    final MockDdlDriver driver = new MockDdlDriver();
+  @Test void testMockDdl() {
+    final AtomicInteger counter = new AtomicInteger();
+
+    // Raw MockDdlDriver does not implement commit.
+    checkMockDdl(counter, false, new MockDdlDriver());
+
+    // MockDdlDriver implements commit if we have supplied a
+    // prepare-factory to do so.
+    checkMockDdl(counter, true,
+        new MockDdlDriver()
+            .withPrepareFactory(() -> new CountingPrepare(counter)));
+
+    // Raw MockDdlDriver2 does not implement commit.
+    final MockDdlDriver2 driver2 = new MockDdlDriver2(counter);
+    checkMockDdl(counter, false, driver2);
+
+    // MockDdlDriver2 implements commit if we have supplied a
+    // prepare-factory to do so.
+    checkMockDdl(counter, true,
+        driver2.withPrepareFactory(() -> new CountingPrepare(counter)));
+
+    // MockDdlDriver2 implements commit if we override its createPrepareFactory
+    // method. The method is deprecated but override still needs to work.
+    checkMockDdl(counter, true,
+        new MockDdlDriver2(counter) {
+          @SuppressWarnings("deprecation")
+          @Override protected Function0<CalcitePrepare> createPrepareFactory() {
+            return () -> new CountingPrepare(counter);
+          }
+        });
+
+    // MockDdlDriver2 implements commit if we override its createPrepareFactory
+    // method.
+    checkMockDdl(counter, true,
+        new MockDdlDriver2(counter) {
+          @Override public CalcitePrepare createPrepare() {
+            return new CountingPrepare(counter);
+          }
+        });
+  }
+
+  static void checkMockDdl(AtomicInteger counter, boolean hasCommit,
+      Driver driver) {
     try (Connection connection =
              driver.connect("jdbc:calcite:", new Properties());
-        Statement statement = connection.createStatement()) {
-      assertThat(driver.counter, is(0));
-      statement.executeUpdate("COMMIT");
-      assertThat(driver.counter, is(1));
+         Statement statement = connection.createStatement()) {
+      final int original = counter.get();
+      if (hasCommit) {
+        int rowCount = statement.executeUpdate("COMMIT");
+        assertThat(rowCount, is(0));
+        assertThat(counter.get() - original, is(1));
+      } else {
+        assertThrows(SQLException.class,
+            () -> statement.executeUpdate("COMMIT"));
+      }
+    } catch (SQLException e) {
+      throw new AssertionError(e);
     }
   }
 
+  @Test void testCustomValidator() {
+    final Driver driver = new MockDdlDriver().withPrepareFactory(MockPrepareImpl::new);
+    assertThat(driver.createPrepare().getClass(), is(MockPrepareImpl.class));
+  }
+
   /**
    * The example in the README.
    */
@@ -1018,21 +1078,21 @@ private void checkResultSetMetaData(Connection connection, String sql)
               int x = rs.findColumn("z");
               fail("expected error, got " + x);
             } catch (SQLException e) {
-              assertThat(e.getMessage(), equalTo("column 'z' not found"));
+              assertThat(e.getMessage(), is("column 'z' not found"));
             }
             try {
               int x = rs.getInt(0);
               fail("expected error, got " + x);
             } catch (SQLException e) {
               assertThat(e.getMessage(),
-                  equalTo("invalid column ordinal: 0"));
+                  is("invalid column ordinal: 0"));
             }
             try {
               int x = rs.getInt(5);
               fail("expected error, got " + x);
             } catch (SQLException e) {
               assertThat(e.getMessage(),
-                  equalTo("invalid column ordinal: 5"));
+                  is("invalid column ordinal: 5"));
             }
           } catch (SQLException e) {
             throw TestUtil.rethrow(e);
@@ -1576,7 +1636,7 @@ private void checkResultSetMetaData(Connection connection, String sql)
           try {
             assertTrue(resultSet.next());
             final BigDecimal bigDecimal = resultSet.getBigDecimal(1);
-            assertThat(bigDecimal, equalTo(BigDecimal.valueOf(2008)));
+            assertThat(bigDecimal, is(BigDecimal.valueOf(2008)));
           } catch (SQLException e) {
             throw TestUtil.rethrow(e);
           }
@@ -1770,7 +1830,6 @@ private void checkResultSetMetaData(Connection connection, String sql)
   /** Test case for
    * <a href="https://issues.apache.org/jira/browse/CALCITE-35">[CALCITE-35]
    * Support parenthesized sub-clause in JOIN</a>. */
-  @Disabled
   @Test void testJoinJoin() {
     CalciteAssert.that()
         .with(CalciteAssert.Config.FOODMART_CLONE)
@@ -1795,24 +1854,22 @@ private void checkResultSetMetaData(Connection connection, String sql)
             + " or \"promotion\".\"media_type\" = 'Sunday Paper'\n"
             + " or \"promotion\".\"media_type\" = 'Street Handout')\n"
             + " and (\"product_class\".\"product_family\" = 'Drink')\n"
-            + " and (\"customer\".\"country\" = 'USA' and \"customer\".\"state_province\""
-            + " = 'WA' and \"customer\".\"city\" = 'Bellingham')\n"
+            + " and (\"customer\".\"country\" = 'USA'\n"
+            + "   and \"customer\".\"state_province\" = 'WA'\n"
+            + "   and \"customer\".\"city\" = 'Bellingham')\n"
             + "group by \"product_class\".\"product_family\",\n"
             + "   \"product_class\".\"product_department\",\n"
             + "   \"customer\".\"country\",\n"
             + "   \"customer\".\"state_province\",\n"
             + "   \"customer\".\"city\"\n"
-            + "order by ISNULL(\"product_class\".\"product_family\") ASC,   \"product_class\".\"product_family\" ASC,\n"
-            + "   ISNULL(\"product_class\".\"product_department\") ASC,   \"product_class\".\"product_department\" ASC,\n"
-            + "   ISNULL(\"customer\".\"country\") ASC,   \"customer\".\"country\" ASC,\n"
-            + "   ISNULL(\"customer\".\"state_province\") ASC,   \"customer\".\"state_province\" ASC,\n"
-            + "   ISNULL(\"customer\".\"city\") ASC,   \"customer\".\"city\" ASC")
-        .returns("+-------+---------------------+-----+------+------------+\n"
-            + "| c0    | c1                  | c2  | c3   | c4         |\n"
-            + "+-------+---------------------+-----+------+------------+\n"
-            + "| Drink | Alcoholic Beverages | USA | WA   | Bellingham |\n"
-            + "| Drink | Dairy               | USA | WA   | Bellingham |\n"
-            + "+-------+---------------------+-----+------+------------+");
+            + "order by \"product_class\".\"product_family\" asc nulls first,\n"
+            + "   \"product_class\".\"product_department\" asc nulls first,\n"
+            + "   \"customer\".\"country\" asc nulls first,\n"
+            + "   \"customer\".\"state_province\" asc nulls first,\n"
+            + "   \"customer\".\"city\" asc nulls first")
+        .returnsUnordered(
+            "c0=Drink; c1=Alcoholic Beverages; c2=USA; c3=WA; c4=Bellingham",
+            "c0=Drink; c1=Dairy; c2=USA; c3=WA; c4=Bellingham");
   }
 
   /** Four-way join. Used to take 80 seconds. */
@@ -1995,8 +2052,9 @@ private static List<Pair<String, String>> querify(String[] queries1) {
     assertFalse(rs.next());
     rs.close();
 
-    rs = calciteStatement.executeQuery(
-        "SELECT ID, CARDINALITY(VALS), VALS[2] FROM ARR_TABLE");
+    rs =
+        calciteStatement.executeQuery("SELECT ID, CARDINALITY(VALS), VALS[2]\n"
+            + "FROM ARR_TABLE");
     assertTrue(rs.next());
     assertEquals(1, rs.getInt(1));
     assertEquals(3, rs.getInt(2));
@@ -2004,12 +2062,11 @@ private static List<Pair<String, String>> querify(String[] queries1) {
     assertFalse(rs.next());
     rs.close();
 
-    rs = calciteStatement.executeQuery(
-        "SELECT * FROM ARR_TABLE2");
+    rs = calciteStatement.executeQuery("SELECT * FROM ARR_TABLE2");
     final ResultSetMetaData metaData = rs.getMetaData();
-    assertThat(metaData.getColumnTypeName(1), equalTo("INTEGER"));
-    assertThat(metaData.getColumnTypeName(2), equalTo("INTEGER ARRAY"));
-    assertThat(metaData.getColumnTypeName(3), equalTo("VARCHAR(10) ARRAY"));
+    assertThat(metaData.getColumnTypeName(1), is("INTEGER"));
+    assertThat(metaData.getColumnTypeName(2), is("INTEGER ARRAY"));
+    assertThat(metaData.getColumnTypeName(3), is("VARCHAR(10) ARRAY"));
     assertTrue(rs.next());
     assertEquals(1, rs.getInt(1));
     assertThat(rs.getArray(2), notNullValue());
@@ -2042,37 +2099,37 @@ private static List<Pair<String, String>> querify(String[] queries1) {
                     + "    array[\"name\"]] as a\n"
                     + "from \"hr\".\"emps\"");
             assertThat(resultSet.next(), is(true));
-            assertThat(resultSet.getInt(1), equalTo(100));
+            assertThat(resultSet.getInt(1), is(100));
             assertThat(resultSet.getString(2),
-                equalTo("[[x, y, z], [Bill]]"));
+                is("[[x, y, z], [Bill]]"));
             final Array array = resultSet.getArray(2);
             assertThat(array.getBaseType(),
-                equalTo(Types.ARRAY));
+                is(Types.ARRAY));
             final Object[] arrayValues =
                 (Object[]) array.getArray();
-            assertThat(arrayValues.length, equalTo(2));
+            assertThat(arrayValues.length, is(2));
             final Array subArray = (Array) arrayValues[0];
             assertThat(subArray.getBaseType(),
-                equalTo(Types.VARCHAR));
+                is(Types.VARCHAR));
             final Object[] subArrayValues =
                 (Object[]) subArray.getArray();
-            assertThat(subArrayValues.length, equalTo(3));
-            assertThat(subArrayValues[2], equalTo((Object) "z"));
+            assertThat(subArrayValues.length, is(3));
+            assertThat(subArrayValues[2], is((Object) "z"));
 
             final ResultSet subResultSet = subArray.getResultSet();
             assertThat(subResultSet.next(), is(true));
-            assertThat(subResultSet.getString(1), equalTo("x"));
+            assertThat(subResultSet.getString(1), is("x"));
             try {
               final String string = subResultSet.getString(2);
               fail("expected error, got " + string);
             } catch (SQLException e) {
               assertThat(e.getMessage(),
-                  equalTo("invalid column ordinal: 2"));
+                  is("invalid column ordinal: 2"));
             }
             assertThat(subResultSet.next(), is(true));
             assertThat(subResultSet.next(), is(true));
             assertThat(subResultSet.isAfterLast(), is(false));
-            assertThat(subResultSet.getString(1), equalTo("z"));
+            assertThat(subResultSet.getString(1), is("z"));
             assertThat(subResultSet.next(), is(false));
             assertThat(subResultSet.isAfterLast(), is(true));
             statement.close();
@@ -2115,7 +2172,7 @@ void checkMultisetQueryWithSingleColumn() {
         .query("select multiset(\n"
             + "  select \"deptno\" from \"hr\".\"emps\") as a\n"
             + "from (values (1))")
-        .returnsUnordered("A=[{10}, {20}, {10}, {10}]");
+        .returnsUnordered("A=[10, 20, 10, 10]");
   }
 
   @Test void testUnnestArray() {
@@ -5075,19 +5132,17 @@ private CalciteAssert.AssertQuery predicate(String foo) {
   /** Tests a correlated scalar sub-query in the SELECT clause.
    *
    * <p>Note that there should be an extra row "empid=200; deptno=20;
-   * DNAME=null" but left join doesn't work.</p> */
+   * DNAME=null" but left join doesn't work. */
   @Test void testScalarSubQuery() {
-    try (TryThreadLocal.Memo ignored = Prepare.THREAD_EXPAND.push(true)) {
-      CalciteAssert.hr()
-          .query("select \"empid\", \"deptno\",\n"
-              + " (select \"name\" from \"hr\".\"depts\"\n"
-              + "  where \"deptno\" = e.\"deptno\") as dname\n"
-              + "from \"hr\".\"emps\" as e")
-          .returnsUnordered("empid=100; deptno=10; DNAME=Sales",
-              "empid=110; deptno=10; DNAME=Sales",
-              "empid=150; deptno=10; DNAME=Sales",
-              "empid=200; deptno=20; DNAME=null");
-    }
+    CalciteAssert.hr()
+        .query("select \"empid\", \"deptno\",\n"
+            + " (select \"name\" from \"hr\".\"depts\"\n"
+            + "  where \"deptno\" = e.\"deptno\") as dname\n"
+            + "from \"hr\".\"emps\" as e")
+        .returnsUnordered("empid=100; deptno=10; DNAME=Sales",
+            "empid=110; deptno=10; DNAME=Sales",
+            "empid=150; deptno=10; DNAME=Sales",
+            "empid=200; deptno=20; DNAME=null");
   }
 
   /** Test case for
@@ -5254,21 +5309,19 @@ private CalciteAssert.AssertQuery withEmpDept(String sql) {
   }
 
   @Test void testScalarSubQueryInCase() {
-    try (TryThreadLocal.Memo ignored = Prepare.THREAD_EXPAND.push(true)) {
-      CalciteAssert.hr()
-          .query("select e.\"name\",\n"
-              + " (CASE e.\"deptno\"\n"
-              + "  WHEN (Select \"deptno\" from \"hr\".\"depts\" d\n"
-              + "        where d.\"deptno\" = e.\"deptno\")\n"
-              + "  THEN (Select d.\"name\" from \"hr\".\"depts\" d\n"
-              + "        where d.\"deptno\" = e.\"deptno\")\n"
-              + "  ELSE 'DepartmentNotFound'  END) AS DEPTNAME\n"
-              + "from \"hr\".\"emps\" e")
-          .returnsUnordered("name=Bill; DEPTNAME=Sales",
-              "name=Eric; DEPTNAME=DepartmentNotFound",
-              "name=Sebastian; DEPTNAME=Sales",
-              "name=Theodore; DEPTNAME=Sales");
-    }
+    CalciteAssert.hr()
+        .query("select e.\"name\",\n"
+            + " (CASE e.\"deptno\"\n"
+            + "  WHEN (Select \"deptno\" from \"hr\".\"depts\" d\n"
+            + "        where d.\"deptno\" = e.\"deptno\")\n"
+            + "  THEN (Select d.\"name\" from \"hr\".\"depts\" d\n"
+            + "        where d.\"deptno\" = e.\"deptno\")\n"
+            + "  ELSE 'DepartmentNotFound'  END) AS DEPTNAME\n"
+            + "from \"hr\".\"emps\" e")
+        .returnsUnordered("name=Bill; DEPTNAME=Sales",
+            "name=Eric; DEPTNAME=DepartmentNotFound",
+            "name=Sebastian; DEPTNAME=Sales",
+            "name=Theodore; DEPTNAME=Sales");
   }
 
   @Test void testScalarSubQueryInCase2() {
@@ -5316,8 +5369,8 @@ private CalciteAssert.AssertQuery withEmpDept(String sql) {
             }
             statement.setMaxRows(2);
             assertEquals(2, statement.getMaxRows());
-            final ResultSet resultSet = statement.executeQuery(
-                "select * from \"hr\".\"emps\"");
+            final ResultSet resultSet =
+                statement.executeQuery("select * from \"hr\".\"emps\"");
             assertTrue(resultSet.next());
             assertTrue(resultSet.next());
             assertFalse(resultSet.next());
@@ -5435,6 +5488,8 @@ private void checkPreparedOffsetFetch(final int offset, final int fetch,
    * Query with parameterized LIMIT and correlated sub-query throws AssertionError "not a
    * literal"</a>.
    */
+  @Disabled("[CALCITE-5229] JdbcTest#testDynamicParameterInLimitOffset"
+      + " throws IllegalArgumentException")
   @Test void testDynamicParameterInLimitOffset() {
     CalciteAssert.hr()
         .query("SELECT * FROM \"hr\".\"emps\" AS a "
@@ -5469,7 +5524,7 @@ private void checkPreparedOffsetFetch(final int offset, final int fetch,
   @Test void testModelWithComment() {
     final String model =
         FoodmartSchema.FOODMART_MODEL.replace("schemas:", "/* comment */ schemas:");
-    assertThat(model, not(equalTo(FoodmartSchema.FOODMART_MODEL)));
+    assertThat(model, not(is(FoodmartSchema.FOODMART_MODEL)));
     CalciteAssert.model(model)
         .query("select count(*) as c from \"foodmart\".\"time_by_day\"")
         .returns("C=730\n");
@@ -5850,8 +5905,9 @@ private CalciteAssert.AssertThat modelWithView(String view,
         }
 
         // views only
-        try (ResultSet r = metaData.getTables(null, "adhoc", null,
-            new String[]{Schema.TableType.VIEW.jdbcName})) {
+        try (ResultSet r =
+                 metaData.getTables(null, "adhoc", null,
+                     new String[]{Schema.TableType.VIEW.jdbcName})) {
           assertEquals(
               "TABLE_CAT=null; TABLE_SCHEM=adhoc; TABLE_NAME=V; TABLE_TYPE=VIEW; REMARKS=null; TYPE_CAT=null; TYPE_SCHEM=null; TYPE_NAME=null; SELF_REFERENCING_COL_NAME=null; REF_GENERATION=null\n",
               CalciteAssert.toString(r));
@@ -6548,8 +6604,9 @@ private void checkGetTimestamp(Connection con) throws SQLException {
         .doWithConnection(connection -> {
           try {
             Statement stmt = connection.createStatement();
-            ResultSet rs = stmt.executeQuery(
-                "select min(\"date\") mindate from \"foodmart\".\"currency\"");
+            ResultSet rs =
+                stmt.executeQuery("select min(\"date\") mindate\n"
+                    + "from \"foodmart\".\"currency\"");
             assertTrue(rs.next());
             assertEquals(
                 Date.valueOf("1997-01-01"),
@@ -6575,8 +6632,10 @@ private void checkGetTimestamp(Connection con) throws SQLException {
         .doWithConnection(connection -> {
           try {
             Statement stmt = connection.createStatement();
-            ResultSet rs = stmt.executeQuery(
-                "select \"hire_date\" from \"foodmart\".\"employee\" where \"employee_id\" = 1");
+            ResultSet rs =
+                stmt.executeQuery("select \"hire_date\"\n"
+                    + "from \"foodmart\".\"employee\"\n"
+                    + "where \"employee_id\" = 1");
             assertTrue(rs.next());
             assertEquals(
                 Timestamp.valueOf("1994-12-01 00:00:00"),
@@ -6651,23 +6710,23 @@ private void checkGetTimestamp(Connection con) throws SQLException {
         .doWithConnection(connection -> {
           try {
             DatabaseMetaData metaData = connection.getMetaData();
-            assertThat(metaData.getIdentifierQuoteString(), equalTo("`"));
+            assertThat(metaData.getIdentifierQuoteString(), is("`"));
             assertThat(metaData.supportsMixedCaseIdentifiers(),
-                equalTo(false));
+                is(false));
             assertThat(metaData.storesMixedCaseIdentifiers(),
-                equalTo(true));
+                is(true));
             assertThat(metaData.storesUpperCaseIdentifiers(),
-                equalTo(false));
+                is(false));
             assertThat(metaData.storesLowerCaseIdentifiers(),
-                equalTo(false));
+                is(false));
             assertThat(metaData.supportsMixedCaseQuotedIdentifiers(),
-                equalTo(false));
+                is(false));
             assertThat(metaData.storesMixedCaseQuotedIdentifiers(),
-                equalTo(true));
+                is(true));
             assertThat(metaData.storesUpperCaseIdentifiers(),
-                equalTo(false));
+                is(false));
             assertThat(metaData.storesLowerCaseQuotedIdentifiers(),
-                equalTo(false));
+                is(false));
           } catch (SQLException e) {
             throw TestUtil.rethrow(e);
           }
@@ -6681,23 +6740,23 @@ private void checkGetTimestamp(Connection con) throws SQLException {
         .doWithConnection(connection -> {
           try {
             DatabaseMetaData metaData = connection.getMetaData();
-            assertThat(metaData.getIdentifierQuoteString(), equalTo("\""));
+            assertThat(metaData.getIdentifierQuoteString(), is("\""));
             assertThat(metaData.supportsMixedCaseIdentifiers(),
-                equalTo(false));
+                is(false));
             assertThat(metaData.storesMixedCaseIdentifiers(),
-                equalTo(true));
+                is(true));
             assertThat(metaData.storesUpperCaseIdentifiers(),
-                equalTo(false));
+                is(false));
             assertThat(metaData.storesLowerCaseIdentifiers(),
-                equalTo(false));
+                is(false));
             assertThat(metaData.supportsMixedCaseQuotedIdentifiers(),
-                equalTo(false));
+                is(false));
             assertThat(metaData.storesMixedCaseQuotedIdentifiers(),
-                equalTo(true));
+                is(true));
             assertThat(metaData.storesUpperCaseIdentifiers(),
-                equalTo(false));
+                is(false));
             assertThat(metaData.storesLowerCaseQuotedIdentifiers(),
-                equalTo(false));
+                is(false));
           } catch (SQLException e) {
             throw TestUtil.rethrow(e);
           }
@@ -6711,23 +6770,23 @@ private void checkGetTimestamp(Connection con) throws SQLException {
         .doWithConnection(connection -> {
           try {
             DatabaseMetaData metaData = connection.getMetaData();
-            assertThat(metaData.getIdentifierQuoteString(), equalTo("["));
+            assertThat(metaData.getIdentifierQuoteString(), is("["));
             assertThat(metaData.supportsMixedCaseIdentifiers(),
-                equalTo(false));
+                is(false));
             assertThat(metaData.storesMixedCaseIdentifiers(),
-                equalTo(true));
+                is(true));
             assertThat(metaData.storesUpperCaseIdentifiers(),
-                equalTo(false));
+                is(false));
             assertThat(metaData.storesLowerCaseIdentifiers(),
-                equalTo(false));
+                is(false));
             assertThat(metaData.supportsMixedCaseQuotedIdentifiers(),
-                equalTo(false));
+                is(false));
             assertThat(metaData.storesMixedCaseQuotedIdentifiers(),
-                equalTo(true));
+                is(true));
             assertThat(metaData.storesUpperCaseIdentifiers(),
-                equalTo(false));
+                is(false));
             assertThat(metaData.storesLowerCaseQuotedIdentifiers(),
-                equalTo(false));
+                is(false));
           } catch (SQLException e) {
             throw TestUtil.rethrow(e);
           }
@@ -6742,26 +6801,26 @@ private void checkGetTimestamp(Connection con) throws SQLException {
           try {
             DatabaseMetaData metaData = connection.getMetaData();
             assertThat(metaData.getIdentifierQuoteString(),
-                equalTo("\""));
+                is("\""));
             assertThat(metaData.supportsMixedCaseIdentifiers(),
-                equalTo(false));
+                is(false));
             assertThat(metaData.storesMixedCaseIdentifiers(),
-                equalTo(false));
+                is(false));
             assertThat(metaData.storesUpperCaseIdentifiers(),
-                equalTo(true));
+                is(true));
             assertThat(metaData.storesLowerCaseIdentifiers(),
-                equalTo(false));
+                is(false));
             assertThat(metaData.supportsMixedCaseQuotedIdentifiers(),
-                equalTo(true));
+                is(true));
             // Oracle JDBC 12.1.0.1.0 returns true here, however it is
             // not clear if the bug is in JDBC specification or Oracle
             // driver
             assertThat(metaData.storesMixedCaseQuotedIdentifiers(),
-                equalTo(false));
+                is(false));
             assertThat(metaData.storesUpperCaseQuotedIdentifiers(),
-                equalTo(false));
+                is(false));
             assertThat(metaData.storesLowerCaseQuotedIdentifiers(),
-                equalTo(false));
+                is(false));
           } catch (SQLException e) {
             throw TestUtil.rethrow(e);
           }
@@ -6776,23 +6835,23 @@ private void checkGetTimestamp(Connection con) throws SQLException {
           try {
             DatabaseMetaData metaData = connection.getMetaData();
             assertThat(metaData.getIdentifierQuoteString(),
-                equalTo("`"));
+                is("`"));
             assertThat(metaData.supportsMixedCaseIdentifiers(),
-                equalTo(true));
+                is(true));
             assertThat(metaData.storesMixedCaseIdentifiers(),
-                equalTo(false));
+                is(false));
             assertThat(metaData.storesUpperCaseIdentifiers(),
-                equalTo(false));
+                is(false));
             assertThat(metaData.storesLowerCaseIdentifiers(),
-                equalTo(false));
+                is(false));
             assertThat(metaData.supportsMixedCaseQuotedIdentifiers(),
-                equalTo(true));
+                is(true));
             assertThat(metaData.storesMixedCaseQuotedIdentifiers(),
-                equalTo(false));
+                is(false));
             assertThat(metaData.storesUpperCaseQuotedIdentifiers(),
-                equalTo(false));
+                is(false));
             assertThat(metaData.storesLowerCaseQuotedIdentifiers(),
-                equalTo(false));
+                is(false));
           } catch (SQLException e) {
             throw TestUtil.rethrow(e);
           }
@@ -6811,23 +6870,23 @@ private void checkGetTimestamp(Connection con) throws SQLException {
           try {
             DatabaseMetaData metaData = connection.getMetaData();
             assertThat(metaData.getIdentifierQuoteString(),
-                equalTo("`"));
+                is("`"));
             assertThat(metaData.supportsMixedCaseIdentifiers(),
-                equalTo(true));
+                is(true));
             assertThat(metaData.storesMixedCaseIdentifiers(),
-                equalTo(false));
+                is(false));
             assertThat(metaData.storesUpperCaseIdentifiers(),
-                equalTo(false));
+                is(false));
             assertThat(metaData.storesLowerCaseIdentifiers(),
-                equalTo(false));
+                is(false));
             assertThat(metaData.supportsMixedCaseQuotedIdentifiers(),
-                equalTo(true));
+                is(true));
             assertThat(metaData.storesMixedCaseQuotedIdentifiers(),
-                equalTo(false));
+                is(false));
             assertThat(metaData.storesUpperCaseQuotedIdentifiers(),
-                equalTo(false));
+                is(false));
             assertThat(metaData.storesLowerCaseQuotedIdentifiers(),
-                equalTo(false));
+                is(false));
           } catch (SQLException e) {
             throw TestUtil.rethrow(e);
           }
@@ -6841,23 +6900,23 @@ private void checkGetTimestamp(Connection con) throws SQLException {
         .doWithConnection(connection -> {
           try {
             DatabaseMetaData metaData = connection.getMetaData();
-            assertThat(metaData.getIdentifierQuoteString(), equalTo("`"));
+            assertThat(metaData.getIdentifierQuoteString(), is("`"));
             assertThat(metaData.supportsMixedCaseIdentifiers(),
-                equalTo(true));
+                is(false));
             assertThat(metaData.storesMixedCaseIdentifiers(),
-                equalTo(false));
+                is(true));
             assertThat(metaData.storesUpperCaseIdentifiers(),
-                equalTo(false));
+                is(false));
             assertThat(metaData.storesLowerCaseIdentifiers(),
-                equalTo(false));
+                is(false));
             assertThat(metaData.supportsMixedCaseQuotedIdentifiers(),
-                equalTo(true));
+                is(false));
             assertThat(metaData.storesMixedCaseQuotedIdentifiers(),
-                equalTo(false));
+                is(true));
             assertThat(metaData.storesUpperCaseIdentifiers(),
-                equalTo(false));
+                is(false));
             assertThat(metaData.storesLowerCaseQuotedIdentifiers(),
-                equalTo(false));
+                is(false));
           } catch (SQLException e) {
             throw TestUtil.rethrow(e);
           }
@@ -6978,12 +7037,12 @@ private void checkGetTimestamp(Connection con) throws SQLException {
    * Enable spatial operator table by adding 'fun=spatial'to JDBC URL</a>. */
   @Test void testFunSpatial() {
     final String sql = "select distinct\n"
-        + "  ST_PointFromText('POINT(-71.0642.28)') as c\n"
+        + "  ST_PointFromText('POINT(-71.0642 .28)') as c\n"
         + "from \"hr\".\"emps\"";
     CalciteAssert.that(CalciteAssert.Config.REGULAR)
         .with(CalciteConnectionProperty.FUN, "spatial")
         .query(sql)
-        .returnsUnordered("C={\"x\":-71.0642,\"y\":0.28}");
+        .returnsUnordered("C=POINT (-71.0642 0.28)");
 
     // NVL is present in the Oracle operator table, but not spatial or core
     CalciteAssert.that(CalciteAssert.Config.REGULAR)
@@ -7024,24 +7083,24 @@ private void checkGetTimestamp(Connection con) throws SQLException {
   /** Tests that {@link Hook#PARSE_TREE} works. */
   @Test void testHook() {
     final int[] callCount = {0};
-    try (Hook.Closeable ignored = Hook.PARSE_TREE.<Object[]>addThread(
-        args -> {
-          assertThat(args.length, equalTo(2));
-          assertThat(args[0], instanceOf(String.class));
-          assertThat(args[0],
-              equalTo("select \"deptno\", \"commission\", sum(\"salary\") s\n"
-                  + "from \"hr\".\"emps\"\n"
-                  + "group by \"deptno\", \"commission\""));
-          assertThat(args[1], instanceOf(SqlSelect.class));
-          ++callCount[0];
-        })) {
+    try (Hook.Closeable ignored =
+             Hook.PARSE_TREE.<Object[]>addThread(args -> {
+               assertThat(args.length, is(2));
+               assertThat(args[0], instanceOf(String.class));
+               assertThat(args[0],
+                   is("select \"deptno\", \"commission\", sum(\"salary\") s\n"
+                       + "from \"hr\".\"emps\"\n"
+                       + "group by \"deptno\", \"commission\""));
+               assertThat(args[1], instanceOf(SqlSelect.class));
+               ++callCount[0];
+             })) {
       // Simple query does not run the hook.
       testSimple();
-      assertThat(callCount[0], equalTo(0));
+      assertThat(callCount[0], is(0));
 
       // Non-trivial query runs hook once.
       testGroupByNull();
-      assertThat(callCount[0], equalTo(1));
+      assertThat(callCount[0], is(1));
     }
   }
 
@@ -7070,8 +7129,8 @@ private void checkGetTimestamp(Connection con) throws SQLException {
 
     // create schema "/a"
     final Map<String, Schema> aSubSchemaMap = new HashMap<>();
-    final SchemaPlus aSchema = rootSchema.add("a",
-        new AbstractSchema() {
+    final SchemaPlus aSchema =
+        rootSchema.add("a", new AbstractSchema() {
           @Override protected Map<String, Schema> getSubSchemaMap() {
             return aSubSchemaMap;
           }
@@ -7094,8 +7153,8 @@ private void checkGetTimestamp(Connection con) throws SQLException {
 
     // create schema "/a"
     final Map<String, Schema> aSubSchemaMap = new HashMap<>();
-    final SchemaPlus aSchema = rootSchema.add("a",
-        new AbstractSchema() {
+    final SchemaPlus aSchema =
+        rootSchema.add("a", new AbstractSchema() {
           @Override protected Map<String, Schema> getSubSchemaMap() {
             return aSubSchemaMap;
           }
@@ -7122,8 +7181,8 @@ private void checkGetTimestamp(Connection con) throws SQLException {
     final Map<String, Schema> dummySubSchemaMap = new HashMap<>();
     final Map<String, Table> dummyTableMap = new HashMap<>();
     final Map<String, RelProtoDataType> dummyTypeMap = new HashMap<>();
-    final SchemaPlus dummySchema = rootSchema.add("dummy",
-        new AbstractSchema() {
+    final SchemaPlus dummySchema =
+        rootSchema.add("dummy", new AbstractSchema() {
           @Override protected Map<String, Schema> getSubSchemaMap() {
             return dummySubSchemaMap;
           }
@@ -7165,8 +7224,8 @@ private void checkGetTimestamp(Connection con) throws SQLException {
     final Multimap<String, org.apache.calcite.schema.Function> functionMap =
         LinkedListMultimap.create();
     // create schema "/a"
-    final SchemaPlus aSchema = rootSchema.add("a",
-        new AbstractSchema() {
+    final SchemaPlus aSchema =
+        rootSchema.add("a", new AbstractSchema() {
           @Override protected Multimap<String, org.apache.calcite.schema.Function>
           getFunctionMultimap() {
             return functionMap;
@@ -7265,13 +7324,13 @@ private void checkGetTimestamp(Connection con) throws SQLException {
     }
 
     // add tables and retrieve with various case sensitivities
-    final TableInRootSchemaTest.SimpleTable table =
-        new TableInRootSchemaTest.SimpleTable();
+    final Smalls.SimpleTable table =
+        new Smalls.SimpleTable();
     a2Schema.add("table1", table);
     a2Schema.add("TABLE1", table);
     a2Schema.add("tabLe1", table);
     a2Schema.add("tabLe2", table);
-    assertThat(a2Schema.getTableNames().size(), equalTo(4));
+    assertThat(a2Schema.getTableNames().size(), is(4));
     final CalciteSchema a2CalciteSchema = CalciteSchema.from(a2Schema);
     assertThat(a2CalciteSchema.getTable("table1", true), notNullValue());
     assertThat(a2CalciteSchema.getTable("table1", false), notNullValue());
@@ -7410,16 +7469,16 @@ private void checkGetTimestamp(Connection con) throws SQLException {
         .executeQuery();
 
     assertThat(rs.next(), is(true));
-    assertThat((Integer) rs.getObject("ID"), equalTo(1));
-    assertThat((Double) rs.getObject("VALS"), equalTo(1.0));
+    assertThat((Integer) rs.getObject("ID"), is(1));
+    assertThat((Double) rs.getObject("VALS"), is(1.0));
 
     assertThat(rs.next(), is(true));
-    assertThat((Integer) rs.getObject("ID"), equalTo(2));
+    assertThat((Integer) rs.getObject("ID"), is(2));
     assertThat(rs.getObject("VALS"), nullValue());
 
     assertThat(rs.next(), is(true));
     assertThat(rs.getObject("ID"), nullValue());
-    assertThat((Double) rs.getObject("VALS"), equalTo(2.0));
+    assertThat((Double) rs.getObject("VALS"), is(2.0));
 
     rs.close();
     calciteConnection.close();
@@ -7479,7 +7538,7 @@ private void checkGetTimestamp(Connection con) throws SQLException {
 
       assertThat(rs.next(), is(true));
       assertThat(rs.getObject("ID"), nullValue());
-      assertThat((Double) rs.getObject("VALS"), equalTo(2.0));
+      assertThat((Double) rs.getObject("VALS"), is(2.0));
 
       rs.close();
 
@@ -7734,9 +7793,9 @@ private void checkGetTimestamp(Connection con) throws SQLException {
         .planContains("static final java.math.BigDecimal $L4J$C$new_java_math_BigDecimal_1_ = "
             + "new java.math.BigDecimal(\n"
             + "              1)")
-        .planContains("org.apache.calcite.runtime.GeoFunctions.ST_MakePoint("
+        .planContains("org.apache.calcite.runtime.SpatialTypeFunctions.ST_MakePoint("
             + "$L4J$C$new_java_math_BigDecimal_1_, literal_value0)")
-        .returns("EXPR$0={\"x\":1,\"y\":2.1}\n");
+        .returns("EXPR$0=POINT (1 2.1)\n");
   }
 
   @Test void testMatchSimple() {
@@ -7749,14 +7808,13 @@ private void checkGetTimestamp(Connection con) throws SQLException {
         + "  pattern (up s)\n"
         + "  define up as up.\"empid\" = 100)";
     final String convert = ""
-        + "LogicalProject(C=[$0], EMPID=[$1], TWO=[$2])\n"
-        + "  LogicalMatch(partition=[[]], order=[[0 DESC]], "
+        + "LogicalMatch(partition=[[]], order=[[0 DESC]], "
         + "outputFields=[[C, EMPID, TWO]], allRows=[false], "
         + "after=[FLAG(SKIP TO NEXT ROW)], pattern=[('UP', 'S')], "
         + "isStrictStarts=[false], isStrictEnds=[false], subsets=[[]], "
         + "patternDefinitions=[[=(CAST(PREV(UP.$0, 0)):INTEGER NOT NULL, 100)]], "
         + "inputFields=[[empid, deptno, name, salary, commission]])\n"
-        + "    LogicalTableScan(table=[[hr, emps]])\n";
+        + "  LogicalTableScan(table=[[hr, emps]])\n";
     final String plan = "PLAN="
         + "EnumerableMatch(partition=[[]], order=[[0 DESC]], "
         + "outputFields=[[C, EMPID, TWO]], allRows=[false], "
@@ -7782,14 +7840,13 @@ private void checkGetTimestamp(Connection con) throws SQLException {
         + "  pattern (s up)\n"
         + "  define up as up.\"commission\" < prev(up.\"commission\"))";
     final String convert = ""
-        + "LogicalProject(C=[$0], EMPID=[$1])\n"
-        + "  LogicalMatch(partition=[[]], order=[[0 DESC]], "
+        + "LogicalMatch(partition=[[]], order=[[0 DESC]], "
         + "outputFields=[[C, EMPID]], allRows=[false], "
         + "after=[FLAG(SKIP TO NEXT ROW)], pattern=[('S', 'UP')], "
         + "isStrictStarts=[false], isStrictEnds=[false], subsets=[[]], "
         + "patternDefinitions=[[<(PREV(UP.$4, 0), PREV(UP.$4, 1))]], "
         + "inputFields=[[empid, deptno, name, salary, commission]])\n"
-        + "    LogicalTableScan(table=[[hr, emps]])\n";
+        + "  LogicalTableScan(table=[[hr, emps]])\n";
     final String plan = "PLAN="
         + "EnumerableMatch(partition=[[]], order=[[0 DESC]], "
         + "outputFields=[[C, EMPID]], allRows=[false], "
@@ -7881,6 +7938,36 @@ private void checkGetTimestamp(Connection con) throws SQLException {
         .returns("A=29; B=35; C=37; D=36\n");
   }
 
+  @Test public void testJsonInsert() {
+    CalciteAssert.that()
+        .with(CalciteConnectionProperty.FUN, "mysql")
+        .query("SELECT JSON_INSERT(v, '$.a', 10, '$.c', '[1]') AS c1\n"
+            + ",JSON_INSERT(v, '$', 10, '$.c', '[1]') AS c2\n"
+            + "FROM (VALUES ('{\"a\": 1,\"b\":[2]}')) AS t(v)\n"
+            + "limit 10")
+        .returns("C1={\"a\":1,\"b\":[2],\"c\":\"[1]\"}; C2={\"a\":1,\"b\":[2],\"c\":\"[1]\"}\n");
+  }
+
+  @Test public void testJsonReplace() {
+    CalciteAssert.that()
+        .with(CalciteConnectionProperty.FUN, "mysql")
+        .query("SELECT JSON_REPLACE(v, '$.a', 10, '$.c', '[1]') AS c1\n"
+            + ",JSON_REPLACE(v, '$', 10, '$.c', '[1]') AS c2\n"
+            + "FROM (VALUES ('{\"a\": 1,\"b\":[2]}')) AS t(v)\n"
+            + "limit 10")
+        .returns("C1={\"a\":10,\"b\":[2]}; C2=10\n");
+  }
+
+  @Test public void testJsonSet() {
+    CalciteAssert.that()
+        .with(CalciteConnectionProperty.FUN, "mysql")
+        .query("SELECT JSON_SET(v, '$.a', 10, '$.c', '[1]') AS c1\n"
+            + ",JSON_SET(v, '$', 10, '$.c', '[1]') AS c2\n"
+            + "FROM (VALUES ('{\"a\": 1,\"b\":[2]}')) AS t(v)\n"
+            + "limit 10")
+        .returns("C1={\"a\":10,\"b\":[2],\"c\":\"[1]\"}; C2=10\n");
+  }
+
   /**
    * Test case for
    * <a href="https://issues.apache.org/jira/browse/CALCITE-2609">[CALCITE-2609]
@@ -8003,6 +8090,90 @@ private void checkGetTimestamp(Connection con) throws SQLException {
         .returns("EXPR$0=[0E+1, 1.1]\n");
   }
 
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5414">[CALCITE-5414]</a>
+   * Convert between standard Gregorian and proleptic Gregorian calendars for
+   * literal dates in local time zone. */
+  @Test void testLiteralDateToSqlTimestamp() {
+    CalciteAssert.that()
+        .with(CalciteConnectionProperty.TIME_ZONE, TimeZone.getDefault().getID())
+        .query("select cast('1500-04-30' as date)")
+        .returns(resultSet -> {
+          try {
+            assertTrue(resultSet.next());
+            assertEquals("1500-04-30", resultSet.getString(1));
+            assertEquals(Date.valueOf("1500-04-30"), resultSet.getDate(1));
+            assertFalse(resultSet.next());
+          } catch (SQLException e) {
+            throw new RuntimeException(e);
+          }
+        });
+  }
+
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5414">[CALCITE-5414]</a>
+   * Convert between standard Gregorian and proleptic Gregorian calendars for
+   * literal timestamps in local time zone. */
+  @Test void testLiteralTimestampToSqlTimestamp() {
+    CalciteAssert.that()
+        .with(CalciteConnectionProperty.TIME_ZONE, TimeZone.getDefault().getID())
+        .query("select cast('1500-04-30 12:00:00' as timestamp)")
+        .returns(resultSet -> {
+          try {
+            assertTrue(resultSet.next());
+            assertEquals("1500-04-30 12:00:00", resultSet.getString(1));
+            assertEquals(Timestamp.valueOf("1500-04-30 12:00:00"), resultSet.getTimestamp(1));
+            assertFalse(resultSet.next());
+          } catch (SQLException e) {
+            throw new RuntimeException(e);
+          }
+        });
+  }
+
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5414">[CALCITE-5414]</a>
+   * Convert between standard Gregorian and proleptic Gregorian calendars for
+   * dynamic dates in local time zone. */
+  @Test void testDynamicDateToSqlTimestamp() {
+    final Date date = Date.valueOf("1500-04-30");
+    CalciteAssert.that()
+        .with(CalciteConnectionProperty.TIME_ZONE, TimeZone.getDefault().getID())
+        .query("select cast(? as date)")
+        .consumesPreparedStatement(statement -> statement.setDate(1, date))
+        .returns(resultSet -> {
+          try {
+            assertTrue(resultSet.next());
+            assertEquals("1500-04-30", resultSet.getString(1));
+            assertEquals(date, resultSet.getDate(1));
+            assertFalse(resultSet.next());
+          } catch (SQLException e) {
+            throw new RuntimeException(e);
+          }
+        });
+  }
+
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5414">[CALCITE-5414]</a>
+   * Convert between standard Gregorian and proleptic Gregorian calendars for
+   * dynamic timestamps in local time zone. */
+  @Test void testDynamicTimestampToSqlTimestamp() {
+    final Timestamp timestamp = Timestamp.valueOf("1500-04-30 12:00:00");
+    CalciteAssert.that()
+        .with(CalciteConnectionProperty.TIME_ZONE, TimeZone.getDefault().getID())
+        .query("select cast(? as timestamp)")
+        .consumesPreparedStatement(statement -> statement.setTimestamp(1, timestamp))
+        .returns(resultSet -> {
+          try {
+            assertTrue(resultSet.next());
+            assertEquals("1500-04-30 12:00:00", resultSet.getString(1));
+            assertEquals(timestamp, resultSet.getTimestamp(1));
+            assertFalse(resultSet.next());
+          } catch (SQLException e) {
+            throw new RuntimeException(e);
+          }
+        });
+  }
+
   private static String sums(int n, boolean c) {
     final StringBuilder b = new StringBuilder();
     for (int i = 0; i < n; i++) {
@@ -8046,7 +8217,7 @@ public Customer(int customer_id) {
 
   /** Factory for EMP and DEPT tables. */
   public static class EmpDeptTableFactory implements TableFactory<Table> {
-    public static final TryThreadLocal<List<Employee>> THREAD_COLLECTION =
+    public static final TryThreadLocal<@Nullable List<Employee>> THREAD_COLLECTION =
         TryThreadLocal.of(null);
 
     public Table create(
@@ -8142,7 +8313,7 @@ public static class AutoTempDriver
 
   /** Mock driver that a given {@link Handler}. */
   public static class HandlerDriver extends org.apache.calcite.jdbc.Driver {
-    private static final TryThreadLocal<Handler> HANDLERS =
+    private static final TryThreadLocal<@Nullable Handler> HANDLERS =
         TryThreadLocal.of(null);
 
     public HandlerDriver() {
@@ -8155,39 +8326,52 @@ public HandlerDriver() {
 
   /** Mock driver that can execute a trivial DDL statement. */
   public static class MockDdlDriver extends org.apache.calcite.jdbc.Driver {
-    public int counter;
+  }
 
-    public MockDdlDriver() {
+  /** Mock driver that can execute a trivial DDL statement. */
+  public static class MockDdlDriver2 extends MockDdlDriver {
+    final AtomicInteger counter;
+
+    public MockDdlDriver2(AtomicInteger counter) {
+      this.counter = counter;
     }
+  }
 
-    @Override protected Function0<CalcitePrepare> createPrepareFactory() {
-      return new Function0<CalcitePrepare>() {
-        @Override public CalcitePrepare apply() {
-          return new CalcitePrepareImpl() {
-            @Override protected SqlParser.Config parserConfig() {
-              return super.parserConfig().withParserFactory(stream ->
-                  new SqlParserImpl(stream) {
-                    @Override public SqlNode parseSqlStmtEof() {
-                      return new SqlCall(SqlParserPos.ZERO) {
-                        @Override public SqlOperator getOperator() {
-                          return new SqlSpecialOperator("COMMIT",
-                              SqlKind.COMMIT);
-                        }
-
-                        @Override public List<SqlNode> getOperandList() {
-                          return ImmutableList.of();
-                        }
-                      };
-                    }
-                  });
-            }
+  /** Implementation of {@link CalcitePrepare} that counts how many DDL
+   * statements have been executed. */
+  private static class CountingPrepare extends CalcitePrepareImpl {
+    private final AtomicInteger counter;
+
+    CountingPrepare(AtomicInteger counter) {
+      this.counter = counter;
+    }
 
-            @Override public void executeDdl(Context context, SqlNode node) {
-              ++counter;
+    @Override protected SqlParser.Config parserConfig() {
+      return super.parserConfig().withParserFactory(stream ->
+          new SqlParserImpl(stream) {
+            @Override public SqlNode parseSqlStmtEof() {
+              return new SqlCall(SqlParserPos.ZERO) {
+                @Override public SqlOperator getOperator() {
+                  return new SqlSpecialOperator("COMMIT",
+                      SqlKind.COMMIT);
+                }
+
+                @Override public List<SqlNode> getOperandList() {
+                  return ImmutableList.of();
+                }
+              };
             }
-          };
-        }
-      };
+          });
+    }
+
+    @Override public void executeDdl(Context context, SqlNode node) {
+      counter.incrementAndGet();
+    }
+  }
+
+  /** Dummy subclass of CalcitePrepareImpl. */
+  public static class MockPrepareImpl extends CalcitePrepareImpl {
+    public MockPrepareImpl() {
     }
   }
 
diff --git a/core/src/test/java/org/apache/calcite/test/LatticeTest.java b/core/src/test/java/org/apache/calcite/test/LatticeTest.java
index 63eca0bd989..8d06c2ebebe 100644
--- a/core/src/test/java/org/apache/calcite/test/LatticeTest.java
+++ b/core/src/test/java/org/apache/calcite/test/LatticeTest.java
@@ -683,8 +683,9 @@ private static CalciteAssert.AssertThat foodmartLatticeModel(
   @Disabled
   @Test void testAllFoodmartQueries() {
     // Test ids that had bugs in them until recently. Useful for a sanity check.
-    final List<Integer> fixed = ImmutableList.of(13, 24, 28, 30, 61, 76, 79, 81,
-        85, 98, 101, 107, 128, 129, 130, 131);
+    final List<Integer> fixed =
+        ImmutableList.of(13, 24, 28, 30, 61, 76, 79, 81,
+            85, 98, 101, 107, 128, 129, 130, 131);
     // Test ids that still have bugs
     final List<Integer> bad = ImmutableList.of(382, 423);
     for (int i = 1; i < 1000; i++) {
@@ -964,8 +965,9 @@ private CalciteAssert.AssertThat foodmartModelWithOneTile() {
 
   // Just for debugging.
   private static void runJdbc() throws SQLException {
-    final Connection connection = DriverManager.getConnection(
-        "jdbc:calcite:model=core/src/test/resources/mysql-foodmart-lattice-model.json");
+    final String url = "jdbc:calcite:model="
+        + "core/src/test/resources/mysql-foodmart-lattice-model.json";
+    final Connection connection = DriverManager.getConnection(url);
     final ResultSet resultSet = connection.createStatement()
         .executeQuery("select * from \"adhoc\".\"m{32, 36}\"");
     System.out.println(CalciteAssert.toString(resultSet));
diff --git a/core/src/test/java/org/apache/calcite/test/MaterializedViewSubstitutionVisitorTest.java b/core/src/test/java/org/apache/calcite/test/MaterializedViewSubstitutionVisitorTest.java
index edabf76d4f5..32b7b8a2a71 100644
--- a/core/src/test/java/org/apache/calcite/test/MaterializedViewSubstitutionVisitorTest.java
+++ b/core/src/test/java/org/apache/calcite/test/MaterializedViewSubstitutionVisitorTest.java
@@ -1477,9 +1477,10 @@ protected final MaterializedViewFixture sql(String materialize,
     //   target:    y = 2 or 1 = x
     // yields
     //   residue:   true
-    newFilter = SubstitutionVisitor.splitFilter(simplify,
-        rexBuilder.makeCall(SqlStdOperatorTable.OR, x_eq_1, y_eq_2),
-        rexBuilder.makeCall(SqlStdOperatorTable.OR, y_eq_2, x_eq_1_b));
+    newFilter =
+        SubstitutionVisitor.splitFilter(simplify,
+            rexBuilder.makeCall(SqlStdOperatorTable.OR, x_eq_1, y_eq_2),
+            rexBuilder.makeCall(SqlStdOperatorTable.OR, y_eq_2, x_eq_1_b));
     assertThat(newFilter, notNullValue());
     assertThat(newFilter.isAlwaysTrue(), equalTo(true));
 
@@ -1488,9 +1489,9 @@ protected final MaterializedViewFixture sql(String materialize,
     //   target:    x = 1 or z = 3
     // yields
     //   residue:   x = 1
-    newFilter = SubstitutionVisitor.splitFilter(simplify,
-        x_eq_1,
-        rexBuilder.makeCall(SqlStdOperatorTable.OR, x_eq_1, z_eq_3));
+    newFilter =
+        SubstitutionVisitor.splitFilter(simplify, x_eq_1,
+            rexBuilder.makeCall(SqlStdOperatorTable.OR, x_eq_1, z_eq_3));
     assertThat(newFilter, notNullValue());
     assertThat(newFilter.toString(), equalTo("=($0, 1)"));
 
@@ -1499,9 +1500,10 @@ protected final MaterializedViewFixture sql(String materialize,
     //   target:    x = 1 or y = 2 or z = 3
     // yields
     //   residue:   x = 1 or y = 2
-    newFilter = SubstitutionVisitor.splitFilter(simplify,
-        rexBuilder.makeCall(SqlStdOperatorTable.OR, x_eq_1, y_eq_2),
-        rexBuilder.makeCall(SqlStdOperatorTable.OR, x_eq_1, y_eq_2, z_eq_3));
+    newFilter =
+        SubstitutionVisitor.splitFilter(simplify,
+            rexBuilder.makeCall(SqlStdOperatorTable.OR, x_eq_1, y_eq_2),
+            rexBuilder.makeCall(SqlStdOperatorTable.OR, x_eq_1, y_eq_2, z_eq_3));
     assertThat(newFilter, notNullValue());
     assertThat(newFilter.toString(), equalTo("OR(=($0, 1), =($1, 2))"));
 
@@ -1510,9 +1512,9 @@ protected final MaterializedViewFixture sql(String materialize,
     //   target:    x = 1 or y = 2 or z = 3
     // yields
     //   residue:   x = 1
-    newFilter = SubstitutionVisitor.splitFilter(simplify,
-        x_eq_1,
-        rexBuilder.makeCall(SqlStdOperatorTable.OR, x_eq_1, y_eq_2, z_eq_3));
+    newFilter =
+        SubstitutionVisitor.splitFilter(simplify, x_eq_1,
+            rexBuilder.makeCall(SqlStdOperatorTable.OR, x_eq_1, y_eq_2, z_eq_3));
     assertThat(newFilter, notNullValue());
     assertThat(newFilter.toString(),
         equalTo("=($0, 1)"));
@@ -1522,9 +1524,10 @@ protected final MaterializedViewFixture sql(String materialize,
     //   target:    y = 2 or x = 1
     // yields
     //   residue:   true
-    newFilter = SubstitutionVisitor.splitFilter(simplify,
-        rexBuilder.makeCall(SqlStdOperatorTable.OR, x_eq_1, y_eq_2),
-        rexBuilder.makeCall(SqlStdOperatorTable.OR, y_eq_2, x_eq_1));
+    newFilter =
+        SubstitutionVisitor.splitFilter(simplify,
+            rexBuilder.makeCall(SqlStdOperatorTable.OR, x_eq_1, y_eq_2),
+            rexBuilder.makeCall(SqlStdOperatorTable.OR, y_eq_2, x_eq_1));
     assertThat(newFilter, notNullValue());
     assertThat(newFilter.isAlwaysTrue(), equalTo(true));
 
@@ -1542,18 +1545,20 @@ protected final MaterializedViewFixture sql(String materialize,
     //   target:    x = 1
     // yields
     //   residue:   null
-    newFilter = SubstitutionVisitor.splitFilter(simplify,
-        rexBuilder.makeCall(SqlStdOperatorTable.OR, x_eq_1, y_eq_2),
-        x_eq_1);
+    newFilter =
+        SubstitutionVisitor.splitFilter(simplify,
+            rexBuilder.makeCall(SqlStdOperatorTable.OR, x_eq_1, y_eq_2),
+            x_eq_1);
     assertNull(newFilter);
 
     // Example 3.
     // Condition [x = 1 and y = 2],
     // target [y = 2 and x = 1] yields
     // residue [true].
-    newFilter = SubstitutionVisitor.splitFilter(simplify,
-        rexBuilder.makeCall(SqlStdOperatorTable.AND, x_eq_1, y_eq_2),
-        rexBuilder.makeCall(SqlStdOperatorTable.AND, y_eq_2, x_eq_1));
+    newFilter =
+        SubstitutionVisitor.splitFilter(simplify,
+            rexBuilder.makeCall(SqlStdOperatorTable.AND, x_eq_1, y_eq_2),
+            rexBuilder.makeCall(SqlStdOperatorTable.AND, y_eq_2, x_eq_1));
     assertThat(newFilter, notNullValue());
     assertThat(newFilter.isAlwaysTrue(), equalTo(true));
 
@@ -1562,9 +1567,10 @@ protected final MaterializedViewFixture sql(String materialize,
     //   target:    y = 2
     // yields
     //   residue:   x = 1
-    newFilter = SubstitutionVisitor.splitFilter(simplify,
-        rexBuilder.makeCall(SqlStdOperatorTable.AND, x_eq_1, y_eq_2),
-        y_eq_2);
+    newFilter =
+        SubstitutionVisitor.splitFilter(simplify,
+            rexBuilder.makeCall(SqlStdOperatorTable.AND, x_eq_1, y_eq_2),
+            y_eq_2);
     assertThat(newFilter, notNullValue());
     assertThat(newFilter.toString(), equalTo("=($0, 1)"));
 
@@ -1573,9 +1579,9 @@ protected final MaterializedViewFixture sql(String materialize,
     //   target:    x = 1 and y = 2
     // yields
     //   residue:   null
-    newFilter = SubstitutionVisitor.splitFilter(simplify,
-        x_eq_1,
-        rexBuilder.makeCall(SqlStdOperatorTable.AND, x_eq_1, y_eq_2));
+    newFilter =
+        SubstitutionVisitor.splitFilter(simplify, x_eq_1,
+            rexBuilder.makeCall(SqlStdOperatorTable.AND, x_eq_1, y_eq_2));
     assertNull(newFilter);
 
     // Example 6.
@@ -1583,9 +1589,7 @@ protected final MaterializedViewFixture sql(String materialize,
     //   target:    y = 2
     // yields
     //   residue:   null
-    newFilter = SubstitutionVisitor.splitFilter(simplify,
-        x_eq_1,
-        y_eq_2);
+    newFilter = SubstitutionVisitor.splitFilter(simplify, x_eq_1, y_eq_2);
     assertNull(newFilter);
 
     // Example 7.
@@ -1593,9 +1597,7 @@ protected final MaterializedViewFixture sql(String materialize,
     //   target:    x = 2
     // yields
     //   residue:   null
-    newFilter = SubstitutionVisitor.splitFilter(simplify,
-        x_eq_1,
-        x_eq_2);
+    newFilter = SubstitutionVisitor.splitFilter(simplify, x_eq_1, x_eq_2);
     assertNull(newFilter);
 
     // Example 8.
@@ -1603,9 +1605,8 @@ protected final MaterializedViewFixture sql(String materialize,
     //   target:    y + x > 2
     // yields
     //   residue:  true
-    newFilter = SubstitutionVisitor.splitFilter(simplify,
-        x_plus_y_gt,
-        y_plus_x_gt);
+    newFilter =
+        SubstitutionVisitor.splitFilter(simplify, x_plus_y_gt, y_plus_x_gt);
     assertThat(newFilter, notNullValue());
     assertThat(newFilter.isAlwaysTrue(), equalTo(true));
 
@@ -1614,9 +1615,8 @@ protected final MaterializedViewFixture sql(String materialize,
     //   target:    x + x > 2
     // yields
     //   residue:  true
-    newFilter = SubstitutionVisitor.splitFilter(simplify,
-        x_plus_x_gt,
-        x_plus_x_gt);
+    newFilter =
+        SubstitutionVisitor.splitFilter(simplify, x_plus_x_gt, x_plus_x_gt);
     assertThat(newFilter, notNullValue());
     assertThat(newFilter.isAlwaysTrue(), equalTo(true));
 
@@ -1625,9 +1625,8 @@ protected final MaterializedViewFixture sql(String materialize,
     //   target:    2 < y * x
     // yields
     //   residue:  true
-    newFilter = SubstitutionVisitor.splitFilter(simplify,
-        x_times_y_gt,
-        y_times_x_gt);
+    newFilter =
+        SubstitutionVisitor.splitFilter(simplify, x_times_y_gt, y_times_x_gt);
     assertThat(newFilter, notNullValue());
     assertThat(newFilter.isAlwaysTrue(), equalTo(true));
   }
diff --git a/core/src/test/java/org/apache/calcite/test/MaterializedViewTester.java b/core/src/test/java/org/apache/calcite/test/MaterializedViewTester.java
index 47a8af6df34..839f21125ae 100644
--- a/core/src/test/java/org/apache/calcite/test/MaterializedViewTester.java
+++ b/core/src/test/java/org/apache/calcite/test/MaterializedViewTester.java
@@ -112,8 +112,9 @@ private TestConfig build(MaterializedViewFixture f) {
       try {
         final SchemaPlus defaultSchema;
         if (f.schemaSpec == null) {
-          defaultSchema = rootSchema.add("hr",
-              new ReflectiveSchema(new MaterializationTest.HrFKUKSchema()));
+          defaultSchema =
+              rootSchema.add("hr",
+                  new ReflectiveSchema(new MaterializationTest.HrFKUKSchema()));
         } else {
           defaultSchema = CalciteAssert.addSchema(rootSchema, f.schemaSpec);
         }
@@ -126,8 +127,9 @@ private TestConfig build(MaterializedViewFixture f) {
         for (Pair<String, String> pair: f.materializationList) {
           String sql = requireNonNull(pair.left, "sql");
           final RelNode mvRel = toRel(cluster, rootSchema, defaultSchema, sql);
-          final Table table = tableFactory.createTable(CalciteSchema.from(rootSchema),
-              sql, ImmutableList.of(defaultSchema.getName()));
+          final Table table =
+              tableFactory.createTable(CalciteSchema.from(rootSchema),
+                  sql, ImmutableList.of(defaultSchema.getName()));
           String name = requireNonNull(pair.right, "name");
           defaultSchema.add(name, table);
           relBuilder.scan(defaultSchema.getName(), name);
@@ -150,11 +152,11 @@ private RelNode toRel(RelOptCluster cluster, SchemaPlus rootSchema,
     final SqlParser parser = SqlParser.create(sql, SqlParser.Config.DEFAULT);
     final SqlNode parsed = parser.parseStmt();
 
-    final CalciteCatalogReader catalogReader = new CalciteCatalogReader(
-        CalciteSchema.from(rootSchema),
-        CalciteSchema.from(defaultSchema).path(null),
-        new JavaTypeFactoryImpl(),
-        CalciteConnectionConfig.DEFAULT);
+    final CalciteCatalogReader catalogReader =
+        new CalciteCatalogReader(CalciteSchema.from(rootSchema),
+            CalciteSchema.from(defaultSchema).path(null),
+            new JavaTypeFactoryImpl(),
+            CalciteConnectionConfig.DEFAULT);
 
     final SqlValidator validator =
         SqlValidatorUtil.newValidator(SqlStdOperatorTable.instance(),
@@ -165,10 +167,13 @@ catalogReader, new JavaTypeFactoryImpl(),
         .withTrimUnusedFields(true)
         .withExpand(true)
         .withDecorrelationEnabled(true);
-    final SqlToRelConverter converter = new SqlToRelConverter(
-        (rowType, queryString, schemaPath, viewPath) -> {
-          throw new UnsupportedOperationException("cannot expand view");
-        }, validator, catalogReader, cluster, StandardConvertletTable.INSTANCE, config);
+    final SqlToRelConverter converter =
+        new SqlToRelConverter(
+            (rowType, queryString, schemaPath, viewPath) -> {
+              throw new UnsupportedOperationException("cannot expand view");
+            },
+            validator, catalogReader, cluster, StandardConvertletTable.INSTANCE,
+            config);
     return converter.convertQuery(validated, false, true).rel;
   }
 
diff --git a/core/src/test/java/org/apache/calcite/test/ModelTest.java b/core/src/test/java/org/apache/calcite/test/ModelTest.java
index 43c569bf1fe..f12c525cf7b 100644
--- a/core/src/test/java/org/apache/calcite/test/ModelTest.java
+++ b/core/src/test/java/org/apache/calcite/test/ModelTest.java
@@ -57,8 +57,7 @@ private ObjectMapper mapper() {
   /** Reads a simple schema from a string into objects. */
   @Test void testRead() throws IOException {
     final ObjectMapper mapper = mapper();
-    JsonRoot root = mapper.readValue(
-        "{\n"
+    final String json = "{\n"
         + "  version: '1.0',\n"
         + "   schemas: [\n"
         + "     {\n"
@@ -96,8 +95,8 @@ private ObjectMapper mapper() {
         + "       ]\n"
         + "     }\n"
         + "   ]\n"
-        + "}",
-        JsonRoot.class);
+        + "}";
+    JsonRoot root = mapper.readValue(json, JsonRoot.class);
     assertEquals("1.0", root.version);
     assertEquals(1, root.schemas.size());
     final JsonMapSchema schema = (JsonMapSchema) root.schemas.get(0);
@@ -119,8 +118,7 @@ private ObjectMapper mapper() {
   /** Reads a simple schema containing JdbcSchema, a sub-type of Schema. */
   @Test void testSubtype() throws IOException {
     final ObjectMapper mapper = mapper();
-    JsonRoot root = mapper.readValue(
-        "{\n"
+    final String json = "{\n"
         + "  version: '1.0',\n"
         + "   schemas: [\n"
         + "     {\n"
@@ -133,8 +131,8 @@ private ObjectMapper mapper() {
         + "       jdbcSchema: ''\n"
         + "     }\n"
         + "   ]\n"
-        + "}",
-        JsonRoot.class);
+        + "}";
+    JsonRoot root = mapper.readValue(json, JsonRoot.class);
     assertEquals("1.0", root.version);
     assertEquals(1, root.schemas.size());
     final JsonJdbcSchema schema = (JsonJdbcSchema) root.schemas.get(0);
diff --git a/core/src/test/java/org/apache/calcite/test/MutableRelTest.java b/core/src/test/java/org/apache/calcite/test/MutableRelTest.java
index 793d5c49eef..6f625c106d0 100644
--- a/core/src/test/java/org/apache/calcite/test/MutableRelTest.java
+++ b/core/src/test/java/org/apache/calcite/test/MutableRelTest.java
@@ -178,11 +178,11 @@ class MutableRelTest {
   }
 
   @Test void testUpdateInputOfUnion() {
-    MutableRel mutableRel = createMutableRel(
-        "select sal from emp where deptno = 10"
+    MutableRel mutableRel =
+        createMutableRel("select sal from emp where deptno = 10"
             + "union select sal from emp where ename like 'John%'");
-    MutableRel childMutableRel = createMutableRel(
-        "select sal from emp where deptno = 12");
+    MutableRel childMutableRel =
+        createMutableRel("select sal from emp where deptno = 12");
     mutableRel.setInput(0, childMutableRel);
     String actual = RelOptUtil.toString(MutableRels.fromMutable(mutableRel));
     String expected = ""
@@ -197,8 +197,8 @@ class MutableRelTest {
   }
 
   @Test void testParentInfoOfUnion() {
-    MutableRel mutableRel = createMutableRel(
-        "select sal from emp where deptno = 10"
+    MutableRel mutableRel =
+        createMutableRel("select sal from emp where deptno = 10"
             + "union select sal from emp where ename like 'John%'");
     for (MutableRel input: mutableRel.getInputs()) {
       assertSame(input.getParent(), mutableRel);
diff --git a/core/src/test/java/org/apache/calcite/test/ReflectiveSchemaTest.java b/core/src/test/java/org/apache/calcite/test/ReflectiveSchemaTest.java
index 2f1dfec33e8..36bffc61b68 100644
--- a/core/src/test/java/org/apache/calcite/test/ReflectiveSchemaTest.java
+++ b/core/src/test/java/org/apache/calcite/test/ReflectiveSchemaTest.java
@@ -176,12 +176,12 @@ public class ReflectiveSchemaTest {
     schema.add("StringUnion",
         TableMacroImpl.create(Smalls.STRING_UNION_METHOD));
     rootSchema.add("hr", new ReflectiveSchema(new HrSchema()));
-    ResultSet resultSet = connection.createStatement().executeQuery(
-        "select *\n"
+    final String sql = "select *\n"
         + "from table(s.StringUnion(\n"
         + "  GenerateStrings(5),\n"
         + "  cursor (select name from emps)))\n"
-        + "where char_length(s) > 3");
+        + "where char_length(s) > 3";
+    ResultSet resultSet = connection.createStatement().executeQuery(sql);
     assertTrue(resultSet.next());
   }
 
@@ -200,14 +200,13 @@ public class ReflectiveSchemaTest {
             "select * from \"hr\".\"emps\" where \"deptno\" = 10",
             null, Arrays.asList("s", "emps_view"), null));
     rootSchema.add("hr", new ReflectiveSchema(new HrSchema()));
-    ResultSet resultSet = connection.createStatement().executeQuery(
-        "select *\n"
+    final String sql = "select *\n"
         + "from \"s\".\"emps_view\"\n"
-        + "where \"empid\" < 120");
-    assertEquals(
-        "empid=100; deptno=10; name=Bill; salary=10000.0; commission=1000\n"
-        + "empid=110; deptno=10; name=Theodore; salary=11500.0; commission=250\n",
-        CalciteAssert.toString(resultSet));
+        + "where \"empid\" < 120";
+    ResultSet resultSet = connection.createStatement().executeQuery(sql);
+    assertThat(CalciteAssert.toString(resultSet),
+        is("empid=100; deptno=10; name=Bill; salary=10000.0; commission=1000\n"
+            + "empid=110; deptno=10; name=Theodore; salary=11500.0; commission=250\n"));
   }
 
   /**
@@ -238,15 +237,19 @@ public class ReflectiveSchemaTest {
             ImmutableList.of("s", "null_emps"), null));
     rootSchema.add("hr", new ReflectiveSchema(new HrSchema()));
     final Statement statement = connection.createStatement();
-    ResultSet resultSet;
-    resultSet = statement.executeQuery(
-        "select * from \"s\".\"hr_emps\"");
-    assertEquals(4, count(resultSet)); // "hr_emps" -> "hr"."emps", 4 rows
-    resultSet = statement.executeQuery(
-        "select * from \"s\".\"s_emps\""); // "s_emps" -> "s"."emps", 3 rows
+
+    // "hr_emps" -> "hr"."emps", 4 rows
+    ResultSet resultSet =
+        statement.executeQuery("select * from \"s\".\"hr_emps\"");
+    assertEquals(4, count(resultSet));
+
+    // "s_emps" -> "s"."emps", 3 rows
+    resultSet =
+        statement.executeQuery("select * from \"s\".\"s_emps\"");
     assertEquals(3, count(resultSet));
-    resultSet = statement.executeQuery(
-        "select * from \"s\".\"null_emps\""); // "null_emps" -> "s"."emps", 3
+
+    // "null_emps" -> "s"."emps", 3
+    resultSet = statement.executeQuery("select * from \"s\".\"null_emps\"");
     assertEquals(3, count(resultSet));
     statement.close();
   }
@@ -329,6 +332,16 @@ private int count(ResultSet resultSet) throws SQLException {
         .returnsUnordered("CITY=Heraklion", "CITY=Besançon", "CITY=Ionia");
   }
 
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5157">[CALCITE-5157]
+   * ClassCastException in checkRollUp with DOT operator</a>. */
+  @Test void testSelectWithFieldAccessOnFirstLevelRecordTypeWithParentheses() {
+    CalciteAssert.that()
+        .with(CalciteAssert.SchemaSpec.BOOKSTORE)
+        .query("select (\"birthPlace\").\"city\" as city from \"bookstore\".\"authors\"\n")
+        .returnsUnordered("CITY=Heraklion", "CITY=Besançon", "CITY=Ionia");
+  }
+
   /** Test case for
    * <a href="https://issues.apache.org/jira/browse/CALCITE-2404">[CALCITE-2404]
    * Accessing structured-types is not implemented by the runtime</a>. */
diff --git a/core/src/test/java/org/apache/calcite/test/RelBuilderTest.java b/core/src/test/java/org/apache/calcite/test/RelBuilderTest.java
index 88a7cbad423..b47b1018779 100644
--- a/core/src/test/java/org/apache/calcite/test/RelBuilderTest.java
+++ b/core/src/test/java/org/apache/calcite/test/RelBuilderTest.java
@@ -95,6 +95,9 @@
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.hamcrest.Matcher;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.function.Executable;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
 
 import java.lang.reflect.Method;
 import java.sql.Connection;
@@ -187,8 +190,9 @@ static Frameworks.ConfigBuilder expandingConfig(Connection connection)
             spec.schemaName, "EMP");
 
     // create view
-    ViewTableMacro macro = ViewTable.viewMacro(root, viewSql,
-        Collections.singletonList("test"), Arrays.asList("test", "view"), false);
+    ViewTableMacro macro =
+        ViewTable.viewMacro(root, viewSql, Collections.singletonList("test"),
+            Arrays.asList("test", "view"), false);
 
     // register view (in root schema)
     root.add("MYVIEW", macro);
@@ -447,9 +451,10 @@ static RelBuilder createBuilder(UnaryOperator<RelBuilder.Config> transform) {
         + "  {\"name\":\"d\",\"type\":\"DATE\",\"nullable\":true}"
         + "]}";
     final int rowCount = 3;
-    RelNode root = builder.functionScan(operator, 0,
-        builder.literal(jsonRowType), builder.literal(rowCount))
-        .build();
+    RelNode root =
+        builder.functionScan(operator, 0, builder.literal(jsonRowType),
+                builder.literal(rowCount))
+            .build();
     final String expected = "LogicalTableFunctionScan("
         + "invocation=[dynamicRowType('{\"nullable\":false,\"fields\":["
         + "  {\"name\":\"i\",\"type\":\"INTEGER\",\"nullable\":false},"
@@ -714,9 +719,9 @@ private void checkSimplify(UnaryOperator<RelBuilder.Config> transform,
     final RelBuilder builder = RelBuilder.create(config().build());
     try {
       builder.scan("EMP");
-      RexNode call = builder.call(SqlStdOperatorTable.PLUS,
-          builder.field(1),
-          builder.field(3));
+      RexNode call =
+          builder.call(SqlStdOperatorTable.PLUS, builder.field(1),
+              builder.field(3));
       fail("expected error, got " + call);
     } catch (IllegalArgumentException e) {
       assertThat(e.getMessage(),
@@ -3839,29 +3844,31 @@ private static RelBuilder assertSize(RelBuilder b,
     final RelDataTypeFactory typeFactory = builder.getTypeFactory();
     final RelDataType intType = typeFactory.createSqlType(SqlTypeName.INTEGER);
 
-    RexNode pattern = builder.patternConcat(
-        builder.literal("STRT"),
-        builder.patternQuantify(builder.literal("DOWN"), builder.literal(1),
-            builder.literal(-1), builder.literal(false)),
-        builder.patternQuantify(builder.literal("UP"), builder.literal(1),
-            builder.literal(-1), builder.literal(false)));
+    RexNode pattern =
+        builder.patternConcat(builder.literal("STRT"),
+            builder.patternQuantify(builder.literal("DOWN"), builder.literal(1),
+                builder.literal(-1), builder.literal(false)),
+            builder.patternQuantify(builder.literal("UP"), builder.literal(1),
+                builder.literal(-1), builder.literal(false)));
 
     ImmutableMap.Builder<String, RexNode> pdBuilder = new ImmutableMap.Builder<>();
-    RexNode downDefinition = builder.lessThan(
-        builder.call(SqlStdOperatorTable.PREV,
-            builder.patternField("DOWN", intType, 3),
-            builder.literal(0)),
-        builder.call(SqlStdOperatorTable.PREV,
-            builder.patternField("DOWN", intType, 3),
-            builder.literal(1)));
+    RexNode downDefinition =
+        builder.lessThan(
+            builder.call(SqlStdOperatorTable.PREV,
+                builder.patternField("DOWN", intType, 3),
+                builder.literal(0)),
+            builder.call(SqlStdOperatorTable.PREV,
+                builder.patternField("DOWN", intType, 3),
+                builder.literal(1)));
     pdBuilder.put("DOWN", downDefinition);
-    RexNode upDefinition = builder.greaterThan(
-        builder.call(SqlStdOperatorTable.PREV,
-            builder.patternField("UP", intType, 3),
-            builder.literal(0)),
-        builder.call(SqlStdOperatorTable.PREV,
-            builder.patternField("UP", intType, 3),
-            builder.literal(1)));
+    RexNode upDefinition =
+        builder.greaterThan(
+            builder.call(SqlStdOperatorTable.PREV,
+                builder.patternField("UP", intType, 3),
+                builder.literal(0)),
+            builder.call(SqlStdOperatorTable.PREV,
+                builder.patternField("UP", intType, 3),
+                builder.literal(1)));
     pdBuilder.put("UP", upDefinition);
 
     ImmutableList.Builder<RexNode> measuresBuilder = new ImmutableList.Builder<>();
@@ -3875,8 +3882,9 @@ private static RelBuilder assertSize(RelBuilder b,
                 builder.literal(0)),
             "bottom_nw"));
 
-    RexNode after = builder.getRexBuilder().makeFlag(
-        SqlMatchRecognize.AfterOption.SKIP_TO_NEXT_ROW);
+    RexNode after =
+        builder.getRexBuilder()
+            .makeFlag(SqlMatchRecognize.AfterOption.SKIP_TO_NEXT_ROW);
 
     ImmutableList.Builder<RexNode> partitionKeysBuilder = new ImmutableList.Builder<>();
     partitionKeysBuilder.add(builder.field("DEPTNO"));
@@ -4031,36 +4039,20 @@ private static RelBuilder assertSize(RelBuilder b,
    * {@link org.apache.calcite.rex.RexUnknownAs#FALSE} mode for filter
    * conditions. */
   @Test void testFilterSimplification() {
-    final RelBuilder builder = RelBuilder.create(config().build());
-    final RelNode root =
-        builder.scan("EMP")
-            .filter(
-                builder.or(
-                     builder.literal(null),
-                     builder.and(
-                         builder.equals(builder.field(2), builder.literal(1)),
-                         builder.equals(builder.field(2), builder.literal(2))
-             )))
-            .build();
-    assertThat(root, hasTree("LogicalValues(tuples=[[]])\n"));
-  }
-
-  @Test void testFilterWithoutSimplification() {
-    final RelBuilder builder = createBuilder(c -> c.withSimplify(false));
-    final RelNode root =
-        builder.scan("EMP")
+    Function<RelBuilder, RelNode> f = b ->
+        b.scan("EMP")
             .filter(
-                builder.or(
-                    builder.literal(null),
-                    builder.and(
-                        builder.equals(builder.field(2), builder.literal(1)),
-                        builder.equals(builder.field(2), builder.literal(2))
-                    )))
+                b.or(b.literal(null),
+                     b.and(b.equals(b.field(2), b.literal(1)),
+                         b.equals(b.field(2), b.literal(2)))))
             .build();
-    final String expected = ""
+    final String expected = "LogicalValues(tuples=[[]])\n";
+    final String expectedWithoutSimplify = ""
         + "LogicalFilter(condition=[OR(null:NULL, AND(=($2, 1), =($2, 2)))])\n"
         + "  LogicalTableScan(table=[[scott, EMP]])\n";
-    assertThat(root, hasTree(expected));
+    assertThat(f.apply(createBuilder()), hasTree(expected));
+    assertThat(f.apply(createBuilder(c -> c.withSimplify(false))),
+        hasTree(expectedWithoutSimplify));
   }
 
   @Test void testRelBuilderToString() {
@@ -4212,8 +4204,24 @@ private void checkExpandTable(RelBuilder builder, Matcher<RelNode> matcher) {
         root, hasTree(expected));
   }
 
-  @Test void testSemiCorrelatedViaJoin() {
-    RelNode root = buildCorrelateWithJoin(JoinRelType.SEMI);
+  @Test void testSimpleSemiCorrelateViaJoinWithoutConvertCorrelateToJoin() {
+    final Function<RelBuilder, RelNode> f = b ->
+        buildSimpleCorrelateWithJoin(JoinRelType.SEMI, b);
+    final String expected = ""
+        + "LogicalCorrelate(correlation=[$cor0], joinType=[semi], requiredColumns=[{7}])\n"
+        + "  LogicalTableScan(table=[[scott, EMP]])\n"
+        + "  LogicalFilter(condition=[=($cor0.DEPTNO, $0)])\n"
+        + "    LogicalTableScan(table=[[scott, DEPT]])\n";
+    assertThat(
+        "Join with correlate id but the id never used should be simplified to a join.",
+        f.apply(createBuilder(c -> c.withConvertCorrelateToJoin(false))), hasTree(expected));
+  }
+
+  @ParameterizedTest
+  @ValueSource(booleans = {true, false})
+  void testSemiCorrelatedViaJoin(boolean convertCorrelateToJoin) {
+    final Function<RelBuilder, RelNode> f = b ->
+        buildCorrelateWithJoin(JoinRelType.SEMI, b);
     final String expected = ""
         + "LogicalCorrelate(correlation=[$cor0], joinType=[semi], requiredColumns=[{0, 7}])\n"
         + "  LogicalTableScan(table=[[scott, EMP]])\n"
@@ -4222,7 +4230,8 @@ private void checkExpandTable(RelBuilder builder, Matcher<RelNode> matcher) {
         + "      LogicalTableScan(table=[[scott, DEPT]])\n";
     assertThat(
         "Correlated semi joins should emmit a correlate with a filter on the right side.",
-        root, hasTree(expected));
+        f.apply(createBuilder(c -> c.withConvertCorrelateToJoin(convertCorrelateToJoin))),
+            hasTree(expected));
   }
 
   @Test void testSimpleAntiCorrelateViaJoin() {
@@ -4236,8 +4245,24 @@ private void checkExpandTable(RelBuilder builder, Matcher<RelNode> matcher) {
         root, hasTree(expected));
   }
 
-  @Test void testAntiCorrelateViaJoin() {
-    RelNode root = buildCorrelateWithJoin(JoinRelType.ANTI);
+  @Test void testSimpleAntiCorrelateViaJoinWithoutConvertCorrelateToJoin() {
+    final Function<RelBuilder, RelNode> f = b ->
+        buildSimpleCorrelateWithJoin(JoinRelType.ANTI, b);
+    final String expected = ""
+        + "LogicalCorrelate(correlation=[$cor0], joinType=[anti], requiredColumns=[{7}])\n"
+        + "  LogicalTableScan(table=[[scott, EMP]])\n"
+        + "  LogicalFilter(condition=[=($cor0.DEPTNO, $0)])\n"
+        + "    LogicalTableScan(table=[[scott, DEPT]])\n";
+    assertThat(
+        "Join with correlate id but the id never used should be simplified to a join.",
+        f.apply(createBuilder(c -> c.withConvertCorrelateToJoin(false))), hasTree(expected));
+  }
+
+  @ParameterizedTest
+  @ValueSource(booleans = {true, false})
+  void testAntiCorrelateViaJoin(boolean convertCorrelateToJoin) {
+    final Function<RelBuilder, RelNode> f = b ->
+        buildCorrelateWithJoin(JoinRelType.ANTI, b);
     final String expected = ""
         + "LogicalCorrelate(correlation=[$cor0], joinType=[anti], requiredColumns=[{0, 7}])\n"
         + "  LogicalTableScan(table=[[scott, EMP]])\n"
@@ -4246,7 +4271,9 @@ private void checkExpandTable(RelBuilder builder, Matcher<RelNode> matcher) {
         + "      LogicalTableScan(table=[[scott, DEPT]])\n";
     assertThat(
         "Correlated anti joins should emmit a correlate with a filter on the right side.",
-        root, hasTree(expected));  }
+        f.apply(createBuilder(c -> c.withConvertCorrelateToJoin(convertCorrelateToJoin))),
+            hasTree(expected));
+  }
 
   @Test void testSimpleLeftCorrelateViaJoin() {
     RelNode root = buildSimpleCorrelateWithJoin(JoinRelType.LEFT);
@@ -4259,8 +4286,26 @@ private void checkExpandTable(RelBuilder builder, Matcher<RelNode> matcher) {
         root, hasTree(expected));
   }
 
-  @Test void testLeftCorrelateViaJoin() {
-    RelNode root = buildCorrelateWithJoin(JoinRelType.LEFT);
+  @Test void testSimpleLeftCorrelateViaJoinWithoutConvertCorrelateToJoin() {
+    final Function<RelBuilder, RelNode> f = b ->
+        buildSimpleCorrelateWithJoin(JoinRelType.LEFT, b);
+    final String expected = ""
+        + "LogicalCorrelate(correlation=[$cor0], joinType=[left], requiredColumns=[{7}])\n"
+        + "  LogicalTableScan(table=[[scott, EMP]])\n"
+        + "  LogicalFilter(condition=[=($cor0.DEPTNO, $0)])\n"
+        + "    LogicalTableScan(table=[[scott, DEPT]])\n";
+    assertThat(
+        "Join with correlate id but the id never used should be simplified to a join.",
+        f.apply(createBuilder(c -> c.withConvertCorrelateToJoin(false))), hasTree(expected));
+  }
+
+  @ParameterizedTest
+  @ValueSource(booleans = {true, false})
+  void testLeftCorrelateViaJoin(boolean convertCorrelateToJoin) {
+    RelNode root =
+        buildCorrelateWithJoin(
+            JoinRelType.LEFT,
+            createBuilder(c -> c.withConvertCorrelateToJoin(convertCorrelateToJoin)));
     final String expected = ""
         + "LogicalCorrelate(correlation=[$cor0], joinType=[left], requiredColumns=[{0, 7}])\n"
         + "  LogicalTableScan(table=[[scott, EMP]])\n"
@@ -4282,8 +4327,23 @@ private void checkExpandTable(RelBuilder builder, Matcher<RelNode> matcher) {
         root, hasTree(expected));
   }
 
-  @Test void testInnerCorrelateViaJoin() {
-    RelNode root = buildCorrelateWithJoin(JoinRelType.INNER);
+  @Test void testSimpleInnerCorrelateViaJoinWithoutConvertCorrelateToJoin() {
+    final Function<RelBuilder, RelNode> f = b ->
+        buildSimpleCorrelateWithJoin(JoinRelType.INNER, b);
+    final String expected = ""
+        + "LogicalFilter(condition=[=($7, $8)])\n"
+        + "  LogicalCorrelate(correlation=[$cor0], joinType=[inner], requiredColumns=[{}])\n"
+        + "    LogicalTableScan(table=[[scott, EMP]])\n"
+        + "    LogicalTableScan(table=[[scott, DEPT]])\n";
+    assertThat("Join with correlate id but never used should be simplified to a join.",
+        f.apply(createBuilder(c -> c.withConvertCorrelateToJoin(false))), hasTree(expected));
+  }
+
+  @ParameterizedTest
+  @ValueSource(booleans = {true, false})
+  void testInnerCorrelateViaJoin(boolean convertCorrelateToJoin) {
+    final Function<RelBuilder, RelNode> f = b ->
+        buildCorrelateWithJoin(JoinRelType.INNER, b);
     final String expected = ""
         + "LogicalFilter(condition=[=($7, $8)])\n"
         + "  LogicalCorrelate(correlation=[$cor0], joinType=[inner], requiredColumns=[{0}])\n"
@@ -4292,7 +4352,8 @@ private void checkExpandTable(RelBuilder builder, Matcher<RelNode> matcher) {
         + "      LogicalTableScan(table=[[scott, DEPT]])\n";
     assertThat(
         "Correlated inner joins should emmit a correlate with a filter on top.",
-        root, hasTree(expected));
+        f.apply(createBuilder(c -> c.withConvertCorrelateToJoin(convertCorrelateToJoin))),
+            hasTree(expected));
   }
 
   @Test void testSimpleRightCorrelateViaJoinThrowsException() {
@@ -4320,7 +4381,10 @@ private void checkExpandTable(RelBuilder builder, Matcher<RelNode> matcher) {
   }
 
   private static RelNode buildSimpleCorrelateWithJoin(JoinRelType type) {
-    final RelBuilder builder = RelBuilder.create(config().build());
+    return buildSimpleCorrelateWithJoin(type, RelBuilder.create(config().build()));
+  }
+
+  private static RelNode buildSimpleCorrelateWithJoin(JoinRelType type, RelBuilder builder) {
     final Holder<@Nullable RexCorrelVariable> v = Holder.empty();
     return builder
         .scan("EMP")
@@ -4334,7 +4398,10 @@ private static RelNode buildSimpleCorrelateWithJoin(JoinRelType type) {
   }
 
   private static RelNode buildCorrelateWithJoin(JoinRelType type) {
-    final RelBuilder builder = RelBuilder.create(config().build());
+    return buildCorrelateWithJoin(type, RelBuilder.create(config().build()));
+  }
+
+  private static RelNode buildCorrelateWithJoin(JoinRelType type, RelBuilder builder) {
     final RexBuilder rexBuilder = builder.getRexBuilder();
     final Holder<@Nullable RexCorrelVariable> v = Holder.empty();
     return builder
@@ -4393,16 +4460,16 @@ private static RelNode buildCorrelateWithJoin(JoinRelType type) {
     assertThat(planBefore, hasTree(expectedLogicalPlan));
 
     RuleSet prepareRules =
-        RuleSets.ofList(
-            EnumerableRules.ENUMERABLE_FILTER_RULE,
+        RuleSets.ofList(EnumerableRules.ENUMERABLE_FILTER_RULE,
             EnumerableRules.ENUMERABLE_SORT_RULE,
             EnumerableRules.ENUMERABLE_LIMIT_RULE,
             EnumerableRules.ENUMERABLE_TABLE_SCAN_RULE);
     RelTraitSet desiredTraits = planBefore.getTraitSet()
         .replace(EnumerableConvention.INSTANCE);
     Program program = Programs.of(prepareRules);
-    RelNode planAfter = program.run(planBefore.getCluster().getPlanner(), planBefore,
-        desiredTraits, ImmutableList.of(), ImmutableList.of());
+    RelNode planAfter =
+        program.run(planBefore.getCluster().getPlanner(), planBefore,
+            desiredTraits, ImmutableList.of(), ImmutableList.of());
     String expectedEnumerablePlan = "EnumerableLimit(offset=[?1], fetch=[?0])\n"
         + "  EnumerableTableScan(table=[[scott, DEPT]])\n";
     assertThat(planAfter, hasTree(expectedEnumerablePlan));
@@ -4511,9 +4578,11 @@ private static RelNode buildCorrelateWithJoin(JoinRelType type) {
     //   ON orders.product = products_temporal.id
     RelNode left = builder.scan("orders").build();
     RelNode right = builder.scan("products_temporal").build();
-    RexNode period = builder.getRexBuilder().makeFieldAccess(
-        builder.getRexBuilder().makeCorrel(left.getRowType(), new CorrelationId(0)),
-        0);
+    RexNode period =
+        builder.getRexBuilder().makeFieldAccess(
+            builder.getRexBuilder().makeCorrel(left.getRowType(),
+                new CorrelationId(0)),
+            0);
     RelNode root3 =
         builder
             .push(left)
@@ -4537,9 +4606,9 @@ private static RelNode buildCorrelateWithJoin(JoinRelType type) {
         .hintOption("_idx2")
         .build();
     // Attach hints on empty stack.
-    final AssertionError error = assertThrows(
-        AssertionError.class,
-        () -> RelBuilder.create(config().build()).hints(indexHint),
+    final AssertionError error =
+        assertThrows(AssertionError.class,
+            () -> RelBuilder.create(config().build()).hints(indexHint),
         "hints() should fail on empty stack");
     assertThat(error.getMessage(),
         containsString("There is no relational expression to attach the hints"));
@@ -4551,80 +4620,90 @@ private static RelNode buildCorrelateWithJoin(JoinRelType type) {
         .hintOption("_idx2")
         .build();
     // Attach hints on non hintable.
-    final AssertionError error1 = assertThrows(
-        AssertionError.class,
-        () -> {
-          // Equivalent SQL:
-          //   SELECT *
-          //   FROM emp
-          //   MATCH_RECOGNIZE (
-          //     PARTITION BY deptno
-          //     ORDER BY empno asc
-          //     MEASURES
-          //       STRT.mgr as start_nw,
-          //       LAST(DOWN.mgr) as bottom_nw,
-          //     PATTERN (STRT DOWN+ UP+) WITHIN INTERVAL '5' SECOND
-          //     DEFINE
-          //       DOWN as DOWN.mgr < PREV(DOWN.mgr),
-          //       UP as UP.mgr > PREV(UP.mgr)
-          //   )
-          final RelBuilder builder = RelBuilder.create(config().build()).scan("EMP");
-          final RelDataTypeFactory typeFactory = builder.getTypeFactory();
-          final RelDataType intType = typeFactory.createSqlType(SqlTypeName.INTEGER);
-
-          RexNode pattern = builder.patternConcat(
-              builder.literal("STRT"),
-              builder.patternQuantify(builder.literal("DOWN"), builder.literal(1),
-                  builder.literal(-1), builder.literal(false)),
-              builder.patternQuantify(builder.literal("UP"), builder.literal(1),
-                  builder.literal(-1), builder.literal(false)));
-
-          ImmutableMap.Builder<String, RexNode> pdBuilder = new ImmutableMap.Builder<>();
-          RexNode downDefinition = builder.lessThan(
-              builder.call(SqlStdOperatorTable.PREV,
-                  builder.patternField("DOWN", intType, 3),
-                  builder.literal(0)),
-              builder.call(SqlStdOperatorTable.PREV,
-                  builder.patternField("DOWN", intType, 3),
-                  builder.literal(1)));
-          pdBuilder.put("DOWN", downDefinition);
-          RexNode upDefinition = builder.greaterThan(
-              builder.call(SqlStdOperatorTable.PREV,
-                  builder.patternField("UP", intType, 3),
-                  builder.literal(0)),
-              builder.call(SqlStdOperatorTable.PREV,
-                  builder.patternField("UP", intType, 3),
-                  builder.literal(1)));
-          pdBuilder.put("UP", upDefinition);
-
-          ImmutableList.Builder<RexNode> measuresBuilder = new ImmutableList.Builder<>();
-          measuresBuilder.add(
-              builder.alias(builder.patternField("STRT", intType, 3), "start_nw"));
-          measuresBuilder.add(
-              builder.alias(
-                  builder.call(SqlStdOperatorTable.LAST,
-                          builder.patternField("DOWN", intType, 3),
-                          builder.literal(0)),
-                  "bottom_nw"));
-
-          RexNode after = builder.getRexBuilder().makeFlag(
-              SqlMatchRecognize.AfterOption.SKIP_TO_NEXT_ROW);
-
-          ImmutableList.Builder<RexNode> partitionKeysBuilder = new ImmutableList.Builder<>();
-          partitionKeysBuilder.add(builder.field("DEPTNO"));
-
-          ImmutableList.Builder<RexNode> orderKeysBuilder = new ImmutableList.Builder<>();
-          orderKeysBuilder.add(builder.field("EMPNO"));
-
-          RexNode interval = builder.literal("INTERVAL '5' SECOND");
-
-          builder
-              .match(pattern, false, false, pdBuilder.build(),
-                  measuresBuilder.build(), after, ImmutableMap.of(), false,
-                  partitionKeysBuilder.build(), orderKeysBuilder.build(), interval)
-              .hints(indexHint);
-        },
-        "hints() should fail on non Hintable relational expression");
+
+    // Equivalent SQL:
+    //   SELECT *
+    //   FROM emp
+    //   MATCH_RECOGNIZE (
+    //     PARTITION BY deptno
+    //     ORDER BY empno asc
+    //     MEASURES
+    //       STRT.mgr as start_nw,
+    //       LAST(DOWN.mgr) as bottom_nw,
+    //     PATTERN (STRT DOWN+ UP+) WITHIN INTERVAL '5' SECOND
+    //     DEFINE
+    //       DOWN as DOWN.mgr < PREV(DOWN.mgr),
+    //       UP as UP.mgr > PREV(UP.mgr)
+    //   )
+    final RelBuilder builder = RelBuilder.create(config().build()).scan("EMP");
+    final RelDataTypeFactory typeFactory = builder.getTypeFactory();
+    final RelDataType intType = typeFactory.createSqlType(SqlTypeName.INTEGER);
+
+    RexNode pattern =
+        builder.patternConcat(builder.literal("STRT"),
+            builder.patternQuantify(builder.literal("DOWN"),
+                builder.literal(1), builder.literal(-1),
+                builder.literal(false)),
+            builder.patternQuantify(builder.literal("UP"),
+                builder.literal(1), builder.literal(-1),
+                builder.literal(false)));
+
+    ImmutableMap.Builder<String, RexNode> pdBuilder =
+        new ImmutableMap.Builder<>();
+    RexNode downDefinition =
+        builder.lessThan(
+            builder.call(SqlStdOperatorTable.PREV,
+                builder.patternField("DOWN", intType, 3),
+                builder.literal(0)),
+            builder.call(SqlStdOperatorTable.PREV,
+                builder.patternField("DOWN", intType, 3),
+                builder.literal(1)));
+    pdBuilder.put("DOWN", downDefinition);
+    RexNode upDefinition =
+        builder.greaterThan(
+            builder.call(SqlStdOperatorTable.PREV,
+                builder.patternField("UP", intType, 3),
+                builder.literal(0)),
+            builder.call(SqlStdOperatorTable.PREV,
+                builder.patternField("UP", intType, 3),
+                builder.literal(1)));
+    pdBuilder.put("UP", upDefinition);
+
+    ImmutableList.Builder<RexNode> measuresBuilder =
+        new ImmutableList.Builder<>();
+    measuresBuilder.add(
+        builder.alias(builder.patternField("STRT", intType, 3), "start_nw"));
+    measuresBuilder.add(
+        builder.alias(
+            builder.call(SqlStdOperatorTable.LAST,
+                builder.patternField("DOWN", intType, 3),
+                builder.literal(0)),
+            "bottom_nw"));
+
+    RexNode after =
+        builder.getRexBuilder().makeFlag(
+            SqlMatchRecognize.AfterOption.SKIP_TO_NEXT_ROW);
+
+    ImmutableList.Builder<RexNode> partitionKeysBuilder =
+        new ImmutableList.Builder<>();
+    partitionKeysBuilder.add(builder.field("DEPTNO"));
+
+    ImmutableList.Builder<RexNode> orderKeysBuilder =
+        new ImmutableList.Builder<>();
+    orderKeysBuilder.add(builder.field("EMPNO"));
+
+    RexNode interval = builder.literal("INTERVAL '5' SECOND");
+
+    Executable executable = () -> {
+      builder
+          .match(pattern, false, false, pdBuilder.build(),
+              measuresBuilder.build(), after, ImmutableMap.of(), false,
+              partitionKeysBuilder.build(), orderKeysBuilder.build(), interval)
+          .hints(indexHint);
+    };
+    final AssertionError error1 =
+        assertThrows(AssertionError.class, executable,
+            "hints() should fail on non Hintable relational expression");
     assertThat(error1.getMessage(),
         containsString("The top relational expression is not a Hintable"));
   }
diff --git a/core/src/test/java/org/apache/calcite/test/RelMdColumnOriginsTest.java b/core/src/test/java/org/apache/calcite/test/RelMdColumnOriginsTest.java
index 4f19ebc9b1f..d034e9906f7 100644
--- a/core/src/test/java/org/apache/calcite/test/RelMdColumnOriginsTest.java
+++ b/core/src/test/java/org/apache/calcite/test/RelMdColumnOriginsTest.java
@@ -17,6 +17,7 @@
 package org.apache.calcite.test;
 
 import org.apache.calcite.jdbc.CalciteConnection;
+import org.apache.calcite.util.Smalls;
 
 import com.google.common.collect.ImmutableMultiset;
 
@@ -43,7 +44,7 @@ class RelMdColumnOriginsTest {
         connection.unwrap(CalciteConnection.class);
 
     calciteConnection.getRootSchema().add("T1",
-        new TableInRootSchemaTest.SimpleTable());
+        new Smalls.SimpleTable());
     Statement statement = calciteConnection.createStatement();
     ResultSet resultSet =
         statement.executeQuery("SELECT TABLE1.ID, TABLE2.ID FROM "
diff --git a/core/src/test/java/org/apache/calcite/test/RelMetadataTest.java b/core/src/test/java/org/apache/calcite/test/RelMetadataTest.java
index 247cf870cba..14aa9aeaf7e 100644
--- a/core/src/test/java/org/apache/calcite/test/RelMetadataTest.java
+++ b/core/src/test/java/org/apache/calcite/test/RelMetadataTest.java
@@ -16,9 +16,12 @@
  */
 package org.apache.calcite.test;
 
+import org.apache.calcite.adapter.enumerable.EnumerableConvention;
 import org.apache.calcite.adapter.enumerable.EnumerableMergeJoin;
+import org.apache.calcite.adapter.enumerable.EnumerableRules;
 import org.apache.calcite.config.CalciteSystemProperty;
 import org.apache.calcite.linq4j.tree.Types;
+import org.apache.calcite.plan.ConventionTraitDef;
 import org.apache.calcite.plan.RelOptCluster;
 import org.apache.calcite.plan.RelOptPlanner;
 import org.apache.calcite.plan.RelOptPredicateList;
@@ -27,6 +30,7 @@
 import org.apache.calcite.plan.hep.HepPlanner;
 import org.apache.calcite.plan.hep.HepProgram;
 import org.apache.calcite.plan.hep.HepProgramBuilder;
+import org.apache.calcite.plan.volcano.VolcanoPlanner;
 import org.apache.calcite.rel.RelCollation;
 import org.apache.calcite.rel.RelCollationTraitDef;
 import org.apache.calcite.rel.RelCollations;
@@ -88,11 +92,12 @@
 import org.apache.calcite.rex.RexTableInputRef;
 import org.apache.calcite.rex.RexTableInputRef.RelTableRef;
 import org.apache.calcite.rex.RexUtil;
+import org.apache.calcite.sql.SqlBasicFunction;
 import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.SqlOperator;
-import org.apache.calcite.sql.SqlSpecialOperator;
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
 import org.apache.calcite.sql.test.SqlTestFactory;
+import org.apache.calcite.sql.type.OperandTypes;
 import org.apache.calcite.sql.type.ReturnTypes;
 import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.test.catalog.MockCatalogReaderSimple;
@@ -644,6 +649,39 @@ final RelMetadataFixture sql(String sql) {
     fixture.assertThatRowCount(is(9D), is(0D), is(10d));
   }
 
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5286">[CALCITE-5286]
+   * Join with parameterized LIMIT throws AssertionError "not a literal". </a>. */
+  @Test void testRowCountJoinWithDynamicParameters() {
+    final String sql = "select r.ename, s.sal from\n"
+        + "(select * from emp limit ?) r join bonus s\n"
+        + "on r.ename=s.ename where r.sal+1=s.sal";
+    sql(sql)
+        .withCluster(cluster -> {
+          RelOptPlanner planner = new VolcanoPlanner();
+          planner.addRule(EnumerableRules.ENUMERABLE_TABLE_SCAN_RULE);
+          planner.addRule(EnumerableRules.ENUMERABLE_PROJECT_RULE);
+          planner.addRule(EnumerableRules.ENUMERABLE_FILTER_RULE);
+          planner.addRule(EnumerableRules.ENUMERABLE_JOIN_RULE);
+          planner.addRule(EnumerableRules.ENUMERABLE_LIMIT_SORT_RULE);
+          planner.addRelTraitDef(ConventionTraitDef.INSTANCE);
+          return RelOptCluster.create(planner, cluster.getRexBuilder());
+        })
+        .withRelTransform(rel -> {
+          RelOptPlanner planner = rel.getCluster().getPlanner();
+          planner.setRoot(rel);
+          RelTraitSet requiredOutputTraits =
+              rel.getCluster().traitSet().replace(EnumerableConvention.INSTANCE);
+          final RelNode rootRel2 = planner.changeTraits(rel, requiredOutputTraits);
+
+          planner.setRoot(rootRel2);
+          final RelOptPlanner planner2 = planner.chooseDelegate();
+          final RelNode rootRel3 = planner2.findBestExp();
+          return rootRel3;
+        })
+        .assertThatRowCount(is(1.0), is(0D), is(Double.POSITIVE_INFINITY));
+  }
+
   @Test void testRowCountSortLimitOffsetDynamic() {
     sql("select * from emp order by ename limit ? offset ?")
         .assertThatRowCount(is(EMP_SIZE), is(0D), is(Double.POSITIVE_INFINITY));
@@ -969,6 +1007,14 @@ final RelMetadataFixture sql(String sql) {
         .assertThatUniqueKeysAre(bitSetOf());
   }
 
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5162">[CALCITE-5162]
+   * RelMdUniqueKeys can return more precise unique keys for Aggregate</a>. */
+  @Test void testGroupByPreciseUniqueKeys() {
+    sql("select empno, ename from emp group by empno, ename")
+        .assertThatUniqueKeysAre(bitSetOf(0));
+  }
+
   @Test void testFullOuterJoinUniqueness1() {
     final String sql = "select e.empno, d.deptno\n"
         + "from (select cast(null as int) empno from sales.emp "
@@ -1116,6 +1162,24 @@ private void checkColumnUniquenessForFilterWithConstantColumns(String sql) {
         .assertThatAreColumnsUnique(bitSetOf(0), is(true));
   }
 
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5149">[CALCITE-5149]
+   * Refine RelMdColumnUniqueness for Aggregate by considering intersect keys
+   * between target keys and group keys</a>. */
+  @Test void testColumnUniquenessForAggregate() {
+    sql("select empno, ename, count(1) as cnt from emp group by empno, ename")
+        .assertThatAreColumnsUnique(bitSetOf(0, 1), is(true));
+
+    sql("select empno, ename, count(1) as cnt from emp group by empno, ename")
+        .assertThatAreColumnsUnique(bitSetOf(0), is(true));
+
+    sql("select ename, empno, count(1) as cnt from emp group by ename, empno")
+        .assertThatAreColumnsUnique(bitSetOf(1), is(true));
+
+    sql("select empno, ename, count(1) as cnt from emp group by empno, ename")
+        .assertThatAreColumnsUnique(bitSetOf(2), is(false));
+  }
+
   @Test void testGroupBy() {
     sql("select deptno, count(*), sum(sal) from emp group by deptno")
         .assertThatUniqueKeysAre(bitSetOf(0));
@@ -1554,10 +1618,11 @@ private void checkCollation(RelOptCluster cluster, RelOptTable empTable,
     assertThat(collations.get(0).getFieldCollations().get(1).getFieldIndex(),
         equalTo(0));
 
-    final LogicalProject project = LogicalProject.create(empSort,
-        ImmutableList.of(),
-        projects,
-        ImmutableList.of("a", "b", "c", "d"));
+    final LogicalProject project =
+        LogicalProject.create(empSort, ImmutableList.of(),
+            projects,
+            ImmutableList.of("a", "b", "c", "d"),
+            ImmutableSet.of());
 
     final LogicalTableScan deptScan =
         LogicalTableScan.create(cluster, deptTable, ImmutableList.of());
@@ -1569,9 +1634,9 @@ private void checkCollation(RelOptCluster cluster, RelOptTable empTable,
 
     final ImmutableIntList leftKeys = ImmutableIntList.of(2);
     final ImmutableIntList rightKeys = ImmutableIntList.of(0);
-    final EnumerableMergeJoin join;
-    join = EnumerableMergeJoin.create(project, deptSort,
-        rexBuilder.makeLiteral(true), leftKeys, rightKeys, JoinRelType.INNER);
+    final EnumerableMergeJoin join =
+        EnumerableMergeJoin.create(project, deptSort,
+            rexBuilder.makeLiteral(true), leftKeys, rightKeys, JoinRelType.INNER);
     collations =
         RelMdCollation.mergeJoin(mq, project, deptSort, leftKeys,
             rightKeys, JoinRelType.INNER);
@@ -1597,8 +1662,8 @@ private void checkCollation(RelOptCluster cluster, RelOptTable empTable,
         equalTo(antiJoin.getTraitSet().getTraits(RelCollationTraitDef.INSTANCE)));
 
     // Values (empty)
-    collations = RelMdCollation.values(mq, empTable.getRowType(),
-        ImmutableList.of());
+    collations =
+        RelMdCollation.values(mq, empTable.getRowType(), ImmutableList.of());
     assertThat(collations.toString(),
         equalTo("[[0, 1, 2, 3, 4, 5, 6, 7, 8], "
             + "[1, 2, 3, 4, 5, 6, 7, 8], "
@@ -1697,8 +1762,8 @@ private void addRow(ImmutableList.Builder<ImmutableList<RexLiteral>> builder,
       if (value == null) {
         literal = rexBuilder.makeNullLiteral(varcharType);
       } else if (value instanceof Integer) {
-        literal = rexBuilder.makeExactLiteral(
-            BigDecimal.valueOf((Integer) value));
+        literal =
+            rexBuilder.makeExactLiteral(BigDecimal.valueOf((Integer) value));
       } else {
         literal = rexBuilder.makeLiteral((String) value);
       }
@@ -1805,7 +1870,8 @@ private void checkAverageRowSize(RelOptCluster cluster, RelOptTable empTable,
                     rexBuilder.makeExactLiteral(BigDecimal.ONE)),
                 rexBuilder.makeCall(SqlStdOperatorTable.CHAR_LENGTH,
                     rexBuilder.makeInputRef(filter, 1))),
-            (List<String>) null);
+            (List<String>) null,
+            ImmutableSet.of());
     rowSize = mq.getAverageRowSize(deptProject);
     columnSizes = mq.getAverageColumnSizes(deptProject);
     assertThat(columnSizes.size(), equalTo(4));
@@ -1869,8 +1935,8 @@ private void checkPredicates(RelOptCluster cluster, RelOptTable empTable,
     final RelBuilder relBuilder = RelBuilder.proto().create(cluster, null);
     final RelMetadataQuery mq = cluster.getMetadataQuery();
 
-    final LogicalTableScan empScan = LogicalTableScan.create(cluster, empTable,
-        ImmutableList.of());
+    final LogicalTableScan empScan =
+        LogicalTableScan.create(cluster, empTable, ImmutableList.of());
     relBuilder.push(empScan);
 
     RelOptPredicateList predicates =
@@ -2193,6 +2259,17 @@ private void assertExpressionLineage(
         String.valueOf(r), is(expected));
   }
 
+
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5392">[CALCITE-5392]
+   * Support Snapshot in RelMdExpressionLineage</a>. */
+  @Test void testExpressionLineageSnapshot() {
+    String expected = "[[CATALOG, SALES, PRODUCTS_TEMPORAL].#0.$0]";
+    String comment = "'productid' is column 0 in 'catalog.sales.products_temporal'";
+    assertExpressionLineage("select productid from products_temporal\n"
+        + "for system_time as of TIMESTAMP '2011-01-02 00:00:00'", 0, expected, comment);
+  }
+
   @Test void testExpressionLineageStar() {
     // All columns in output
     final RelNode tableRel = sql("select * from emp").toRel();
@@ -2819,8 +2896,8 @@ public void checkAllPredicatesAndTableSetOp(String sql) {
   @Test void testTableReferencesJoinUnknownNode() {
     final String sql = "select * from emp limit 10";
     final RelNode node = sql(sql).toRel();
-    final RelNode nodeWithUnknown = new DummyRelNode(
-        node.getCluster(), node.getTraitSet(), node);
+    final RelNode nodeWithUnknown =
+        new DummyRelNode(node.getCluster(), node.getTraitSet(), node);
     final RexBuilder rexBuilder = node.getCluster().getRexBuilder();
     // Join
     final LogicalJoin join =
@@ -2854,8 +2931,8 @@ public void checkAllPredicatesAndTableSetOp(String sql) {
   @Test void testTableReferencesUnionUnknownNode() {
     final String sql = "select * from emp limit 10";
     final RelNode node = sql(sql).toRel();
-    final RelNode nodeWithUnknown = new DummyRelNode(
-        node.getCluster(), node.getTraitSet(), node);
+    final RelNode nodeWithUnknown =
+        new DummyRelNode(node.getCluster(), node.getTraitSet(), node);
     // Union
     final LogicalUnion union =
         LogicalUnion.create(ImmutableList.of(nodeWithUnknown, node),
@@ -3145,17 +3222,9 @@ public void checkAllPredicatesAndTableSetOp(String sql) {
         is(mq.getPopulationSize(rel, bitSetOf(0))));
   }
 
-  private static final SqlOperator NONDETERMINISTIC_OP = new SqlSpecialOperator(
-          "NDC",
-          SqlKind.OTHER_FUNCTION,
-          0,
-          false,
-          ReturnTypes.BOOLEAN,
-          null, null) {
-    @Override public boolean isDeterministic() {
-      return false;
-    }
-  };
+  private static final SqlOperator NONDETERMINISTIC_OP =
+      SqlBasicFunction.create("NDC", ReturnTypes.BOOLEAN, OperandTypes.VARIADIC)
+          .withDeterministic(false);
 
   /** Tests calling {@link RelMetadataQuery#getTableOrigin} for
    * an aggregate with no columns. Previously threw. */
@@ -3235,6 +3304,44 @@ public void checkAllPredicatesAndTableSetOp(String sql) {
     });
   }
 
+  /** Unit test for
+   * {@link org.apache.calcite.rel.metadata.RelMetadataQuery#getAverageColumnSizes(org.apache.calcite.rel.RelNode)}
+   * with a table that has its own implementation of {@link BuiltInMetadata.Size}. */
+  @Test void testCustomizedAverageColumnSizes() {
+    SqlTestFactory.CatalogReaderFactory factory = (typeFactory, caseSensitive) -> {
+      CompositeKeysCatalogReader catalogReader =
+          new CompositeKeysCatalogReader(typeFactory, false);
+      catalogReader.init();
+      return catalogReader;
+    };
+
+    final RelNode rel = sql("select key1, key2 from s.composite_keys_table")
+        .withCatalogReaderFactory(factory).toRel();
+    final RelMetadataQuery mq = rel.getCluster().getMetadataQuery();
+    List<Double> columnSizes = mq.getAverageColumnSizes(rel);
+    assertThat(columnSizes.size(), is(2));
+    assertThat(columnSizes.get(0), is(2.0));
+    assertThat(columnSizes.get(1), is(3.0));
+  }
+
+  /** Unit test for
+   * {@link org.apache.calcite.rel.metadata.RelMetadataQuery#getDistinctRowCount(RelNode, ImmutableBitSet, RexNode)}
+   * with a table that has its own implementation of {@link BuiltInMetadata.Size}. */
+  @Test void testCustomizedDistinctRowcount() {
+    SqlTestFactory.CatalogReaderFactory factory = (typeFactory, caseSensitive) -> {
+      CompositeKeysCatalogReader catalogReader =
+          new CompositeKeysCatalogReader(typeFactory, false);
+      catalogReader.init();
+      return catalogReader;
+    };
+
+    final RelNode rel = sql("select key1, key2 from s.composite_keys_table")
+        .withCatalogReaderFactory(factory).toRel();
+    final RelMetadataQuery mq = rel.getCluster().getMetadataQuery();
+    Double ndv = mq.getDistinctRowCount(rel, ImmutableBitSet.of(0, 1), null);
+    assertThat(ndv, is(100.0));
+  }
+
   private void checkInputForCollationAndLimit(RelOptCluster cluster, RelOptTable empTable,
       RelOptTable deptTable) {
     final RexBuilder rexBuilder = cluster.getRexBuilder();
@@ -3378,8 +3485,48 @@ private static class CompositeKeysCatalogReader
       t1.addColumn("key1", typeFactory.createSqlType(SqlTypeName.VARCHAR), true);
       t1.addColumn("key2", typeFactory.createSqlType(SqlTypeName.VARCHAR), true);
       t1.addColumn("value1", typeFactory.createSqlType(SqlTypeName.INTEGER));
+      addSizeHandler(t1);
+      addDistinctRowcountHandler(t1);
+      addUniqueKeyHandler(t1);
       registerTable(t1);
       return this;
     }
+
+    private void addSizeHandler(MockTable table) {
+      table.addWrap(
+          new BuiltInMetadata.Size.Handler() {
+            @Override public @Nullable Double averageRowSize(RelNode r, RelMetadataQuery mq) {
+              return null;
+            }
+
+            @Override public @Nullable List<@Nullable Double> averageColumnSizes(RelNode r,
+                RelMetadataQuery mq) {
+              List<Double> colSize = new ArrayList<>();
+              colSize.add(2D);
+              colSize.add(3D);
+              return colSize;
+            }
+          });
+    }
+
+    private void addDistinctRowcountHandler(MockTable table) {
+      table.addWrap(
+          new BuiltInMetadata.DistinctRowCount.Handler() {
+            @Override public @Nullable Double getDistinctRowCount(RelNode r, RelMetadataQuery mq,
+                ImmutableBitSet groupKey, @Nullable RexNode predicate) {
+              return 100D;
+            }
+          });
+    }
+
+    private void addUniqueKeyHandler(MockTable table) {
+      table.addWrap(
+          new BuiltInMetadata.UniqueKeys.Handler() {
+            @Override public @Nullable Set<ImmutableBitSet> getUniqueKeys(RelNode r,
+                RelMetadataQuery mq, boolean ignoreNulls) {
+              return ImmutableSet.of(ImmutableBitSet.of(0, 1));
+            }
+          });
+    }
   }
 }
diff --git a/core/src/test/java/org/apache/calcite/test/RelOptRulesTest.java b/core/src/test/java/org/apache/calcite/test/RelOptRulesTest.java
index 1431407c89e..26866db0650 100644
--- a/core/src/test/java/org/apache/calcite/test/RelOptRulesTest.java
+++ b/core/src/test/java/org/apache/calcite/test/RelOptRulesTest.java
@@ -99,18 +99,16 @@
 import org.apache.calcite.rex.RexLiteral;
 import org.apache.calcite.rex.RexNode;
 import org.apache.calcite.rex.RexUtil;
+import org.apache.calcite.sql.SqlBasicFunction;
 import org.apache.calcite.sql.SqlFunction;
 import org.apache.calcite.sql.SqlFunctionCategory;
 import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.SqlOperator;
-import org.apache.calcite.sql.SqlOperatorBinding;
-import org.apache.calcite.sql.SqlSpecialOperator;
 import org.apache.calcite.sql.fun.SqlLibrary;
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
 import org.apache.calcite.sql.test.SqlTestFactory;
 import org.apache.calcite.sql.type.OperandTypes;
 import org.apache.calcite.sql.type.ReturnTypes;
-import org.apache.calcite.sql.type.SqlTypeFactoryImpl;
 import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.sql.validate.SqlConformanceEnum;
 import org.apache.calcite.sql.validate.SqlMonotonicity;
@@ -123,15 +121,20 @@
 import org.apache.calcite.tools.RelBuilder;
 import org.apache.calcite.tools.RuleSet;
 import org.apache.calcite.tools.RuleSets;
+import org.apache.calcite.util.DateString;
 import org.apache.calcite.util.ImmutableBitSet;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
 import org.immutables.value.Value;
+import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.EnumSet;
 import java.util.List;
@@ -170,15 +173,14 @@
  * for details on the schema.
  *
  * <li>Run the test. It should fail. Inspect the output in
- * {@code target/surefire/.../RelOptRulesTest.xml}.
- * (If you are running using maven and this file does not exist, add a
- * {@code -X} flag to the maven command line.)
+ * {@code build/resources/.../RelOptRulesTest_actual.xml}
+ * (e.g., {@code diff src/test/resources/.../RelOptRulesTest.xml
+ * build/resources/.../RelOptRulesTest_actual.xml}).
  *
- * <li>Verify that the "planBefore" is the correct
- * translation of your SQL, and that it contains the pattern on which your rule
- * is supposed to fire. If all is well, replace
- * {@code src/test/resources/.../RelOptRulesTest.xml} and
- * with the new {@code target/surefire/.../RelOptRulesTest.xml}.
+ * <li>Verify that the "planBefore" is the correct translation of your SQL,
+ * and that it contains the pattern on which your rule is supposed to fire.
+ * If all is well, replace {@code src/test/resources/.../RelOptRulesTest.xml}
+ * with the new {@code build/resources/.../RelOptRulesTest_actual.xml}.
  *
  * <li>Run the test again. It should fail again, but this time it should contain
  * a "planAfter" entry for your rule. Verify that your rule applied its
@@ -191,9 +193,21 @@
 class RelOptRulesTest extends RelOptTestBase {
   //~ Methods ----------------------------------------------------------------
 
+  @Nullable
+  private static DiffRepository diffRepos = null;
+
+  @AfterAll
+  public static void checkActualAndReferenceFiles() {
+    if (diffRepos != null) {
+      diffRepos.checkActualAndReferenceFiles();
+    }
+  }
+
   @Override RelOptFixture fixture() {
-    return super.fixture()
+    RelOptFixture fixture = super.fixture()
         .withDiffRepos(DiffRepository.lookup(RelOptRulesTest.class));
+    diffRepos = fixture.diffRepos();
+    return fixture;
   }
 
   private static boolean skipItem(RexNode expr) {
@@ -293,17 +307,20 @@ private static boolean skipItem(RexNode expr) {
 
   /** Test case for
    * <a href="https://issues.apache.org/jira/browse/CALCITE-2865">[CALCITE-2865]
-   * FilterProjectTransposeRule generates wrong traitSet when copyFilter/Project is true</a>. */
+   * FilterProjectTransposeRule generates wrong traitSet when
+   * copyFilter/copyProject is true</a>. */
   @Test void testFilterProjectTransposeRule() {
-    List<RelOptRule> rules = Arrays.asList(
-        CoreRules.FILTER_PROJECT_TRANSPOSE, // default: copyFilter=true, copyProject=true
-        CoreRules.FILTER_PROJECT_TRANSPOSE.config
-            .withOperandFor(Filter.class,
-                filter -> !RexUtil.containsCorrelation(filter.getCondition()),
-                Project.class, project -> true)
-            .withCopyFilter(false)
-            .withCopyProject(false)
-            .toRule());
+    List<RelOptRule> rules =
+        Arrays.asList(
+            // default: copyFilter=true, copyProject=true
+            CoreRules.FILTER_PROJECT_TRANSPOSE,
+            CoreRules.FILTER_PROJECT_TRANSPOSE.config
+                .withOperandFor(Filter.class,
+                    filter -> !RexUtil.containsCorrelation(filter.getCondition()),
+                    Project.class, project -> true)
+                .withCopyFilter(false)
+                .withCopyProject(false)
+                .toRule());
 
     for (RelOptRule rule : rules) {
       RelBuilder b = RelBuilder.create(RelBuilderTest.config().build());
@@ -357,7 +374,10 @@ private static boolean skipItem(RexNode expr) {
     final String sql = "SELECT CASE WHEN 1=2 "
         + "THEN cast((values(1)) as integer) "
         + "ELSE 2 end from (values(1))";
-    sql(sql).withPlanner(hepPlanner).checkUnchanged();
+    sql(sql)
+        .withExpand(true)
+        .withPlanner(hepPlanner)
+        .checkUnchanged();
   }
 
   @Test void testReduceNullableCase2() {
@@ -369,7 +389,10 @@ private static boolean skipItem(RexNode expr) {
     final String sql = "SELECT deptno, ename, CASE WHEN 1=2 "
         + "THEN substring(ename, 1, cast(2 as int)) ELSE NULL end from emp"
         + " group by deptno, ename, case when 1=2 then substring(ename,1, cast(2 as int))  else null end";
-    sql(sql).withPlanner(hepPlanner).checkUnchanged();
+    sql(sql)
+        .withExpand(true)
+        .withPlanner(hepPlanner)
+        .checkUnchanged();
   }
 
   @Test void testProjectToWindowRuleForMultipleWindows() {
@@ -411,6 +434,102 @@ private static boolean skipItem(RexNode expr) {
     sql(sql).withRule(CoreRules.JOIN_ADD_REDUNDANT_SEMI_JOIN).check();
   }
 
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-3890">[CALCITE-3890]
+   * Derive IS NOT NULL predicates from a inner join and create filters with those predicates
+   * as new inputs of the join</a>. */
+  @Test void testJoinDeriveIsNotNullFilterRule1() {
+    final String sql = "select t1.deptno from emp t1 inner join emp t2 on t1.mgr = t2.mgr";
+    sql(sql).withRule(CoreRules.JOIN_DERIVE_IS_NOT_NULL_FILTER_RULE).check();
+  }
+
+  /** As {@link #testJoinDeriveIsNotNullFilterRule1()};
+   * should create IS NOT NULL filter for the right input of join, but not for
+   * the left input since its child already has one. */
+  @Test void testJoinDeriveIsNotNullFilterRule2() {
+    final String sql = "select t1.deptno from (select * from emp where mgr is not null) t1 "
+        + "join emp t2 on t1.mgr = t2.mgr";
+    sql(sql).withRule(CoreRules.JOIN_DERIVE_IS_NOT_NULL_FILTER_RULE).check();
+  }
+
+  /** As {@link #testJoinDeriveIsNotNullFilterRule1()};
+   * should create IS NOT NULL filter in both sides. */
+  @Test void testJoinDeriveIsNotNullFilterRule3() {
+    final String sql = "select t1.deptno from emp t1 inner join emp t2 on t1.mgr > t2.mgr";
+    sql(sql).withRule(CoreRules.JOIN_DERIVE_IS_NOT_NULL_FILTER_RULE).check();
+  }
+
+  /** As {@link #testJoinDeriveIsNotNullFilterRule1()};
+   * should create IS NOT NULL filter for both join keys. */
+  @Test void testJoinDeriveIsNotNullFilterRule4() {
+    final String sql = "select t1.deptno from empnullables t1 inner join\n"
+        + "empnullables t2 on t1.ename = t2.ename and t1.mgr > t2.mgr";
+    sql(sql).withRule(CoreRules.JOIN_DERIVE_IS_NOT_NULL_FILTER_RULE).check();
+  }
+
+  /** As {@link #testJoinDeriveIsNotNullFilterRule1()};
+   * should create IS NOT NULL filter for the right input of join, but not for
+   * the left input since its ancestor already has one. */
+  @Test void testJoinDeriveIsNotNullFilterRule5() {
+    final String sql = "select t1.deptno from (select ename, deptno+1 as deptno from\n"
+        + "empnullables where ename is not null) t1 inner join\n"
+        + "empnullables t2 on t1.ename = t2.ename";
+    sql(sql).withRule(CoreRules.JOIN_DERIVE_IS_NOT_NULL_FILTER_RULE).check();
+  }
+
+  /** As {@link #testJoinDeriveIsNotNullFilterRule1()};
+   * should not create IS NOT NULL filter in any side since it is full join. */
+  @Test void testJoinDeriveIsNotNullFilterRule6() {
+    final String sql = "select t1.deptno from emp t1 full join emp t2 on t1.mgr = t2.mgr";
+    sql(sql).withRule(CoreRules.JOIN_DERIVE_IS_NOT_NULL_FILTER_RULE).checkUnchanged();
+  }
+
+  /** As {@link #testJoinDeriveIsNotNullFilterRule1()};
+   * should not create IS NOT NULL filter in any side since it is left join. */
+  @Test void testJoinDeriveIsNotNullFilterRule7() {
+    final String sql = "select t1.deptno from emp t1 left join emp t2 on t1.mgr = t2.mgr";
+    sql(sql).withRule(CoreRules.JOIN_DERIVE_IS_NOT_NULL_FILTER_RULE).checkUnchanged();
+  }
+
+  /** As {@link #testJoinDeriveIsNotNullFilterRule1()};
+   * should not create IS NOT NULL filter in any side since it is right join. */
+  @Test void testJoinDeriveIsNotNullFilterRule8() {
+    final String sql = "select t1.deptno from emp t1 right join emp t2 on t1.mgr = t2.mgr";
+    sql(sql).withRule(CoreRules.JOIN_DERIVE_IS_NOT_NULL_FILTER_RULE).checkUnchanged();
+  }
+
+  /** As {@link #testJoinDeriveIsNotNullFilterRule1()};
+   * should not create IS NOT NULL filter in both sides since they already have the filter. */
+  @Test void testJoinDeriveIsNotNullFilterRule9() {
+    final String sql = "select t1.deptno from (select * from emp where mgr is not null) t1\n"
+        + "join (select * from emp where mgr is not null) t2 on t1.mgr = t2.mgr";
+    sql(sql).withRule(CoreRules.JOIN_DERIVE_IS_NOT_NULL_FILTER_RULE).checkUnchanged();
+  }
+
+  /** As {@link #testJoinDeriveIsNotNullFilterRule1()};
+   * should not create IS NOT NULL filter in any side since the join condition is not strong. */
+  @Test void testJoinDeriveIsNotNullFilterRule10() {
+    final String sql = "select t1.deptno from emp t1 inner join emp t2\n"
+        + "on t1.mgr is not distinct from t2.mgr";
+    sql(sql).withRule(CoreRules.JOIN_DERIVE_IS_NOT_NULL_FILTER_RULE).checkUnchanged();
+  }
+
+  /** As {@link #testJoinDeriveIsNotNullFilterRule1()};
+   * should not create IS NOT NULL filter since it's cartesian product. */
+  @Test void testJoinDeriveIsNotNullFilterRule11() {
+    final String sql = "select t1.deptno from empnullables t1 inner join\n"
+        + "empnullables t2 on t1.ename = t2.ename or 1 = 1";
+    sql(sql).withRule(CoreRules.JOIN_DERIVE_IS_NOT_NULL_FILTER_RULE).checkUnchanged();
+  }
+
+  /** As {@link #testJoinDeriveIsNotNullFilterRule1()};
+   * should create IS NOT NULL filter for one of the join keys. */
+  @Test void testJoinDeriveIsNotNullFilterRule12() {
+    final String sql = "select t1.deptno from empnullables t1 inner join\n"
+        + "empnullables t2 on t1.ename = t2.ename and t1.mgr is not distinct from t2.mgr";
+    sql(sql).withRule(CoreRules.JOIN_DERIVE_IS_NOT_NULL_FILTER_RULE).check();
+  }
+
   @Test void testStrengthenJoinType() {
     // The "Filter(... , right.c IS NOT NULL)" above a left join is pushed into
     // the join, makes it an inner join, and then disappears because c is NOT
@@ -529,14 +648,14 @@ private void checkCanNotPushSemiOrAntiJoinConditionsToLeft(JoinRelType type) {
       RexInputRef ref4 = b.field(2, 1, "DNAME");
 
       // ref1 IS NOT DISTINCT FROM ref2
-      RexCall cond1 = (RexCall) b.call(SqlStdOperatorTable.OR,
-          b.equals(ref1, ref2),
-          b.call(SqlStdOperatorTable.AND, b.isNull(ref1), b.isNull(ref2)));
+      RexCall cond1 =
+          (RexCall) b.call(SqlStdOperatorTable.OR, b.equals(ref1, ref2),
+              b.call(SqlStdOperatorTable.AND, b.isNull(ref1), b.isNull(ref2)));
 
       // ref3 IS NOT DISTINCT FROM ref4
-      RexCall cond2 = (RexCall) b.call(SqlStdOperatorTable.OR,
-          b.equals(ref3, ref4),
-          b.call(SqlStdOperatorTable.AND, b.isNull(ref3), b.isNull(ref4)));
+      RexCall cond2 =
+          (RexCall) b.call(SqlStdOperatorTable.OR, b.equals(ref3, ref4),
+              b.call(SqlStdOperatorTable.AND, b.isNull(ref3), b.isNull(ref4)));
 
       RexNode cond = b.and(cond1, cond2);
       return b.semiJoin(cond)
@@ -998,8 +1117,7 @@ private void checkSemiOrAntiJoinProjectTranspose(JoinRelType type) {
     diffRepos.assertEquals("planBefore", "${planBefore}", planBefore);
 
     RuleSet ruleSet =
-        RuleSets.ofList(
-            EnumerableRules.ENUMERABLE_SORT_RULE,
+        RuleSets.ofList(EnumerableRules.ENUMERABLE_SORT_RULE,
             EnumerableRules.ENUMERABLE_LIMIT_RULE,
             EnumerableRules.ENUMERABLE_LIMIT_SORT_RULE,
             EnumerableRules.ENUMERABLE_PROJECT_RULE,
@@ -1012,8 +1130,9 @@ private void checkSemiOrAntiJoinProjectTranspose(JoinRelType type) {
         rel.getCluster().traitSet()
             .replace(0, EnumerableConvention.INSTANCE);
 
-    RelNode relAfter = program.run(fixture.planner, rel, toTraits,
-        Collections.emptyList(), Collections.emptyList());
+    RelNode relAfter =
+        program.run(fixture.planner, rel, toTraits,
+            Collections.emptyList(), Collections.emptyList());
 
     String planAfter = NL + RelOptUtil.toString(relAfter);
     diffRepos.assertEquals("planAfter", "${planAfter}", planAfter);
@@ -1025,6 +1144,7 @@ private void checkSemiOrAntiJoinProjectTranspose(JoinRelType type) {
         + "  where emp.deptno = dept.deptno\n"
         + "  and emp.sal > 100)";
     sql(sql)
+        .withExpand(true)
         .withDecorrelate(true)
         .withTrim(true)
         .withRelBuilderConfig(b -> b.withPruneInputOfAggregate(true))
@@ -1049,6 +1169,46 @@ private void checkSemiOrAntiJoinProjectTranspose(JoinRelType type) {
         .check();
   }
 
+  @Test void testSemiJoinRuleDoNotMatchAggregate() {
+    final String sql = "select *\n"
+        + "from emp\n"
+        + "where exists(select * from dept where emp.deptno = dept.deptno)";
+    sql(sql)
+        .withExpand(true)
+        .withDecorrelate(true)
+        .withPreRule(CoreRules.PROJECT_MERGE)
+        .withRule(CoreRules.JOIN_ON_UNIQUE_TO_SEMI_JOIN)
+        .checkUnchanged();
+  }
+
+  @Test void testSemiJoinRuleWithJoinOnUniqueInput() {
+    final String sql = "select *\n"
+        + "from emp\n"
+        + "where exists(select * from dept where emp.deptno = dept.deptno)";
+    sql(sql)
+        .withExpand(true)
+        .withDecorrelate(true)
+        .withTrim(true)
+        .withRule(CoreRules.JOIN_ON_UNIQUE_TO_SEMI_JOIN)
+        .check();
+  }
+
+  /**
+   * Test case of
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5391">[CALCITE-5391]
+   * JoinOnUniqueToSemiJoinRule should preserve field names, if possible</a>. */
+  @Test void testSemiJoinRuleWithJoinOnUniqueInputWithAlias() {
+    final String sql = "select emp.deptno as department_id, emp.sal as salary\n"
+        + "from emp\n"
+        + "where exists(select * from dept where emp.deptno = dept.deptno)";
+    sql(sql)
+        .withExpand(true)
+        .withDecorrelate(true)
+        .withTrim(true)
+        .withRule(CoreRules.JOIN_ON_UNIQUE_TO_SEMI_JOIN)
+        .check();
+  }
+
   /** Test case for
    * <a href="https://issues.apache.org/jira/browse/CALCITE-1495">[CALCITE-1495]
    * SemiJoinRule should not apply to RIGHT and FULL JOIN</a>. */
@@ -1147,6 +1307,7 @@ private void checkSemiOrAntiJoinProjectTranspose(JoinRelType type) {
         + "    select emp.deptno from emp))R\n"
         + "where R.deptno <=10";
     sql(sql)
+        .withExpand(true)
         .withDecorrelate(true)
         .withTrim(false)
         .withPreRule(CoreRules.PROJECT_TO_SEMI_JOIN)
@@ -1167,6 +1328,7 @@ private void checkSemiOrAntiJoinProjectTranspose(JoinRelType type) {
         + "  select e2.deptno from emp e2 where e2.sal = 100)";
     sql(sql)
         .withDecorrelate(false)
+        .withExpand(true)
         .withTrim(true)
         .withPreRule(CoreRules.PROJECT_TO_SEMI_JOIN)
         .withRule(CoreRules.JOIN_REDUCE_EXPRESSIONS)
@@ -1192,6 +1354,7 @@ private void checkSemiOrAntiJoinProjectTranspose(JoinRelType type) {
             .build();
 
     sql(sql)
+        .withExpand(true)
         .withDecorrelate(true)
         .withPre(program)
         .withRule() // empty program
@@ -1202,6 +1365,40 @@ private void checkSemiOrAntiJoinProjectTranspose(JoinRelType type) {
         .check();
   }
 
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5169">[CALCITE-5169]
+   * 'xx < 1 OR xx > 1' cannot be simplified to 'xx <> 1'</a>.
+   *
+   * <p>{@code ename <> '' and ename <> '3'} should be simplified to Sarg.
+   */
+  @Test void testExpressionSimplification1() {
+    final String sql = "select * from emp\n"
+        + "where ename <> '' and ename <> '3'";
+    sql(sql)
+        .withRule(CoreRules.FILTER_REDUCE_EXPRESSIONS)
+        .check();
+  }
+
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5169">[CALCITE-5169]
+   * 'xx < 1 OR xx > 1' cannot be simplified to 'xx <> 1'</a>.
+   *
+   * <p>{@code (ename < '' or ename > '') and (ename < '3' or ename > '3')} should be
+   * simplified to Sarg too.
+   * The difference between this and {@link #testExpressionSimplification1()} is
+   * that '<' and '<>' have different
+   * {@link org.apache.calcite.sql.type.SqlOperandTypeChecker.Consistency} which
+   * will lead to different type inference result for literals. These two tests
+   * show that the simplification could handle this case.
+   */
+  @Test void testExpressionSimplification2() {
+    final String sql = "select * from emp\n"
+        + "where (ename < '' or ename > '') and (ename < '3' or ename > '3')";
+    sql(sql)
+        .withRule(CoreRules.FILTER_REDUCE_EXPRESSIONS)
+        .check();
+  }
+
   @Test void testReduceAverage() {
     final String sql = "select name, max(name), avg(deptno), min(name)\n"
         + "from sales.dept group by name";
@@ -1743,9 +1940,10 @@ private void checkProjectCorrelateTransposeRuleSemiOrAntiCorrelate(JoinRelType t
           .values(new String[]{"f3", "f4"}, "1", "2")
           .project(b.field(0),
               b.getRexBuilder().makeFieldAccess(rexCorrel, 0)).build();
-      LogicalCorrelate correlate = new LogicalCorrelate(left.getCluster(),
-          left.getTraitSet(), ImmutableList.of(), left, right, correlationId,
-          ImmutableBitSet.of(0), type);
+      LogicalCorrelate correlate =
+          new LogicalCorrelate(left.getCluster(), left.getTraitSet(),
+              ImmutableList.of(), left, right, correlationId,
+              ImmutableBitSet.of(0), type);
 
       b.push(correlate);
       return b.project(b.field(0))
@@ -1977,6 +2175,18 @@ private void checkProjectCorrelateTransposeRuleSemiOrAntiCorrelate(JoinRelType t
     sql(sql).withRule(CoreRules.PROJECT_JOIN_TRANSPOSE).check();
   }
 
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-4982">[CALCITE-4982]
+   * NonNull field shouldn't be pushed down into leaf of outer-join
+   * in 'ProjectJoinTransposeRule'</a>. */
+  @Test void testPushProjectPastOutJoinWithCastNonNullExpr() {
+    final String sql = "select e.empno + 1 as c1, coalesce(d.name, b.job, '') as c2\n"
+        + "from emp e\n"
+        + "left join bonus b on e.ename = b.ename\n"
+        + "left join dept d on e.deptno = d.deptno";
+    sql(sql).withRule(CoreRules.PROJECT_JOIN_TRANSPOSE).check();
+  }
+
   @Test void testPushProjectPastSetOp() {
     final String sql = "select sal from\n"
         + "(select * from emp e1 union all select * from emp e2)";
@@ -2052,6 +2262,122 @@ private void checkPushJoinThroughUnionOnRightDoesNotMatchSemiOrAntiJoin(JoinRelT
         .check();
   }
 
+  /**
+   * Test case for <a href="https://issues.apache.org/jira/browse/CALCITE-5073">[CALCITE-5073]
+   * JoinConditionPushRule cannot infer 'LHS.C1 = LHS.C2' from
+   * 'LHS.C1 = RHS.C1 AND LHS.C2 = RHS.C1'</a>.
+   */
+  @Test void testJoinConditionPushdown1() {
+    final String sql = "select *\n"
+        + "from emp e1, emp e2, dept d2\n"
+        + "where e1.deptno = d2.deptno and e2.deptno = d2.deptno";
+    sql(sql)
+        .withRule(CoreRules.FILTER_INTO_JOIN,
+            CoreRules.JOIN_CONDITION_PUSH,
+            CoreRules.PROJECT_MERGE,
+            CoreRules.FILTER_PROJECT_TRANSPOSE)
+        .check();
+  }
+
+  /**
+   * Test case for <a href="https://issues.apache.org/jira/browse/CALCITE-5073">[CALCITE-5073]
+   * JoinConditionPushRule cannot infer 'LHS.C1 = LHS.C2' from
+   * 'LHS.C1 = RHS.C1 AND LHS.C2 = RHS.C1'</a>.
+   */
+  @Test void testJoinConditionPushdown2() {
+    final String sql = "select *\n"
+        + "from emp e, dept d\n"
+        + "where e.deptno = d.deptno and e.empno = d.deptno";
+    sql(sql)
+        .withRule(CoreRules.FILTER_INTO_JOIN,
+            CoreRules.JOIN_CONDITION_PUSH,
+            CoreRules.PROJECT_MERGE,
+            CoreRules.FILTER_PROJECT_TRANSPOSE)
+        .check();
+  }
+
+  /** Similar to {@link #testJoinConditionPushdown1()} but full join
+   * from which more equality conditions can not be inferred. */
+  @Test void testJoinConditionPushdown3() {
+    final String sql = "select *\n"
+        + "from emp e full join dept d\n"
+        + "on e.deptno = d.deptno and e.empno = d.deptno";
+    sql(sql)
+        .withRule(CoreRules.FILTER_INTO_JOIN,
+            CoreRules.JOIN_CONDITION_PUSH,
+            CoreRules.PROJECT_MERGE,
+            CoreRules.FILTER_PROJECT_TRANSPOSE)
+        .checkUnchanged();
+  }
+
+  /** Similar to {@link #testJoinConditionPushdown1()} but semi join
+   * from which more equality conditions can be inferred. */
+  @Test void testJoinConditionPushdown4() {
+    final Function<RelBuilder, RelNode> relFn = b -> {
+      RelNode left = b.scan("EMP")
+          .project(
+              b.field("DEPTNO"),
+              b.field("ENAME"))
+          .build();
+      RelNode right = b.scan("DEPT")
+          .project(
+              b.field("DEPTNO"),
+              b.field("DNAME"))
+          .build();
+
+      b.push(left).push(right);
+
+      RexInputRef ref1 = b.field(2, 0, "DEPTNO");
+      RexInputRef ref2 = b.field(2, 1, "DEPTNO");
+      RexInputRef ref3 = b.field(2, 1, "DNAME");
+
+      RexCall cond1 = (RexCall) b.equals(ref1, ref2);
+      RexCall cond2 = (RexCall) b.equals(ref1, ref3);
+
+      RexNode cond = b.and(cond1, cond2);
+      return b.semiJoin(cond)
+          .project(b.field(0))
+          .build();
+    };
+
+    relFn(relFn)
+        .withRule(
+            CoreRules.JOIN_PUSH_EXPRESSIONS,
+            CoreRules.JOIN_CONDITION_PUSH,
+            CoreRules.SEMI_JOIN_PROJECT_TRANSPOSE,
+            CoreRules.JOIN_REDUCE_EXPRESSIONS,
+            CoreRules.FILTER_REDUCE_EXPRESSIONS)
+        .check();
+  }
+
+  /** Similar to {@link #testJoinConditionPushdown1()} but left join
+   * from which more equality conditions can not be inferred. */
+  @Test void testJoinConditionPushdown5() {
+    final String sql = "select *\n"
+        + "from emp e left join dept d\n"
+        + "on e.deptno = d.deptno and e.empno = d.deptno";
+    sql(sql)
+        .withRule(CoreRules.FILTER_INTO_JOIN,
+            CoreRules.JOIN_CONDITION_PUSH,
+            CoreRules.PROJECT_MERGE,
+            CoreRules.FILTER_PROJECT_TRANSPOSE)
+        .checkUnchanged();
+  }
+
+  /** Similar to {@link #testJoinConditionPushdown1()} but right join
+   * from which more equality conditions can be inferred. */
+  @Test void testJoinConditionPushdown6() {
+    final String sql = "select *\n"
+        + "from emp e right join dept d\n"
+        + "on e.deptno = d.deptno and e.empno = d.deptno";
+    sql(sql)
+        .withRule(CoreRules.FILTER_INTO_JOIN,
+            CoreRules.JOIN_CONDITION_PUSH,
+            CoreRules.PROJECT_MERGE,
+            CoreRules.FILTER_PROJECT_TRANSPOSE)
+        .check();
+  }
+
   /** Tests that filters are combined if they are identical. */
   @Test void testMergeFilter() {
     final String sql = "select name from (\n"
@@ -2694,6 +3020,32 @@ private void checkPushJoinThroughUnionOnRightDoesNotMatchSemiOrAntiJoin(JoinRelT
         .withProgram(program).check();
   }
 
+  @Test void testReducingConstantsInferredFromCorrelate() {
+    HepProgram program = new HepProgramBuilder()
+        .addRuleInstance(CoreRules.PROJECT_REDUCE_EXPRESSIONS)
+        .build();
+
+    final String sql = "SELECT ename,\n"
+        + "  empno,\n"
+        + "  T.empno_r,\n"
+        + "  CASE\n"
+        + "    WHEN __source__type__ = 'bounded'\n"
+        + "      THEN 1\n"
+        + "    ELSE 2\n"
+        + "    END AS type\n"
+        + "FROM (\n"
+        + "  SELECT ename,\n"
+        + "    empno,\n"
+        + "    'bounded' AS __source__type__\n"
+        + "  FROM emp\n"
+        + "  ) a,\n"
+        + "  lateral TABLE (ramp(empno)) AS T(empno_r)";
+    sql(sql)
+        .withRelBuilderConfig(c -> c.withSimplifyValues(false))
+        .withProgram(program).check();
+  }
+
+
   @Test void testRemoveSemiJoin() {
     final String sql = "select e.ename from emp e, dept d\n"
         + "where e.deptno = d.deptno";
@@ -2972,12 +3324,8 @@ RelOptFixture checkDynamicFunctions(boolean treatDynamicCallsAsConstant) {
    * functions</a>. */
   @Test void testReduceConstantsNonDeterministicFunction() {
     final SqlOperator nonDeterministicOp =
-        new SqlSpecialOperator("NDC", SqlKind.OTHER_FUNCTION, 0, false,
-            ReturnTypes.INTEGER, null, null) {
-          @Override public boolean isDeterministic() {
-            return false;
-          }
-        };
+        SqlBasicFunction.create("NDC", ReturnTypes.INTEGER,
+            OperandTypes.VARIADIC).withDeterministic(false);
 
     // Build a tree equivalent to the SQL
     //  SELECT sal, n
@@ -3144,6 +3492,33 @@ RelOptFixture checkDynamicFunctions(boolean treatDynamicCallsAsConstant) {
         .check();
   }
 
+  @Test void testEmptyTable() {
+    // table is transformed to empty values and extra project will be removed.
+    final String sql = "select * from EMPTY_PRODUCTS\n";
+    sql(sql)
+        .withRule(
+            PruneEmptyRules.EMPTY_TABLE_INSTANCE,
+            PruneEmptyRules.PROJECT_INSTANCE)
+        .check();
+  }
+
+  @Test void testEmptyTableTransformsComplexQueryToSingleTableScan() {
+    final String sql = "select products.PRODUCTID, products.NAME from products left join\n"
+        + "(select * from products as e\n"
+        + " inner join EMPTY_PRODUCTS as d on e.PRODUCTID = d.PRODUCTID\n"
+        + " where e.SUPPLIERID > 10) dt\n"
+        + " on products.PRODUCTID = dt.PRODUCTID";
+    Collection<RelOptRule> rules =
+        Arrays.asList(PruneEmptyRules.EMPTY_TABLE_INSTANCE,
+            PruneEmptyRules.JOIN_RIGHT_INSTANCE,
+            PruneEmptyRules.FILTER_INSTANCE,
+            PruneEmptyRules.PROJECT_INSTANCE,
+            CoreRules.PROJECT_MERGE);
+    sql(sql)
+        .withProgram(HepProgram.builder().addRuleCollection(rules).build())
+        .check();
+  }
+
   @Test void testLeftEmptyInnerJoin() {
     // Plan should be empty
     final String sql = "select * from (\n"
@@ -3447,17 +3822,24 @@ private void checkEmptyJoin(RelOptFixture f) {
       // CASE WHEN x % 2 = 1 THEN x < 2
       //      WHEN x % 3 = 2 THEN x < 1
       //      ELSE x < 3
-      final RexNode caseRexNode = rexBuilder.makeCall(SqlStdOperatorTable.CASE,
-          rexBuilder.makeCall(SqlStdOperatorTable.EQUALS,
-              rexBuilder.makeCall(SqlStdOperatorTable.MOD, ref, literal2), literal1),
-          rexBuilder.makeCall(SqlStdOperatorTable.LESS_THAN, ref, literal2),
-          rexBuilder.makeCall(SqlStdOperatorTable.EQUALS,
-              rexBuilder.makeCall(SqlStdOperatorTable.MOD, ref, literal3), literal2),
-          rexBuilder.makeCall(SqlStdOperatorTable.LESS_THAN, ref, literal1),
-          rexBuilder.makeCall(SqlStdOperatorTable.LESS_THAN, ref, literal3));
-
-      final RexNode castNode = rexBuilder.makeCast(rexBuilder.getTypeFactory().
-          createTypeWithNullability(caseRexNode.getType(), true), caseRexNode);
+      final RexNode caseRexNode =
+          rexBuilder.makeCall(
+              SqlStdOperatorTable.CASE,
+              rexBuilder.makeCall(SqlStdOperatorTable.EQUALS,
+                  rexBuilder.makeCall(SqlStdOperatorTable.MOD, ref, literal2),
+                  literal1),
+              rexBuilder.makeCall(SqlStdOperatorTable.LESS_THAN, ref, literal2),
+              rexBuilder.makeCall(SqlStdOperatorTable.EQUALS,
+                  rexBuilder.makeCall(SqlStdOperatorTable.MOD, ref, literal3),
+                  literal2),
+              rexBuilder.makeCall(SqlStdOperatorTable.LESS_THAN, ref, literal1),
+              rexBuilder.makeCall(SqlStdOperatorTable.LESS_THAN, ref, literal3));
+
+      final RexNode castNode =
+          rexBuilder.makeCast(
+              rexBuilder.getTypeFactory()
+                  .createTypeWithNullability(caseRexNode.getType(), true),
+              caseRexNode);
       return b
           .push(left)
           .project(castNode)
@@ -3672,6 +4054,17 @@ private void basePullConstantTroughAggregate() {
         .check();
   }
 
+  @Test void testPullConstantThroughUnionSameTypeNullableField() {
+    final String sql = "select deptno, ename from empnullables where deptno = 1\n"
+        + "union all\n"
+        + "select deptno, ename from empnullables where deptno = 1";
+    sql(sql)
+        .withTrim(true)
+        .withRule(CoreRules.UNION_PULL_UP_CONSTANTS,
+            CoreRules.PROJECT_MERGE)
+        .check();
+  }
+
   @Test void testAggregateProjectMerge() {
     final String sql = "select x, sum(z), y from (\n"
         + "  select deptno as x, empno as y, sal as z, sal * 2 as zz\n"
@@ -4003,6 +4396,13 @@ private HepProgram getTransitiveProgram() {
         .check();
   }
 
+  /** Tests propagation of a filter derived from an "IS NOT DISTINCT FROM"
+   * predicate.
+   *
+   * <p>By the time the rule sees the predicate, it has been converted to
+   * "deptno = 10 OR (deptno IS NULL AND 10 IS NULL)", so
+   * {@link #testPullConstantIntoProjectWithIsNotDistinctFromDate()} is a purer
+   * test of the functionality. */
   @Test void testPullConstantIntoProjectWithIsNotDistinctFrom() {
     final String sql = "select deptno, deptno + 1, empno + deptno\n"
         + "from sales.emp\n"
@@ -4023,6 +4423,37 @@ private HepProgram getTransitiveProgram() {
         .check();
   }
 
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5336">[CALCITE-5336]
+   * Infer constants from predicates with IS NOT DISTINCT FROM operator</a>.
+   *
+   * <p>Reduce expression rules should identify constants with
+   * {@code IS NOT DISTINCT FROM} operator as they do for {@code =}. */
+  @Test void testPullConstantIntoProjectWithIsNotDistinctFromDate() {
+    // Build a tree equivalent to the SQL
+    //   SELECT hiredate
+    //   FROM emp
+    //   WHERE hiredate IS NOT DISTINCT FROM DATE '2020-12-11'
+    //
+    // We build a tree because if we used the SQL parser, it would expand
+    //   x IS NOT DISTINCT FROM y
+    // to
+    //   x = y OR (x IS NULL AND y IS NULL)
+    final Function<RelBuilder, RelNode> relFn = b ->
+        b.scan("EMP")
+            .filter(
+                b.getRexBuilder()
+                    .makeCall(SqlStdOperatorTable.IS_NOT_DISTINCT_FROM,
+                        b.field(4),
+                        b.literal(new DateString(2020, 12, 11))))
+            .project(b.field(4))
+            .build();
+
+    relFn(relFn)
+        .withRule(CoreRules.PROJECT_REDUCE_EXPRESSIONS)
+        .check();
+  }
+
   @Test void testPullConstantIntoFilter() {
     final String sql = "select * from (select * from sales.emp where deptno = 10)\n"
         + "where deptno + 5 > empno";
@@ -4099,28 +4530,27 @@ private HepProgram getTransitiveProgram() {
         + "and e1.sal > (select avg(sal) from emp e2 where e1.empno = e2.empno)";
 
     // Convert sql to rel
-    final RelOptFixture fixture = sql(sql);
+    final RelOptFixture fixture = sql(sql).withExpand(true);
     final RelNode rel = fixture.toRel();
 
     // Create a duplicate rel tree with a CustomCorrelate instead of
     // LogicalCorrelate.
     final LogicalCorrelate logicalCorrelate =
         (LogicalCorrelate) rel.getInput(0).getInput(0);
-    CustomCorrelate customCorrelate = new CustomCorrelate(
-        logicalCorrelate.getCluster(),
-        logicalCorrelate.getTraitSet(),
-        logicalCorrelate.getHints(),
-        logicalCorrelate.getLeft(),
-        logicalCorrelate.getRight(),
-        logicalCorrelate.getCorrelationId(),
-        logicalCorrelate.getRequiredColumns(),
-        logicalCorrelate.getJoinType());
-    RelNode newRoot = rel.copy(
-        rel.getTraitSet(),
-        ImmutableList.of(
-            rel.getInput(0).copy(
-                rel.getInput(0).getTraitSet(),
-                ImmutableList.of(customCorrelate))));
+    CustomCorrelate customCorrelate =
+        new CustomCorrelate(logicalCorrelate.getCluster(),
+            logicalCorrelate.getTraitSet(),
+            logicalCorrelate.getHints(),
+            logicalCorrelate.getLeft(),
+            logicalCorrelate.getRight(),
+            logicalCorrelate.getCorrelationId(),
+            logicalCorrelate.getRequiredColumns(),
+            logicalCorrelate.getJoinType());
+    RelNode newRoot =
+        rel.copy(rel.getTraitSet(),
+            ImmutableList.of(
+                rel.getInput(0).copy(rel.getInput(0).getTraitSet(),
+                    ImmutableList.of(customCorrelate))));
 
     // Decorrelate both trees using the same relBuilder
     final RelBuilder relBuilder = RelBuilder.create(RelBuilderTest.config().build());
@@ -4586,6 +5016,7 @@ private HepProgram getTransitiveProgram() {
         + "IN (select e.deptno from sales.emp e "
         + "where e.deptno = d.deptno or e.deptno = 4)";
     sql(sql)
+        .withExpand(true)
         .withPreRule(CoreRules.FILTER_INTO_JOIN,
             CoreRules.JOIN_CONDITION_PUSH,
             CoreRules.JOIN_PUSH_TRANSITIVE_PREDICATES)
@@ -4604,6 +5035,7 @@ private HepProgram getTransitiveProgram() {
         + "  from EMPNULLABLES_20 n2\n"
         + "  where n1.SAL = n2.SAL or n1.SAL = 4)";
     sql(sql).withDecorrelate(true)
+        .withExpand(true)
         .withRule(CoreRules.FILTER_INTO_JOIN,
             CoreRules.JOIN_CONDITION_PUSH,
             CoreRules.JOIN_PUSH_TRANSITIVE_PREDICATES)
@@ -4837,6 +5269,48 @@ private HepProgram getTransitiveProgram() {
         .check();
   }
 
+  /** Tests that ProjectAggregateMergeRule does nothing with non-numeric literals
+   * and does not throw an exception. */
+  @Test void testProjectAggregateMergeNonNumericLiteral() {
+    // Requires a NULLABLE column to trigger
+    final SqlTestFactory.CatalogReaderFactory catalogReaderFactory = (typeFactory, caseSensitive) ->
+        new MockCatalogReader(typeFactory, caseSensitive) {
+          @Override public MockCatalogReader init() {
+            MockSchema schema = new MockSchema("SALES");
+            registerSchema(schema);
+            final boolean nullable = true;
+            final RelDataType timestampType =
+                typeFactory.createTypeWithNullability(
+                    typeFactory.createSqlType(SqlTypeName.TIMESTAMP),
+                    nullable);
+            String tableName = "NULLABLE";
+            MockTable table = MockTable
+                .create(this, schema, tableName, false, 100);
+            table.addColumn("HIREDATE", timestampType);
+            registerTable(table);
+            return this;
+          }
+        }.init();
+    final String sql = "select hiredate, coalesce(hiredate, {ts '1969-12-31 00:00:00'}) as c1\n"
+        + "from sales.nullable\n"
+        + "group by hiredate";
+    sql(sql)
+        .withCatalogReaderFactory(catalogReaderFactory)
+        .withRule(CoreRules.PROJECT_AGGREGATE_MERGE)
+        .checkUnchanged();
+  }
+
+  @Test void testProjectAggregateMergeNoOpForNonSum() {
+    final String sql = "select coalesce(m, 0)\n"
+        + "from (\n"
+        + "  select max(deptno) as m\n"
+        + "  from sales.emp\n"
+        + ")";
+    sql(sql)
+        .withRule(CoreRules.PROJECT_AGGREGATE_MERGE)
+        .checkUnchanged();
+  }
+
   /**
    * Test case for AggregateMergeRule, should merge 2 aggregates
    * into a single aggregate.
@@ -5893,8 +6367,7 @@ private void checkSemiJoinRuleOnAntiJoin(RelOptRule rule) {
       return false;
     };
     RuleSet ruleSet =
-        RuleSets.ofList(
-            CoreRules.FILTER_PROJECT_TRANSPOSE,
+        RuleSets.ofList(CoreRules.FILTER_PROJECT_TRANSPOSE,
             CoreRules.FILTER_MERGE,
             CoreRules.PROJECT_MERGE,
             ProjectFilterTransposeRule.Config.DEFAULT
@@ -5944,6 +6417,7 @@ private void checkSemiJoinRuleOnAntiJoin(RelOptRule rule) {
     final String sql = "select * from emp e1 where exists ("
         + "select * from emp e2 where e1.deptno = (e2.deptno+30))";
     sql(sql).withDecorrelate(false)
+        .withExpand(true)
         .withRule(FilterFlattenCorrelatedConditionRule.Config.DEFAULT.toRule())
         .check();
   }
@@ -5952,6 +6426,7 @@ private void checkSemiJoinRuleOnAntiJoin(RelOptRule rule) {
     final String sql = "select * from emp e1 where exists ("
         + "select * from emp e2 where (e1.deptno+30) = e2.deptno)";
     sql(sql).withDecorrelate(false)
+        .withExpand(true)
         .withRule(FilterFlattenCorrelatedConditionRule.Config.DEFAULT.toRule())
         .checkUnchanged();
   }
@@ -5960,6 +6435,7 @@ private void checkSemiJoinRuleOnAntiJoin(RelOptRule rule) {
     final String sql = "select * from emp e1 where exists ("
         + "select * from emp e2 where e1.deptno = (2 * e2.deptno+30))";
     sql(sql).withDecorrelate(false)
+        .withExpand(true)
         .withRule(FilterFlattenCorrelatedConditionRule.Config.DEFAULT.toRule())
         .check();
   }
@@ -5968,6 +6444,7 @@ private void checkSemiJoinRuleOnAntiJoin(RelOptRule rule) {
     final String sql = "select * from emp e1 where exists ("
         + "select * from emp e2 where (e1.deptno + (e2.deptno+30)) > 0)";
     sql(sql).withDecorrelate(false)
+        .withExpand(true)
         .withRule(FilterFlattenCorrelatedConditionRule.Config.DEFAULT.toRule())
         .checkUnchanged();
   }
@@ -5976,6 +6453,7 @@ private void checkSemiJoinRuleOnAntiJoin(RelOptRule rule) {
     final String sql = "select * from emp e1 where exists ("
         + "select * from emp e2 where (e2.empno+50) < 20 and e1.deptno >= (30+e2.deptno))";
     sql(sql).withDecorrelate(false)
+        .withExpand(true)
         .withRule(FilterFlattenCorrelatedConditionRule.Config.DEFAULT.toRule())
         .check();
   }
@@ -6142,6 +6620,7 @@ private void checkSemiJoinRuleOnAntiJoin(RelOptRule rule) {
         + "  where A.mgr = B.empno\n"
         + "  group by deptno, 'abc')";
     sql(sql)
+        .withExpand(true)
         .withLateDecorrelate(true)
         .withTrim(true)
         .withRule() // empty program
@@ -6280,7 +6759,7 @@ private RelOptFixture spatial(String sql) {
   /** Constant reduction on geo-spatial expression. */
   @Test void testSpatialReduce() {
     final String sql = "select\n"
-        + "  ST_Buffer(ST_Point(0.0, 1.0), 2) as b\n"
+        + "  ST_Buffer(ST_Point(0.0, 0.0), 1, 4) as b\n"
         + "from GEO.Restaurants as r";
     spatial(sql)
         .withRelBuilderSimplify(false)
@@ -6441,8 +6920,7 @@ private RelOptFixture spatial(String sql) {
         + "union all\n"
         + "(select n_name from CUSTOMER_MODIFIABLEVIEW)";
     RuleSet ruleSet =
-        RuleSets.ofList(
-            EnumerableRules.ENUMERABLE_PROJECT_RULE,
+        RuleSets.ofList(EnumerableRules.ENUMERABLE_PROJECT_RULE,
             EnumerableRules.ENUMERABLE_TABLE_SCAN_RULE,
             EnumerableRules.ENUMERABLE_UNION_RULE);
     sql(sql)
@@ -6484,16 +6962,10 @@ private RelOptFixture spatial(String sql) {
    * collation</a>. */
   @Test void testMonotonicityUDF() {
     final SqlFunction monotonicityFun =
-        new SqlFunction("MONOFUN", SqlKind.OTHER_FUNCTION, ReturnTypes.BIGINT, null,
-            OperandTypes.NILADIC, SqlFunctionCategory.USER_DEFINED_FUNCTION) {
-          @Override public boolean isDeterministic() {
-            return false;
-          }
-
-          @Override public SqlMonotonicity getMonotonicity(SqlOperatorBinding call) {
-            return SqlMonotonicity.INCREASING;
-          }
-        };
+        SqlBasicFunction.create("MONOFUN", ReturnTypes.BIGINT,
+            OperandTypes.NILADIC, SqlFunctionCategory.USER_DEFINED_FUNCTION)
+            .withDeterministic(false)
+            .withMonotonicityInference(call -> SqlMonotonicity.INCREASING);
 
     // Build a tree equivalent to the SQL
     // SELECT sal, MONOFUN() AS n FROM emp
@@ -6587,8 +7059,9 @@ protected MyFilterRule(Config config) {
     @Override public void onMatch(RelOptRuleCall call) {
       final LogicalFilter logicalFilter = call.rel(0);
       final RelNode input = logicalFilter.getInput();
-      final MyFilter myFilter = new MyFilter(input.getCluster(), input.getTraitSet(), input,
-          logicalFilter.getCondition());
+      final MyFilter myFilter =
+          new MyFilter(input.getCluster(), input.getTraitSet(), input,
+              logicalFilter.getCondition());
       call.transformTo(myFilter);
     }
 
@@ -6615,7 +7088,7 @@ private static class MyProject extends Project {
         RelNode input,
         List<? extends RexNode> projects,
         RelDataType rowType) {
-      super(cluster, traitSet, ImmutableList.of(), input, projects, rowType);
+      super(cluster, traitSet, ImmutableList.of(), input, projects, rowType, ImmutableSet.of());
     }
 
     public MyProject copy(RelTraitSet traitSet, RelNode input,
@@ -6642,8 +7115,9 @@ protected MyProjectRule(Config config) {
     @Override public void onMatch(RelOptRuleCall call) {
       final LogicalProject logicalProject = call.rel(0);
       final RelNode input = logicalProject.getInput();
-      final MyProject myProject = new MyProject(input.getCluster(), input.getTraitSet(), input,
-          logicalProject.getProjects(), logicalProject.getRowType());
+      final MyProject myProject =
+          new MyProject(input.getCluster(), input.getTraitSet(), input,
+              logicalProject.getProjects(), logicalProject.getRowType());
       call.transformTo(myProject);
     }
 
@@ -6689,6 +7163,7 @@ public interface Config extends RelRule.Config {
     final String sql = "select * from sales.dept d where d.deptno in\n"
         + " (select e.deptno from sales.emp e) order by d.deptno";
     sql(sql)
+        .withExpand(true)
         .withPreRule(CoreRules.PROJECT_TO_SEMI_JOIN)
         .withRule(CoreRules.SORT_JOIN_COPY)
         .check();
@@ -6699,6 +7174,7 @@ public interface Config extends RelRule.Config {
         + " (select e.deptno from sales.emp e) order by d.deptno limit 10 offset 2";
     // Do not copy the limit and offset
     sql(sql)
+        .withExpand(true)
         .withPreRule(CoreRules.PROJECT_TO_SEMI_JOIN)
         .withRule(CoreRules.SORT_JOIN_COPY)
         .check();
@@ -6709,6 +7185,7 @@ public interface Config extends RelRule.Config {
         + " (select e.deptno from sales.emp e) order by d.deptno offset 2";
     // Do not copy the offset
     sql(sql)
+        .withExpand(true)
         .withPreRule(CoreRules.PROJECT_TO_SEMI_JOIN)
         .withRule(CoreRules.SORT_JOIN_COPY)
         .check();
@@ -6728,6 +7205,7 @@ public interface Config extends RelRule.Config {
 
     sql(sql)
         .withRule() // empty program
+        .withExpand(true)
         .withDecorrelate(true)
         .checkUnchanged();
   }
@@ -6877,6 +7355,46 @@ public interface Config extends RelRule.Config {
         .checkUnchanged();
   }
 
+  /**
+   * Test case for <a href="https://issues.apache.org/jira/browse/CALCITE-5247">[CALCITE-5247]
+   *    * FilterJoinRule cannot simplify left join to inner join for `WHERE RHS.C1 IS NOT NULL OR
+   *    RHS.C2 IS NOT NULL`</a>.
+   *
+   *    This tests the case where the condition contains an OR between the IS NOT NULL filters
+   */
+  @Test void testFilterJoinRuleOrIsNotNull() {
+    final String sql = "select * from\n"
+        + "emp LHS\n"
+        + "left join dept RHS on LHS.EMPNO = RHS.DEPTNO\n"
+        + "where\n"
+        + "RHS.DEPTNO is not null\n"
+        + "OR RHS.NAME is not null";
+
+    sql(sql)
+        .withRule(CoreRules.FILTER_INTO_JOIN)
+        .check();
+  }
+
+  /**
+   * Test case for <a href="https://issues.apache.org/jira/browse/CALCITE-5247">[CALCITE-5247]
+   *    * FilterJoinRule cannot simplify left join to inner join for `WHERE RHS.C1 IS NOT NULL OR
+   *    RHS.C2 IS NOT NULL`</a>.
+   *
+   *    This tests the case where the condition contains an AND between the IS NOT NULL filters
+   */
+  @Test void testFilterJoinRuleAndIsNotNull() {
+    final String sql = "select * from\n"
+        + "emp LHS\n"
+        + "left join dept RHS on LHS.EMPNO = RHS.DEPTNO\n"
+        + "where\n"
+        + "RHS.DEPTNO is not null\n"
+        + "AND RHS.NAME is not null";
+
+    sql(sql)
+        .withRule(CoreRules.FILTER_INTO_JOIN)
+        .check();
+  }
+
   @Test void testJoinCommuteRuleWithAlwaysTrueConditionAllowed() {
     checkJoinCommuteRuleWithAlwaysTrueConditionDisallowed(true);
   }
@@ -7024,9 +7542,6 @@ private void checkJoinAssociateRuleWithTopAlwaysTrueCondition(boolean allowAlway
       }
     };
 
-    SqlTestFactory.TypeFactoryFactory typeFactorySupplier =
-        conformance -> new SqlTypeFactoryImpl(typeSystem);
-
     // Expected plan:
     // LogicalProject(EXPR$0=[CAST($0):BIGINT NOT NULL], EXPR$1=[$1])
     //   LogicalAggregate(group=[{}], EXPR$0=[$SUM0($1)], EXPR$1=[COUNT($0)])
@@ -7038,7 +7553,7 @@ private void checkJoinAssociateRuleWithTopAlwaysTrueCondition(boolean allowAlway
     // because type of original expression 'COUNT(DISTINCT comm)' is BIGINT
     // and type of SUM (of BIGINT) is DECIMAL.
     sql("SELECT count(comm), COUNT(DISTINCT comm) FROM emp")
-        .withFactory(f -> f.withTypeFactoryFactory(typeFactorySupplier))
+        .withFactory(f -> f.withTypeSystem(ignore -> typeSystem))
         .withRule(CoreRules.AGGREGATE_EXPAND_DISTINCT_AGGREGATES_TO_JOIN)
         .check();
   }
@@ -7067,9 +7582,6 @@ private void checkJoinAssociateRuleWithTopAlwaysTrueCondition(boolean allowAlway
       }
     };
 
-    SqlTestFactory.TypeFactoryFactory typeFactoryFactory =
-        conformance -> new SqlTypeFactoryImpl(typeSystem);
-
     // Expected plan:
     // LogicalProject(EXPR$0=[CAST($0):BIGINT], EXPR$1=[$1])
     //  LogicalAggregate(group=[{}], EXPR$0=[SUM($1)], EXPR$1=[SUM($0)]) // RowType[DECIMAL, BIGINT]
@@ -7081,8 +7593,9 @@ private void checkJoinAssociateRuleWithTopAlwaysTrueCondition(boolean allowAlway
     // because type of original expression 'COUNT(DISTINCT comm)' is BIGINT
     // and type of SUM (of BIGINT) is DECIMAL.
     sql("SELECT SUM(comm), SUM(DISTINCT comm) FROM emp")
-        .withFactory(f -> f.withTypeFactoryFactory(typeFactoryFactory))
+        .withFactory(f -> f.withTypeSystem(ignore -> typeSystem))
         .withRule(CoreRules.AGGREGATE_EXPAND_DISTINCT_AGGREGATES_TO_JOIN)
         .check();
   }
+
 }
diff --git a/core/src/test/java/org/apache/calcite/test/RexImplicationCheckerTest.java b/core/src/test/java/org/apache/calcite/test/RexImplicationCheckerTest.java
index 75932b5bf22..b15267eddf7 100644
--- a/core/src/test/java/org/apache/calcite/test/RexImplicationCheckerTest.java
+++ b/core/src/test/java/org/apache/calcite/test/RexImplicationCheckerTest.java
@@ -347,8 +347,9 @@ public class RexImplicationCheckerTest {
     // In this case, the cast is not nullable. Thus, in both cases, the
     // simplified expression only consists of the literal.
     RelDataType notNullIntRelDataType = f.typeFactory.createJavaType(int.class);
-    final RexNode e2 = f.cast(notNullIntRelDataType,
-        f.cast(notNullIntRelDataType, f.literal(2014)));
+    final RexNode e2 =
+        f.cast(notNullIntRelDataType,
+            f.cast(notNullIntRelDataType, f.literal(2014)));
     assertThat(
         f.simplify.simplifyPreservingType(e2, RexUnknownAs.UNKNOWN, true)
             .toString(),
@@ -371,19 +372,19 @@ public class RexImplicationCheckerTest {
     final RexNode literalTs =
         f.timestampLiteral(new TimestampString("2010-10-10 00:00:00"));
     for (int i = 0; i < timeUnitRanges.size(); i++) {
-      final RexNode innerFloorCall = f.rexBuilder.makeCall(
-          SqlStdOperatorTable.FLOOR, literalTs,
-          f.rexBuilder.makeFlag(timeUnitRanges.get(i)));
-      final RexNode innerCeilCall = f.rexBuilder.makeCall(
-          SqlStdOperatorTable.CEIL, literalTs,
-          f.rexBuilder.makeFlag(timeUnitRanges.get(i)));
+      final RexNode innerFloorCall =
+          f.rexBuilder.makeCall(SqlStdOperatorTable.FLOOR, literalTs,
+              f.rexBuilder.makeFlag(timeUnitRanges.get(i)));
+      final RexNode innerCeilCall =
+          f.rexBuilder.makeCall(SqlStdOperatorTable.CEIL, literalTs,
+              f.rexBuilder.makeFlag(timeUnitRanges.get(i)));
       for (int j = 0; j <= i; j++) {
-        final RexNode outerFloorCall = f.rexBuilder.makeCall(
-            SqlStdOperatorTable.FLOOR, innerFloorCall,
-            f.rexBuilder.makeFlag(timeUnitRanges.get(j)));
-        final RexNode outerCeilCall = f.rexBuilder.makeCall(
-            SqlStdOperatorTable.CEIL, innerCeilCall,
-            f.rexBuilder.makeFlag(timeUnitRanges.get(j)));
+        final RexNode outerFloorCall =
+            f.rexBuilder.makeCall(SqlStdOperatorTable.FLOOR, innerFloorCall,
+                f.rexBuilder.makeFlag(timeUnitRanges.get(j)));
+        final RexNode outerCeilCall =
+            f.rexBuilder.makeCall(SqlStdOperatorTable.CEIL, innerCeilCall,
+                f.rexBuilder.makeFlag(timeUnitRanges.get(j)));
         final RexCall floorSimplifiedExpr =
             (RexCall) f.simplify.simplifyPreservingType(outerFloorCall,
                 RexUnknownAs.UNKNOWN, true);
@@ -405,19 +406,19 @@ public class RexImplicationCheckerTest {
 
     // Negative test
     for (int i = timeUnitRanges.size() - 1; i >= 0; i--) {
-      final RexNode innerFloorCall = f.rexBuilder.makeCall(
-          SqlStdOperatorTable.FLOOR, literalTs,
-          f.rexBuilder.makeFlag(timeUnitRanges.get(i)));
-      final RexNode innerCeilCall = f.rexBuilder.makeCall(
-          SqlStdOperatorTable.CEIL, literalTs,
-          f.rexBuilder.makeFlag(timeUnitRanges.get(i)));
+      final RexNode innerFloorCall =
+          f.rexBuilder.makeCall(SqlStdOperatorTable.FLOOR, literalTs,
+              f.rexBuilder.makeFlag(timeUnitRanges.get(i)));
+      final RexNode innerCeilCall =
+          f.rexBuilder.makeCall(SqlStdOperatorTable.CEIL, literalTs,
+              f.rexBuilder.makeFlag(timeUnitRanges.get(i)));
       for (int j = timeUnitRanges.size() - 1; j > i; j--) {
-        final RexNode outerFloorCall = f.rexBuilder.makeCall(
-            SqlStdOperatorTable.FLOOR, innerFloorCall,
-            f.rexBuilder.makeFlag(timeUnitRanges.get(j)));
-        final RexNode outerCeilCall = f.rexBuilder.makeCall(
-            SqlStdOperatorTable.CEIL, innerCeilCall,
-            f.rexBuilder.makeFlag(timeUnitRanges.get(j)));
+        final RexNode outerFloorCall =
+            f.rexBuilder.makeCall(SqlStdOperatorTable.FLOOR, innerFloorCall,
+                f.rexBuilder.makeFlag(timeUnitRanges.get(j)));
+        final RexNode outerCeilCall =
+            f.rexBuilder.makeCall(SqlStdOperatorTable.CEIL, innerCeilCall,
+                f.rexBuilder.makeFlag(timeUnitRanges.get(j)));
         final RexCall floorSimplifiedExpr =
             (RexCall) f.simplify.simplifyPreservingType(outerFloorCall,
                 RexUnknownAs.UNKNOWN, true);
diff --git a/core/src/test/java/org/apache/calcite/test/RexTransformerTest.java b/core/src/test/java/org/apache/calcite/test/RexTransformerTest.java
index 65472b398dc..34ab31167fa 100644
--- a/core/src/test/java/org/apache/calcite/test/RexTransformerTest.java
+++ b/core/src/test/java/org/apache/calcite/test/RexTransformerTest.java
@@ -76,15 +76,15 @@ private static RelNode toRel(String sql) {
     rexBuilder = new RexBuilder(typeFactory);
     boolRelDataType = typeFactory.createSqlType(SqlTypeName.BOOLEAN);
 
-    x = new RexInputRef(
-        0,
-        typeFactory.createTypeWithNullability(boolRelDataType, true));
-    y = new RexInputRef(
-        1,
-        typeFactory.createTypeWithNullability(boolRelDataType, true));
-    z = new RexInputRef(
-        2,
-        typeFactory.createTypeWithNullability(boolRelDataType, true));
+    x =
+        new RexInputRef(0,
+            typeFactory.createTypeWithNullability(boolRelDataType, true));
+    y =
+        new RexInputRef(1,
+            typeFactory.createTypeWithNullability(boolRelDataType, true));
+    z =
+        new RexInputRef(2,
+            typeFactory.createTypeWithNullability(boolRelDataType, true));
     trueRex = rexBuilder.makeLiteral(true);
     falseRex = rexBuilder.makeLiteral(false);
   }
@@ -363,14 +363,10 @@ private RexNode isTrue(RexNode node) {
     final List<RexNode> leftJoinKeys = new ArrayList<>();
     final List<RexNode> rightJoinKeys = new ArrayList<>();
     final ArrayList<RelDataTypeField> sysFieldList = new ArrayList<>();
-    final RexNode remaining = RelOptUtil.splitJoinCondition(sysFieldList,
-        join.getInputs().get(0),
-        join.getInputs().get(1),
-        join.getCondition(),
-        leftJoinKeys,
-        rightJoinKeys,
-        null,
-        null);
+    final RexNode remaining =
+        RelOptUtil.splitJoinCondition(sysFieldList, join.getInputs().get(0),
+            join.getInputs().get(1), join.getCondition(),
+            leftJoinKeys, rightJoinKeys, null, null);
 
     assertThat(remaining.toString(), is("<>($0, $9)"));
     assertThat(leftJoinKeys.isEmpty(), is(true));
diff --git a/core/src/test/java/org/apache/calcite/test/RuleMatchVisualizerTest.java b/core/src/test/java/org/apache/calcite/test/RuleMatchVisualizerTest.java
index ac5e0952aab..28c39ab6b08 100644
--- a/core/src/test/java/org/apache/calcite/test/RuleMatchVisualizerTest.java
+++ b/core/src/test/java/org/apache/calcite/test/RuleMatchVisualizerTest.java
@@ -26,6 +26,8 @@
 import org.apache.calcite.rel.RelCollationTraitDef;
 import org.apache.calcite.rel.rules.CoreRules;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.Test;
 
 import java.util.HashMap;
@@ -36,11 +38,23 @@
 /**
  * Check the output of {@link RuleMatchVisualizer}.
  */
-public class RuleMatchVisualizerTest extends RelOptTestBase {
+class RuleMatchVisualizerTest extends RelOptTestBase {
+
+  @Nullable
+  private static DiffRepository diffRepos = null;
+
+  @AfterAll
+  public static void checkActualAndReferenceFiles() {
+    if (diffRepos != null) {
+      diffRepos.checkActualAndReferenceFiles();
+    }
+  }
 
   @Override RelOptFixture fixture() {
-    return super.fixture()
+    RelOptFixture fixture = super.fixture()
         .withDiffRepos(DiffRepository.lookup(RuleMatchVisualizerTest.class));
+    diffRepos = fixture.diffRepos();
+    return fixture;
   }
 
   @Test void testHepPlanner() {
@@ -95,11 +109,13 @@ public class RuleMatchVisualizerTest extends RelOptTestBase {
    */
   private String normalize(String str) {
     // rename rel ids
-    str = renameMatches(
-        str, Pattern.compile("\"([0-9]+)\"|"
-        + "\"label\" *: *\"#([0-9]+)-|"
-        + "\"label\" *: *\"subset#([0-9]+)-|"
-        + "\"explanation\" *: *\"\\{subset=rel#([0-9]+):"), 1000);
+    str =
+        renameMatches(str,
+            Pattern.compile("\"([0-9]+)\"|"
+                + "\"label\" *: *\"#([0-9]+)-|"
+                + "\"label\" *: *\"subset#([0-9]+)-|"
+                + "\"explanation\" *: *\"\\{subset=rel#([0-9]+):"),
+            1000);
     // rename rule call ids
     str = renameMatches(str, Pattern.compile("\"id\" *: *\"([0-9]+)-"), 100);
     return str;
diff --git a/core/src/test/java/org/apache/calcite/test/ScannableTableTest.java b/core/src/test/java/org/apache/calcite/test/ScannableTableTest.java
index 0339cd45fc6..ceb97421169 100644
--- a/core/src/test/java/org/apache/calcite/test/ScannableTableTest.java
+++ b/core/src/test/java/org/apache/calcite/test/ScannableTableTest.java
@@ -46,7 +46,6 @@
 import com.google.common.collect.ImmutableMap;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
-import org.jetbrains.annotations.NotNull;
 import org.junit.jupiter.api.Test;
 
 import java.math.BigDecimal;
@@ -423,8 +422,8 @@ private static Pair<Integer, Object> getFilter(boolean cooperative, List<RexNode
     properties.setProperty("caseSensitive", "true");
     try (Connection connection =
              DriverManager.getConnection("jdbc:calcite:", properties)) {
-      final CalciteConnection calciteConnection = connection.unwrap(
-          CalciteConnection.class);
+      final CalciteConnection calciteConnection =
+          connection.unwrap(CalciteConnection.class);
 
       final AtomicInteger scanCount = new AtomicInteger();
       final AtomicInteger enumerateCount = new AtomicInteger();
@@ -652,7 +651,7 @@ private Enumerable<Object[]> superScan(DataContext root) {
       @Override public Enumerable<@Nullable Object[]> scan(DataContext root) {
         scanCount.incrementAndGet();
         return new AbstractEnumerable<Object[]>() {
-          @NotNull @Override public Enumerator<Object[]> enumerator() {
+          @Override public Enumerator<Object[]> enumerator() {
             enumerateCount.incrementAndGet();
             final Enumerator<Object[]> enumerator =
                 superScan(root).enumerator();
diff --git a/core/src/test/java/org/apache/calcite/test/SqlFunctionsTest.java b/core/src/test/java/org/apache/calcite/test/SqlFunctionsTest.java
index ce60ca8d564..704b0208716 100644
--- a/core/src/test/java/org/apache/calcite/test/SqlFunctionsTest.java
+++ b/core/src/test/java/org/apache/calcite/test/SqlFunctionsTest.java
@@ -22,21 +22,33 @@
 import org.apache.calcite.runtime.SqlFunctions;
 import org.apache.calcite.runtime.Utilities;
 
+import com.google.common.collect.ImmutableList;
+
 import org.junit.jupiter.api.Test;
 
 import java.math.BigDecimal;
+import java.sql.Time;
+import java.sql.Timestamp;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Calendar;
 import java.util.Collections;
 import java.util.List;
+import java.util.Locale;
+import java.util.TimeZone;
 
-import static org.apache.calcite.avatica.util.DateTimeUtils.ymdToUnixDate;
-import static org.apache.calcite.runtime.SqlFunctions.addMonths;
+import static org.apache.calcite.avatica.util.DateTimeUtils.MILLIS_PER_DAY;
+import static org.apache.calcite.avatica.util.DateTimeUtils.dateStringToUnixDate;
+import static org.apache.calcite.avatica.util.DateTimeUtils.timeStringToUnixDate;
+import static org.apache.calcite.avatica.util.DateTimeUtils.timestampStringToUnixDate;
 import static org.apache.calcite.runtime.SqlFunctions.charLength;
 import static org.apache.calcite.runtime.SqlFunctions.concat;
 import static org.apache.calcite.runtime.SqlFunctions.fromBase64;
 import static org.apache.calcite.runtime.SqlFunctions.greater;
 import static org.apache.calcite.runtime.SqlFunctions.initcap;
+import static org.apache.calcite.runtime.SqlFunctions.internalToDate;
+import static org.apache.calcite.runtime.SqlFunctions.internalToTime;
+import static org.apache.calcite.runtime.SqlFunctions.internalToTimestamp;
 import static org.apache.calcite.runtime.SqlFunctions.lesser;
 import static org.apache.calcite.runtime.SqlFunctions.lower;
 import static org.apache.calcite.runtime.SqlFunctions.ltrim;
@@ -45,8 +57,11 @@
 import static org.apache.calcite.runtime.SqlFunctions.regexpReplace;
 import static org.apache.calcite.runtime.SqlFunctions.rtrim;
 import static org.apache.calcite.runtime.SqlFunctions.sha1;
-import static org.apache.calcite.runtime.SqlFunctions.subtractMonths;
 import static org.apache.calcite.runtime.SqlFunctions.toBase64;
+import static org.apache.calcite.runtime.SqlFunctions.toInt;
+import static org.apache.calcite.runtime.SqlFunctions.toIntOptional;
+import static org.apache.calcite.runtime.SqlFunctions.toLong;
+import static org.apache.calcite.runtime.SqlFunctions.toLongOptional;
 import static org.apache.calcite.runtime.SqlFunctions.trim;
 import static org.apache.calcite.runtime.SqlFunctions.upper;
 import static org.apache.calcite.test.Matchers.within;
@@ -55,7 +70,6 @@
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.CoreMatchers.nullValue;
 import static org.hamcrest.MatcherAssert.assertThat;
-import static org.hamcrest.core.AnyOf.anyOf;
 import static org.junit.jupiter.api.Assertions.assertSame;
 import static org.junit.jupiter.api.Assertions.fail;
 
@@ -69,6 +83,14 @@
  * rather than {@code assertEquals}.
  */
 class SqlFunctionsTest {
+  static <E> List<E> list(E... es) {
+    return Arrays.asList(es);
+  }
+
+  static <E> List<E> list() {
+    return ImmutableList.of();
+  }
+
   @Test void testCharLength() {
     assertThat(charLength("xyz"), is(3));
   }
@@ -157,7 +179,7 @@ class SqlFunctionsTest {
       fail("'regexp_replace' on an invalid pos is not possible");
     } catch (CalciteException e) {
       assertThat(e.getMessage(),
-          is("Not a valid input for REGEXP_REPLACE: '0'"));
+          is("Invalid input for REGEXP_REPLACE: '0'"));
     }
 
     try {
@@ -165,7 +187,7 @@ class SqlFunctionsTest {
       fail("'regexp_replace' on an invalid matchType is not possible");
     } catch (CalciteException e) {
       assertThat(e.getMessage(),
-          is("Not a valid input for REGEXP_REPLACE: 'WWW'"));
+          is("Invalid input for REGEXP_REPLACE: 'WWW'"));
     }
   }
 
@@ -286,47 +308,6 @@ static String trimSpacesBoth(String s) {
     return trim(true, true, " ", s);
   }
 
-  @Test void testAddMonths() {
-    checkAddMonths(2016, 1, 1, 2016, 2, 1, 1);
-    checkAddMonths(2016, 1, 1, 2017, 1, 1, 12);
-    checkAddMonths(2016, 1, 1, 2017, 2, 1, 13);
-    checkAddMonths(2016, 1, 1, 2015, 1, 1, -12);
-    checkAddMonths(2016, 1, 1, 2018, 10, 1, 33);
-    checkAddMonths(2016, 1, 31, 2016, 4, 30, 3);
-    checkAddMonths(2016, 4, 30, 2016, 7, 30, 3);
-    checkAddMonths(2016, 1, 31, 2016, 2, 29, 1);
-    checkAddMonths(2016, 3, 31, 2016, 2, 29, -1);
-    checkAddMonths(2016, 3, 31, 2116, 3, 31, 1200);
-    checkAddMonths(2016, 2, 28, 2116, 2, 28, 1200);
-    checkAddMonths(2019, 9, 1, 2020, 3, 1, 6);
-    checkAddMonths(2019, 9, 1, 2016, 8, 1, -37);
-  }
-
-  private void checkAddMonths(int y0, int m0, int d0, int y1, int m1, int d1,
-      int months) {
-    final int date0 = ymdToUnixDate(y0, m0, d0);
-    final long date = addMonths(date0, months);
-    final int date1 = ymdToUnixDate(y1, m1, d1);
-    assertThat((int) date, is(date1));
-
-    assertThat(subtractMonths(date1, date0),
-        anyOf(is(months), is(months + 1)));
-    assertThat(subtractMonths(date1 + 1, date0),
-        anyOf(is(months), is(months + 1)));
-    assertThat(subtractMonths(date1, date0 + 1),
-        anyOf(is(months), is(months - 1)));
-    assertThat(subtractMonths(d2ts(date1, 1), d2ts(date0, 0)),
-        anyOf(is(months), is(months + 1)));
-    assertThat(subtractMonths(d2ts(date1, 0), d2ts(date0, 1)),
-        anyOf(is(months - 1), is(months), is(months + 1)));
-  }
-
-  /** Converts a date (days since epoch) and milliseconds (since midnight)
-   * into a timestamp (milliseconds since epoch). */
-  private long d2ts(int date, int millis) {
-    return date * DateTimeUtils.MILLIS_PER_DAY + millis;
-  }
-
   @Test void testFloor() {
     checkFloor(0, 10, 0);
     checkFloor(27, 10, 20);
@@ -536,6 +517,64 @@ private void checkCeil(int x, int y, int result) {
     assertThat(SqlFunctions.sround(-12000, -5), within(0d, 0.001));
   }
 
+  @Test void testSplit() {
+    assertThat("no occurrence of delimiter",
+        SqlFunctions.split("abc", ","), is(list("abc")));
+    assertThat("delimiter in middle",
+        SqlFunctions.split("abc", "b"), is(list("a", "c")));
+    assertThat("delimiter at end",
+        SqlFunctions.split("abc", "c"), is(list("ab", "")));
+    assertThat("delimiter at start",
+        SqlFunctions.split("abc", "a"), is(list("", "bc")));
+    assertThat("empty delimiter",
+        SqlFunctions.split("abc", ""), is(list("abc")));
+    assertThat("empty delimiter and string",
+        SqlFunctions.split("", ""), is(list()));
+    assertThat("empty string",
+        SqlFunctions.split("", ","), is(list()));
+    assertThat("long delimiter (occurs at start)",
+        SqlFunctions.split("abracadabra", "ab"), is(list("", "racad", "ra")));
+    assertThat("long delimiter (occurs at end)",
+        SqlFunctions.split("sabracadabrab", "ab"),
+        is(list("s", "racad", "r", "")));
+
+    // Same as above but for ByteString
+    final ByteString a = ByteString.of("aa", 16);
+    final ByteString ab = ByteString.of("aabb", 16);
+    final ByteString abc = ByteString.of("aabbcc", 16);
+    final ByteString abracadabra = ByteString.of("aabb44aaccaaddaabb44aa", 16);
+    final ByteString b = ByteString.of("bb", 16);
+    final ByteString bc = ByteString.of("bbcc", 16);
+    final ByteString c = ByteString.of("cc", 16);
+    final ByteString f = ByteString.of("ff", 16);
+    final ByteString r = ByteString.of("44", 16);
+    final ByteString ra = ByteString.of("44aa", 16);
+    final ByteString racad = ByteString.of("44aaccaadd", 16);
+    final ByteString empty = ByteString.of("", 16);
+    final ByteString s = ByteString.of("55", 16);
+    final ByteString sabracadabrab =
+        ByteString.of("55", 16).concat(abracadabra).concat(b);
+    assertThat("no occurrence of delimiter",
+        SqlFunctions.split(abc, f), is(list(abc)));
+    assertThat("delimiter in middle",
+        SqlFunctions.split(abc, b), is(list(a, c)));
+    assertThat("delimiter at end",
+        SqlFunctions.split(abc, c), is(list(ab, empty)));
+    assertThat("delimiter at start",
+        SqlFunctions.split(abc, a), is(list(empty, bc)));
+    assertThat("empty delimiter",
+        SqlFunctions.split(abc, empty), is(list(abc)));
+    assertThat("empty delimiter and string",
+        SqlFunctions.split(empty, empty), is(list()));
+    assertThat("empty string",
+        SqlFunctions.split(empty, f), is(list()));
+    assertThat("long delimiter (occurs at start)",
+        SqlFunctions.split(abracadabra, ab), is(list(empty, racad, ra)));
+    assertThat("long delimiter (occurs at end)",
+        SqlFunctions.split(sabracadabrab, ab),
+        is(list(s, racad, r, empty)));
+  }
+
   @Test void testByteString() {
     final byte[] bytes = {(byte) 0xAB, (byte) 0xFF};
     final ByteString byteString = new ByteString(bytes);
@@ -974,4 +1013,329 @@ private void thereAndBack(byte[] bytes) {
       // ok
     }
   }
+
+  /**
+   * Tests that a date in the local time zone converts to a Unix timestamp in
+   * UTC.
+   */
+  @Test void testToIntWithSqlDate() {
+    assertThat(toInt(new java.sql.Date(0L)), is(0));  // rounded to closest day
+    assertThat(sqlDate("1970-01-01"), is(0));
+    assertThat(sqlDate("1500-04-30"), is(dateStringToUnixDate("1500-04-30")));
+  }
+
+  /**
+   * Test calendar conversion from the standard Gregorian calendar used by
+   * {@code java.sql} and the proleptic Gregorian calendar used by Unix
+   * timestamps.
+   */
+  @Test void testToIntWithSqlDateInGregorianShift() {
+    assertThat(sqlDate("1582-10-04"), is(dateStringToUnixDate("1582-10-04")));
+    assertThat(sqlDate("1582-10-05"), is(dateStringToUnixDate("1582-10-15")));
+    assertThat(sqlDate("1582-10-15"), is(dateStringToUnixDate("1582-10-15")));
+  }
+
+  /**
+   * Test date range 0001-01-01 to 9999-12-31 required by ANSI SQL.
+   *
+   * <p>Java may not be able to represent 0001-01-01 depending on the default
+   * time zone. If the date would fall outside of Anno Domini (AD) when
+   * converted to the default time zone, that date should not be tested.
+   *
+   * <p>Not every time zone has a January 1st 12:00am, so this test skips those
+   * dates.
+   */
+  @Test void testToIntWithSqlDateInAnsiDateRange() {
+    for (int i = 2; i <= 9999; ++i) {
+      final String str = String.format(Locale.ROOT, "%04d-01-01", i);
+      final java.sql.Date date = java.sql.Date.valueOf(str);
+      final Timestamp timestamp = new Timestamp(date.getTime());
+      if (timestamp.toString().endsWith("00:00:00.0")) {
+        // Test equality if the time is valid in Java
+        assertThat("Converts '" + str + "' from SQL to Unix date",
+            toInt(date),
+            is(dateStringToUnixDate(str)));
+      } else {
+        // Test result matches legacy behavior if the time cannot be
+        // represented in Java. This probably results in a different date but
+        // is pretty rare.
+        final long expected =
+            (date.getTime() + DateTimeUtils.DEFAULT_ZONE.getOffset(date.getTime()))
+                / DateTimeUtils.MILLIS_PER_DAY;
+        assertThat("Converts '" + str
+                + "' from SQL to Unix date using legacy behavior",
+            toInt(date),
+            is((int) expected));
+      }
+    }
+  }
+
+  /**
+   * Test using a custom {@link TimeZone} to calculate the Unix timestamp.
+   * Dates created by a {@link java.sql.Date} method should be converted
+   * relative to the local time and not UTC.
+   */
+  @Test public void testToIntWithTimeZone() {
+    // Dates created by a Calendar should be converted to a Unix date in that
+    // time zone
+    final Calendar utcCal =
+        Calendar.getInstance(TimeZone.getTimeZone("UTC"), Locale.ROOT);
+    utcCal.set(1970, Calendar.JANUARY, 1, 0, 0, 0);
+    utcCal.set(Calendar.MILLISECOND, 0);
+    assertThat(
+        toInt(new java.sql.Date(utcCal.getTimeInMillis()),
+            utcCal.getTimeZone()),
+        is(0));
+
+    // Dates should be relative to the local time and not UTC
+    final java.sql.Date epoch = java.sql.Date.valueOf("1970-01-01");
+
+    final TimeZone minusDayZone = TimeZone.getDefault();
+    minusDayZone.setRawOffset((int) (minusDayZone.getRawOffset() - MILLIS_PER_DAY));
+    assertThat(toInt(epoch, minusDayZone), is(-1));
+
+    final TimeZone plusDayZone = TimeZone.getDefault();
+    plusDayZone.setRawOffset((int) (plusDayZone.getRawOffset() + MILLIS_PER_DAY));
+    assertThat(toInt(epoch, plusDayZone), is(1));
+  }
+
+  /**
+   * Tests that a nullable date in the local time zone converts to a Unix
+   * timestamp in UTC.
+   */
+  @Test void testToIntOptionalWithLocalTimeZone() {
+    assertThat(toIntOptional(java.sql.Date.valueOf("1970-01-01")), is(0));
+    assertThat(toIntOptional((java.sql.Date) null), is(nullValue()));
+  }
+
+  /**
+   * Tests that a nullable date in the given time zone converts to a Unix
+   * timestamp in UTC.
+   */
+  @Test void testToIntOptionalWithCustomTimeZone() {
+    final TimeZone utc = TimeZone.getTimeZone("UTC");
+    assertThat(toIntOptional(new java.sql.Date(0L), utc), is(0));
+    assertThat(toIntOptional(null, utc), is(nullValue()));
+  }
+
+  /**
+   * Tests that a time in the local time zone converts to a Unix time in UTC.
+   */
+  @Test void testToIntWithSqlTime() {
+    assertThat(sqlTime("00:00:00"), is(timeStringToUnixDate("00:00:00")));
+    assertThat(sqlTime("23:59:59"), is(timeStringToUnixDate("23:59:59")));
+  }
+
+  /**
+   * Tests that a nullable time in the local time zone converts to a Unix time
+   * in UTC.
+   */
+  @Test void testToIntOptionalWithSqlTime() {
+    assertThat(toIntOptional(Time.valueOf("00:00:00")), is(0));
+    assertThat(toIntOptional((Time) null), is(nullValue()));
+  }
+
+  /**
+   * Tests that a timestamp in the local time zone converts to a Unix timestamp
+   * in UTC.
+   */
+  @Test void testToLongWithSqlTimestamp() {
+    assertThat(sqlTimestamp("1970-01-01 00:00:00"), is(0L));
+    assertThat(sqlTimestamp("2014-09-30 15:28:27.356"),
+        is(timestampStringToUnixDate("2014-09-30 15:28:27.356")));
+    assertThat(sqlTimestamp("1500-04-30 12:00:00.123"),
+        is(timestampStringToUnixDate("1500-04-30 12:00:00.123")));
+  }
+
+  /**
+   * Test using a custom {@link TimeZone} to calculate the Unix timestamp.
+   * Timestamps created by a {@link Calendar} should be converted to a Unix
+   * timestamp in the given time zone. Timestamps created by a {@link Timestamp}
+   * method should be converted relative to the local time and not UTC.
+   */
+  @Test void testToLongWithSqlTimestampAndCustomTimeZone() {
+    final Timestamp epoch = java.sql.Timestamp.valueOf("1970-01-01 00:00:00");
+
+    final Calendar utcCal =
+        Calendar.getInstance(TimeZone.getTimeZone("UTC"), Locale.ROOT);
+    utcCal.set(1970, Calendar.JANUARY, 1, 0, 0, 0);
+    utcCal.set(Calendar.MILLISECOND, 0);
+    assertThat(toLong(new Timestamp(utcCal.getTimeInMillis()), utcCal.getTimeZone()),
+        is(0L));
+
+    final TimeZone est = TimeZone.getTimeZone("GMT-5:00");
+    assertThat(toLong(epoch, est),
+        is(epoch.getTime() + est.getOffset(epoch.getTime())));
+
+    final TimeZone ist = TimeZone.getTimeZone("GMT+5:00");
+    assertThat(toLong(epoch, ist),
+        is(epoch.getTime() + ist.getOffset(epoch.getTime())));
+  }
+
+  /**
+   * Test calendar conversion from the standard Gregorian calendar used by
+   * {@code java.sql} and the proleptic Gregorian calendar used by Unix
+   * timestamps.
+   */
+  @Test void testToLongWithSqlTimestampInGregorianShift() {
+    assertThat(sqlTimestamp("1582-10-04 00:00:00"),
+        is(timestampStringToUnixDate("1582-10-04 00:00:00")));
+    assertThat(sqlTimestamp("1582-10-05 00:00:00"),
+        is(timestampStringToUnixDate("1582-10-15 00:00:00")));
+    assertThat(sqlTimestamp("1582-10-15 00:00:00"),
+        is(timestampStringToUnixDate("1582-10-15 00:00:00")));
+  }
+
+  /**
+   * Test date range 0001-01-01 to 9999-12-31 required by ANSI SQL.
+   *
+   * <p>Java may not be able to represent 0001-01-01 depending on the default
+   * time zone. If the date would fall outside of Anno Domini (AD) when
+   * converted to the default time zone, that date should not be tested.
+   *
+   * <p>Not every time zone has a January 1st 12:00am, so this test skips those
+   * dates.
+   */
+  @Test void testToLongWithSqlTimestampInAnsiDateRange() {
+    for (int i = 2; i <= 9999; ++i) {
+      final String str = String.format(Locale.ROOT, "%04d-01-01 00:00:00", i);
+      final Timestamp timestamp = Timestamp.valueOf(str);
+      if (timestamp.toString().endsWith("00:00:00.0")) {
+        // Test equality if the time is valid in Java
+        assertThat("Converts '" + str + "' from SQL to Unix timestamp",
+            toLong(timestamp),
+            is(timestampStringToUnixDate(str)));
+      } else {
+        // Test result matches legacy behavior if the time cannot be represented in Java
+        // This probably results in a different date but is pretty rare
+        final long expected = timestamp.getTime()
+            + DateTimeUtils.DEFAULT_ZONE.getOffset(timestamp.getTime());
+        assertThat("Converts '" + str
+                + "' from SQL to Unix timestamp using legacy behavior",
+            toLong(timestamp),
+            is(expected));
+      }
+    }
+  }
+
+  /**
+   * Tests that a nullable timestamp in the local time zone converts to a Unix
+   * timestamp in UTC.
+   */
+  @Test void testToLongOptionalWithLocalTimeZone() {
+    assertThat(toLongOptional(Timestamp.valueOf("1970-01-01 00:00:00")), is(0L));
+    assertThat(toLongOptional(null), is(nullValue()));
+  }
+
+  /**
+   * Tests that a nullable timestamp in the given time zone converts to a Unix
+   * timestamp in UTC.
+   */
+  @Test void testToLongOptionalWithCustomTimeZone() {
+    final TimeZone utc = TimeZone.getTimeZone("UTC");
+    assertThat(toLongOptional(new Timestamp(0L), utc), is(0L));
+    assertThat(toLongOptional(null, utc), is(nullValue()));
+  }
+
+  /**
+   * Tests that a Unix timestamp converts to a date in the local time zone.
+   */
+  @Test void testInternalToDate() {
+    assertThat(internalToDate(0), is(java.sql.Date.valueOf("1970-01-01")));
+    assertThat(internalToDate(dateStringToUnixDate("1500-04-30")),
+        is(java.sql.Date.valueOf("1500-04-30")));
+  }
+
+  /**
+   * Test calendar conversion from the standard Gregorian calendar used by
+   * {@code java.sql} and the proleptic Gregorian calendar used by Unix
+   * timestamps.
+   */
+  @Test void testInternalToDateWithGregorianShift() {
+    // Gregorian shift
+    assertThat(internalToDate(dateStringToUnixDate("1582-10-04")),
+        is(java.sql.Date.valueOf("1582-10-04")));
+    assertThat(internalToDate(dateStringToUnixDate("1582-10-05")),
+        is(java.sql.Date.valueOf("1582-10-15")));
+    assertThat(internalToDate(dateStringToUnixDate("1582-10-15")),
+        is(java.sql.Date.valueOf("1582-10-15")));
+  }
+
+  /**
+   * Test date range 0001-01-01 to 9999-12-31 required by ANSI SQL.
+   *
+   * <p>Java may not be able to represent all dates depending on the default time zone, but both
+   * the expected and actual assertion values handles that in the same way.
+   */
+  @Test void testInternalToDateWithAnsiDateRange() {
+    for (int i = 2; i <= 9999; ++i) {
+      final String str = String.format(Locale.ROOT, "%04d-01-01", i);
+      assertThat(internalToDate(dateStringToUnixDate(str)),
+          is(java.sql.Date.valueOf(str)));
+    }
+  }
+
+  /**
+   * Tests that a Unix time converts to a SQL time in the local time zone.
+   */
+  @Test void testInternalToTime() {
+    assertThat(internalToTime(0), is(Time.valueOf("00:00:00")));
+    assertThat(internalToTime(86399000), is(Time.valueOf("23:59:59")));
+  }
+
+  /**
+   * Tests that a Unix timestamp converts to a SQL timestamp in the local time
+   * zone.
+   */
+  @Test void testInternalToTimestamp() {
+    assertThat(internalToTimestamp(0),
+        is(Timestamp.valueOf("1970-01-01 00:00:00.0")));
+    assertThat(internalToTimestamp(timestampStringToUnixDate("2014-09-30 15:28:27.356")),
+        is(Timestamp.valueOf("2014-09-30 15:28:27.356")));
+    assertThat(internalToTimestamp(timestampStringToUnixDate("1500-04-30 12:00:00.123")),
+        is(Timestamp.valueOf("1500-04-30 12:00:00.123")));
+  }
+
+  /**
+   * Test calendar conversion from the standard Gregorian calendar used by
+   * {@code java.sql} and the proleptic Gregorian calendar used by Unix timestamps.
+   */
+  @Test void testInternalToTimestampWithGregorianShift() {
+    assertThat(
+        internalToTimestamp(timestampStringToUnixDate("1582-10-04 00:00:00")),
+        is(Timestamp.valueOf("1582-10-04 00:00:00.0")));
+    assertThat(
+        internalToTimestamp(timestampStringToUnixDate("1582-10-05 00:00:00")),
+        is(Timestamp.valueOf("1582-10-15 00:00:00.0")));
+    assertThat(
+        internalToTimestamp(timestampStringToUnixDate("1582-10-15 00:00:00")),
+        is(Timestamp.valueOf("1582-10-15 00:00:00.0")));
+  }
+
+  /**
+   * Test date range 0001-01-01 to 9999-12-31 required by ANSI SQL.
+   *
+   * <p>Java may not be able to represent all dates depending on the default
+   * time zone, but both the expected and actual assertion values handles that
+   * in the same way.
+   */
+  @Test void testInternalToTimestampWithAnsiDateRange() {
+    for (int i = 2; i <= 9999; ++i) {
+      final String str = String.format(Locale.ROOT, "%04d-01-01 00:00:00", i);
+      assertThat(internalToTimestamp(timestampStringToUnixDate(str)),
+          is(Timestamp.valueOf(str)));
+    }
+  }
+
+  private int sqlDate(String str) {
+    return toInt(java.sql.Date.valueOf(str));
+  }
+
+  private int sqlTime(String str) {
+    return toInt(java.sql.Time.valueOf(str));
+  }
+
+  private long sqlTimestamp(String str) {
+    return toLong(java.sql.Timestamp.valueOf(str));
+  }
 }
diff --git a/core/src/test/java/org/apache/calcite/test/SqlHintsConverterTest.java b/core/src/test/java/org/apache/calcite/test/SqlHintsConverterTest.java
index 0f3154a0ef4..c3b3513e136 100644
--- a/core/src/test/java/org/apache/calcite/test/SqlHintsConverterTest.java
+++ b/core/src/test/java/org/apache/calcite/test/SqlHintsConverterTest.java
@@ -75,6 +75,8 @@
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.immutables.value.Value;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
@@ -100,6 +102,7 @@
 
 /**
  * Unit test for {@link org.apache.calcite.rel.hint.RelHint}.
+ * See {@link RelOptRulesTest} for an explanation of how to add tests.
  */
 class SqlHintsConverterTest {
 
@@ -109,7 +112,8 @@ class SqlHintsConverterTest {
           "?", false, false)
           .withFactory(f ->
               f.withSqlToRelConfig(c ->
-                  c.withHintStrategyTable(HintTools.HINT_STRATEGY_TABLE)));
+                  c.withHintStrategyTable(HintTools.HINT_STRATEGY_TABLE)
+                      .withExpand(true)));
 
   static final RelOptFixture RULE_FIXTURE =
       RelOptFixture.DEFAULT
@@ -117,11 +121,22 @@ class SqlHintsConverterTest {
           .withConfig(c ->
               c.withHintStrategyTable(HintTools.HINT_STRATEGY_TABLE));
 
+  @Nullable
+  private static DiffRepository diffRepos = null;
+
+  @AfterAll
+  public static void checkActualAndReferenceFiles() {
+    if (diffRepos != null) {
+      diffRepos.checkActualAndReferenceFiles();
+    }
+  }
+
   protected Fixture fixture() {
     return FIXTURE;
   }
 
   protected RelOptFixture ruleFixture() {
+    diffRepos = RULE_FIXTURE.diffRepos();
     return RULE_FIXTURE;
   }
 
@@ -242,6 +257,13 @@ public final Fixture sql(String sql) {
     sql(sql).ok();
   }
 
+  @Test void testSnapshotHints() {
+    final String sql = "select /*+ fast_snapshot(products_temporal) */ stream * from\n"
+        + " orders join products_temporal for system_time as of timestamp '2022-08-11 15:00:00'\n"
+        + " on orders.productid = products_temporal.productid";
+    sql(sql).ok();
+  }
+
   @Test void testHintsInSubQueryWithDecorrelation() {
     final String sql = "select /*+ resource(parallelism='3'), AGG_STRATEGY(TWO_PHASE) */\n"
         + "sum(e1.empno) from emp e1, dept d1\n"
@@ -339,13 +361,12 @@ public final Fixture sql(String sql) {
     final SqlInsert insert = (SqlInsert) sql(sql).parseQuery();
     assert insert.getTargetTable() instanceof SqlTableRef;
     final SqlTableRef tableRef = (SqlTableRef) insert.getTargetTable();
-    List<RelHint> hints = SqlUtil.getRelHint(HintTools.HINT_STRATEGY_TABLE,
-        (SqlNodeList) tableRef.getOperandList().get(1));
+    List<RelHint> hints =
+        SqlUtil.getRelHint(HintTools.HINT_STRATEGY_TABLE,
+            (SqlNodeList) tableRef.getOperandList().get(1));
     assertHintsEquals(
-        Arrays.asList(
-          HintTools.PROPS_HINT,
-          HintTools.IDX_HINT,
-          HintTools.JOIN_HINT),
+        Arrays.asList(HintTools.PROPS_HINT, HintTools.IDX_HINT,
+            HintTools.JOIN_HINT),
         hints);
   }
 
@@ -355,13 +376,12 @@ public final Fixture sql(String sql) {
     final SqlUpdate sqlUpdate = (SqlUpdate) sql(sql).parseQuery();
     assert sqlUpdate.getTargetTable() instanceof SqlTableRef;
     final SqlTableRef tableRef = (SqlTableRef) sqlUpdate.getTargetTable();
-    List<RelHint> hints = SqlUtil.getRelHint(HintTools.HINT_STRATEGY_TABLE,
-        (SqlNodeList) tableRef.getOperandList().get(1));
+    List<RelHint> hints =
+        SqlUtil.getRelHint(HintTools.HINT_STRATEGY_TABLE,
+            (SqlNodeList) tableRef.getOperandList().get(1));
     assertHintsEquals(
-        Arrays.asList(
-          HintTools.PROPS_HINT,
-          HintTools.IDX_HINT,
-          HintTools.JOIN_HINT),
+        Arrays.asList(HintTools.PROPS_HINT, HintTools.IDX_HINT,
+            HintTools.JOIN_HINT),
         hints);
   }
 
@@ -370,13 +390,12 @@ public final Fixture sql(String sql) {
     final SqlDelete sqlDelete = (SqlDelete) sql(sql).parseQuery();
     assert sqlDelete.getTargetTable() instanceof SqlTableRef;
     final SqlTableRef tableRef = (SqlTableRef) sqlDelete.getTargetTable();
-    List<RelHint> hints = SqlUtil.getRelHint(HintTools.HINT_STRATEGY_TABLE,
-        (SqlNodeList) tableRef.getOperandList().get(1));
+    List<RelHint> hints =
+        SqlUtil.getRelHint(HintTools.HINT_STRATEGY_TABLE,
+            (SqlNodeList) tableRef.getOperandList().get(1));
     assertHintsEquals(
-        Arrays.asList(
-          HintTools.PROPS_HINT,
-          HintTools.IDX_HINT,
-          HintTools.JOIN_HINT),
+        Arrays.asList(HintTools.PROPS_HINT, HintTools.IDX_HINT,
+            HintTools.JOIN_HINT),
         hints);
   }
 
@@ -394,12 +413,11 @@ public final Fixture sql(String sql) {
     final SqlMerge sqlMerge = (SqlMerge) sql(sql1).parseQuery();
     assert sqlMerge.getTargetTable() instanceof SqlTableRef;
     final SqlTableRef tableRef = (SqlTableRef) sqlMerge.getTargetTable();
-    List<RelHint> hints = SqlUtil.getRelHint(HintTools.HINT_STRATEGY_TABLE,
-        (SqlNodeList) tableRef.getOperandList().get(1));
+    List<RelHint> hints =
+        SqlUtil.getRelHint(HintTools.HINT_STRATEGY_TABLE,
+            (SqlNodeList) tableRef.getOperandList().get(1));
     assertHintsEquals(
-        Arrays.asList(
-            HintTools.PROPS_HINT,
-            HintTools.IDX_HINT,
+        Arrays.asList(HintTools.PROPS_HINT, HintTools.IDX_HINT,
             HintTools.JOIN_HINT),
         hints);
   }
@@ -474,17 +492,17 @@ public final Fixture sql(String sql) {
         .hintOption("DEPT")
         .build();
     // Validate Volcano planner.
-    RuleSet ruleSet = RuleSets.ofList(
-        MockEnumerableJoinRule.create(hint), // Rule to validate the hint.
-        CoreRules.FILTER_PROJECT_TRANSPOSE,
-        CoreRules.FILTER_MERGE,
-        CoreRules.PROJECT_MERGE,
-        EnumerableRules.ENUMERABLE_JOIN_RULE,
-        EnumerableRules.ENUMERABLE_PROJECT_RULE,
-        EnumerableRules.ENUMERABLE_FILTER_RULE,
-        EnumerableRules.ENUMERABLE_SORT_RULE,
-        EnumerableRules.ENUMERABLE_LIMIT_RULE,
-        EnumerableRules.ENUMERABLE_TABLE_SCAN_RULE);
+    RuleSet ruleSet =
+        RuleSets.ofList(MockEnumerableJoinRule.create(hint), // validates hint
+            CoreRules.FILTER_PROJECT_TRANSPOSE,
+            CoreRules.FILTER_MERGE,
+            CoreRules.PROJECT_MERGE,
+            EnumerableRules.ENUMERABLE_JOIN_RULE,
+            EnumerableRules.ENUMERABLE_PROJECT_RULE,
+            EnumerableRules.ENUMERABLE_FILTER_RULE,
+            EnumerableRules.ENUMERABLE_SORT_RULE,
+            EnumerableRules.ENUMERABLE_LIMIT_RULE,
+            EnumerableRules.ENUMERABLE_TABLE_SCAN_RULE);
     ruleFixture()
         .sql(sql)
         .withVolcanoPlanner(false, p -> {
@@ -495,6 +513,48 @@ public final Fixture sql(String sql) {
         .check();
   }
 
+  @Test void testHintsPropagationInVolcanoPlannerRules2() {
+    final String sql = "select /*+ no_hash_join */ ename, job\n"
+        + "from emp where not exists (select 1 from dept where emp.deptno = dept.deptno)";
+    final RelHint hint = RelHint.builder("NO_HASH_JOIN")
+        .inheritPath(0, 0)
+        .build();
+    // Validate Volcano planner.
+    RuleSet ruleSet =
+        RuleSets.ofList(MockEnumerableJoinRule.create(hint));  // validates hint
+    ruleFixture()
+        .sql(sql)
+        .withTrim(true)
+        .withVolcanoPlanner(false, p -> {
+          p.addRelTraitDef(RelCollationTraitDef.INSTANCE);
+          RelOptUtil.registerDefaultRules(p, false, false);
+          ruleSet.forEach(p::addRule);
+        })
+        .withExpand(true)
+        .check();
+  }
+
+  @Test void testHintsPropagationInVolcanoPlannerRules3() {
+    final String sql = "select /*+ no_hash_join */ ename, job\n"
+        + "from emp where not exists (select 1 from dept where emp.deptno = dept.deptno) order by ename";
+    final RelHint hint = RelHint.builder("NO_HASH_JOIN")
+        .inheritPath(0, 0, 0)
+        .build();
+    // Validate Volcano planner.
+    RuleSet ruleSet =
+        RuleSets.ofList(MockEnumerableJoinRule.create(hint)); // validates hint
+    ruleFixture()
+        .sql(sql)
+        .withTrim(true)
+        .withVolcanoPlanner(false, p -> {
+          p.addRelTraitDef(RelCollationTraitDef.INSTANCE);
+          RelOptUtil.registerDefaultRules(p, false, false);
+          ruleSet.forEach(p::addRule);
+        })
+        .withExpand(true)
+        .check();
+  }
+
   @Test void testHintsPropagateWithDifferentKindOfRels() {
     final String sql = "select /*+ AGG_STRATEGY(TWO_PHASE) */\n"
         + "ename, avg(sal)\n"
@@ -519,8 +579,8 @@ public final Fixture sql(String sql) {
     final String sql = "select /*+ use_merge_join(emp, dept) */\n"
         + "ename, job, sal, dept.name\n"
         + "from emp join dept on emp.deptno = dept.deptno";
-    RuleSet ruleSet = RuleSets.ofList(
-        EnumerableRules.ENUMERABLE_MERGE_JOIN_RULE,
+    RuleSet ruleSet =
+        RuleSets.ofList(EnumerableRules.ENUMERABLE_MERGE_JOIN_RULE,
         EnumerableRules.ENUMERABLE_JOIN_RULE,
         EnumerableRules.ENUMERABLE_PROJECT_RULE,
         EnumerableRules.ENUMERABLE_TABLE_SCAN_RULE,
@@ -536,6 +596,24 @@ public final Fixture sql(String sql) {
         .check();
   }
 
+  @Test void testHintExcludeRules() {
+    final String sql = "select empno from (select * from "
+            + "(select /*+ preserved_project */ empno, ename, deptno from emp)"
+            + " where deptno = 20)";
+
+    final RelNode rel = ruleFixture().sql(sql).toRel();
+    HepProgram program = new HepProgramBuilder()
+            .addRuleInstance(CoreRules.FILTER_PROJECT_TRANSPOSE)
+            .build();
+    HepPlanner planner = new HepPlanner(program);
+    planner.setRoot(rel);
+    RelNode newRel = planner.findBestExp();
+    Assertions.assertTrue(rel.deepEquals(newRel),
+        "Expected:\n"
+        + RelOptUtil.toString(rel) + "Computed:\n"
+        + RelOptUtil.toString(newRel));
+  }
+
   //~ Methods ----------------------------------------------------------------
 
   private static boolean equalsStringList(List<String> l, List<String> r) {
@@ -551,7 +629,8 @@ private static boolean equalsStringList(List<String> l, List<String> r) {
   }
 
   private static void assertHintsEquals(List<RelHint> expected, List<RelHint> actual) {
-    assertArrayEquals(expected.toArray(new RelHint[0]), actual.toArray(new RelHint[0]));
+    assertArrayEquals(expected.toArray(new RelHint[0]),
+        actual.toArray(new RelHint[0]));
   }
 
   //~ Inner Class ------------------------------------------------------------
@@ -847,6 +926,11 @@ private static class HintCollector extends RelShuttleImpl {
           if (window.getHints().size() > 0) {
             this.hintsCollect.add("Window:" + window.getHints());
           }
+        } else if (other instanceof Snapshot) {
+          Snapshot snapshot = (Snapshot) other;
+          if (snapshot.getHints().size() > 0) {
+            this.hintsCollect.add("Snapshot:" + snapshot.getHints());
+          }
         }
         return super.visit(other);
       }
@@ -936,10 +1020,14 @@ static HintStrategyTable createHintStrategies(HintStrategyTable.Builder builder)
         .hintStrategy("async_merge", HintPredicates.SORT)
         .hintStrategy("mini_batch",
                 HintPredicates.and(HintPredicates.WINDOW, HintPredicates.PROJECT))
+        .hintStrategy("fast_snapshot", HintPredicates.SNAPSHOT)
         .hintStrategy("use_merge_join",
             HintStrategy.builder(
                 HintPredicates.and(HintPredicates.JOIN, joinWithFixedTableName()))
                 .excludedRules(EnumerableRules.ENUMERABLE_JOIN_RULE).build())
+              .hintStrategy(
+                  "preserved_project", HintStrategy.builder(
+               HintPredicates.PROJECT).excludedRules(CoreRules.FILTER_PROJECT_TRANSPOSE).build())
         .build();
     }
 
diff --git a/core/src/test/java/org/apache/calcite/test/SqlJsonFunctionsTest.java b/core/src/test/java/org/apache/calcite/test/SqlJsonFunctionsTest.java
index 0d1a3b3b633..605b99320f7 100644
--- a/core/src/test/java/org/apache/calcite/test/SqlJsonFunctionsTest.java
+++ b/core/src/test/java/org/apache/calcite/test/SqlJsonFunctionsTest.java
@@ -595,6 +595,39 @@ class SqlJsonFunctionsTest {
     assertIsJsonScalar("{]", is(false));
   }
 
+  @Test public void testJsonInsert() {
+    assertJsonInsert(
+        JsonFunctions.jsonValueExpression("{\"a\": 1, \"b\": [2]}"),
+        new Object[]{"$.a", 10, "$.c", "[true]"},
+        is("{\"a\":1,\"b\":[2],\"c\":\"[true]\"}"));
+    assertJsonInsert(
+        JsonFunctions.jsonValueExpression("{\"a\": 1, \"b\": [2]}"),
+        new Object[]{"$", 10, "$.c", "[true]"},
+        is("{\"a\":1,\"b\":[2],\"c\":\"[true]\"}"));
+  }
+
+  @Test public void testJsonReplace() {
+    assertJsonReplace(
+        JsonFunctions.jsonValueExpression("{\"a\": 1, \"b\": [2]}"),
+        new Object[]{"$.a", 10, "$.c", "[true]"},
+        is("{\"a\":10,\"b\":[2]}"));
+    assertJsonReplace(
+        JsonFunctions.jsonValueExpression("{\"a\": 1, \"b\": [2]}"),
+        new Object[]{"$", 10, "$.c", "[true]"},
+        is("10"));
+  }
+
+  @Test public void testJsonSet() {
+    assertJsonSet(
+        JsonFunctions.jsonValueExpression("{\"a\": 1, \"b\": [2]}"),
+        new Object[]{"$.a", 10, "$.c", "[true]"},
+        is("{\"a\":10,\"b\":[2],\"c\":\"[true]\"}"));
+    assertJsonSet(
+        JsonFunctions.jsonValueExpression("{\"a\": 1, \"b\": [2]}"),
+        new Object[]{"$", 10, "$.c", "[true]"},
+        is("10"));
+  }
+
   private void assertJsonValueExpression(String input,
       Matcher<? super JsonFunctions.JsonValueContext> matcher) {
     assertThat(
@@ -764,6 +797,30 @@ private void assertJsonStorageSizeFailed(String input,
         matcher);
   }
 
+  private void assertJsonInsert(JsonFunctions.JsonValueContext jsonDoc,
+      Object[] kvs,
+      Matcher<? super String> matcher) {
+    assertThat(invocationDesc(BuiltInMethod.JSON_INSERT.getMethodName(), jsonDoc, kvs),
+        JsonFunctions.jsonInsert(jsonDoc, kvs),
+        matcher);
+  }
+
+  private void assertJsonReplace(JsonFunctions.JsonValueContext jsonDoc,
+      Object[] kvs,
+      Matcher<? super String> matcher) {
+    assertThat(invocationDesc(BuiltInMethod.JSON_REPLACE.getMethodName(), jsonDoc, kvs),
+        JsonFunctions.jsonReplace(jsonDoc, kvs),
+        matcher);
+  }
+
+  private void assertJsonSet(JsonFunctions.JsonValueContext jsonDoc,
+      Object[] kvs,
+      Matcher<? super String> matcher) {
+    assertThat(invocationDesc(BuiltInMethod.JSON_SET.getMethodName(), jsonDoc, kvs),
+        JsonFunctions.jsonSet(jsonDoc, kvs),
+        matcher);
+  }
+
   private void assertDejsonize(String input,
       Matcher<Object> matcher) {
     assertThat(invocationDesc(BuiltInMethod.DEJSONIZE.getMethodName(), input),
diff --git a/core/src/test/java/org/apache/calcite/test/SqlOperatorBindingTest.java b/core/src/test/java/org/apache/calcite/test/SqlOperatorBindingTest.java
index 4f8ea4e0f76..368572bc867 100644
--- a/core/src/test/java/org/apache/calcite/test/SqlOperatorBindingTest.java
+++ b/core/src/test/java/org/apache/calcite/test/SqlOperatorBindingTest.java
@@ -123,18 +123,18 @@ void setUp() {
    * literal</a>.
    */
   @Test void testRexNodeLiteral() {
-    final RexNode literal = rexBuilder.makeZeroLiteral(
-        integerDataType);
+    final RexNode literal =
+        rexBuilder.makeZeroLiteral(integerDataType);
 
-    final RexNode castLiteral = rexBuilder.makeCall(
-        integerDataType,
-        SqlStdOperatorTable.CAST,
-        Lists.newArrayList(literal));
+    final RexNode castLiteral =
+        rexBuilder.makeCall(integerDataType,
+            SqlStdOperatorTable.CAST,
+            Lists.newArrayList(literal));
 
-    final RexNode castCastLiteral = rexBuilder.makeCall(
-        integerDataType,
-        SqlStdOperatorTable.CAST,
-        Lists.newArrayList(castLiteral));
+    final RexNode castCastLiteral =
+        rexBuilder.makeCall(integerDataType,
+            SqlStdOperatorTable.CAST,
+            Lists.newArrayList(castLiteral));
 
     // RexLiteral is considered a literal
     assertThat(RexUtil.isLiteral(literal, true), is(true));
diff --git a/core/src/test/java/org/apache/calcite/test/SqlTestGen.java b/core/src/test/java/org/apache/calcite/test/SqlTestGen.java
index 791850fb6ac..8e5c29b0df2 100644
--- a/core/src/test/java/org/apache/calcite/test/SqlTestGen.java
+++ b/core/src/test/java/org/apache/calcite/test/SqlTestGen.java
@@ -77,7 +77,7 @@ private static List<Method> getJunitMethods(Class<SqlValidatorSpooler> clazz) {
       if (method.getName().startsWith("test")
           && Modifier.isPublic(method.getModifiers())
           && !Modifier.isStatic(method.getModifiers())
-          && (method.getParameterTypes().length == 0)
+          && (method.getParameterCount() == 0)
           && (method.getReturnType() == Void.TYPE)) {
         list.add(method);
       }
diff --git a/core/src/test/java/org/apache/calcite/test/SqlToRelConverterExtendedTest.java b/core/src/test/java/org/apache/calcite/test/SqlToRelConverterExtendedTest.java
index c18608aa6e2..f1ae4443a35 100644
--- a/core/src/test/java/org/apache/calcite/test/SqlToRelConverterExtendedTest.java
+++ b/core/src/test/java/org/apache/calcite/test/SqlToRelConverterExtendedTest.java
@@ -28,12 +28,14 @@
 
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.parallel.ResourceLock;
 
 import java.io.IOException;
 
 /**
  * Runs {@link org.apache.calcite.test.SqlToRelConverterTest} with extensions.
  */
+@ResourceLock(value = "SqlToRelConverterTest.xml")
 class SqlToRelConverterExtendedTest extends SqlToRelConverterTest {
   Hook.Closeable closeable;
 
@@ -66,9 +68,8 @@ public static void foo(RelNode rel) {
 
     // Convert JSON back to rel tree.
     Frameworks.withPlanner((cluster, relOptSchema, rootSchema) -> {
-      final RelJsonReader reader = new RelJsonReader(
-          cluster,
-          schemas[0], rootSchema);
+      final RelJsonReader reader =
+          new RelJsonReader(cluster, schemas[0], rootSchema);
       try {
         RelNode x = reader.read(json);
       } catch (IOException e) {
diff --git a/core/src/test/java/org/apache/calcite/test/SqlToRelConverterTest.java b/core/src/test/java/org/apache/calcite/test/SqlToRelConverterTest.java
index 880846127c2..7541d68e274 100644
--- a/core/src/test/java/org/apache/calcite/test/SqlToRelConverterTest.java
+++ b/core/src/test/java/org/apache/calcite/test/SqlToRelConverterTest.java
@@ -40,18 +40,23 @@
 import org.apache.calcite.rel.rules.CoreRules;
 import org.apache.calcite.rex.RexNode;
 import org.apache.calcite.sql.SqlExplainLevel;
+import org.apache.calcite.sql.fun.SqlLibrary;
 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.sql.validate.SqlDelegatingConformance;
+import org.apache.calcite.test.catalog.MockCatalogReaderExtended;
 import org.apache.calcite.util.Bug;
 import org.apache.calcite.util.TestUtil;
 import org.apache.calcite.util.Util;
 
 import com.google.common.collect.ImmutableList;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.parallel.ResourceLock;
 
 import java.io.PrintWriter;
 import java.io.StringWriter;
@@ -67,14 +72,27 @@
 
 /**
  * Unit test for {@link org.apache.calcite.sql2rel.SqlToRelConverter}.
+ * See {@link RelOptRulesTest} for an explanation of how to add tests;
  */
+@ResourceLock(value = "SqlToRelConverterTest.xml")
 class SqlToRelConverterTest extends SqlToRelTestBase {
 
   private static final SqlToRelFixture LOCAL_FIXTURE =
       SqlToRelFixture.DEFAULT
           .withDiffRepos(DiffRepository.lookup(SqlToRelConverterTest.class));
 
+  @Nullable
+  private static DiffRepository diffRepos = null;
+
+  @AfterAll
+  public static void checkActualAndReferenceFiles() {
+    if (diffRepos != null) {
+      diffRepos.checkActualAndReferenceFiles();
+    }
+  }
+
   @Override public SqlToRelFixture fixture() {
+    diffRepos = LOCAL_FIXTURE.diffRepos();
     return LOCAL_FIXTURE;
   }
 
@@ -88,7 +106,12 @@ class SqlToRelConverterTest extends SqlToRelTestBase {
     sql(sql).ok();
   }
 
-  @Test void testRowValueConstructorWithSubquery() {
+  @Test void testDotAfterParenthesizedIdentifier() {
+    final String sql = "select (home_address).city from emp_address";
+    sql(sql).ok();
+  }
+
+  @Test void testRowValueConstructorWithSubQuery() {
     final String sql = "select ROW("
         + "(select deptno\n"
         + "from dept\n"
@@ -362,6 +385,23 @@ class SqlToRelConverterTest extends SqlToRelTestBase {
         .withConformance(SqlConformanceEnum.LENIENT).ok();
   }
 
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5507">[CALCITE-5507]
+   * HAVING alias failed when aggregate function in condition</a>. */
+  @Test void testAggregateFunAndAliasInHaving1() {
+    sql("select count(empno) as e\n"
+        + "from emp\n"
+        + "having e > 10 and count(empno) > 10")
+        .withConformance(SqlConformanceEnum.LENIENT).ok();
+  }
+
+  @Test void testAggregateFunAndAliasInHaving2() {
+    sql("select count(empno) as e\n"
+        + "from emp\n"
+        + "having e > 10 or count(empno) < 5")
+        .withConformance(SqlConformanceEnum.LENIENT).ok();
+  }
+
   @Test void testGroupJustOneAgg() {
     // just one agg
     final String sql =
@@ -815,6 +855,27 @@ class SqlToRelConverterTest extends SqlToRelTestBase {
     sql(sql).ok();
   }
 
+  /**
+   * Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5468">[CALCITE-5468]
+   * SqlToRelConverter throws if ORDER BY contains IN</a>.
+   */
+  @Test void testOrderByWithIn() {
+    String sql = "SELECT empno\n"
+        + "FROM emp\n"
+        + "ORDER BY\n"
+        + "CASE WHEN empno IN (1,2) THEN 0 ELSE 1 END";
+    sql(sql).ok();
+  }
+
+  @Test void testOrderByWithSubQuery() {
+    String sql = "SELECT empno\n"
+        + "FROM emp\n"
+        + "ORDER BY\n"
+        + "(SELECT empno FROM emp LIMIT 1)";
+    sql(sql).ok();
+  }
+
   @Test void testOrderUnion() {
     final String sql = "select empno, sal from emp\n"
         + "union all\n"
@@ -1288,6 +1349,21 @@ class SqlToRelConverterTest extends SqlToRelTestBase {
         + "from emp e");
   }
 
+  @Test void testCorrelatedScalarSubQueryInSelectList() {
+    Consumer<String> fn = sql -> {
+      sql(sql).withExpand(true).withDecorrelate(false)
+          .convertsTo("${planExpanded}");
+      sql(sql).withExpand(false).withDecorrelate(false)
+          .convertsTo("${planNotExpanded}");
+    };
+    fn.accept("select deptno,\n"
+        + "  (select min(1) from emp where empno > d.deptno) as i0,\n"
+        + "  (select min(0) from emp where deptno = d.deptno "
+        + "                            and ename = 'SMITH'"
+        + "                            and d.deptno > 0) as i1\n"
+        + "from dept as d");
+  }
+
   @Test void testCorrelationLateralSubQuery() {
     String sql = "SELECT deptno, ename\n"
         + "FROM\n"
@@ -1671,7 +1747,8 @@ void checkCorrelatedMapSubQuery(boolean expand) {
   @Test void testUniqueWithExpand() {
     final String sql = "select * from emp\n"
         + "where unique (select 1 from dept where deptno=55)";
-    sql(sql).withExpand(true).throws_("UNIQUE is only supported if expand = false");
+    sql(sql).withExpand(true)
+        .throws_("UNIQUE is only supported if expand = false");
   }
 
   @Test void testUniqueWithProjectLateral() {
@@ -2197,6 +2274,91 @@ void checkCorrelatedMapSubQuery(boolean expand) {
     sql(sql).ok();
   }
 
+  @Test void testTableFunctionWithPartitionKey() {
+    final String sql = "select *\n"
+        + "from table(topn(table orders partition by productid, 3))";
+    sql(sql).ok();
+  }
+
+  @Test void testTableFunctionWithMultiplePartitionKeys() {
+    final String sql = "select *\n"
+        + "from table(topn(table orders partition by (orderId, productid), 3))";
+    sql(sql).ok();
+  }
+
+  @Test void testTableFunctionWithOrderKey() {
+    final String sql = "select *\n"
+        + "from table(topn(table orders order by orderId, 3))";
+    sql(sql).ok();
+  }
+
+  @Test void testTableFunctionWithMultipleOrderKeys() {
+    final String sql = "select *\n"
+        + "from table(topn(table orders order by (orderId, productid), 3))";
+    sql(sql).ok();
+  }
+
+  @Test void testTableFunctionWithComplexOrderBy() {
+    final String sql = "select *\n"
+        + "from table(topn(table orders order by (orderId desc, productid desc nulls last), 3))";
+    sql(sql).ok();
+  }
+
+  @Test void testTableFunctionWithOrderByWithNullLast() {
+    final String sql = "select *\n"
+        + "from table(topn(table orders order by orderId desc nulls last, 3))";
+    sql(sql).ok();
+  }
+
+  @Test void testTableFunctionWithPartitionKeyAndOrderKey() {
+    final String sql = "select *\n"
+        + "from table(topn(table orders partition by productid order by orderId, 3))";
+    sql(sql).ok();
+  }
+
+  @Test void testTableFunctionWithParamNames() {
+    final String sql = "select *\n"
+        + "from table(\n"
+        + "topn(\n"
+        + "  DATA => table orders partition by productid order by orderId,\n"
+        + "  COL => 3))";
+    sql(sql).ok();
+  }
+
+  @Test void testTableFunctionWithSubQuery() {
+    final String sql = "select *\n"
+        + "from table(topn("
+        + "select * from orders partition by productid order by orderId desc nulls last, 3))";
+    sql(sql).ok();
+  }
+
+  @Test void testTableFunctionWithSubQueryWithParamNames() {
+    final String sql = "select *\n"
+        + "from table(\n"
+        + "topn(\n"
+        + "  DATA => select * from orders partition by productid order by orderId nulls first,\n"
+        + "  COL => 3))";
+    sql(sql).ok();
+  }
+
+  @Test void testTableFunctionWithMultipleInputTables() {
+    final String sql = "select *\n"
+        + "from table(\n"
+        + "similarlity(\n"
+        + "  table emp partition by deptno order by empno nulls first,\n"
+        + "  table emp_b partition by deptno order by empno nulls first))";
+    sql(sql).ok();
+  }
+
+  @Test void testTableFunctionWithMultipleInputTablesWithParamNames() {
+    final String sql = "select *\n"
+        + "from table(\n"
+        + "similarlity(\n"
+        + "  LTABLE => table emp partition by deptno order by empno nulls first,\n"
+        + "  RTABLE => table emp_b partition by deptno order by empno nulls first))";
+    sql(sql).ok();
+  }
+
   @Test void testNotNotIn() {
     final String sql = "select * from EMP where not (ename not in ('Fred') )";
     sql(sql).ok();
@@ -2477,6 +2639,15 @@ void checkCorrelatedMapSubQuery(boolean expand) {
     sql(sql).withTrim(true).ok();
   }
 
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5377">[CALCITE-5377]
+   * RelFieldTrimmer support Sort with dynamic param</a>. */
+  @Test void testDynamicParameterSortWithTrim() {
+    final String sql = "select ename from "
+        + "(select * from emp order by sal limit ? offset ?) a";
+    sql(sql).withTrim(true).ok();
+  }
+
   /** Test case for
    * <a href="https://issues.apache.org/jira/browse/CALCITE-3183">[CALCITE-3183]
    * Trimming method for Filter rel uses wrong traitSet</a>. */
@@ -2535,7 +2706,7 @@ void checkCorrelatedMapSubQuery(boolean expand) {
     programBuilder.addRuleInstance(CoreRules.PROJECT_TO_CALC);
     final HepPlanner planner = new HepPlanner(programBuilder.build());
     planner.setRoot(rel);
-    final LogicalCalc calc = (LogicalCalc) planner.findBestExp();
+    final RelNode calc = planner.findBestExp();
     final List<RelNode> rels = new ArrayList<>();
     final RelShuttleImpl visitor = new RelShuttleImpl() {
       @Override public RelNode visit(LogicalCalc calc) {
@@ -2544,14 +2715,14 @@ void checkCorrelatedMapSubQuery(boolean expand) {
         return visitedRel;
       }
     };
-    visitor.visit(calc);
+    calc.accept(visitor);
     assertThat(rels.size(), is(1));
     assertThat(rels.get(0), isA(LogicalCalc.class));
   }
 
   @Test void testRelShuttleForLogicalTableModify() {
     final String sql = "insert into emp select * from emp";
-    final LogicalTableModify rel = (LogicalTableModify) sql(sql).toRel();
+    final RelNode rel = sql(sql).toRel();
     final List<RelNode> rels = new ArrayList<>();
     final RelShuttleImpl visitor = new RelShuttleImpl() {
       @Override public RelNode visit(LogicalTableModify modify) {
@@ -2560,7 +2731,7 @@ void checkCorrelatedMapSubQuery(boolean expand) {
         return visitedRel;
       }
     };
-    visitor.visit(rel);
+    rel.accept(visitor);
     assertThat(rels.size(), is(1));
     assertThat(rels.get(0), isA(LogicalTableModify.class));
   }
@@ -2624,6 +2795,14 @@ void checkCorrelatedMapSubQuery(boolean expand) {
     sql(sql).withExpand(false).ok();
   }
 
+  @Test void testCorrelatedForOuterFields() {
+    final String sql = "SELECT ARRAY(SELECT dept.deptno)\n"
+        + "FROM emp\n"
+        + "LEFT OUTER JOIN dept\n"
+        + "ON emp.empno = dept.deptno";
+    sql(sql).ok();
+  }
+
   /**
    * Test case for
    * <a href="https://issues.apache.org/jira/browse/CALCITE-614">[CALCITE-614]
@@ -3168,6 +3347,109 @@ void checkCorrelatedMapSubQuery(boolean expand) {
     sql(sql).ok();
   }
 
+
+  @Test void testQualifyWithoutReferences() {
+    sql("SELECT empno, ename, deptno\n"
+        + "FROM emp\n"
+        + "QUALIFY ROW_NUMBER() over (partition by ename order by deptno) = 1")
+        .ok();
+  }
+
+  @Test void testQualifyWithoutReferencesAndFilter() {
+    sql("SELECT empno, ename, deptno\n"
+        + "FROM emp\n"
+        + "WHERE deptno > 5\n"
+        + "QUALIFY ROW_NUMBER() over (partition by ename order by deptno) = 1")
+        .ok();
+  }
+
+  @Test void testQualifyWithReferences() {
+    sql("SELECT empno, ename, deptno,\n"
+        + "   ROW_NUMBER() over (partition by ename order by deptno) as row_num\n"
+        + "FROM emp\n"
+        + "QUALIFY row_num = 1")
+        .ok();
+  }
+
+  @Test void testQualifyWithMultipleReferences() {
+    sql("SELECT empno, ename, deptno + 1 as derived_deptno,\n"
+        + "   ROW_NUMBER() over (partition by ename order by deptno) as row_num\n"
+        + "FROM emp\n"
+        + "QUALIFY row_num = derived_deptno")
+        .ok();
+  }
+
+  @Test void testQualifyWithDerivedColumn() {
+    sql("SELECT empno, ename, deptno, SUBSTRING(ename,1,1) as DERIVED_COLUMN "
+        + "FROM emp "
+        + "QUALIFY ROW_NUMBER() OVER (PARTITION BY deptno\n"
+        + "                           ORDER BY DERIVED_COLUMN) = 1")
+        .ok();
+  }
+
+  @Test void testQualifyWithWindowClause() {
+    sql("SELECT empno, ename, SUM(deptno) OVER myWindow as sumDeptNo\n"
+        + "FROM emp\n"
+        + "WINDOW myWindow AS (PARTITION BY ename ORDER BY empno)\n"
+        + "QUALIFY sumDeptNo = 1")
+        .ok();
+  }
+
+  @Test void testQualifyInDdl() {
+    sql("INSERT INTO dept(deptno, name)\n"
+        + "SELECT DISTINCT empno, ename\n"
+        + "FROM emp\n"
+        + "WHERE deptno > 5\n"
+        + "QUALIFY RANK() OVER (PARTITION BY ename\n"
+        + "                     ORDER BY slacker DESC) = 1")
+        .ok();
+  }
+
+  @Test void testQualifyInSubQuery() {
+    sql("SELECT *\n"
+        + "FROM (\n"
+        + " SELECT DISTINCT empno, ename, deptno\n"
+        + " FROM emp\n"
+        + " QUALIFY RANK() OVER (PARTITION BY ename\n"
+        + "                      ORDER BY deptno DESC) = 1)")
+        .ok();
+  }
+
+  @Test void testQualifyWithSubQueryFilter() {
+    sql("SELECT empno, ename, deptno,\n"
+        + "    RANK() OVER (PARTITION BY ename\n"
+        + "                 ORDER BY deptno DESC) as rank_val\n"
+        + "FROM emp\n"
+        + "QUALIFY rank_val = (SELECT COUNT(*) FROM emp)")
+        .ok();
+  }
+
+  @Test void testQualifyWithEverything() {
+    sql("SELECT DISTINCT empno, ename, deptno,\n"
+        + "    RANK() OVER (PARTITION BY ename\n"
+        + "                 ORDER BY deptno DESC) as rank_val\n"
+        + "FROM emp\n"
+        + "WHERE sal > 1000\n"
+        + "QUALIFY rank_val = (SELECT COUNT(*) FROM emp)\n"
+        + "ORDER BY deptno\n"
+        + "LIMIT 5")
+        .ok();
+  }
+
+  @Test void testQualifyInCorrelatedSubQuery() {
+    // The QUALIFY clause is inside a WHERE EXISTS and references columns from
+    // the enclosing query.
+    sql("SELECT *\n"
+        + "FROM emp\n"
+        + "WHERE EXISTS(\n"
+        + " SELECT name\n"
+        + " FROM dept\n"
+        + " QUALIFY RANK() OVER (PARTITION BY name\n"
+        + "                      ORDER BY dept.deptno DESC) = emp.deptno\n"
+        + ")")
+        .ok();
+  }
+
   /** Test case for
    * <a href="https://issues.apache.org/jira/browse/CALCITE-1313">[CALCITE-1313]
    * Validator should derive type of expression in ORDER BY</a>.
@@ -3270,6 +3552,30 @@ void checkCorrelatedMapSubQuery(boolean expand) {
     sql(sql).withDecorrelate(true).ok();
   }
 
+  @Test void testCorrelationInProjectionWithScan() {
+    final String sql = "select array(select e.deptno) from emp e";
+    sql(sql).withExpand(false).withDecorrelate(false).ok();
+  }
+
+  @Test void testCorrelationInProjectionWithProjection() {
+    final String sql = "select array(select e.deptno)\n"
+        + "from (select deptno, ename from emp) e";
+    sql(sql).withExpand(false).withDecorrelate(false).ok();
+  }
+
+  @Test void testMultiCorrelationInProjectionWithProjection() {
+    final String sql = "select cardinality(array(select e.deptno)), array(select e.ename)[0]\n"
+        + "from (select deptno, ename from emp) e";
+    sql(sql).withExpand(false).withDecorrelate(false).ok();
+  }
+
+  @Test void testCorrelationInProjectionWithCorrelatedProjection() {
+    final String sql = "select cardinality(arr) from (\n"
+        + "  select array(select e.deptno) arr from (\n"
+        + "    select deptno, ename from emp) e)";
+    sql(sql).withExpand(false).withDecorrelate(false).ok();
+  }
+
   @Test void testCustomColumnResolving() {
     final String sql = "select k0 from struct.t";
     sql(sql).ok();
@@ -3409,6 +3715,12 @@ void checkCorrelatedMapSubQuery(boolean expand) {
     sql(sql).ok();
   }
 
+  @Test void testNestedStructSingleFieldAccessWhere() {
+    final String sql = "select dn.skill\n"
+        + "from sales.dept_single dn WHERE dn.skill.type = ''";
+    sql(sql).ok();
+  }
+
   @Test void testFunctionWithStructInput() {
     final String sql = "select json_type(skill)\n"
         + "from sales.dept_nested";
@@ -3527,7 +3839,7 @@ void checkCorrelatedMapSubQuery(boolean expand) {
   @Test void testDynamicSchemaUnnest() {
     final String sql = "select t1.c_nationkey, t3.fake_col3\n"
         + "from SALES.CUSTOMER as t1,\n"
-        + "lateral (select t2.\"$unnest\" as fake_col3\n"
+        + "lateral (select t2 as fake_col3\n"
         + "         from unnest(t1.fake_col) as t2) as t3";
     sql(sql).withDynamicTable().ok();
   }
@@ -3535,7 +3847,7 @@ void checkCorrelatedMapSubQuery(boolean expand) {
   @Test void testStarDynamicSchemaUnnest() {
     final String sql = "select *\n"
         + "from SALES.CUSTOMER as t1,\n"
-        + "lateral (select t2.\"$unnest\" as fake_col3\n"
+        + "lateral (select t2 as fake_col3\n"
         + "         from unnest(t1.fake_col) as t2) as t3";
     sql(sql).withDynamicTable().ok();
   }
@@ -3883,15 +4195,31 @@ void checkCorrelatedMapSubQuery(boolean expand) {
    * <a href="https://issues.apache.org/jira/browse/CALCITE-2323">[CALCITE-2323]
    * Validator should allow alternative nullCollations for ORDER BY in
    * OVER</a>. */
-  @Test void testUserDefinedOrderByOver() {
+  @Test void testUserDefinedOrderByOverLow() {
+    checkUserDefinedOrderByOver(NullCollation.LOW);
+  }
+
+  @Test void testUserDefinedOrderByOverHigh() {
+    checkUserDefinedOrderByOver(NullCollation.HIGH);
+  }
+
+  @Test void testUserDefinedOrderByOverFirst() {
+    checkUserDefinedOrderByOver(NullCollation.FIRST);
+  }
+
+  @Test void testUserDefinedOrderByOverLast() {
+    checkUserDefinedOrderByOver(NullCollation.LAST);
+  }
+
+  void checkUserDefinedOrderByOver(NullCollation nullCollation) {
     String sql = "select deptno,\n"
-        + "  rank() over(partition by empno order by deptno)\n"
+        + "  rank() over (partition by empno order by comm desc)\n"
         + "from emp\n"
-        + "order by row_number() over(partition by empno order by deptno)";
+        + "order by row_number() over (partition by empno order by comm)";
     Properties properties = new Properties();
     properties.setProperty(
         CalciteConnectionProperty.DEFAULT_NULL_COLLATION.camelName(),
-        NullCollation.LOW.name());
+        nullCollation.name());
     CalciteConnectionConfigImpl connectionConfig =
         new CalciteConnectionConfigImpl(properties);
     sql(sql)
@@ -4099,6 +4427,32 @@ void checkCorrelatedMapSubQuery(boolean expand) {
     sql(sql).ok();
   }
 
+  @Test void testArgMinFunction() {
+    final String sql = "select arg_min(ename, deptno)\n"
+        + "from emp";
+    sql(sql).withTrim(true).ok();
+  }
+
+  @Test void testArgMinFunctionWithWinAgg() {
+    final String sql = "select job,\n"
+        + "  arg_min(ename, deptno) over (partition by job order by sal)\n"
+        + "from emp";
+    sql(sql).withTrim(true).ok();
+  }
+
+  @Test void testArgMaxFunction() {
+    final String sql = "select arg_max(ename, deptno)\n"
+        + "from emp";
+    sql(sql).withTrim(true).ok();
+  }
+
+  @Test void testArgMaxFunctionWithWinAgg() {
+    final String sql = "select job,\n"
+        + "  arg_max(ename, deptno) over (partition by job order by sal)\n"
+        + "from emp";
+    sql(sql).withTrim(true).ok();
+  }
+
   @Test void testModeFunction() {
     final String sql = "select mode(deptno)\n"
         + "from emp";
@@ -4243,6 +4597,22 @@ void checkCorrelatedMapSubQuery(boolean expand) {
     sql(sql).ok();
   }
 
+  /** Tests a reference to a measure column in an underlying table. The measure
+   * is treated as a black box: it is not expanded, just wrapped in a call to
+   * AGGREGATE. */
+  @Test void testMeasureRef() {
+    final String sql = "select deptno, aggregate(count_plus_100) as c\n"
+        + "from empm\n"
+        + "group by deptno";
+    fixture()
+        .withFactory(c ->
+            c.withOperatorTable(t ->
+                SqlValidatorTest.operatorTableFor(SqlLibrary.CALCITE)))
+        .withCatalogReader(MockCatalogReaderExtended::create)
+        .withSql(sql)
+        .ok();
+  }
+
   /** Test case for:
    * <a href="https://issues.apache.org/jira/browse/CALCITE-3310">[CALCITE-3310]
    * Approximate and exact aggregate calls are recognized as the same
@@ -4493,4 +4863,86 @@ void checkCorrelatedMapSubQuery(boolean expand) {
         .withTrim(false)
         .ok();
   }
+
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5089">[CALCITE-5089]
+   * Allow GROUP BY ALL or DISTINCT set quantifier on GROUPING SETS</a>. */
+  @Test void testGroupByDistinct() {
+    final String sql = "SELECT deptno, job, count(*)\n"
+        + "FROM emp\n"
+        + "GROUP BY DISTINCT\n"
+        + "CUBE (deptno, job),\n"
+        + "ROLLUP (deptno, job)";
+    sql(sql).ok();
+  }
+
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5089">[CALCITE-5089]
+   * Allow GROUP BY ALL or DISTINCT set quantifier on GROUPING SETS</a>. */
+  @Test void testGroupByAll() {
+    final String sql = "SELECT deptno, job, count(*)\n"
+        + "FROM emp\n"
+        + "GROUP BY ALL\n"
+        + "CUBE (deptno, job),\n"
+        + "ROLLUP (deptno, job)";
+    sql(sql).ok();
+  }
+
+  /**
+   * Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5045">[CALCITE-5045]
+   * Alias within GroupingSets throws type mis-match exception</a>.
+   */
+  @Test void testAliasWithinGroupingSets() {
+    final String sql = "SELECT empno / 2 AS x\n"
+        + "FROM emp\n"
+        + "GROUP BY ROLLUP(x)";
+    sql(sql)
+        .withConformance(SqlConformanceEnum.LENIENT)
+        .ok();
+  }
+
+  /**
+   * Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5145">[CALCITE-5145]
+   * CASE statement within GROUPING SETS throws type mis-match exception</a>.
+   */
+  @Test void testCaseAliasWithinGroupingSets() {
+    sql("SELECT empno,\n"
+        + "CASE\n"
+        + "WHEN ename in ('Fred','Eric') THEN 'CEO'\n"
+        + "ELSE 'Other'\n"
+        + "END AS derived_col\n"
+        + "FROM emp\n"
+        + "GROUP BY GROUPING SETS ((empno, derived_col),(empno))")
+        .withConformance(SqlConformanceEnum.LENIENT).ok();
+  }
+
+  /**
+   * Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5145">[CALCITE-5145]
+   * CASE statement within GROUPING SETS throws type mis-match exception</a>.
+   */
+  @Test void testCaseWithinGroupingSets() {
+    String sql = "SELECT empno,\n"
+        + "CASE WHEN ename IN ('Fred','Eric') THEN 'Manager' ELSE 'Other' END\n"
+        + "FROM emp\n"
+        + "GROUP BY GROUPING SETS (\n"
+        + "(empno, CASE WHEN ename IN ('Fred','Eric') THEN 'Manager' ELSE 'Other' END),\n"
+        + "(empno)\n"
+        + ")";
+    sql(sql)
+        .withConformance(SqlConformanceEnum.LENIENT)
+        .ok();
+  }
+
+  /**
+   * Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5297">[CALCITE-5297]
+   * Casting dynamic variable twice throws exception</a>.
+   */
+  @Test void testDynamicParameterDoubleCast() {
+    String sql = "SELECT CAST(CAST(? AS INTEGER) AS CHAR)";
+    sql(sql).ok();
+  }
 }
diff --git a/core/src/test/java/org/apache/calcite/test/SqlValidatorTest.java b/core/src/test/java/org/apache/calcite/test/SqlValidatorTest.java
index a8692e61cfc..2c7f67b4c98 100644
--- a/core/src/test/java/org/apache/calcite/test/SqlValidatorTest.java
+++ b/core/src/test/java/org/apache/calcite/test/SqlValidatorTest.java
@@ -20,16 +20,17 @@
 import org.apache.calcite.avatica.util.Quoting;
 import org.apache.calcite.avatica.util.TimeUnit;
 import org.apache.calcite.config.Lex;
+import org.apache.calcite.rel.type.DelegatingTypeSystem;
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeFactory;
 import org.apache.calcite.rel.type.RelDataTypeSystem;
+import org.apache.calcite.rel.type.TimeFrameSet;
 import org.apache.calcite.runtime.CalciteContextException;
 import org.apache.calcite.sql.SqlCollation;
 import org.apache.calcite.sql.SqlIdentifier;
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.sql.SqlOperator;
 import org.apache.calcite.sql.SqlOperatorTable;
-import org.apache.calcite.sql.SqlSelect;
 import org.apache.calcite.sql.SqlSpecialOperator;
 import org.apache.calcite.sql.fun.SqlLibrary;
 import org.apache.calcite.sql.fun.SqlLibraryOperatorTableFactory;
@@ -41,7 +42,6 @@
 import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.sql.type.SqlTypeUtil;
 import org.apache.calcite.sql.util.SqlShuttle;
-import org.apache.calcite.sql.validate.SelectScope;
 import org.apache.calcite.sql.validate.SqlAbstractConformance;
 import org.apache.calcite.sql.validate.SqlConformance;
 import org.apache.calcite.sql.validate.SqlConformanceEnum;
@@ -50,7 +50,6 @@
 import org.apache.calcite.sql.validate.SqlValidator;
 import org.apache.calcite.sql.validate.SqlValidatorCatalogReader;
 import org.apache.calcite.sql.validate.SqlValidatorImpl;
-import org.apache.calcite.sql.validate.SqlValidatorScope;
 import org.apache.calcite.sql.validate.SqlValidatorUtil;
 import org.apache.calcite.test.catalog.CountingFactory;
 import org.apache.calcite.testlib.annotations.LocaleEnUs;
@@ -58,11 +57,12 @@
 import org.apache.calcite.util.Bug;
 import org.apache.calcite.util.ImmutableBitSet;
 
-import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Ordering;
 
 import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -76,6 +76,7 @@
 import java.util.Locale;
 import java.util.Map;
 import java.util.Objects;
+import java.util.function.BiConsumer;
 import java.util.function.Consumer;
 
 import static org.apache.calcite.test.Matchers.isCharset;
@@ -246,6 +247,37 @@ static SqlOperatorTable operatorTableFor(SqlLibrary library) {
         .columnType("BOOLEAN");
   }
 
+  /** Tests that date-time literals with invalid strings are considered invalid.
+   * Originally the parser did that checking, but now the parser creates a
+   * {@link org.apache.calcite.sql.SqlUnknownLiteral} and the checking is
+   * deferred to the validator. */
+  @Test void testLiteral() {
+    expr("^DATE '12/21/99'^")
+        .fails("(?s).*Illegal DATE literal.*");
+    expr("^TIME '1230:33'^")
+        .fails("(?s).*Illegal TIME literal.*");
+    expr("^TIME '12:00:00 PM'^")
+        .fails("(?s).*Illegal TIME literal.*");
+    expr("^TIMESTAMP '12-21-99, 12:30:00'^")
+        .fails("(?s).*Illegal TIMESTAMP literal.*");
+    expr("^TIMESTAMP WITH LOCAL TIME ZONE '12-21-99, 12:30:00'^")
+        .fails("(?s).*Illegal TIMESTAMP WITH LOCAL TIME ZONE literal.*");
+  }
+
+  /** PostgreSQL and Redshift allow TIMESTAMP literals that contain only a
+   * date part. */
+  @Test void testShortTimestampLiteral() {
+    sql("select timestamp '1969-07-20'")
+        .ok();
+    // PostgreSQL allows the following. We should too.
+    sql("select ^timestamp '1969-07-20 1:2'^")
+        .fails("Illegal TIMESTAMP literal '1969-07-20 1:2': not in format "
+            + "'yyyy-MM-dd HH:mm:ss'"); // PostgreSQL gives 1969-07-20 01:02:00
+    sql("select ^timestamp '1969-07-20:23:'^")
+        .fails("Illegal TIMESTAMP literal '1969-07-20:23:': not in format "
+            + "'yyyy-MM-dd HH:mm:ss'"); // PostgreSQL gives 1969-07-20 23:00:00
+  }
+
   @Test void testBooleans() {
     sql("select TRUE OR unknowN from (values(true))").ok();
     sql("select false AND unknown from (values(true))").ok();
@@ -496,6 +528,12 @@ static SqlOperatorTable operatorTableFor(SqlLibrary library) {
 
     expr("mod(5.1, 3)").ok();
     expr("mod(2,5.1)").ok();
+    expr("5.1 % 3")
+        .withConformance(SqlConformanceEnum.LENIENT)
+        .columnType("DECIMAL(2, 1) NOT NULL");
+    expr("2 % 5.1")
+        .withConformance(SqlConformanceEnum.LENIENT)
+        .columnType("DECIMAL(2, 1) NOT NULL");
     expr("exp(3.67)").ok();
   }
 
@@ -782,10 +820,10 @@ static SqlOperatorTable operatorTableFor(SqlLibrary library) {
         .fails(ANY);
   }
 
-  // FIXME jvs 2-Feb-2005: all collation-related tests are disabled due to
-  // dtbug 280
+  // FIXME jvs 2-Feb-2005:
 
-  public void _testSimpleCollate() {
+  @Disabled("all collation-related tests are disabled due to dtbug 280")
+  void testSimpleCollate() {
     expr("'s' collate latin1$en$1").ok();
     expr("'s' collate latin1$en$1")
         .columnType("CHAR(1)");
@@ -797,19 +835,22 @@ public void _testSimpleCollate() {
             is(SqlCollation.Coercibility.EXPLICIT));
   }
 
-  public void _testCharsetAndCollateMismatch() {
+  @Disabled("all collation-related tests are disabled due to dtbug 280")
+  void testCharsetAndCollateMismatch() {
     // todo
     expr("_UTF16's' collate latin1$en$1")
         .fails("?");
   }
 
-  public void _testDyadicCollateCompare() {
+  @Disabled("all collation-related tests are disabled due to dtbug 280")
+  void testDyadicCollateCompare() {
     expr("'s' collate latin1$en$1 < 't'").ok();
     expr("'t' > 's' collate latin1$en$1").ok();
     expr("'s' collate latin1$en$1 <> 't' collate latin1$en$1").ok();
   }
 
-  public void _testDyadicCompareCollateFails() {
+  @Disabled("all collation-related tests are disabled due to dtbug 280")
+  void testDyadicCompareCollateFails() {
     // two different explicit collations. difference in strength
     expr("'s' collate latin1$en$1 <= 't' collate latin1$en$2")
         .fails("(?s).*Two explicit different collations.*are illegal.*");
@@ -819,7 +860,8 @@ public void _testDyadicCompareCollateFails() {
         .fails("(?s).*Two explicit different collations.*are illegal.*");
   }
 
-  public void _testDyadicCollateOperator() {
+  @Disabled("all collation-related tests are disabled due to dtbug 280")
+  void testDyadicCollateOperator() {
     sql("'a' || 'b'")
         .assertCollation(is("ISO-8859-1$en_US$primary"),
             is(SqlCollation.Coercibility.COERCIBLE));
@@ -900,7 +942,8 @@ public void _testDyadicCollateOperator() {
         .fails("(?s).*not comparable to each other.*");
   }
 
-  public void _testConvertAndTranslate() {
+  @Disabled
+  void testConvertAndTranslate() {
     expr("convert('abc' using conversion)").ok();
     expr("translate('abc' using translation)").ok();
   }
@@ -1042,7 +1085,8 @@ public void _testConvertAndTranslate() {
         .columnType("BOOLEAN NOT NULL");
   }
 
-  public void _testLikeAndSimilarFails() {
+  @Disabled
+  void testLikeAndSimilarFails() {
     expr("'a' like _UTF16'b'  escape 'c'")
         .fails("(?s).*Operands _ISO-8859-1.a. COLLATE ISO-8859-1.en_US.primary,"
             + " _SHIFT_JIS.b..*");
@@ -1564,6 +1608,56 @@ public void _testLikeAndSimilarFails() {
         .fails("No match found for function signature FOO..");
   }
 
+  @Test void testInvalidTableFunction() {
+    // A table function at most have one input table with row semantics
+    sql("select * from table(^invalid(table orders, table emp)^)")
+        .fails("A table function at most has one input table with row semantics."
+            + " Table function 'INVALID' has multiple input tables with row semantics");
+    // Only tables with set semantics may be partitioned
+    sql("select * from table(^score(table orders partition by productid)^)")
+        .fails("Only tables with set semantics may be partitioned."
+            + " Invalid PARTITION BY clause in the 0-th operand of table function 'SCORE'");
+    // Only tables with set semantics may be ordered
+    sql("select * from table(^score(table orders order by orderId)^)")
+        .fails("Only tables with set semantics may be ordered."
+            + " Invalid ORDER BY clause in the 0-th operand of table function 'SCORE'");
+  }
+
+  @Test void testTableFunctionWithTableParam() {
+    // test input table with row semantic
+    sql("select * from table(score(table orders))").ok();
+    // test no partition by clause and order by clause for input table with set semantic
+    sql("select * from table(topn(table orders, 3))").ok();
+    // test one partition key for input table with set semantic
+    sql("select * from table(topn(table orders partition by productid, 3))")
+        .ok();
+    // test multiple partition keys for input table with set semantic
+    sql("select * from table(topn(table orders partition by (orderId, productid), 3))")
+        .ok();
+    // test one order key for input table with set semantic
+    sql("select * from table(topn(table orders order by orderId, 3))")
+        .ok();
+    // test multiple order keys for input table with set semantic
+    sql("select * from table(topn(table orders order by (orderId, productid), 3))")
+        .ok();
+    // test complex order-by clause for input table with set semantic
+    sql("select * from table(topn(table orders order by (orderId desc, productid asc), 3))")
+        .ok();
+    // test partition by clause and order by clause for input table with set semantic
+    sql("select * from table(topn(table orders partition by productid order by orderId, 3))")
+        .ok();
+    // test partition by clause and order by clause for subquery
+    sql("select * from table(topn(select * from Orders partition by productid\n "
+        + "order by orderId, 3))")
+        .ok();
+    // test multiple input tables
+    sql("select * from table(\n"
+        + "similarlity(\n"
+        + "  table emp partition by deptno order by empno,\n"
+        + "  table emp_b partition by deptno order by empno))")
+        .ok();
+  }
+
   @Test void testUnknownFunctionHandling() {
     final SqlValidatorFixture s = fixture().withLenientOperatorLookup(true);
     s.withExpr("concat('a', 2)").ok();
@@ -1707,6 +1801,11 @@ public void _testLikeAndSimilarFails() {
         .fails("(?s).*Incompatible types.*");
   }
 
+  @Test void testDotAfterParenthesizedIdentifier() {
+    sql("select (home_address).city from emp_address")
+        .columnType("VARCHAR(20) NOT NULL");
+  }
+
   @Test void testMultiset() {
     expr("multiset[1]")
         .columnType("INTEGER NOT NULL MULTISET NOT NULL");
@@ -2115,1700 +2214,6 @@ public void _testLikeAndSimilarFails() {
         .assertInterval(is(3_903_123L));
   }
 
-  /**
-   * Runs tests for INTERVAL... YEAR that should pass both parser and
-   * validator. A substantially identical set of tests exists in
-   * SqlParserTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXPositive() tests.
-   */
-  void subTestIntervalYearPositive() {
-    // default precision
-    expr("INTERVAL '1' YEAR")
-        .columnType("INTERVAL YEAR NOT NULL");
-    expr("INTERVAL '99' YEAR")
-        .columnType("INTERVAL YEAR NOT NULL");
-
-    // explicit precision equal to default
-    expr("INTERVAL '1' YEAR(2)")
-        .columnType("INTERVAL YEAR(2) NOT NULL");
-    expr("INTERVAL '99' YEAR(2)")
-        .columnType("INTERVAL YEAR(2) NOT NULL");
-
-    // max precision
-    expr("INTERVAL '2147483647' YEAR(10)")
-        .columnType("INTERVAL YEAR(10) NOT NULL");
-
-    // min precision
-    expr("INTERVAL '0' YEAR(1)")
-        .columnType("INTERVAL YEAR(1) NOT NULL");
-
-    // alternate precision
-    expr("INTERVAL '1234' YEAR(4)")
-        .columnType("INTERVAL YEAR(4) NOT NULL");
-
-    // sign
-    expr("INTERVAL '+1' YEAR")
-        .columnType("INTERVAL YEAR NOT NULL");
-    expr("INTERVAL '-1' YEAR")
-        .columnType("INTERVAL YEAR NOT NULL");
-    expr("INTERVAL +'1' YEAR")
-        .columnType("INTERVAL YEAR NOT NULL");
-    expr("INTERVAL +'+1' YEAR")
-        .columnType("INTERVAL YEAR NOT NULL");
-    expr("INTERVAL +'-1' YEAR")
-        .columnType("INTERVAL YEAR NOT NULL");
-    expr("INTERVAL -'1' YEAR")
-        .columnType("INTERVAL YEAR NOT NULL");
-    expr("INTERVAL -'+1' YEAR")
-        .columnType("INTERVAL YEAR NOT NULL");
-    expr("INTERVAL -'-1' YEAR")
-        .columnType("INTERVAL YEAR NOT NULL");
-  }
-
-  /**
-   * Runs tests for INTERVAL... YEAR TO MONTH that should pass both parser and
-   * validator. A substantially identical set of tests exists in
-   * SqlParserTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXPositive() tests.
-   */
-  void subTestIntervalYearToMonthPositive() {
-    // default precision
-    expr("INTERVAL '1-2' YEAR TO MONTH")
-        .columnType("INTERVAL YEAR TO MONTH NOT NULL");
-    expr("INTERVAL '99-11' YEAR TO MONTH")
-        .columnType("INTERVAL YEAR TO MONTH NOT NULL");
-    expr("INTERVAL '99-0' YEAR TO MONTH")
-        .columnType("INTERVAL YEAR TO MONTH NOT NULL");
-
-    // explicit precision equal to default
-    expr("INTERVAL '1-2' YEAR(2) TO MONTH")
-        .columnType("INTERVAL YEAR(2) TO MONTH NOT NULL");
-    expr("INTERVAL '99-11' YEAR(2) TO MONTH")
-        .columnType("INTERVAL YEAR(2) TO MONTH NOT NULL");
-    expr("INTERVAL '99-0' YEAR(2) TO MONTH")
-        .columnType("INTERVAL YEAR(2) TO MONTH NOT NULL");
-
-    // max precision
-    expr("INTERVAL '2147483647-11' YEAR(10) TO MONTH")
-        .columnType("INTERVAL YEAR(10) TO MONTH NOT NULL");
-
-    // min precision
-    expr("INTERVAL '0-0' YEAR(1) TO MONTH")
-        .columnType("INTERVAL YEAR(1) TO MONTH NOT NULL");
-
-    // alternate precision
-    expr("INTERVAL '2006-2' YEAR(4) TO MONTH")
-        .columnType("INTERVAL YEAR(4) TO MONTH NOT NULL");
-
-    // sign
-    expr("INTERVAL '-1-2' YEAR TO MONTH")
-        .columnType("INTERVAL YEAR TO MONTH NOT NULL");
-    expr("INTERVAL '+1-2' YEAR TO MONTH")
-        .columnType("INTERVAL YEAR TO MONTH NOT NULL");
-    expr("INTERVAL +'1-2' YEAR TO MONTH")
-        .columnType("INTERVAL YEAR TO MONTH NOT NULL");
-    expr("INTERVAL +'-1-2' YEAR TO MONTH")
-        .columnType("INTERVAL YEAR TO MONTH NOT NULL");
-    expr("INTERVAL +'+1-2' YEAR TO MONTH")
-        .columnType("INTERVAL YEAR TO MONTH NOT NULL");
-    expr("INTERVAL -'1-2' YEAR TO MONTH")
-        .columnType("INTERVAL YEAR TO MONTH NOT NULL");
-    expr("INTERVAL -'-1-2' YEAR TO MONTH")
-        .columnType("INTERVAL YEAR TO MONTH NOT NULL");
-    expr("INTERVAL -'+1-2' YEAR TO MONTH")
-        .columnType("INTERVAL YEAR TO MONTH NOT NULL");
-  }
-
-  /**
-   * Runs tests for INTERVAL... MONTH that should pass both parser and
-   * validator. A substantially identical set of tests exists in
-   * SqlParserTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXPositive() tests.
-   */
-  void subTestIntervalMonthPositive() {
-    // default precision
-    expr("INTERVAL '1' MONTH")
-        .columnType("INTERVAL MONTH NOT NULL");
-    expr("INTERVAL '99' MONTH")
-        .columnType("INTERVAL MONTH NOT NULL");
-
-    // explicit precision equal to default
-    expr("INTERVAL '1' MONTH(2)")
-        .columnType("INTERVAL MONTH(2) NOT NULL");
-    expr("INTERVAL '99' MONTH(2)")
-        .columnType("INTERVAL MONTH(2) NOT NULL");
-
-    // max precision
-    expr("INTERVAL '2147483647' MONTH(10)")
-        .columnType("INTERVAL MONTH(10) NOT NULL");
-
-    // min precision
-    expr("INTERVAL '0' MONTH(1)")
-        .columnType("INTERVAL MONTH(1) NOT NULL");
-
-    // alternate precision
-    expr("INTERVAL '1234' MONTH(4)")
-        .columnType("INTERVAL MONTH(4) NOT NULL");
-
-    // sign
-    expr("INTERVAL '+1' MONTH")
-        .columnType("INTERVAL MONTH NOT NULL");
-    expr("INTERVAL '-1' MONTH")
-        .columnType("INTERVAL MONTH NOT NULL");
-    expr("INTERVAL +'1' MONTH")
-        .columnType("INTERVAL MONTH NOT NULL");
-    expr("INTERVAL +'+1' MONTH")
-        .columnType("INTERVAL MONTH NOT NULL");
-    expr("INTERVAL +'-1' MONTH")
-        .columnType("INTERVAL MONTH NOT NULL");
-    expr("INTERVAL -'1' MONTH")
-        .columnType("INTERVAL MONTH NOT NULL");
-    expr("INTERVAL -'+1' MONTH")
-        .columnType("INTERVAL MONTH NOT NULL");
-    expr("INTERVAL -'-1' MONTH")
-        .columnType("INTERVAL MONTH NOT NULL");
-  }
-
-  /**
-   * Runs tests for INTERVAL... DAY that should pass both parser and
-   * validator. A substantially identical set of tests exists in
-   * SqlParserTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXPositive() tests.
-   */
-  void subTestIntervalDayPositive() {
-    // default precision
-    expr("INTERVAL '1' DAY")
-        .columnType("INTERVAL DAY NOT NULL");
-    expr("INTERVAL '99' DAY")
-        .columnType("INTERVAL DAY NOT NULL");
-
-    // explicit precision equal to default
-    expr("INTERVAL '1' DAY(2)")
-        .columnType("INTERVAL DAY(2) NOT NULL");
-    expr("INTERVAL '99' DAY(2)")
-        .columnType("INTERVAL DAY(2) NOT NULL");
-
-    // max precision
-    expr("INTERVAL '2147483647' DAY(10)")
-        .columnType("INTERVAL DAY(10) NOT NULL");
-
-    // min precision
-    expr("INTERVAL '0' DAY(1)")
-        .columnType("INTERVAL DAY(1) NOT NULL");
-
-    // alternate precision
-    expr("INTERVAL '1234' DAY(4)")
-        .columnType("INTERVAL DAY(4) NOT NULL");
-
-    // sign
-    expr("INTERVAL '+1' DAY")
-        .columnType("INTERVAL DAY NOT NULL");
-    expr("INTERVAL '-1' DAY")
-        .columnType("INTERVAL DAY NOT NULL");
-    expr("INTERVAL +'1' DAY")
-        .columnType("INTERVAL DAY NOT NULL");
-    expr("INTERVAL +'+1' DAY")
-        .columnType("INTERVAL DAY NOT NULL");
-    expr("INTERVAL +'-1' DAY")
-        .columnType("INTERVAL DAY NOT NULL");
-    expr("INTERVAL -'1' DAY")
-        .columnType("INTERVAL DAY NOT NULL");
-    expr("INTERVAL -'+1' DAY")
-        .columnType("INTERVAL DAY NOT NULL");
-    expr("INTERVAL -'-1' DAY")
-        .columnType("INTERVAL DAY NOT NULL");
-  }
-
-  void subTestIntervalDayToHourPositive() {
-    // default precision
-    expr("INTERVAL '1 2' DAY TO HOUR")
-        .columnType("INTERVAL DAY TO HOUR NOT NULL");
-    expr("INTERVAL '99 23' DAY TO HOUR")
-        .columnType("INTERVAL DAY TO HOUR NOT NULL");
-    expr("INTERVAL '99 0' DAY TO HOUR")
-        .columnType("INTERVAL DAY TO HOUR NOT NULL");
-
-    // explicit precision equal to default
-    expr("INTERVAL '1 2' DAY(2) TO HOUR")
-        .columnType("INTERVAL DAY(2) TO HOUR NOT NULL");
-    expr("INTERVAL '99 23' DAY(2) TO HOUR")
-        .columnType("INTERVAL DAY(2) TO HOUR NOT NULL");
-    expr("INTERVAL '99 0' DAY(2) TO HOUR")
-        .columnType("INTERVAL DAY(2) TO HOUR NOT NULL");
-
-    // max precision
-    expr("INTERVAL '2147483647 23' DAY(10) TO HOUR")
-        .columnType("INTERVAL DAY(10) TO HOUR NOT NULL");
-
-    // min precision
-    expr("INTERVAL '0 0' DAY(1) TO HOUR")
-        .columnType("INTERVAL DAY(1) TO HOUR NOT NULL");
-
-    // alternate precision
-    expr("INTERVAL '2345 2' DAY(4) TO HOUR")
-        .columnType("INTERVAL DAY(4) TO HOUR NOT NULL");
-
-    // sign
-    expr("INTERVAL '-1 2' DAY TO HOUR")
-        .columnType("INTERVAL DAY TO HOUR NOT NULL");
-    expr("INTERVAL '+1 2' DAY TO HOUR")
-        .columnType("INTERVAL DAY TO HOUR NOT NULL");
-    expr("INTERVAL +'1 2' DAY TO HOUR")
-        .columnType("INTERVAL DAY TO HOUR NOT NULL");
-    expr("INTERVAL +'-1 2' DAY TO HOUR")
-        .columnType("INTERVAL DAY TO HOUR NOT NULL");
-    expr("INTERVAL +'+1 2' DAY TO HOUR")
-        .columnType("INTERVAL DAY TO HOUR NOT NULL");
-    expr("INTERVAL -'1 2' DAY TO HOUR")
-        .columnType("INTERVAL DAY TO HOUR NOT NULL");
-    expr("INTERVAL -'-1 2' DAY TO HOUR")
-        .columnType("INTERVAL DAY TO HOUR NOT NULL");
-    expr("INTERVAL -'+1 2' DAY TO HOUR")
-        .columnType("INTERVAL DAY TO HOUR NOT NULL");
-  }
-
-  /**
-   * Runs tests for INTERVAL... DAY TO MINUTE that should pass both parser and
-   * validator. A substantially identical set of tests exists in
-   * SqlParserTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXPositive() tests.
-   */
-  void subTestIntervalDayToMinutePositive() {
-    // default precision
-    expr("INTERVAL '1 2:3' DAY TO MINUTE")
-        .columnType("INTERVAL DAY TO MINUTE NOT NULL");
-    expr("INTERVAL '99 23:59' DAY TO MINUTE")
-        .columnType("INTERVAL DAY TO MINUTE NOT NULL");
-    expr("INTERVAL '99 0:0' DAY TO MINUTE")
-        .columnType("INTERVAL DAY TO MINUTE NOT NULL");
-
-    // explicit precision equal to default
-    expr("INTERVAL '1 2:3' DAY(2) TO MINUTE")
-        .columnType("INTERVAL DAY(2) TO MINUTE NOT NULL");
-    expr("INTERVAL '99 23:59' DAY(2) TO MINUTE")
-        .columnType("INTERVAL DAY(2) TO MINUTE NOT NULL");
-    expr("INTERVAL '99 0:0' DAY(2) TO MINUTE")
-        .columnType("INTERVAL DAY(2) TO MINUTE NOT NULL");
-
-    // max precision
-    expr("INTERVAL '2147483647 23:59' DAY(10) TO MINUTE")
-        .columnType("INTERVAL DAY(10) TO MINUTE NOT NULL");
-
-    // min precision
-    expr("INTERVAL '0 0:0' DAY(1) TO MINUTE")
-        .columnType("INTERVAL DAY(1) TO MINUTE NOT NULL");
-
-    // alternate precision
-    expr("INTERVAL '2345 6:7' DAY(4) TO MINUTE")
-        .columnType("INTERVAL DAY(4) TO MINUTE NOT NULL");
-
-    // sign
-    expr("INTERVAL '-1 2:3' DAY TO MINUTE")
-        .columnType("INTERVAL DAY TO MINUTE NOT NULL");
-    expr("INTERVAL '+1 2:3' DAY TO MINUTE")
-        .columnType("INTERVAL DAY TO MINUTE NOT NULL");
-    expr("INTERVAL +'1 2:3' DAY TO MINUTE")
-        .columnType("INTERVAL DAY TO MINUTE NOT NULL");
-    expr("INTERVAL +'-1 2:3' DAY TO MINUTE")
-        .columnType("INTERVAL DAY TO MINUTE NOT NULL");
-    expr("INTERVAL +'+1 2:3' DAY TO MINUTE")
-        .columnType("INTERVAL DAY TO MINUTE NOT NULL");
-    expr("INTERVAL -'1 2:3' DAY TO MINUTE")
-        .columnType("INTERVAL DAY TO MINUTE NOT NULL");
-    expr("INTERVAL -'-1 2:3' DAY TO MINUTE")
-        .columnType("INTERVAL DAY TO MINUTE NOT NULL");
-    expr("INTERVAL -'+1 2:3' DAY TO MINUTE")
-        .columnType("INTERVAL DAY TO MINUTE NOT NULL");
-  }
-
-  /**
-   * Runs tests for INTERVAL... DAY TO SECOND that should pass both parser and
-   * validator. A substantially identical set of tests exists in
-   * SqlParserTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXPositive() tests.
-   */
-  void subTestIntervalDayToSecondPositive() {
-    // default precision
-    expr("INTERVAL '1 2:3:4' DAY TO SECOND")
-        .columnType("INTERVAL DAY TO SECOND NOT NULL");
-    expr("INTERVAL '99 23:59:59' DAY TO SECOND")
-        .columnType("INTERVAL DAY TO SECOND NOT NULL");
-    expr("INTERVAL '99 0:0:0' DAY TO SECOND")
-        .columnType("INTERVAL DAY TO SECOND NOT NULL");
-    expr("INTERVAL '99 23:59:59.999999' DAY TO SECOND")
-        .columnType("INTERVAL DAY TO SECOND NOT NULL");
-    expr("INTERVAL '99 0:0:0.0' DAY TO SECOND")
-        .columnType("INTERVAL DAY TO SECOND NOT NULL");
-
-    // explicit precision equal to default
-    expr("INTERVAL '1 2:3:4' DAY(2) TO SECOND")
-        .columnType("INTERVAL DAY(2) TO SECOND NOT NULL");
-    expr("INTERVAL '99 23:59:59' DAY(2) TO SECOND")
-        .columnType("INTERVAL DAY(2) TO SECOND NOT NULL");
-    expr("INTERVAL '99 0:0:0' DAY(2) TO SECOND")
-        .columnType("INTERVAL DAY(2) TO SECOND NOT NULL");
-    expr("INTERVAL '99 23:59:59.999999' DAY TO SECOND(6)")
-        .columnType("INTERVAL DAY TO SECOND(6) NOT NULL");
-    expr("INTERVAL '99 0:0:0.0' DAY TO SECOND(6)")
-        .columnType("INTERVAL DAY TO SECOND(6) NOT NULL");
-
-    // max precision
-    expr("INTERVAL '2147483647 23:59:59' DAY(10) TO SECOND")
-        .columnType("INTERVAL DAY(10) TO SECOND NOT NULL");
-    expr("INTERVAL '2147483647 23:59:59.999999999' DAY(10) TO SECOND(9)")
-        .columnType("INTERVAL DAY(10) TO SECOND(9) NOT NULL");
-
-    // min precision
-    expr("INTERVAL '0 0:0:0' DAY(1) TO SECOND")
-        .columnType("INTERVAL DAY(1) TO SECOND NOT NULL");
-    expr("INTERVAL '0 0:0:0.0' DAY(1) TO SECOND(1)")
-        .columnType("INTERVAL DAY(1) TO SECOND(1) NOT NULL");
-
-    // alternate precision
-    expr("INTERVAL '2345 6:7:8' DAY(4) TO SECOND")
-        .columnType("INTERVAL DAY(4) TO SECOND NOT NULL");
-    expr("INTERVAL '2345 6:7:8.9012' DAY(4) TO SECOND(4)")
-        .columnType("INTERVAL DAY(4) TO SECOND(4) NOT NULL");
-
-    // sign
-    expr("INTERVAL '-1 2:3:4' DAY TO SECOND")
-        .columnType("INTERVAL DAY TO SECOND NOT NULL");
-    expr("INTERVAL '+1 2:3:4' DAY TO SECOND")
-        .columnType("INTERVAL DAY TO SECOND NOT NULL");
-    expr("INTERVAL +'1 2:3:4' DAY TO SECOND")
-        .columnType("INTERVAL DAY TO SECOND NOT NULL");
-    expr("INTERVAL +'-1 2:3:4' DAY TO SECOND")
-        .columnType("INTERVAL DAY TO SECOND NOT NULL");
-    expr("INTERVAL +'+1 2:3:4' DAY TO SECOND")
-        .columnType("INTERVAL DAY TO SECOND NOT NULL");
-    expr("INTERVAL -'1 2:3:4' DAY TO SECOND")
-        .columnType("INTERVAL DAY TO SECOND NOT NULL");
-    expr("INTERVAL -'-1 2:3:4' DAY TO SECOND")
-        .columnType("INTERVAL DAY TO SECOND NOT NULL");
-    expr("INTERVAL -'+1 2:3:4' DAY TO SECOND")
-        .columnType("INTERVAL DAY TO SECOND NOT NULL");
-  }
-
-  /**
-   * Runs tests for INTERVAL... HOUR that should pass both parser and
-   * validator. A substantially identical set of tests exists in
-   * SqlParserTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXPositive() tests.
-   */
-  void subTestIntervalHourPositive() {
-    // default precision
-    expr("INTERVAL '1' HOUR")
-        .columnType("INTERVAL HOUR NOT NULL");
-    expr("INTERVAL '99' HOUR")
-        .columnType("INTERVAL HOUR NOT NULL");
-
-    // explicit precision equal to default
-    expr("INTERVAL '1' HOUR(2)")
-        .columnType("INTERVAL HOUR(2) NOT NULL");
-    expr("INTERVAL '99' HOUR(2)")
-        .columnType("INTERVAL HOUR(2) NOT NULL");
-
-    // max precision
-    expr("INTERVAL '2147483647' HOUR(10)")
-        .columnType("INTERVAL HOUR(10) NOT NULL");
-
-    // min precision
-    expr("INTERVAL '0' HOUR(1)")
-        .columnType("INTERVAL HOUR(1) NOT NULL");
-
-    // alternate precision
-    expr("INTERVAL '1234' HOUR(4)")
-        .columnType("INTERVAL HOUR(4) NOT NULL");
-
-    // sign
-    expr("INTERVAL '+1' HOUR")
-        .columnType("INTERVAL HOUR NOT NULL");
-    expr("INTERVAL '-1' HOUR")
-        .columnType("INTERVAL HOUR NOT NULL");
-    expr("INTERVAL +'1' HOUR")
-        .columnType("INTERVAL HOUR NOT NULL");
-    expr("INTERVAL +'+1' HOUR")
-        .columnType("INTERVAL HOUR NOT NULL");
-    expr("INTERVAL +'-1' HOUR")
-        .columnType("INTERVAL HOUR NOT NULL");
-    expr("INTERVAL -'1' HOUR")
-        .columnType("INTERVAL HOUR NOT NULL");
-    expr("INTERVAL -'+1' HOUR")
-        .columnType("INTERVAL HOUR NOT NULL");
-    expr("INTERVAL -'-1' HOUR")
-        .columnType("INTERVAL HOUR NOT NULL");
-  }
-
-  /**
-   * Runs tests for INTERVAL... HOUR TO MINUTE that should pass both parser
-   * and validator. A substantially identical set of tests exists in
-   * SqlParserTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXPositive() tests.
-   */
-  void subTestIntervalHourToMinutePositive() {
-    // default precision
-    expr("INTERVAL '2:3' HOUR TO MINUTE")
-        .columnType("INTERVAL HOUR TO MINUTE NOT NULL");
-    expr("INTERVAL '23:59' HOUR TO MINUTE")
-        .columnType("INTERVAL HOUR TO MINUTE NOT NULL");
-    expr("INTERVAL '99:0' HOUR TO MINUTE")
-        .columnType("INTERVAL HOUR TO MINUTE NOT NULL");
-
-    // explicit precision equal to default
-    expr("INTERVAL '2:3' HOUR(2) TO MINUTE")
-        .columnType("INTERVAL HOUR(2) TO MINUTE NOT NULL");
-    expr("INTERVAL '23:59' HOUR(2) TO MINUTE")
-        .columnType("INTERVAL HOUR(2) TO MINUTE NOT NULL");
-    expr("INTERVAL '99:0' HOUR(2) TO MINUTE")
-        .columnType("INTERVAL HOUR(2) TO MINUTE NOT NULL");
-
-    // max precision
-    expr("INTERVAL '2147483647:59' HOUR(10) TO MINUTE")
-        .columnType("INTERVAL HOUR(10) TO MINUTE NOT NULL");
-
-    // min precision
-    expr("INTERVAL '0:0' HOUR(1) TO MINUTE")
-        .columnType("INTERVAL HOUR(1) TO MINUTE NOT NULL");
-
-    // alternate precision
-    expr("INTERVAL '2345:7' HOUR(4) TO MINUTE")
-        .columnType("INTERVAL HOUR(4) TO MINUTE NOT NULL");
-
-    // sign
-    expr("INTERVAL '-1:3' HOUR TO MINUTE")
-        .columnType("INTERVAL HOUR TO MINUTE NOT NULL");
-    expr("INTERVAL '+1:3' HOUR TO MINUTE")
-        .columnType("INTERVAL HOUR TO MINUTE NOT NULL");
-    expr("INTERVAL +'2:3' HOUR TO MINUTE")
-        .columnType("INTERVAL HOUR TO MINUTE NOT NULL");
-    expr("INTERVAL +'-2:3' HOUR TO MINUTE")
-        .columnType("INTERVAL HOUR TO MINUTE NOT NULL");
-    expr("INTERVAL +'+2:3' HOUR TO MINUTE")
-        .columnType("INTERVAL HOUR TO MINUTE NOT NULL");
-    expr("INTERVAL -'2:3' HOUR TO MINUTE")
-        .columnType("INTERVAL HOUR TO MINUTE NOT NULL");
-    expr("INTERVAL -'-2:3' HOUR TO MINUTE")
-        .columnType("INTERVAL HOUR TO MINUTE NOT NULL");
-    expr("INTERVAL -'+2:3' HOUR TO MINUTE")
-        .columnType("INTERVAL HOUR TO MINUTE NOT NULL");
-  }
-
-  /**
-   * Runs tests for INTERVAL... HOUR TO SECOND that should pass both parser
-   * and validator. A substantially identical set of tests exists in
-   * SqlParserTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXPositive() tests.
-   */
-  void subTestIntervalHourToSecondPositive() {
-    // default precision
-    expr("INTERVAL '2:3:4' HOUR TO SECOND")
-        .columnType("INTERVAL HOUR TO SECOND NOT NULL");
-    expr("INTERVAL '23:59:59' HOUR TO SECOND")
-        .columnType("INTERVAL HOUR TO SECOND NOT NULL");
-    expr("INTERVAL '99:0:0' HOUR TO SECOND")
-        .columnType("INTERVAL HOUR TO SECOND NOT NULL");
-    expr("INTERVAL '23:59:59.999999' HOUR TO SECOND")
-        .columnType("INTERVAL HOUR TO SECOND NOT NULL");
-    expr("INTERVAL '99:0:0.0' HOUR TO SECOND")
-        .columnType("INTERVAL HOUR TO SECOND NOT NULL");
-
-    // explicit precision equal to default
-    expr("INTERVAL '2:3:4' HOUR(2) TO SECOND")
-        .columnType("INTERVAL HOUR(2) TO SECOND NOT NULL");
-    expr("INTERVAL '99:59:59' HOUR(2) TO SECOND")
-        .columnType("INTERVAL HOUR(2) TO SECOND NOT NULL");
-    expr("INTERVAL '99:0:0' HOUR(2) TO SECOND")
-        .columnType("INTERVAL HOUR(2) TO SECOND NOT NULL");
-    expr("INTERVAL '99:59:59.999999' HOUR TO SECOND(6)")
-        .columnType("INTERVAL HOUR TO SECOND(6) NOT NULL");
-    expr("INTERVAL '99:0:0.0' HOUR TO SECOND(6)")
-        .columnType("INTERVAL HOUR TO SECOND(6) NOT NULL");
-
-    // max precision
-    expr("INTERVAL '2147483647:59:59' HOUR(10) TO SECOND")
-        .columnType("INTERVAL HOUR(10) TO SECOND NOT NULL");
-    expr("INTERVAL '2147483647:59:59.999999999' HOUR(10) TO SECOND(9)")
-        .columnType("INTERVAL HOUR(10) TO SECOND(9) NOT NULL");
-
-    // min precision
-    expr("INTERVAL '0:0:0' HOUR(1) TO SECOND")
-        .columnType("INTERVAL HOUR(1) TO SECOND NOT NULL");
-    expr("INTERVAL '0:0:0.0' HOUR(1) TO SECOND(1)")
-        .columnType("INTERVAL HOUR(1) TO SECOND(1) NOT NULL");
-
-    // alternate precision
-    expr("INTERVAL '2345:7:8' HOUR(4) TO SECOND")
-        .columnType("INTERVAL HOUR(4) TO SECOND NOT NULL");
-    expr("INTERVAL '2345:7:8.9012' HOUR(4) TO SECOND(4)")
-        .columnType("INTERVAL HOUR(4) TO SECOND(4) NOT NULL");
-
-    // sign
-    expr("INTERVAL '-2:3:4' HOUR TO SECOND")
-        .columnType("INTERVAL HOUR TO SECOND NOT NULL");
-    expr("INTERVAL '+2:3:4' HOUR TO SECOND")
-        .columnType("INTERVAL HOUR TO SECOND NOT NULL");
-    expr("INTERVAL +'2:3:4' HOUR TO SECOND")
-        .columnType("INTERVAL HOUR TO SECOND NOT NULL");
-    expr("INTERVAL +'-2:3:4' HOUR TO SECOND")
-        .columnType("INTERVAL HOUR TO SECOND NOT NULL");
-    expr("INTERVAL +'+2:3:4' HOUR TO SECOND")
-        .columnType("INTERVAL HOUR TO SECOND NOT NULL");
-    expr("INTERVAL -'2:3:4' HOUR TO SECOND")
-        .columnType("INTERVAL HOUR TO SECOND NOT NULL");
-    expr("INTERVAL -'-2:3:4' HOUR TO SECOND")
-        .columnType("INTERVAL HOUR TO SECOND NOT NULL");
-    expr("INTERVAL -'+2:3:4' HOUR TO SECOND")
-        .columnType("INTERVAL HOUR TO SECOND NOT NULL");
-  }
-
-  /**
-   * Runs tests for INTERVAL... MINUTE that should pass both parser and
-   * validator. A substantially identical set of tests exists in
-   * SqlParserTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXPositive() tests.
-   */
-  void subTestIntervalMinutePositive() {
-    // default precision
-    expr("INTERVAL '1' MINUTE")
-        .columnType("INTERVAL MINUTE NOT NULL");
-    expr("INTERVAL '99' MINUTE")
-        .columnType("INTERVAL MINUTE NOT NULL");
-
-    // explicit precision equal to default
-    expr("INTERVAL '1' MINUTE(2)")
-        .columnType("INTERVAL MINUTE(2) NOT NULL");
-    expr("INTERVAL '99' MINUTE(2)")
-        .columnType("INTERVAL MINUTE(2) NOT NULL");
-
-    // max precision
-    expr("INTERVAL '2147483647' MINUTE(10)")
-        .columnType("INTERVAL MINUTE(10) NOT NULL");
-
-    // min precision
-    expr("INTERVAL '0' MINUTE(1)")
-        .columnType("INTERVAL MINUTE(1) NOT NULL");
-
-    // alternate precision
-    expr("INTERVAL '1234' MINUTE(4)")
-        .columnType("INTERVAL MINUTE(4) NOT NULL");
-
-    // sign
-    expr("INTERVAL '+1' MINUTE")
-        .columnType("INTERVAL MINUTE NOT NULL");
-    expr("INTERVAL '-1' MINUTE")
-        .columnType("INTERVAL MINUTE NOT NULL");
-    expr("INTERVAL +'1' MINUTE")
-        .columnType("INTERVAL MINUTE NOT NULL");
-    expr("INTERVAL +'+1' MINUTE")
-        .columnType("INTERVAL MINUTE NOT NULL");
-    expr("INTERVAL +'-1' MINUTE")
-        .columnType("INTERVAL MINUTE NOT NULL");
-    expr("INTERVAL -'1' MINUTE")
-        .columnType("INTERVAL MINUTE NOT NULL");
-    expr("INTERVAL -'+1' MINUTE")
-        .columnType("INTERVAL MINUTE NOT NULL");
-    expr("INTERVAL -'-1' MINUTE")
-        .columnType("INTERVAL MINUTE NOT NULL");
-  }
-
-  /**
-   * Runs tests for INTERVAL... MINUTE TO SECOND that should pass both parser
-   * and validator. A substantially identical set of tests exists in
-   * SqlParserTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXPositive() tests.
-   */
-  void subTestIntervalMinuteToSecondPositive() {
-    // default precision
-    expr("INTERVAL '2:4' MINUTE TO SECOND")
-        .columnType("INTERVAL MINUTE TO SECOND NOT NULL");
-    expr("INTERVAL '59:59' MINUTE TO SECOND")
-        .columnType("INTERVAL MINUTE TO SECOND NOT NULL");
-    expr("INTERVAL '99:0' MINUTE TO SECOND")
-        .columnType("INTERVAL MINUTE TO SECOND NOT NULL");
-    expr("INTERVAL '59:59.999999' MINUTE TO SECOND")
-        .columnType("INTERVAL MINUTE TO SECOND NOT NULL");
-    expr("INTERVAL '99:0.0' MINUTE TO SECOND")
-        .columnType("INTERVAL MINUTE TO SECOND NOT NULL");
-
-    // explicit precision equal to default
-    expr("INTERVAL '2:4' MINUTE(2) TO SECOND")
-        .columnType("INTERVAL MINUTE(2) TO SECOND NOT NULL");
-    expr("INTERVAL '99:59' MINUTE(2) TO SECOND")
-        .columnType("INTERVAL MINUTE(2) TO SECOND NOT NULL");
-    expr("INTERVAL '99:0' MINUTE(2) TO SECOND")
-        .columnType("INTERVAL MINUTE(2) TO SECOND NOT NULL");
-    expr("INTERVAL '99:59.999999' MINUTE TO SECOND(6)")
-        .columnType("INTERVAL MINUTE TO SECOND(6) NOT NULL");
-    expr("INTERVAL '99:0.0' MINUTE TO SECOND(6)")
-        .columnType("INTERVAL MINUTE TO SECOND(6) NOT NULL");
-
-    // max precision
-    expr("INTERVAL '2147483647:59' MINUTE(10) TO SECOND")
-        .columnType("INTERVAL MINUTE(10) TO SECOND NOT NULL");
-    expr("INTERVAL '2147483647:59.999999999' MINUTE(10) TO SECOND(9)")
-        .columnType("INTERVAL MINUTE(10) TO SECOND(9) NOT NULL");
-
-    // min precision
-    expr("INTERVAL '0:0' MINUTE(1) TO SECOND")
-        .columnType("INTERVAL MINUTE(1) TO SECOND NOT NULL");
-    expr("INTERVAL '0:0.0' MINUTE(1) TO SECOND(1)")
-        .columnType("INTERVAL MINUTE(1) TO SECOND(1) NOT NULL");
-
-    // alternate precision
-    expr("INTERVAL '2345:8' MINUTE(4) TO SECOND")
-        .columnType("INTERVAL MINUTE(4) TO SECOND NOT NULL");
-    expr("INTERVAL '2345:7.8901' MINUTE(4) TO SECOND(4)")
-        .columnType("INTERVAL MINUTE(4) TO SECOND(4) NOT NULL");
-
-    // sign
-    expr("INTERVAL '-3:4' MINUTE TO SECOND")
-        .columnType("INTERVAL MINUTE TO SECOND NOT NULL");
-    expr("INTERVAL '+3:4' MINUTE TO SECOND")
-        .columnType("INTERVAL MINUTE TO SECOND NOT NULL");
-    expr("INTERVAL +'3:4' MINUTE TO SECOND")
-        .columnType("INTERVAL MINUTE TO SECOND NOT NULL");
-    expr("INTERVAL +'-3:4' MINUTE TO SECOND")
-        .columnType("INTERVAL MINUTE TO SECOND NOT NULL");
-    expr("INTERVAL +'+3:4' MINUTE TO SECOND")
-        .columnType("INTERVAL MINUTE TO SECOND NOT NULL");
-    expr("INTERVAL -'3:4' MINUTE TO SECOND")
-        .columnType("INTERVAL MINUTE TO SECOND NOT NULL");
-    expr("INTERVAL -'-3:4' MINUTE TO SECOND")
-        .columnType("INTERVAL MINUTE TO SECOND NOT NULL");
-    expr("INTERVAL -'+3:4' MINUTE TO SECOND")
-        .columnType("INTERVAL MINUTE TO SECOND NOT NULL");
-  }
-
-  /**
-   * Runs tests for INTERVAL... SECOND that should pass both parser and
-   * validator. A substantially identical set of tests exists in
-   * SqlParserTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXPositive() tests.
-   */
-  void subTestIntervalSecondPositive() {
-    // default precision
-    expr("INTERVAL '1' SECOND")
-        .columnType("INTERVAL SECOND NOT NULL");
-    expr("INTERVAL '99' SECOND")
-        .columnType("INTERVAL SECOND NOT NULL");
-
-    // explicit precision equal to default
-    expr("INTERVAL '1' SECOND(2)")
-        .columnType("INTERVAL SECOND(2) NOT NULL");
-    expr("INTERVAL '99' SECOND(2)")
-        .columnType("INTERVAL SECOND(2) NOT NULL");
-    expr("INTERVAL '1' SECOND(2, 6)")
-        .columnType("INTERVAL SECOND(2, 6) NOT NULL");
-    expr("INTERVAL '99' SECOND(2, 6)")
-        .columnType("INTERVAL SECOND(2, 6) NOT NULL");
-
-    // max precision
-    expr("INTERVAL '2147483647' SECOND(10)")
-        .columnType("INTERVAL SECOND(10) NOT NULL");
-    expr("INTERVAL '2147483647.999999999' SECOND(10, 9)")
-        .columnType("INTERVAL SECOND(10, 9) NOT NULL");
-
-    // min precision
-    expr("INTERVAL '0' SECOND(1)")
-        .columnType("INTERVAL SECOND(1) NOT NULL");
-    expr("INTERVAL '0.0' SECOND(1, 1)")
-        .columnType("INTERVAL SECOND(1, 1) NOT NULL");
-
-    // alternate precision
-    expr("INTERVAL '1234' SECOND(4)")
-        .columnType("INTERVAL SECOND(4) NOT NULL");
-    expr("INTERVAL '1234.56789' SECOND(4, 5)")
-        .columnType("INTERVAL SECOND(4, 5) NOT NULL");
-
-    // sign
-    expr("INTERVAL '+1' SECOND")
-        .columnType("INTERVAL SECOND NOT NULL");
-    expr("INTERVAL '-1' SECOND")
-        .columnType("INTERVAL SECOND NOT NULL");
-    expr("INTERVAL +'1' SECOND")
-        .columnType("INTERVAL SECOND NOT NULL");
-    expr("INTERVAL +'+1' SECOND")
-        .columnType("INTERVAL SECOND NOT NULL");
-    expr("INTERVAL +'-1' SECOND")
-        .columnType("INTERVAL SECOND NOT NULL");
-    expr("INTERVAL -'1' SECOND")
-        .columnType("INTERVAL SECOND NOT NULL");
-    expr("INTERVAL -'+1' SECOND")
-        .columnType("INTERVAL SECOND NOT NULL");
-    expr("INTERVAL -'-1' SECOND")
-        .columnType("INTERVAL SECOND NOT NULL");
-  }
-
-  /**
-   * Runs tests for INTERVAL... YEAR that should pass parser but fail
-   * validator. A substantially identical set of tests exists in
-   * SqlParserTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXNegative() tests.
-   */
-  void subTestIntervalYearNegative() {
-    // Qualifier - field mismatches
-    wholeExpr("INTERVAL '-' YEAR")
-        .fails("Illegal interval literal format '-' for INTERVAL YEAR.*");
-    wholeExpr("INTERVAL '1-2' YEAR")
-        .fails("Illegal interval literal format '1-2' for INTERVAL YEAR.*");
-    wholeExpr("INTERVAL '1.2' YEAR")
-        .fails("Illegal interval literal format '1.2' for INTERVAL YEAR.*");
-    wholeExpr("INTERVAL '1 2' YEAR")
-        .fails("Illegal interval literal format '1 2' for INTERVAL YEAR.*");
-    wholeExpr("INTERVAL '1-2' YEAR(2)")
-        .fails("Illegal interval literal format '1-2' for INTERVAL YEAR\\(2\\)");
-    wholeExpr("INTERVAL 'bogus text' YEAR")
-        .fails("Illegal interval literal format 'bogus text' for INTERVAL YEAR.*");
-
-    // negative field values
-    wholeExpr("INTERVAL '--1' YEAR")
-        .fails("Illegal interval literal format '--1' for INTERVAL YEAR.*");
-
-    // Field value out of range
-    //  (default, explicit default, alt, neg alt, max, neg max)
-    wholeExpr("INTERVAL '100' YEAR")
-        .fails("Interval field value 100 exceeds precision of YEAR\\(2\\) field.*");
-    wholeExpr("INTERVAL '100' YEAR(2)")
-        .fails("Interval field value 100 exceeds precision of YEAR\\(2\\) field.*");
-    wholeExpr("INTERVAL '1000' YEAR(3)")
-        .fails("Interval field value 1,000 exceeds precision of YEAR\\(3\\) field.*");
-    wholeExpr("INTERVAL '-1000' YEAR(3)")
-        .fails("Interval field value -1,000 exceeds precision of YEAR\\(3\\) field.*");
-    wholeExpr("INTERVAL '2147483648' YEAR(10)")
-        .fails("Interval field value 2,147,483,648 exceeds precision of "
-            + "YEAR\\(10\\) field.*");
-    wholeExpr("INTERVAL '-2147483648' YEAR(10)")
-        .fails("Interval field value -2,147,483,648 exceeds precision of "
-            + "YEAR\\(10\\) field");
-
-    // precision > maximum
-    expr("INTERVAL '1' ^YEAR(11)^")
-        .fails("Interval leading field precision '11' out of range for "
-            + "INTERVAL YEAR\\(11\\)");
-
-    // precision < minimum allowed)
-    // note: parser will catch negative values, here we
-    // just need to check for 0
-    expr("INTERVAL '0' ^YEAR(0)^")
-        .fails("Interval leading field precision '0' out of range for "
-            + "INTERVAL YEAR\\(0\\)");
-  }
-
-  /**
-   * Runs tests for INTERVAL... YEAR TO MONTH that should pass parser but fail
-   * validator. A substantially identical set of tests exists in
-   * SqlParserTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXNegative() tests.
-   */
-  void subTestIntervalYearToMonthNegative() {
-    // Qualifier - field mismatches
-    wholeExpr("INTERVAL '-' YEAR TO MONTH")
-        .fails("Illegal interval literal format '-' for INTERVAL YEAR TO MONTH");
-    wholeExpr("INTERVAL '1' YEAR TO MONTH")
-        .fails("Illegal interval literal format '1' for INTERVAL YEAR TO MONTH");
-    wholeExpr("INTERVAL '1:2' YEAR TO MONTH")
-        .fails("Illegal interval literal format '1:2' for INTERVAL YEAR TO MONTH");
-    wholeExpr("INTERVAL '1.2' YEAR TO MONTH")
-        .fails("Illegal interval literal format '1.2' for INTERVAL YEAR TO MONTH");
-    wholeExpr("INTERVAL '1 2' YEAR TO MONTH")
-        .fails("Illegal interval literal format '1 2' for INTERVAL YEAR TO MONTH");
-    wholeExpr("INTERVAL '1:2' YEAR(2) TO MONTH")
-        .fails("Illegal interval literal format '1:2' for "
-            + "INTERVAL YEAR\\(2\\) TO MONTH");
-    wholeExpr("INTERVAL 'bogus text' YEAR TO MONTH")
-        .fails("Illegal interval literal format 'bogus text' for "
-            + "INTERVAL YEAR TO MONTH");
-
-    // negative field values
-    wholeExpr("INTERVAL '--1-2' YEAR TO MONTH")
-        .fails("Illegal interval literal format '--1-2' for "
-            + "INTERVAL YEAR TO MONTH");
-    wholeExpr("INTERVAL '1--2' YEAR TO MONTH")
-        .fails("Illegal interval literal format '1--2' for "
-            + "INTERVAL YEAR TO MONTH");
-
-    // Field value out of range
-    //  (default, explicit default, alt, neg alt, max, neg max)
-    //  plus >max value for mid/end fields
-    wholeExpr("INTERVAL '100-0' YEAR TO MONTH")
-        .fails("Interval field value 100 exceeds precision of YEAR\\(2\\) field.*");
-    wholeExpr("INTERVAL '100-0' YEAR(2) TO MONTH")
-        .fails("Interval field value 100 exceeds precision of YEAR\\(2\\) field.*");
-    wholeExpr("INTERVAL '1000-0' YEAR(3) TO MONTH")
-        .fails("Interval field value 1,000 exceeds precision of YEAR\\(3\\) field.*");
-    wholeExpr("INTERVAL '-1000-0' YEAR(3) TO MONTH")
-        .fails("Interval field value -1,000 exceeds precision of YEAR\\(3\\) field.*");
-    wholeExpr("INTERVAL '2147483648-0' YEAR(10) TO MONTH")
-        .fails("Interval field value 2,147,483,648 exceeds precision of YEAR\\(10\\) field.*");
-    wholeExpr("INTERVAL '-2147483648-0' YEAR(10) TO MONTH")
-        .fails("Interval field value -2,147,483,648 exceeds precision of YEAR\\(10\\) field.*");
-    wholeExpr("INTERVAL '1-12' YEAR TO MONTH")
-        .fails("Illegal interval literal format '1-12' for INTERVAL YEAR TO MONTH.*");
-
-    // precision > maximum
-    expr("INTERVAL '1-1' ^YEAR(11) TO MONTH^")
-        .fails("Interval leading field precision '11' out of range for "
-            + "INTERVAL YEAR\\(11\\) TO MONTH");
-
-    // precision < minimum allowed)
-    // note: parser will catch negative values, here we
-    // just need to check for 0
-    expr("INTERVAL '0-0' ^YEAR(0) TO MONTH^")
-        .fails("Interval leading field precision '0' out of range for "
-            + "INTERVAL YEAR\\(0\\) TO MONTH");
-  }
-
-  /**
-   * Runs tests for INTERVAL... MONTH that should pass parser but fail
-   * validator. A substantially identical set of tests exists in
-   * SqlParserTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXNegative() tests.
-   */
-  void subTestIntervalMonthNegative() {
-    // Qualifier - field mismatches
-    wholeExpr("INTERVAL '-' MONTH")
-        .fails("Illegal interval literal format '-' for INTERVAL MONTH.*");
-    wholeExpr("INTERVAL '1-2' MONTH")
-        .fails("Illegal interval literal format '1-2' for INTERVAL MONTH.*");
-    wholeExpr("INTERVAL '1.2' MONTH")
-        .fails("Illegal interval literal format '1.2' for INTERVAL MONTH.*");
-    wholeExpr("INTERVAL '1 2' MONTH")
-        .fails("Illegal interval literal format '1 2' for INTERVAL MONTH.*");
-    wholeExpr("INTERVAL '1-2' MONTH(2)")
-        .fails("Illegal interval literal format '1-2' for INTERVAL MONTH\\(2\\)");
-    wholeExpr("INTERVAL 'bogus text' MONTH")
-        .fails("Illegal interval literal format 'bogus text' for INTERVAL MONTH.*");
-
-    // negative field values
-    wholeExpr("INTERVAL '--1' MONTH")
-        .fails("Illegal interval literal format '--1' for INTERVAL MONTH.*");
-
-    // Field value out of range
-    //  (default, explicit default, alt, neg alt, max, neg max)
-    wholeExpr("INTERVAL '100' MONTH")
-        .fails("Interval field value 100 exceeds precision of MONTH\\(2\\) field.*");
-    wholeExpr("INTERVAL '100' MONTH(2)")
-        .fails("Interval field value 100 exceeds precision of MONTH\\(2\\) field.*");
-    wholeExpr("INTERVAL '1000' MONTH(3)")
-        .fails("Interval field value 1,000 exceeds precision of MONTH\\(3\\) field.*");
-    wholeExpr("INTERVAL '-1000' MONTH(3)")
-        .fails("Interval field value -1,000 exceeds precision of MONTH\\(3\\) field.*");
-    wholeExpr("INTERVAL '2147483648' MONTH(10)")
-        .fails("Interval field value 2,147,483,648 exceeds precision of MONTH\\(10\\) field.*");
-    wholeExpr("INTERVAL '-2147483648' MONTH(10)")
-        .fails("Interval field value -2,147,483,648 exceeds precision of MONTH\\(10\\) field.*");
-
-    // precision > maximum
-    expr("INTERVAL '1' ^MONTH(11)^")
-        .fails("Interval leading field precision '11' out of range for "
-            + "INTERVAL MONTH\\(11\\)");
-
-    // precision < minimum allowed)
-    // note: parser will catch negative values, here we
-    // just need to check for 0
-    expr("INTERVAL '0' ^MONTH(0)^")
-        .fails("Interval leading field precision '0' out of range for "
-            + "INTERVAL MONTH\\(0\\)");
-  }
-
-  /**
-   * Runs tests for INTERVAL... DAY that should pass parser but fail
-   * validator. A substantially identical set of tests exists in
-   * SqlParserTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXNegative() tests.
-   */
-  void subTestIntervalDayNegative() {
-    // Qualifier - field mismatches
-    wholeExpr("INTERVAL '-' DAY")
-        .fails("Illegal interval literal format '-' for INTERVAL DAY.*");
-    wholeExpr("INTERVAL '1-2' DAY")
-        .fails("Illegal interval literal format '1-2' for INTERVAL DAY.*");
-    wholeExpr("INTERVAL '1.2' DAY")
-        .fails("Illegal interval literal format '1.2' for INTERVAL DAY.*");
-    wholeExpr("INTERVAL '1 2' DAY")
-        .fails("Illegal interval literal format '1 2' for INTERVAL DAY.*");
-    wholeExpr("INTERVAL '1:2' DAY")
-        .fails("Illegal interval literal format '1:2' for INTERVAL DAY.*");
-    wholeExpr("INTERVAL '1-2' DAY(2)")
-        .fails("Illegal interval literal format '1-2' for INTERVAL DAY\\(2\\)");
-    wholeExpr("INTERVAL 'bogus text' DAY")
-        .fails("Illegal interval literal format 'bogus text' for INTERVAL DAY.*");
-
-    // negative field values
-    wholeExpr("INTERVAL '--1' DAY")
-        .fails("Illegal interval literal format '--1' for INTERVAL DAY.*");
-
-    // Field value out of range
-    //  (default, explicit default, alt, neg alt, max, neg max)
-    wholeExpr("INTERVAL '100' DAY")
-        .fails("Interval field value 100 exceeds precision of DAY\\(2\\) field.*");
-    wholeExpr("INTERVAL '100' DAY(2)")
-        .fails("Interval field value 100 exceeds precision of DAY\\(2\\) field.*");
-    wholeExpr("INTERVAL '1000' DAY(3)")
-        .fails("Interval field value 1,000 exceeds precision of DAY\\(3\\) field.*");
-    wholeExpr("INTERVAL '-1000' DAY(3)")
-        .fails("Interval field value -1,000 exceeds precision of DAY\\(3\\) field.*");
-    wholeExpr("INTERVAL '2147483648' DAY(10)")
-        .fails("Interval field value 2,147,483,648 exceeds precision of "
-            + "DAY\\(10\\) field.*");
-    wholeExpr("INTERVAL '-2147483648' DAY(10)")
-        .fails("Interval field value -2,147,483,648 exceeds precision of "
-            + "DAY\\(10\\) field.*");
-
-    // precision > maximum
-    expr("INTERVAL '1' ^DAY(11)^")
-        .fails("Interval leading field precision '11' out of range for "
-            + "INTERVAL DAY\\(11\\)");
-
-    // precision < minimum allowed)
-    // note: parser will catch negative values, here we
-    // just need to check for 0
-    expr("INTERVAL '0' ^DAY(0)^")
-        .fails("Interval leading field precision '0' out of range for "
-            + "INTERVAL DAY\\(0\\)");
-  }
-
-  /**
-   * Runs tests for INTERVAL... DAY TO HOUR that should pass parser but fail
-   * validator. A substantially identical set of tests exists in
-   * SqlParserTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXNegative() tests.
-   */
-  void subTestIntervalDayToHourNegative() {
-    // Qualifier - field mismatches
-    wholeExpr("INTERVAL '-' DAY TO HOUR")
-        .fails("Illegal interval literal format '-' for INTERVAL DAY TO HOUR");
-    wholeExpr("INTERVAL '1' DAY TO HOUR")
-        .fails("Illegal interval literal format '1' for INTERVAL DAY TO HOUR");
-    wholeExpr("INTERVAL '1:2' DAY TO HOUR")
-        .fails("Illegal interval literal format '1:2' for INTERVAL DAY TO HOUR");
-    wholeExpr("INTERVAL '1.2' DAY TO HOUR")
-        .fails("Illegal interval literal format '1.2' for INTERVAL DAY TO HOUR");
-    wholeExpr("INTERVAL '1 x' DAY TO HOUR")
-        .fails("Illegal interval literal format '1 x' for INTERVAL DAY TO HOUR");
-    wholeExpr("INTERVAL ' ' DAY TO HOUR")
-        .fails("Illegal interval literal format ' ' for INTERVAL DAY TO HOUR");
-    wholeExpr("INTERVAL '1:2' DAY(2) TO HOUR")
-        .fails("Illegal interval literal format '1:2' for "
-            + "INTERVAL DAY\\(2\\) TO HOUR");
-    wholeExpr("INTERVAL 'bogus text' DAY TO HOUR")
-        .fails("Illegal interval literal format 'bogus text' for "
-            + "INTERVAL DAY TO HOUR");
-
-    // negative field values
-    wholeExpr("INTERVAL '--1 1' DAY TO HOUR")
-        .fails("Illegal interval literal format '--1 1' for INTERVAL DAY TO HOUR");
-    wholeExpr("INTERVAL '1 -1' DAY TO HOUR")
-        .fails("Illegal interval literal format '1 -1' for INTERVAL DAY TO HOUR");
-
-    // Field value out of range
-    //  (default, explicit default, alt, neg alt, max, neg max)
-    //  plus >max value for mid/end fields
-    wholeExpr("INTERVAL '100 0' DAY TO HOUR")
-        .fails("Interval field value 100 exceeds precision of DAY\\(2\\) field.*");
-    wholeExpr("INTERVAL '100 0' DAY(2) TO HOUR")
-        .fails("Interval field value 100 exceeds precision of DAY\\(2\\) field.*");
-    wholeExpr("INTERVAL '1000 0' DAY(3) TO HOUR")
-        .fails("Interval field value 1,000 exceeds precision of DAY\\(3\\) field.*");
-    wholeExpr("INTERVAL '-1000 0' DAY(3) TO HOUR")
-        .fails("Interval field value -1,000 exceeds precision of DAY\\(3\\) field.*");
-    wholeExpr("INTERVAL '2147483648 0' DAY(10) TO HOUR")
-        .fails("Interval field value 2,147,483,648 exceeds precision of DAY\\(10\\) field.*");
-    wholeExpr("INTERVAL '-2147483648 0' DAY(10) TO HOUR")
-        .fails("Interval field value -2,147,483,648 exceeds precision of "
-            + "DAY\\(10\\) field.*");
-    wholeExpr("INTERVAL '1 24' DAY TO HOUR")
-        .fails("Illegal interval literal format '1 24' for INTERVAL DAY TO HOUR.*");
-
-    // precision > maximum
-    expr("INTERVAL '1 1' ^DAY(11) TO HOUR^")
-        .fails("Interval leading field precision '11' out of range for "
-            + "INTERVAL DAY\\(11\\) TO HOUR");
-
-    // precision < minimum allowed)
-    // note: parser will catch negative values, here we
-    // just need to check for 0
-    expr("INTERVAL '0 0' ^DAY(0) TO HOUR^")
-        .fails("Interval leading field precision '0' out of range for INTERVAL DAY\\(0\\) TO HOUR");
-  }
-
-  /**
-   * Runs tests for INTERVAL... DAY TO MINUTE that should pass parser but fail
-   * validator. A substantially identical set of tests exists in
-   * SqlParserTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXNegative() tests.
-   */
-  void subTestIntervalDayToMinuteNegative() {
-    // Qualifier - field mismatches
-    wholeExpr("INTERVAL ' :' DAY TO MINUTE")
-        .fails("Illegal interval literal format ' :' for INTERVAL DAY TO MINUTE");
-    wholeExpr("INTERVAL '1' DAY TO MINUTE")
-        .fails("Illegal interval literal format '1' for INTERVAL DAY TO MINUTE");
-    wholeExpr("INTERVAL '1 2' DAY TO MINUTE")
-        .fails("Illegal interval literal format '1 2' for INTERVAL DAY TO MINUTE");
-    wholeExpr("INTERVAL '1:2' DAY TO MINUTE")
-        .fails("Illegal interval literal format '1:2' for INTERVAL DAY TO MINUTE");
-    wholeExpr("INTERVAL '1.2' DAY TO MINUTE")
-        .fails("Illegal interval literal format '1.2' for INTERVAL DAY TO MINUTE");
-    wholeExpr("INTERVAL 'x 1:1' DAY TO MINUTE")
-        .fails("Illegal interval literal format 'x 1:1' for INTERVAL DAY TO MINUTE");
-    wholeExpr("INTERVAL '1 x:1' DAY TO MINUTE")
-        .fails("Illegal interval literal format '1 x:1' for INTERVAL DAY TO MINUTE");
-    wholeExpr("INTERVAL '1 1:x' DAY TO MINUTE")
-        .fails("Illegal interval literal format '1 1:x' for INTERVAL DAY TO MINUTE");
-    wholeExpr("INTERVAL '1 1:2:3' DAY TO MINUTE")
-        .fails("Illegal interval literal format '1 1:2:3' for INTERVAL DAY TO MINUTE");
-    wholeExpr("INTERVAL '1 1:1:1.2' DAY TO MINUTE")
-        .fails("Illegal interval literal format '1 1:1:1.2' for INTERVAL DAY TO MINUTE");
-    wholeExpr("INTERVAL '1 1:2:3' DAY(2) TO MINUTE")
-        .fails("Illegal interval literal format '1 1:2:3' for "
-            + "INTERVAL DAY\\(2\\) TO MINUTE");
-    wholeExpr("INTERVAL '1 1' DAY(2) TO MINUTE")
-        .fails("Illegal interval literal format '1 1' for "
-            + "INTERVAL DAY\\(2\\) TO MINUTE");
-    wholeExpr("INTERVAL 'bogus text' DAY TO MINUTE")
-        .fails("Illegal interval literal format 'bogus text' for "
-            + "INTERVAL DAY TO MINUTE");
-
-    // negative field values
-    wholeExpr("INTERVAL '--1 1:1' DAY TO MINUTE")
-        .fails("Illegal interval literal format '--1 1:1' for INTERVAL DAY TO MINUTE");
-    wholeExpr("INTERVAL '1 -1:1' DAY TO MINUTE")
-        .fails("Illegal interval literal format '1 -1:1' for INTERVAL DAY TO MINUTE");
-    wholeExpr("INTERVAL '1 1:-1' DAY TO MINUTE")
-        .fails("Illegal interval literal format '1 1:-1' for INTERVAL DAY TO MINUTE");
-
-    // Field value out of range
-    //  (default, explicit default, alt, neg alt, max, neg max)
-    //  plus >max value for mid/end fields
-    wholeExpr("INTERVAL '100 0:0' DAY TO MINUTE")
-        .fails("Interval field value 100 exceeds precision of DAY\\(2\\) field.*");
-    wholeExpr("INTERVAL '100 0:0' DAY(2) TO MINUTE")
-        .fails("Interval field value 100 exceeds precision of DAY\\(2\\) field.*");
-    wholeExpr("INTERVAL '1000 0:0' DAY(3) TO MINUTE")
-        .fails("Interval field value 1,000 exceeds precision of DAY\\(3\\) field.*");
-    wholeExpr("INTERVAL '-1000 0:0' DAY(3) TO MINUTE")
-        .fails("Interval field value -1,000 exceeds precision of DAY\\(3\\) field.*");
-    wholeExpr("INTERVAL '2147483648 0:0' DAY(10) TO MINUTE")
-        .fails("Interval field value 2,147,483,648 exceeds precision of "
-            + "DAY\\(10\\) field.*");
-    wholeExpr("INTERVAL '-2147483648 0:0' DAY(10) TO MINUTE")
-        .fails("Interval field value -2,147,483,648 exceeds precision of "
-            + "DAY\\(10\\) field.*");
-    wholeExpr("INTERVAL '1 24:1' DAY TO MINUTE")
-        .fails("Illegal interval literal format '1 24:1' for "
-            + "INTERVAL DAY TO MINUTE.*");
-    wholeExpr("INTERVAL '1 1:60' DAY TO MINUTE")
-        .fails("Illegal interval literal format '1 1:60' for INTERVAL DAY TO MINUTE.*");
-
-    // precision > maximum
-    expr("INTERVAL '1 1:1' ^DAY(11) TO MINUTE^")
-        .fails("Interval leading field precision '11' out of range for "
-            + "INTERVAL DAY\\(11\\) TO MINUTE");
-
-    // precision < minimum allowed)
-    // note: parser will catch negative values, here we
-    // just need to check for 0
-    expr("INTERVAL '0 0' ^DAY(0) TO MINUTE^")
-        .fails("Interval leading field precision '0' out of range for "
-            + "INTERVAL DAY\\(0\\) TO MINUTE");
-  }
-
-  /**
-   * Runs tests for INTERVAL... DAY TO SECOND that should pass parser but fail
-   * validator. A substantially identical set of tests exists in
-   * SqlParserTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXNegative() tests.
-   */
-  void subTestIntervalDayToSecondNegative() {
-    // Qualifier - field mismatches
-    wholeExpr("INTERVAL ' ::' DAY TO SECOND")
-        .fails("Illegal interval literal format ' ::' for INTERVAL DAY TO SECOND");
-    wholeExpr("INTERVAL ' ::.' DAY TO SECOND")
-        .fails("Illegal interval literal format ' ::\\.' for INTERVAL DAY TO SECOND");
-    wholeExpr("INTERVAL '1' DAY TO SECOND")
-        .fails("Illegal interval literal format '1' for INTERVAL DAY TO SECOND");
-    wholeExpr("INTERVAL '1 2' DAY TO SECOND")
-        .fails("Illegal interval literal format '1 2' for INTERVAL DAY TO SECOND");
-    wholeExpr("INTERVAL '1:2' DAY TO SECOND")
-        .fails("Illegal interval literal format '1:2' for "
-            + "INTERVAL DAY TO SECOND");
-    wholeExpr("INTERVAL '1.2' DAY TO SECOND")
-        .fails("Illegal interval literal format '1\\.2' for "
-            + "INTERVAL DAY TO SECOND");
-    wholeExpr("INTERVAL '1 1:2' DAY TO SECOND")
-        .fails("Illegal interval literal format '1 1:2' for "
-            + "INTERVAL DAY TO SECOND");
-    wholeExpr("INTERVAL '1 1:2:x' DAY TO SECOND")
-        .fails("Illegal interval literal format '1 1:2:x' for "
-            + "INTERVAL DAY TO SECOND");
-    wholeExpr("INTERVAL '1:2:3' DAY TO SECOND")
-        .fails("Illegal interval literal format '1:2:3' for "
-            + "INTERVAL DAY TO SECOND");
-    wholeExpr("INTERVAL '1:1:1.2' DAY TO SECOND")
-        .fails("Illegal interval literal format '1:1:1\\.2' for "
-            + "INTERVAL DAY TO SECOND");
-    wholeExpr("INTERVAL '1 1:2' DAY(2) TO SECOND")
-        .fails("Illegal interval literal format '1 1:2' for "
-            + "INTERVAL DAY\\(2\\) TO SECOND");
-    wholeExpr("INTERVAL '1 1' DAY(2) TO SECOND")
-        .fails("Illegal interval literal format '1 1' for "
-            + "INTERVAL DAY\\(2\\) TO SECOND");
-    wholeExpr("INTERVAL 'bogus text' DAY TO SECOND")
-        .fails("Illegal interval literal format 'bogus text' for "
-            + "INTERVAL DAY TO SECOND");
-    wholeExpr("INTERVAL '2345 6:7:8901' DAY TO SECOND(4)")
-        .fails("Illegal interval literal format '2345 6:7:8901' for "
-            + "INTERVAL DAY TO SECOND\\(4\\)");
-
-    // negative field values
-    wholeExpr("INTERVAL '--1 1:1:1' DAY TO SECOND")
-        .fails("Illegal interval literal format '--1 1:1:1' for "
-            + "INTERVAL DAY TO SECOND");
-    wholeExpr("INTERVAL '1 -1:1:1' DAY TO SECOND")
-        .fails("Illegal interval literal format '1 -1:1:1' for "
-            + "INTERVAL DAY TO SECOND");
-    wholeExpr("INTERVAL '1 1:-1:1' DAY TO SECOND")
-        .fails("Illegal interval literal format '1 1:-1:1' for "
-            + "INTERVAL DAY TO SECOND");
-    wholeExpr("INTERVAL '1 1:1:-1' DAY TO SECOND")
-        .fails("Illegal interval literal format '1 1:1:-1' for "
-            + "INTERVAL DAY TO SECOND");
-    wholeExpr("INTERVAL '1 1:1:1.-1' DAY TO SECOND")
-        .fails("Illegal interval literal format '1 1:1:1.-1' for "
-            + "INTERVAL DAY TO SECOND");
-
-    // Field value out of range
-    //  (default, explicit default, alt, neg alt, max, neg max)
-    //  plus >max value for mid/end fields
-    wholeExpr("INTERVAL '100 0' DAY TO SECOND")
-        .fails("Illegal interval literal format '100 0' for "
-            + "INTERVAL DAY TO SECOND.*");
-    wholeExpr("INTERVAL '100 0' DAY(2) TO SECOND")
-        .fails("Illegal interval literal format '100 0' for "
-            + "INTERVAL DAY\\(2\\) TO SECOND.*");
-    wholeExpr("INTERVAL '1000 0' DAY(3) TO SECOND")
-        .fails("Illegal interval literal format '1000 0' for "
-            + "INTERVAL DAY\\(3\\) TO SECOND.*");
-    wholeExpr("INTERVAL '-1000 0' DAY(3) TO SECOND")
-        .fails("Illegal interval literal format '-1000 0' for "
-            + "INTERVAL DAY\\(3\\) TO SECOND.*");
-    wholeExpr("INTERVAL '2147483648 1:1:0' DAY(10) TO SECOND")
-        .fails("Interval field value 2,147,483,648 exceeds precision of "
-            + "DAY\\(10\\) field.*");
-    wholeExpr("INTERVAL '-2147483648 1:1:0' DAY(10) TO SECOND")
-        .fails("Interval field value -2,147,483,648 exceeds precision of "
-            + "DAY\\(10\\) field.*");
-    wholeExpr("INTERVAL '2147483648 0' DAY(10) TO SECOND")
-        .fails("Illegal interval literal format '2147483648 0' for "
-            + "INTERVAL DAY\\(10\\) TO SECOND.*");
-    wholeExpr("INTERVAL '-2147483648 0' DAY(10) TO SECOND")
-        .fails("Illegal interval literal format '-2147483648 0' for "
-            + "INTERVAL DAY\\(10\\) TO SECOND.*");
-    wholeExpr("INTERVAL '1 24:1:1' DAY TO SECOND")
-        .fails("Illegal interval literal format '1 24:1:1' for "
-            + "INTERVAL DAY TO SECOND.*");
-    wholeExpr("INTERVAL '1 1:60:1' DAY TO SECOND")
-        .fails("Illegal interval literal format '1 1:60:1' for "
-            + "INTERVAL DAY TO SECOND.*");
-    wholeExpr("INTERVAL '1 1:1:60' DAY TO SECOND")
-        .fails("Illegal interval literal format '1 1:1:60' for "
-            + "INTERVAL DAY TO SECOND.*");
-    wholeExpr("INTERVAL '1 1:1:1.0000001' DAY TO SECOND")
-        .fails("Illegal interval literal format '1 1:1:1\\.0000001' for "
-            + "INTERVAL DAY TO SECOND.*");
-    wholeExpr("INTERVAL '1 1:1:1.0001' DAY TO SECOND(3)")
-        .fails("Illegal interval literal format '1 1:1:1\\.0001' for "
-            + "INTERVAL DAY TO SECOND\\(3\\).*");
-
-    // precision > maximum
-    expr("INTERVAL '1 1' ^DAY(11) TO SECOND^")
-        .fails("Interval leading field precision '11' out of range for "
-            + "INTERVAL DAY\\(11\\) TO SECOND");
-    expr("INTERVAL '1 1' ^DAY TO SECOND(10)^")
-        .fails("Interval fractional second precision '10' out of range for "
-            + "INTERVAL DAY TO SECOND\\(10\\)");
-
-    // precision < minimum allowed)
-    // note: parser will catch negative values, here we
-    // just need to check for 0
-    expr("INTERVAL '0 0:0:0' ^DAY(0) TO SECOND^")
-        .fails("Interval leading field precision '0' out of range for "
-            + "INTERVAL DAY\\(0\\) TO SECOND");
-    expr("INTERVAL '0 0:0:0' ^DAY TO SECOND(0)^")
-        .fails("Interval fractional second precision '0' out of range for "
-            + "INTERVAL DAY TO SECOND\\(0\\)");
-  }
-
-  /**
-   * Runs tests for INTERVAL... HOUR that should pass parser but fail
-   * validator. A substantially identical set of tests exists in
-   * SqlParserTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXNegative() tests.
-   */
-  void subTestIntervalHourNegative() {
-    // Qualifier - field mismatches
-    wholeExpr("INTERVAL '-' HOUR")
-        .fails("Illegal interval literal format '-' for INTERVAL HOUR.*");
-    wholeExpr("INTERVAL '1-2' HOUR")
-        .fails("Illegal interval literal format '1-2' for INTERVAL HOUR.*");
-    wholeExpr("INTERVAL '1.2' HOUR")
-        .fails("Illegal interval literal format '1.2' for INTERVAL HOUR.*");
-    wholeExpr("INTERVAL '1 2' HOUR")
-        .fails("Illegal interval literal format '1 2' for INTERVAL HOUR.*");
-    wholeExpr("INTERVAL '1:2' HOUR")
-        .fails("Illegal interval literal format '1:2' for INTERVAL HOUR.*");
-    wholeExpr("INTERVAL '1-2' HOUR(2)")
-        .fails("Illegal interval literal format '1-2' for INTERVAL HOUR\\(2\\)");
-    wholeExpr("INTERVAL 'bogus text' HOUR")
-        .fails("Illegal interval literal format 'bogus text' for "
-            + "INTERVAL HOUR.*");
-
-    // negative field values
-    wholeExpr("INTERVAL '--1' HOUR")
-        .fails("Illegal interval literal format '--1' for INTERVAL HOUR.*");
-
-    // Field value out of range
-    //  (default, explicit default, alt, neg alt, max, neg max)
-    wholeExpr("INTERVAL '100' HOUR")
-        .fails("Interval field value 100 exceeds precision of "
-            + "HOUR\\(2\\) field.*");
-    wholeExpr("INTERVAL '100' HOUR(2)")
-        .fails("Interval field value 100 exceeds precision of "
-            + "HOUR\\(2\\) field.*");
-    wholeExpr("INTERVAL '1000' HOUR(3)")
-        .fails("Interval field value 1,000 exceeds precision of "
-            + "HOUR\\(3\\) field.*");
-    wholeExpr("INTERVAL '-1000' HOUR(3)")
-        .fails("Interval field value -1,000 exceeds precision of "
-            + "HOUR\\(3\\) field.*");
-    wholeExpr("INTERVAL '2147483648' HOUR(10)")
-        .fails("Interval field value 2,147,483,648 exceeds precision of "
-            + "HOUR\\(10\\) field.*");
-    wholeExpr("INTERVAL '-2147483648' HOUR(10)")
-        .fails("Interval field value -2,147,483,648 exceeds precision of "
-            + "HOUR\\(10\\) field.*");
-
-    // precision > maximum
-    expr("INTERVAL '1' ^HOUR(11)^")
-        .fails("Interval leading field precision '11' out of range for "
-            + "INTERVAL HOUR\\(11\\)");
-
-    // precision < minimum allowed)
-    // note: parser will catch negative values, here we
-    // just need to check for 0
-    expr("INTERVAL '0' ^HOUR(0)^")
-        .fails("Interval leading field precision '0' out of range for "
-            + "INTERVAL HOUR\\(0\\)");
-  }
-
-  /**
-   * Runs tests for INTERVAL... HOUR TO MINUTE that should pass parser but
-   * fail validator. A substantially identical set of tests exists in
-   * SqlParserTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXNegative() tests.
-   */
-  void subTestIntervalHourToMinuteNegative() {
-    // Qualifier - field mismatches
-    wholeExpr("INTERVAL ':' HOUR TO MINUTE")
-        .fails("Illegal interval literal format ':' for INTERVAL HOUR TO MINUTE");
-    wholeExpr("INTERVAL '1' HOUR TO MINUTE")
-        .fails("Illegal interval literal format '1' for INTERVAL HOUR TO MINUTE");
-    wholeExpr("INTERVAL '1:x' HOUR TO MINUTE")
-        .fails("Illegal interval literal format '1:x' for INTERVAL HOUR TO MINUTE");
-    wholeExpr("INTERVAL '1.2' HOUR TO MINUTE")
-        .fails("Illegal interval literal format '1.2' for INTERVAL HOUR TO MINUTE");
-    wholeExpr("INTERVAL '1 2' HOUR TO MINUTE")
-        .fails("Illegal interval literal format '1 2' for INTERVAL HOUR TO MINUTE");
-    wholeExpr("INTERVAL '1:2:3' HOUR TO MINUTE")
-        .fails("Illegal interval literal format '1:2:3' for INTERVAL HOUR TO MINUTE");
-    wholeExpr("INTERVAL '1 2' HOUR(2) TO MINUTE")
-        .fails("Illegal interval literal format '1 2' for "
-            + "INTERVAL HOUR\\(2\\) TO MINUTE");
-    wholeExpr("INTERVAL 'bogus text' HOUR TO MINUTE")
-        .fails("Illegal interval literal format 'bogus text' for "
-            + "INTERVAL HOUR TO MINUTE");
-
-    // negative field values
-    wholeExpr("INTERVAL '--1:1' HOUR TO MINUTE")
-        .fails("Illegal interval literal format '--1:1' for INTERVAL HOUR TO MINUTE");
-    wholeExpr("INTERVAL '1:-1' HOUR TO MINUTE")
-        .fails("Illegal interval literal format '1:-1' for INTERVAL HOUR TO MINUTE");
-
-    // Field value out of range
-    //  (default, explicit default, alt, neg alt, max, neg max)
-    //  plus >max value for mid/end fields
-    wholeExpr("INTERVAL '100:0' HOUR TO MINUTE")
-        .fails("Interval field value 100 exceeds precision of HOUR\\(2\\) field.*");
-    wholeExpr("INTERVAL '100:0' HOUR(2) TO MINUTE")
-        .fails("Interval field value 100 exceeds precision of HOUR\\(2\\) field.*");
-    wholeExpr("INTERVAL '1000:0' HOUR(3) TO MINUTE")
-        .fails("Interval field value 1,000 exceeds precision of HOUR\\(3\\) field.*");
-    wholeExpr("INTERVAL '-1000:0' HOUR(3) TO MINUTE")
-        .fails("Interval field value -1,000 exceeds precision of HOUR\\(3\\) field.*");
-    wholeExpr("INTERVAL '2147483648:0' HOUR(10) TO MINUTE")
-        .fails("Interval field value 2,147,483,648 exceeds precision of HOUR\\(10\\) field.*");
-    wholeExpr("INTERVAL '-2147483648:0' HOUR(10) TO MINUTE")
-        .fails("Interval field value -2,147,483,648 exceeds precision of HOUR\\(10\\) field.*");
-    wholeExpr("INTERVAL '1:60' HOUR TO MINUTE")
-        .fails("Illegal interval literal format '1:60' for INTERVAL HOUR TO MINUTE.*");
-
-    // precision > maximum
-    expr("INTERVAL '1:1' ^HOUR(11) TO MINUTE^")
-        .fails("Interval leading field precision '11' out of range for "
-            + "INTERVAL HOUR\\(11\\) TO MINUTE");
-
-    // precision < minimum allowed)
-    // note: parser will catch negative values, here we
-    // just need to check for 0
-    expr("INTERVAL '0:0' ^HOUR(0) TO MINUTE^")
-        .fails("Interval leading field precision '0' out of range for "
-            + "INTERVAL HOUR\\(0\\) TO MINUTE");
-  }
-
-  /**
-   * Runs tests for INTERVAL... HOUR TO SECOND that should pass parser but
-   * fail validator. A substantially identical set of tests exists in
-   * SqlParserTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXNegative() tests.
-   */
-  void subTestIntervalHourToSecondNegative() {
-    // Qualifier - field mismatches
-    wholeExpr("INTERVAL '::' HOUR TO SECOND")
-        .fails("Illegal interval literal format '::' for INTERVAL HOUR TO SECOND");
-    wholeExpr("INTERVAL '::.' HOUR TO SECOND")
-        .fails("Illegal interval literal format '::\\.' for INTERVAL HOUR TO SECOND");
-    wholeExpr("INTERVAL '1' HOUR TO SECOND")
-        .fails("Illegal interval literal format '1' for INTERVAL HOUR TO SECOND");
-    wholeExpr("INTERVAL '1 2' HOUR TO SECOND")
-        .fails("Illegal interval literal format '1 2' for INTERVAL HOUR TO SECOND");
-    wholeExpr("INTERVAL '1:2' HOUR TO SECOND")
-        .fails("Illegal interval literal format '1:2' for INTERVAL HOUR TO SECOND");
-    wholeExpr("INTERVAL '1.2' HOUR TO SECOND")
-        .fails("Illegal interval literal format '1\\.2' for INTERVAL HOUR TO SECOND");
-    wholeExpr("INTERVAL '1 1:2' HOUR TO SECOND")
-        .fails("Illegal interval literal format '1 1:2' for INTERVAL HOUR TO SECOND");
-    wholeExpr("INTERVAL '1:2:x' HOUR TO SECOND")
-        .fails("Illegal interval literal format '1:2:x' for INTERVAL HOUR TO SECOND");
-    wholeExpr("INTERVAL '1:x:3' HOUR TO SECOND")
-        .fails("Illegal interval literal format '1:x:3' for INTERVAL HOUR TO SECOND");
-    wholeExpr("INTERVAL '1:1:1.x' HOUR TO SECOND")
-        .fails("Illegal interval literal format '1:1:1\\.x' for INTERVAL HOUR TO SECOND");
-    wholeExpr("INTERVAL '1 1:2' HOUR(2) TO SECOND")
-        .fails("Illegal interval literal format '1 1:2' for INTERVAL HOUR\\(2\\) TO SECOND");
-    wholeExpr("INTERVAL '1 1' HOUR(2) TO SECOND")
-        .fails("Illegal interval literal format '1 1' for INTERVAL HOUR\\(2\\) TO SECOND");
-    wholeExpr("INTERVAL 'bogus text' HOUR TO SECOND")
-        .fails("Illegal interval literal format 'bogus text' for INTERVAL HOUR TO SECOND");
-    wholeExpr("INTERVAL '6:7:8901' HOUR TO SECOND(4)")
-        .fails("Illegal interval literal format '6:7:8901' for INTERVAL HOUR TO SECOND\\(4\\)");
-
-    // negative field values
-    wholeExpr("INTERVAL '--1:1:1' HOUR TO SECOND")
-        .fails("Illegal interval literal format '--1:1:1' for INTERVAL HOUR TO SECOND");
-    wholeExpr("INTERVAL '1:-1:1' HOUR TO SECOND")
-        .fails("Illegal interval literal format '1:-1:1' for INTERVAL HOUR TO SECOND");
-    wholeExpr("INTERVAL '1:1:-1' HOUR TO SECOND")
-        .fails("Illegal interval literal format '1:1:-1' for INTERVAL HOUR TO SECOND");
-    wholeExpr("INTERVAL '1:1:1.-1' HOUR TO SECOND")
-        .fails("Illegal interval literal format '1:1:1\\.-1' for INTERVAL HOUR TO SECOND");
-
-    // Field value out of range
-    //  (default, explicit default, alt, neg alt, max, neg max)
-    //  plus >max value for mid/end fields
-    wholeExpr("INTERVAL '100:0:0' HOUR TO SECOND")
-        .fails("Interval field value 100 exceeds precision of "
-            + "HOUR\\(2\\) field.*");
-    wholeExpr("INTERVAL '100:0:0' HOUR(2) TO SECOND")
-        .fails("Interval field value 100 exceeds precision of "
-            + "HOUR\\(2\\) field.*");
-    wholeExpr("INTERVAL '1000:0:0' HOUR(3) TO SECOND")
-        .fails("Interval field value 1,000 exceeds precision of "
-            + "HOUR\\(3\\) field.*");
-    wholeExpr("INTERVAL '-1000:0:0' HOUR(3) TO SECOND")
-        .fails("Interval field value -1,000 exceeds precision of "
-            + "HOUR\\(3\\) field.*");
-    wholeExpr("INTERVAL '2147483648:0:0' HOUR(10) TO SECOND")
-        .fails("Interval field value 2,147,483,648 exceeds precision of "
-            + "HOUR\\(10\\) field.*");
-    wholeExpr("INTERVAL '-2147483648:0:0' HOUR(10) TO SECOND")
-        .fails("Interval field value -2,147,483,648 exceeds precision of "
-            + "HOUR\\(10\\) field.*");
-    wholeExpr("INTERVAL '1:60:1' HOUR TO SECOND")
-        .fails("Illegal interval literal format '1:60:1' for "
-            + "INTERVAL HOUR TO SECOND.*");
-    wholeExpr("INTERVAL '1:1:60' HOUR TO SECOND")
-        .fails("Illegal interval literal format '1:1:60' for "
-            + "INTERVAL HOUR TO SECOND.*");
-    wholeExpr("INTERVAL '1:1:1.0000001' HOUR TO SECOND")
-        .fails("Illegal interval literal format '1:1:1\\.0000001' for "
-            + "INTERVAL HOUR TO SECOND.*");
-    wholeExpr("INTERVAL '1:1:1.0001' HOUR TO SECOND(3)")
-        .fails("Illegal interval literal format '1:1:1\\.0001' for "
-            + "INTERVAL HOUR TO SECOND\\(3\\).*");
-
-    // precision > maximum
-    expr("INTERVAL '1:1:1' ^HOUR(11) TO SECOND^")
-        .fails("Interval leading field precision '11' out of range for "
-            + "INTERVAL HOUR\\(11\\) TO SECOND");
-    expr("INTERVAL '1:1:1' ^HOUR TO SECOND(10)^")
-        .fails("Interval fractional second precision '10' out of range for "
-            + "INTERVAL HOUR TO SECOND\\(10\\)");
-
-    // precision < minimum allowed)
-    // note: parser will catch negative values, here we
-    // just need to check for 0
-    expr("INTERVAL '0:0:0' ^HOUR(0) TO SECOND^")
-        .fails("Interval leading field precision '0' out of range for "
-            + "INTERVAL HOUR\\(0\\) TO SECOND");
-    expr("INTERVAL '0:0:0' ^HOUR TO SECOND(0)^")
-        .fails("Interval fractional second precision '0' out of range for "
-            + "INTERVAL HOUR TO SECOND\\(0\\)");
-  }
-
-  /**
-   * Runs tests for INTERVAL... MINUTE that should pass parser but fail
-   * validator. A substantially identical set of tests exists in
-   * SqlParserTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXNegative() tests.
-   */
-  void subTestIntervalMinuteNegative() {
-    // Qualifier - field mismatches
-    wholeExpr("INTERVAL '-' MINUTE")
-        .fails("Illegal interval literal format '-' for INTERVAL MINUTE.*");
-    wholeExpr("INTERVAL '1-2' MINUTE")
-        .fails("Illegal interval literal format '1-2' for INTERVAL MINUTE.*");
-    wholeExpr("INTERVAL '1.2' MINUTE")
-        .fails("Illegal interval literal format '1.2' for INTERVAL MINUTE.*");
-    wholeExpr("INTERVAL '1 2' MINUTE")
-        .fails("Illegal interval literal format '1 2' for INTERVAL MINUTE.*");
-    wholeExpr("INTERVAL '1:2' MINUTE")
-        .fails("Illegal interval literal format '1:2' for INTERVAL MINUTE.*");
-    wholeExpr("INTERVAL '1-2' MINUTE(2)")
-        .fails("Illegal interval literal format '1-2' for INTERVAL MINUTE\\(2\\)");
-    wholeExpr("INTERVAL 'bogus text' MINUTE")
-        .fails("Illegal interval literal format 'bogus text' for INTERVAL MINUTE.*");
-
-    // negative field values
-    wholeExpr("INTERVAL '--1' MINUTE")
-        .fails("Illegal interval literal format '--1' for INTERVAL MINUTE.*");
-
-    // Field value out of range
-    //  (default, explicit default, alt, neg alt, max, neg max)
-    wholeExpr("INTERVAL '100' MINUTE")
-        .fails("Interval field value 100 exceeds precision of MINUTE\\(2\\) field.*");
-    wholeExpr("INTERVAL '100' MINUTE(2)")
-        .fails("Interval field value 100 exceeds precision of MINUTE\\(2\\) field.*");
-    wholeExpr("INTERVAL '1000' MINUTE(3)")
-        .fails("Interval field value 1,000 exceeds precision of MINUTE\\(3\\) field.*");
-    wholeExpr("INTERVAL '-1000' MINUTE(3)")
-        .fails("Interval field value -1,000 exceeds precision of MINUTE\\(3\\) field.*");
-    wholeExpr("INTERVAL '2147483648' MINUTE(10)")
-        .fails("Interval field value 2,147,483,648 exceeds precision of MINUTE\\(10\\) field.*");
-    wholeExpr("INTERVAL '-2147483648' MINUTE(10)")
-        .fails("Interval field value -2,147,483,648 exceeds precision of MINUTE\\(10\\) field.*");
-
-    // precision > maximum
-    expr("INTERVAL '1' ^MINUTE(11)^")
-        .fails("Interval leading field precision '11' out of range for "
-            + "INTERVAL MINUTE\\(11\\)");
-
-    // precision < minimum allowed)
-    // note: parser will catch negative values, here we
-    // just need to check for 0
-    expr("INTERVAL '0' ^MINUTE(0)^")
-        .fails("Interval leading field precision '0' out of range for "
-            + "INTERVAL MINUTE\\(0\\)");
-  }
-
-  /**
-   * Runs tests for INTERVAL... MINUTE TO SECOND that should pass parser but
-   * fail validator. A substantially identical set of tests exists in
-   * SqlParserTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXNegative() tests.
-   */
-  void subTestIntervalMinuteToSecondNegative() {
-    // Qualifier - field mismatches
-    wholeExpr("INTERVAL ':' MINUTE TO SECOND")
-        .fails("Illegal interval literal format ':' for INTERVAL MINUTE TO SECOND");
-    wholeExpr("INTERVAL ':.' MINUTE TO SECOND")
-        .fails("Illegal interval literal format ':\\.' for INTERVAL MINUTE TO SECOND");
-    wholeExpr("INTERVAL '1' MINUTE TO SECOND")
-        .fails("Illegal interval literal format '1' for INTERVAL MINUTE TO SECOND");
-    wholeExpr("INTERVAL '1 2' MINUTE TO SECOND")
-        .fails("Illegal interval literal format '1 2' for INTERVAL MINUTE TO SECOND");
-    wholeExpr("INTERVAL '1.2' MINUTE TO SECOND")
-        .fails("Illegal interval literal format '1\\.2' for INTERVAL MINUTE TO SECOND");
-    wholeExpr("INTERVAL '1 1:2' MINUTE TO SECOND")
-        .fails("Illegal interval literal format '1 1:2' for INTERVAL MINUTE TO SECOND");
-    wholeExpr("INTERVAL '1:x' MINUTE TO SECOND")
-        .fails("Illegal interval literal format '1:x' for INTERVAL MINUTE TO SECOND");
-    wholeExpr("INTERVAL 'x:3' MINUTE TO SECOND")
-        .fails("Illegal interval literal format 'x:3' for INTERVAL MINUTE TO SECOND");
-    wholeExpr("INTERVAL '1:1.x' MINUTE TO SECOND")
-        .fails("Illegal interval literal format '1:1\\.x' for INTERVAL MINUTE TO SECOND");
-    wholeExpr("INTERVAL '1 1:2' MINUTE(2) TO SECOND")
-        .fails("Illegal interval literal format '1 1:2' for INTERVAL MINUTE\\(2\\) TO SECOND");
-    wholeExpr("INTERVAL '1 1' MINUTE(2) TO SECOND")
-        .fails("Illegal interval literal format '1 1' for INTERVAL MINUTE\\(2\\) TO SECOND");
-    wholeExpr("INTERVAL 'bogus text' MINUTE TO SECOND")
-        .fails("Illegal interval literal format 'bogus text' for INTERVAL MINUTE TO SECOND");
-    wholeExpr("INTERVAL '7:8901' MINUTE TO SECOND(4)")
-        .fails("Illegal interval literal format '7:8901' for INTERVAL MINUTE TO SECOND\\(4\\)");
-
-    // negative field values
-    wholeExpr("INTERVAL '--1:1' MINUTE TO SECOND")
-        .fails("Illegal interval literal format '--1:1' for INTERVAL MINUTE TO SECOND");
-    wholeExpr("INTERVAL '1:-1' MINUTE TO SECOND")
-        .fails("Illegal interval literal format '1:-1' for INTERVAL MINUTE TO SECOND");
-    wholeExpr("INTERVAL '1:1.-1' MINUTE TO SECOND")
-        .fails("Illegal interval literal format '1:1.-1' for INTERVAL MINUTE TO SECOND");
-
-    // Field value out of range
-    //  (default, explicit default, alt, neg alt, max, neg max)
-    //  plus >max value for mid/end fields
-    wholeExpr("INTERVAL '100:0' MINUTE TO SECOND")
-        .fails("Interval field value 100 exceeds precision of MINUTE\\(2\\) field.*");
-    wholeExpr("INTERVAL '100:0' MINUTE(2) TO SECOND")
-        .fails("Interval field value 100 exceeds precision of MINUTE\\(2\\) field.*");
-    wholeExpr("INTERVAL '1000:0' MINUTE(3) TO SECOND")
-        .fails("Interval field value 1,000 exceeds precision of MINUTE\\(3\\) field.*");
-    wholeExpr("INTERVAL '-1000:0' MINUTE(3) TO SECOND")
-        .fails("Interval field value -1,000 exceeds precision of MINUTE\\(3\\) field.*");
-    wholeExpr("INTERVAL '2147483648:0' MINUTE(10) TO SECOND")
-        .fails("Interval field value 2,147,483,648 exceeds precision of MINUTE\\(10\\) field.*");
-    wholeExpr("INTERVAL '-2147483648:0' MINUTE(10) TO SECOND")
-        .fails("Interval field value -2,147,483,648 exceeds precision of MINUTE\\(10\\) field.*");
-    wholeExpr("INTERVAL '1:60' MINUTE TO SECOND")
-        .fails("Illegal interval literal format '1:60' for"
-            + " INTERVAL MINUTE TO SECOND.*");
-    wholeExpr("INTERVAL '1:1.0000001' MINUTE TO SECOND")
-        .fails("Illegal interval literal format '1:1\\.0000001' for"
-            + " INTERVAL MINUTE TO SECOND.*");
-    wholeExpr("INTERVAL '1:1:1.0001' MINUTE TO SECOND(3)")
-        .fails("Illegal interval literal format '1:1:1\\.0001' for"
-            + " INTERVAL MINUTE TO SECOND\\(3\\).*");
-
-    // precision > maximum
-    expr("INTERVAL '1:1' ^MINUTE(11) TO SECOND^")
-        .fails("Interval leading field precision '11' out of range for"
-            + " INTERVAL MINUTE\\(11\\) TO SECOND");
-    expr("INTERVAL '1:1' ^MINUTE TO SECOND(10)^")
-        .fails("Interval fractional second precision '10' out of range for"
-            + " INTERVAL MINUTE TO SECOND\\(10\\)");
-
-    // precision < minimum allowed)
-    // note: parser will catch negative values, here we
-    // just need to check for 0
-    expr("INTERVAL '0:0' ^MINUTE(0) TO SECOND^")
-        .fails("Interval leading field precision '0' out of range for"
-            + " INTERVAL MINUTE\\(0\\) TO SECOND");
-    expr("INTERVAL '0:0' ^MINUTE TO SECOND(0)^")
-        .fails("Interval fractional second precision '0' out of range for"
-            + " INTERVAL MINUTE TO SECOND\\(0\\)");
-  }
-
-  /**
-   * Runs tests for INTERVAL... SECOND that should pass parser but fail
-   * validator. A substantially identical set of tests exists in
-   * SqlParserTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXNegative() tests.
-   */
-  void subTestIntervalSecondNegative() {
-    // Qualifier - field mismatches
-    wholeExpr("INTERVAL ':' SECOND")
-        .fails("Illegal interval literal format ':' for INTERVAL SECOND.*");
-    wholeExpr("INTERVAL '.' SECOND")
-        .fails("Illegal interval literal format '\\.' for INTERVAL SECOND.*");
-    wholeExpr("INTERVAL '1-2' SECOND")
-        .fails("Illegal interval literal format '1-2' for INTERVAL SECOND.*");
-    wholeExpr("INTERVAL '1.x' SECOND")
-        .fails("Illegal interval literal format '1\\.x' for INTERVAL SECOND.*");
-    wholeExpr("INTERVAL 'x.1' SECOND")
-        .fails("Illegal interval literal format 'x\\.1' for INTERVAL SECOND.*");
-    wholeExpr("INTERVAL '1 2' SECOND")
-        .fails("Illegal interval literal format '1 2' for INTERVAL SECOND.*");
-    wholeExpr("INTERVAL '1:2' SECOND")
-        .fails("Illegal interval literal format '1:2' for INTERVAL SECOND.*");
-    wholeExpr("INTERVAL '1-2' SECOND(2)")
-        .fails("Illegal interval literal format '1-2' for INTERVAL SECOND\\(2\\)");
-    wholeExpr("INTERVAL 'bogus text' SECOND")
-        .fails("Illegal interval literal format 'bogus text' for INTERVAL SECOND.*");
-
-    // negative field values
-    wholeExpr("INTERVAL '--1' SECOND")
-        .fails("Illegal interval literal format '--1' for INTERVAL SECOND.*");
-    wholeExpr("INTERVAL '1.-1' SECOND")
-        .fails("Illegal interval literal format '1.-1' for INTERVAL SECOND.*");
-
-    // Field value out of range
-    //  (default, explicit default, alt, neg alt, max, neg max)
-    wholeExpr("INTERVAL '100' SECOND")
-        .fails("Interval field value 100 exceeds precision of SECOND\\(2\\) field.*");
-    wholeExpr("INTERVAL '100' SECOND(2)")
-        .fails("Interval field value 100 exceeds precision of SECOND\\(2\\) field.*");
-    wholeExpr("INTERVAL '1000' SECOND(3)")
-        .fails("Interval field value 1,000 exceeds precision of SECOND\\(3\\) field.*");
-    wholeExpr("INTERVAL '-1000' SECOND(3)")
-        .fails("Interval field value -1,000 exceeds precision of SECOND\\(3\\) field.*");
-    wholeExpr("INTERVAL '2147483648' SECOND(10)")
-        .fails("Interval field value 2,147,483,648 exceeds precision of SECOND\\(10\\) field.*");
-    wholeExpr("INTERVAL '-2147483648' SECOND(10)")
-        .fails("Interval field value -2,147,483,648 exceeds precision of SECOND\\(10\\) field.*");
-    wholeExpr("INTERVAL '1.0000001' SECOND")
-        .fails("Illegal interval literal format '1\\.0000001' for INTERVAL SECOND.*");
-    wholeExpr("INTERVAL '1.0000001' SECOND(2)")
-        .fails("Illegal interval literal format '1\\.0000001' for INTERVAL SECOND\\(2\\).*");
-    wholeExpr("INTERVAL '1.0001' SECOND(2, 3)")
-        .fails("Illegal interval literal format '1\\.0001' for INTERVAL SECOND\\(2, 3\\).*");
-    wholeExpr("INTERVAL '1.0000000001' SECOND(2, 9)")
-        .fails("Illegal interval literal format '1\\.0000000001' for"
-            + " INTERVAL SECOND\\(2, 9\\).*");
-
-    // precision > maximum
-    expr("INTERVAL '1' ^SECOND(11)^")
-        .fails("Interval leading field precision '11' out of range for"
-            + " INTERVAL SECOND\\(11\\)");
-    expr("INTERVAL '1.1' ^SECOND(1, 10)^")
-        .fails("Interval fractional second precision '10' out of range for"
-            + " INTERVAL SECOND\\(1, 10\\)");
-
-    // precision < minimum allowed)
-    // note: parser will catch negative values, here we
-    // just need to check for 0
-    expr("INTERVAL '0' ^SECOND(0)^")
-        .fails("Interval leading field precision '0' out of range for"
-            + " INTERVAL SECOND\\(0\\)");
-    expr("INTERVAL '0' ^SECOND(1, 0)^")
-        .fails("Interval fractional second precision '0' out of range for"
-            + " INTERVAL SECOND\\(1, 0\\)");
-  }
-
   @Test void testDatetimePlusNullInterval() {
     expr("TIME '8:8:8' + cast(NULL AS interval hour)").columnType("TIME(0)");
     expr("TIME '8:8:8' + cast(NULL AS interval YEAR)").columnType("TIME(0)");
@@ -3841,46 +2246,34 @@ void subTestIntervalSecondNegative() {
       assertThat(typeName.getDefaultScale(), is(6));
     }
 
-    // Tests that should pass both parser and validator
-    subTestIntervalYearPositive();
-    subTestIntervalYearToMonthPositive();
-    subTestIntervalMonthPositive();
-    subTestIntervalDayPositive();
-    subTestIntervalDayToHourPositive();
-    subTestIntervalDayToMinutePositive();
-    subTestIntervalDayToSecondPositive();
-    subTestIntervalHourPositive();
-    subTestIntervalHourToMinutePositive();
-    subTestIntervalHourToSecondPositive();
-    subTestIntervalMinutePositive();
-    subTestIntervalMinuteToSecondPositive();
-    subTestIntervalSecondPositive();
-
-    // Tests that should pass parser but fail validator
-    subTestIntervalYearNegative();
-    subTestIntervalYearToMonthNegative();
-    subTestIntervalMonthNegative();
-    subTestIntervalDayNegative();
-    subTestIntervalDayToHourNegative();
-    subTestIntervalDayToMinuteNegative();
-    subTestIntervalDayToSecondNegative();
-    subTestIntervalHourNegative();
-    subTestIntervalHourToMinuteNegative();
-    subTestIntervalHourToSecondNegative();
-    subTestIntervalMinuteNegative();
-    subTestIntervalMinuteToSecondNegative();
-    subTestIntervalSecondNegative();
-
-    // Miscellaneous
-    // fractional value is not OK, even if it is 0
-    wholeExpr("INTERVAL '1.0' HOUR")
-        .fails("Illegal interval literal format '1.0' for INTERVAL HOUR");
-    // only seconds are allowed to have a fractional part
-    expr("INTERVAL '1.0' SECOND")
-        .columnType("INTERVAL SECOND NOT NULL");
-    // leading zeros do not cause precision to be exceeded
-    expr("INTERVAL '0999' MONTH(3)")
-        .columnType("INTERVAL MONTH(3) NOT NULL");
+    final SqlValidatorFixture f = fixture();
+    final IntervalTest.Fixture intervalFixture = new IntervalTest.Fixture() {
+      @Override public IntervalTest.Fixture2 expr(String s) {
+        return getFixture2(f.withExpr(s));
+      }
+
+      @Override public IntervalTest.Fixture2 wholeExpr(String s) {
+        return getFixture2(f.withExpr(s).withWhole(true));
+      }
+
+      private IntervalTest.Fixture2 getFixture2(SqlValidatorFixture f2) {
+        return new IntervalTest.Fixture2() {
+          @Override public void fails(String message) {
+            f2.fails(message);
+          }
+
+          @Override public void columnType(String expectedType) {
+            f2.columnType(expectedType);
+          }
+
+          @Override public IntervalTest.Fixture2 assertParse(String expected) {
+            return this;
+          }
+        };
+      }
+    };
+
+    new IntervalTest(intervalFixture).testAll();
   }
 
   @Test void testIntervalExpression() {
@@ -4023,9 +2416,9 @@ void subTestIntervalSecondNegative() {
         .columnType("INTEGER");
 
     expr("timestampadd(^incorrect^, 1, current_timestamp)")
-        .fails("(?s).*Was expecting one of.*");
+        .fails("'INCORRECT' is not a valid time frame");
     expr("timestampdiff(^incorrect^, current_timestamp, current_timestamp)")
-        .fails("(?s).*Was expecting one of.*");
+        .fails("'INCORRECT' is not a valid time frame");
   }
 
   @Test void testTimestampAddNullInterval() {
@@ -4241,6 +2634,137 @@ void subTestIntervalSecondNegative() {
         .columnType("INTERVAL SECOND NOT NULL");
   }
 
+  /** Tests that EXTRACT, FLOOR, CEIL functions accept abbreviations for
+   * time units (such as "Y" for "YEAR").
+   *
+   * <p>This used to be accomplished via the now deprecated
+   * {@code timeUnitCodes} method in {@link SqlParser.Config}, and is now
+   * accomplished via
+   * {@link RelDataTypeSystem#deriveTimeFrameSet(TimeFrameSet)}. */
+  @Test void testTimeUnitCodes() {
+    final Map<String, TimeUnit> simpleCodes =
+        ImmutableMap.<String, TimeUnit>builder()
+            .put("Y", TimeUnit.YEAR)
+            .put("M", TimeUnit.MONTH)
+            .put("D", TimeUnit.DAY)
+            .put("H", TimeUnit.HOUR)
+            .put("N", TimeUnit.MINUTE)
+            .put("S", TimeUnit.SECOND)
+            .build();
+
+    // Time unit abbreviations for Microsoft SQL Server
+    final Map<String, TimeUnit> mssqlCodes =
+        ImmutableMap.<String, TimeUnit>builder()
+            .put("Y", TimeUnit.YEAR)
+            .put("YY", TimeUnit.YEAR)
+            .put("YYYY", TimeUnit.YEAR)
+            .put("Q", TimeUnit.QUARTER)
+            .put("QQ", TimeUnit.QUARTER)
+            .put("M", TimeUnit.MONTH)
+            .put("MM", TimeUnit.MONTH)
+            .put("W", TimeUnit.WEEK)
+            .put("WK", TimeUnit.WEEK)
+            .put("WW", TimeUnit.WEEK)
+            .put("DY", TimeUnit.DOY)
+            .put("DW", TimeUnit.DOW)
+            .put("D", TimeUnit.DAY)
+            .put("DD", TimeUnit.DAY)
+            .put("H", TimeUnit.HOUR)
+            .put("HH", TimeUnit.HOUR)
+            .put("N", TimeUnit.MINUTE)
+            .put("MI", TimeUnit.MINUTE)
+            .put("S", TimeUnit.SECOND)
+            .put("SS", TimeUnit.SECOND)
+            .put("MS", TimeUnit.MILLISECOND)
+            .build();
+
+    checkTimeUnitCodes(ImmutableMap.of());
+    checkTimeUnitCodes(simpleCodes);
+    checkTimeUnitCodes(mssqlCodes);
+  }
+
+  /** Checks parsing of built-in functions that accept time unit
+   * abbreviations.
+   *
+   * <p>For example, {@code EXTRACT(Y FROM orderDate)} is using
+   * "Y" as an abbreviation for "YEAR".
+   *
+   * <p>Override if your parser supports more such functions. */
+  protected void checkTimeUnitCodes(Map<String, TimeUnit> timeUnitCodes) {
+    SqlValidatorFixture f = fixture()
+        .withFactory(tf ->
+            tf.withTypeSystem(typeSystem ->
+                new DelegatingTypeSystem(typeSystem) {
+                  @Override public TimeFrameSet deriveTimeFrameSet(
+                      TimeFrameSet frameSet) {
+                    TimeFrameSet.Builder b = TimeFrameSet.builder();
+                    b.addAll(frameSet);
+                    timeUnitCodes.forEach((name, unit) ->
+                        b.addAlias(name, unit.name()));
+                    return b.build();
+                  }
+                }));
+    final String ts = "TIMESTAMP '2020-08-27 18:16:43'";
+    BiConsumer<String, TimeUnit> validConsumer = (abbrev, timeUnit) -> {
+      f.withSql("select extract(" + abbrev + " from " + ts + ")").ok();
+      f.withSql("select floor(" + ts + " to " + abbrev + ")").ok();
+      f.withSql("select ceil(" + ts + " to " + abbrev + ")").ok();
+    };
+    BiConsumer<String, TimeUnit> invalidConsumer = (abbrev, timeUnit) -> {
+      final String upAbbrev = abbrev.toUpperCase(Locale.ROOT);
+      String message = "'" + upAbbrev + "' is not a valid time frame";
+      f.withSql("select extract(^" + abbrev + "^ from " + ts + ")")
+          .fails(message);
+      f.withSql("SELECT FLOOR(" + ts + " to ^" + abbrev + "^)")
+          .fails(message);
+      f.withSql("SELECT CEIL(" + ts + " to ^" + abbrev + "^)")
+          .fails(message);
+    };
+
+    // Check that each valid code passes each query that it should.
+    timeUnitCodes.forEach(validConsumer);
+
+    // If "M" is a valid code then "m" should be also.
+    timeUnitCodes.forEach((abbrev, timeUnit) ->
+        validConsumer.accept(abbrev.toLowerCase(Locale.ROOT), timeUnit));
+
+    // Check that invalid codes generate the right error messages.
+    final Map<String, TimeUnit> invalidCodes =
+        ImmutableMap.of("A", TimeUnit.YEAR,
+            "a", TimeUnit.YEAR);
+    invalidCodes.forEach(invalidConsumer);
+  }
+
+  /** Checks parsing of built-in functions that accept time unit
+   *  Checks WEEK(WEEKDAY)
+   * <p>Override if your parser supports more such functions. */
+  @Test void checkWeekdayCustomTimeFrames() {
+    SqlValidatorFixture f = fixture()
+        .withOperatorTable(operatorTableFor(SqlLibrary.BIG_QUERY));
+
+    // Check that each valid code passes each query that it should.
+    final String ds = "DATE '2022-12-25'";
+    Consumer<String> validConsumer = weekday -> {
+      f.withSql("select date_trunc(" + ds + ", " + weekday + ")").ok();
+    };
+    validConsumer.accept("WEEK");
+    validConsumer.accept("WEEK(SUNDAY)");
+    validConsumer.accept("WEEK(MONDAY)");
+    validConsumer.accept("WEEK(TUESDAY)");
+    validConsumer.accept("WEEK(WEDNESDAY)");
+    validConsumer.accept("WEEK(THURSDAY)");
+    validConsumer.accept("WEEK(FRIDAY)");
+    validConsumer.accept("WEEK(SUNDAY)");
+
+    // Check that each invalid code fails each query that it should.
+    Consumer<String> invalidConsumer = weekday -> {
+      String errorMessage = "Column '" + weekday + "' not found in any table";
+      f.withSql("select date_trunc(" + ds + ", ^" + weekday + "^)")
+          .fails(errorMessage);
+    };
+    invalidConsumer.accept("A");
+  }
+
   public void checkWinFuncExpWithWinClause(
       String sql,
       String expectedMsgPattern) {
@@ -4248,7 +2772,8 @@ public void checkWinFuncExpWithWinClause(
   }
 
   // test window partition clause. See SQL 2003 specification for detail
-  public void _testWinPartClause() {
+  @Disabled
+  void testWinPartClause() {
     win("window w as (w2 order by deptno), w2 as (^rang^e 100 preceding)")
         .fails("Referenced window cannot have framing declarations");
     // Test specified collation, window clause syntax rule 4,5.
@@ -4864,7 +3389,7 @@ public void _testWinPartClause() {
     // (partition by sal order by deptno), w2 as (w partition by sal)",
     // null); d) valid because existing window does not have an ORDER BY
     // clause
-    win("window w as (w2 range 2 preceding ), w2 as (order by sal)").ok();
+    win("window w as (w2 range 2 preceding), w2 as (order by sal)").ok();
     win("window w as ^(partition by sal)^, w2 as (w order by deptno)").ok();
     win("window w as (w2 partition by ^sal^), w2 as (order by deptno)")
         .fails("PARTITION BY not allowed with existing window reference");
@@ -5211,6 +3736,96 @@ private void checkNegWindow(String s, String msg) {
         .type("RecordType(CHAR(2) NOT NULL A, INTEGER NOT NULL B) NOT NULL");
   }
 
+  @Test void testMeasureRef() {
+    // A measure can be used in the SELECT clause of a GROUP BY query even
+    // though it is not a GROUP BY key.
+    SqlValidatorFixture f =
+        fixture().withExtendedCatalog()
+            .withOperatorTable(operatorTableFor(SqlLibrary.CALCITE));
+    SqlValidatorFixture f2 =
+        f.withValidatorConfig(c -> c.withNakedMeasures(false));
+
+    final String measureIllegal =
+        "Measure expressions can only occur within AGGREGATE function";
+    final String measureIllegal2 =
+        "Measure expressions can only occur within a GROUP BY query";
+
+    final String sql0 = "select deptno, ^count_plus_100^\n"
+        + "from empm\n"
+        + "group by deptno";
+    f.withSql(sql0)
+        .isAggregate(is(true))
+        .ok();
+
+    // Same SQL is invalid if naked measures are not enabled
+    f2.withSql(sql0).fails(measureIllegal);
+
+    // Similarly, with alias
+    final String sql1b = "select deptno, ^count_plus_100^ as x\n"
+        + "from empm\n"
+        + "group by deptno";
+    f.withSql(sql1b).isAggregate(is(true)).ok();
+    f2.withSql(sql1b).fails(measureIllegal);
+
+    // Similarly, in an expression
+    final String sql1c = "select deptno, deptno + ^count_plus_100^ * 2 as x\n"
+        + "from empm\n"
+        + "group by deptno";
+    f.withSql(sql1c).isAggregate(is(true)).ok();
+    f2.withSql(sql1c).fails(measureIllegal);
+
+    // Similarly, for a query that is an aggregate query because of another
+    // aggregate function.
+    final String sql1 = "select count(*), ^count_plus_100^\n"
+        + "from empm";
+    f.withSql(sql1).isAggregate(is(true)).ok();
+    f2.withSql(sql1).fails(measureIllegal);
+
+    // A measure in a non-aggregate query.
+    // Using a measure should not make it an aggregate query.
+    // The type of the measure should be the result type of the COUNT aggregate
+    // function (BIGINT), not type of the un-aggregated argument type (VARCHAR).
+    final String sql2 = "select deptno, ^count_plus_100^, ename\n"
+        + "from empm";
+    f.withSql(sql2)
+        .type("RecordType(INTEGER NOT NULL DEPTNO, "
+            + "MEASURE<INTEGER NOT NULL> NOT NULL COUNT_PLUS_100, "
+            + "VARCHAR(20) NOT NULL ENAME) NOT NULL")
+        .isAggregate(is(false));
+    f2.withSql(sql2).fails(measureIllegal2);
+
+    // as above, wrapping the measure in AGGREGATE
+    final String sql3 = "select deptno, aggregate(count_plus_100) as x, ename\n"
+        + "from empm\n"
+        + "group by deptno, ename";
+    f.withSql(sql3)
+        .type("RecordType(INTEGER NOT NULL DEPTNO, "
+            + "MEASURE<INTEGER NOT NULL> NOT NULL X, "
+            + "VARCHAR(20) NOT NULL ENAME) NOT NULL");
+
+    // you can apply the AGGREGATE function only to measures
+    f.withSql("select deptno, aggregate(count_plus_100), ^aggregate(ename)^\n"
+            + "from empm\n"
+            + "group by deptno, ename")
+        .fails("Argument to function 'AGGREGATE' must be a measure");
+
+    f.withSql("select deptno, ^aggregate(count_plus_100 + 1)^\n"
+            + "from empm\n"
+            + "group by deptno, ename")
+        .fails("Argument to function 'AGGREGATE' must be a measure");
+
+    // A query with AGGREGATE is an aggregate query, even without GROUP BY,
+    // and even if it is inside an expression.
+    f.withSql("select aggregate(count_plus_100) + 1\n"
+            + "from empm")
+        .isAggregate(is(true));
+
+    // Including a measure in a query does not make it an aggregate query
+    f.withSql("select count_plus_100\n"
+            + "from empm")
+        .isAggregate(is(false));
+  }
+
   @Test void testAmbiguousColumnInIn() {
     // ok: cyclic reference
     sql("select * from emp as e\n"
@@ -6069,7 +4684,7 @@ private ImmutableList<ImmutableBitSet> cube(ImmutableBitSet... sets) {
   @Test void testNaturalJoinIncompatibleDatatype() {
     sql("select *\n"
         + "from (select ename as name, hiredate as deptno from emp)\n"
-        + "natural ^join^\n"
+        + "^natural^ join\n"
         + "(select deptno, name as sal from dept)")
         .fails("Column 'DEPTNO' matched using NATURAL keyword or USING clause "
             + "has incompatible types: "
@@ -6105,9 +4720,116 @@ private ImmutableList<ImmutableBitSet> cube(ImmutableBitSet... sets) {
         .fails("Column 'GENDER' not found in any table");
   }
 
-  @Test void testJoinUsingDupColsFails() {
-    sql("select * from emp left join (select deptno, name as deptno from dept) using (^deptno^)")
-        .fails("Column name 'DEPTNO' in USING clause is not unique on one side of join");
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5171">[CALCITE-5171]
+   * NATURAL join and USING should fail if join columns are not unique</a>. */
+  @Test void testJoinDuplicateColumns() {
+    // NATURAL join and USING should fail if join columns are not unique
+    final String message = "Column name 'DEPTNO' in NATURAL join or "
+        + "USING clause is not unique on one side of join";
+    sql("select e.ename, d.name\n"
+        + "from dept as d\n"
+        + "^natural^ join (select ename, sal as deptno, deptno from emp) as e")
+        .fails(message);
+
+    // A similar query with USING fails with the same error
+    sql("select e.ename, d.name\n"
+        + "from dept as d\n"
+        + "join (select ename, sal as deptno, deptno from emp) as e\n"
+        + "  using (^deptno^)")
+        .fails(message);
+
+    // Reversed query gives reversed error message
+    sql("select e.ename, d.name\n"
+        + "from (select ename, sal as deptno, deptno from emp) as e\n"
+        + "join dept as d\n"
+        + "  using (^deptno^)")
+        .fails(message);
+
+    // Also with "*". (Proves that FROM is validated before SELECT.)
+    sql("select *\n"
+        + "from emp\n"
+        + "left join (select deptno, name as deptno from dept)\n"
+        + "  using (^deptno^)")
+        .fails(message);
+  }
+
+  @Test @DisplayName("Natural join require input column uniqueness")
+  void testNaturalJoinRequireInputColumnUniqueness() {
+    final String message = "Column name 'DEPTNO' in NATURAL join or "
+        + "USING clause is not unique on one side of join";
+    // Invalid. NATURAL JOIN eliminates duplicate columns from its output but
+    // requires input columns to be unique.
+    sql("select *\n"
+        + "from (emp as e cross join dept as d)\n"
+        + "^natural^ join\n"
+        + "(emp as e2 cross join dept as d2)")
+        .fails(message);
+  }
+
+  @Test @DisplayName("Should produce two DEPTNO columns")
+  void testReturnsCorrectRowTypeOnCombinedJoin() {
+    sql("select *\n"
+        + "from emp as e\n"
+        + "natural join dept as d\n"
+        + "join (select deptno as x, deptno from dept) as d2"
+        + "  on d2.deptno = e.deptno")
+        .type("RecordType("
+            + "INTEGER NOT NULL DEPTNO, "
+            + "INTEGER NOT NULL EMPNO, "
+            + "VARCHAR(20) NOT NULL ENAME, "
+            + "VARCHAR(10) NOT NULL JOB, "
+            + "INTEGER MGR, "
+            + "TIMESTAMP(0) NOT NULL HIREDATE, "
+            + "INTEGER NOT NULL SAL, "
+            + "INTEGER NOT NULL COMM, "
+            + "BOOLEAN NOT NULL SLACKER, "
+            + "VARCHAR(10) NOT NULL NAME, "
+            + "INTEGER NOT NULL X, "
+            + "INTEGER NOT NULL DEPTNO1) NOT NULL");
+  }
+
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5171">[CALCITE-5171]
+   * NATURAL join and USING should fail if join columns are not unique</a>. */
+  @Test void testCorrectJoinDuplicateColumns() {
+    // The error only occurs if the duplicate column is referenced. The
+    // following query has a duplicate hiredate column.
+    sql("select e.ename, d.name\n"
+        + "from dept as d\n"
+        + "join (select ename, sal as hiredate, deptno from emp) as e\n"
+        + "  using (deptno)")
+        .ok();
+
+    // Previous join chain does not affect validation.
+    sql("select * from EMP natural join EMPNULLABLES natural join DEPT")
+        .ok();
+  }
+
+  @Test void testNaturalEmptyKey() {
+    // If there are no columns in common, natural join is empty, and that's OK.
+    sql("select *\n"
+        + "from (select ename from emp) as e\n"
+        + "natural join dept as d")
+        .type("RecordType("
+            + "VARCHAR(20) NOT NULL ENAME, "
+            + "INTEGER NOT NULL DEPTNO, "
+            + "VARCHAR(10) NOT NULL NAME) NOT NULL");
+
+    // If there are duplicates on one side, that's OK, because the empty natural
+    // join prevents us from checking.
+    sql("select d.*\n"
+        + "from (select ename, sal as ename from emp) as e\n"
+        + "natural join dept as d")
+        .type("RecordType("
+            + "INTEGER NOT NULL DEPTNO, "
+            + "VARCHAR(10) NOT NULL NAME) NOT NULL");
+    // Cannot expand star if it contains duplicate columns.
+    // (Postgres thinks this query is OK.)
+    sql("select ^e.*^\n"
+        + "from (select ename, sal as ename from emp) as e\n"
+        + "natural join dept as d")
+        .fails("Column 'ENAME' is ambiguous");
   }
 
   @Test void testJoinRowType() {
@@ -6151,25 +4873,24 @@ private ImmutableList<ImmutableBitSet> cube(ImmutableBitSet... sets) {
             + " VARCHAR(10) NAME) NOT NULL");
   }
 
-  // todo: Cannot handle '(a join b)' yet -- we see the '(' and expect to
-  // see 'select'.
-  public void _testJoinUsing() {
+  @Test void testJoinUsingWithParentheses() {
     sql("select * from (emp join bonus using (job))\n"
         + "join dept using (deptno)").ok();
 
-    // cannot alias a JOIN (actually this is a parser error, but who's
-    // counting?)
-    sql("select * from (emp join bonus using (job)) as x\n"
+    // Cannot alias a JOIN (until
+    // [CALCITE-5168] Allow AS after parenthesized JOIN
+    // is fixed).
+    sql("select * from (emp ^join^ bonus using (job)) as x\n"
         + "join dept using (deptno)")
-        .fails("as wrong here");
+        .fails("Join expression encountered in illegal context");
     sql("select * from (emp join bonus using (job))\n"
         + "join dept using (^dname^)")
-        .fails("dname not found in lhs");
+        .fails("Column 'DNAME' not found in any table");
 
     // Needs real Error Message and error marks in query
     sql("select * from (emp join bonus using (job))\n"
-        + "join (select 1 as job from (true)) using (job)")
-        .fails("ambig");
+        + "join (select 1 as job from ^(^true)) using (job)")
+        .fails("(?s).*Encountered \"\\( true\" at .*");
   }
 
   @Disabled("bug: should fail if sub-query does not have alias")
@@ -6230,9 +4951,7 @@ public void _testJoinUsing() {
         + "from emp as e\n"
         + "join dept as d using (deptno)\n"
         + "join dept as d2 using (^deptno^)";
-    final String expected = "Column name 'DEPTNO' in USING clause is not "
-        + "unique on one side of join";
-    sql(sql1).fails(expected);
+    sql(sql1).ok();
 
     final String sql2 = "select *\n"
         + "from emp as e\n"
@@ -6298,6 +5017,113 @@ public void _testJoinUsing() {
     sql("select deptno from emp group by deptno having deptno + 5 > 10").ok();
   }
 
+  /** Tests the {@code QUALIFY} clause. */
+  @Test void testQualifyPositive() {
+    final SqlValidatorFixture f =
+        fixture().withConformance(SqlConformanceEnum.LENIENT);
+
+    final String qualifyWithoutAlias = "SELECT\n"
+        + "empno, ename\n"
+        + "FROM emp\n"
+        + "QUALIFY ROW_NUMBER() over (partition by ename order by deptno) = 1";
+    f.withSql(qualifyWithoutAlias).ok();
+
+    final String qualifyWithAlias = "SELECT empno, ename, deptno,\n"
+        + "   ROW_NUMBER() over (partition by ename order by deptno) as row_num\n"
+        + "FROM emp\n"
+        + "QUALIFY row_num = 1";
+    f.withSql(qualifyWithAlias).ok();
+
+    final String qualifyWithWindowClause = "SELECT empno, ename,\n"
+        + " SUM(deptno) OVER myWindow as sumDeptNo\n"
+        + "FROM emp\n"
+        + "WINDOW myWindow AS (PARTITION BY ename ORDER BY empno)\n"
+        + "QUALIFY sumDeptNo = 1";
+    f.withSql(qualifyWithWindowClause).ok();
+
+    final String qualifyWithEverything = "SELECT DISTINCT empno, ename, deptno,\n"
+        + "    RANK() OVER (PARTITION BY ename ORDER BY deptno DESC) as rank_val\n"
+        + "FROM emp\n"
+        + "WHERE sal > 1000\n"
+        + "QUALIFY rank_val = (SELECT COUNT(*) FROM emp)\n"
+        + "ORDER BY deptno\n"
+        + "LIMIT 5";
+    f.withSql(qualifyWithEverything).ok();
+
+    final String qualifyReferencingCommonColumnInJoin = "SELECT * \n"
+        + "FROM emp\n"
+        + "NATURAL JOIN dept\n"
+        + "QUALIFY ROW_NUMBER() over (partition by ename order by emp.deptno) = 1";
+    f.withSql(qualifyReferencingCommonColumnInJoin).ok();
+
+    final String qualifyOnMultipleWindowFunctions = "SELECT"
+        + "   AVG(deptno) OVER (PARTITION BY ename) avgDeptNo,"
+        + "   RANK() OVER (PARTITION BY deptno ORDER BY ename) as myRank\n"
+        + "FROM emp\n"
+        + "QUALIFY avgDeptNo = 1 AND myRank = 1";
+    f.withSql(qualifyOnMultipleWindowFunctions).ok();
+  }
+
+  /** Negative tests for the {@code QUALIFY} clause. */
+  @Test void testQualifyNegative() {
+    final SqlValidatorFixture f =
+        fixture().withConformance(SqlConformanceEnum.LENIENT);
+
+    // The predicate in the QUALIFY clause expression must be a boolean, since
+    // we use it as a filter.
+    final String qualifyWithNonBooleanExpression = "SELECT\n"
+        + "empno, ename\n"
+        + "FROM emp\n"
+        + "QUALIFY ^1 + 1^";
+    f.withSql(qualifyWithNonBooleanExpression)
+        .fails("QUALIFY clause must be a condition");
+
+    // We don't allow for using ordinal column references in QUALIFY.
+    final String qualifyWithOrdinal = "SELECT\n"
+        + "empno, ename, ROW_NUMBER() over (partition by ename order by deptno) = 1\n"
+        + "FROM emp\n"
+        + "QUALIFY ^3^";
+    f.withSql(qualifyWithOrdinal)
+        .fails("QUALIFY clause must be a condition");
+
+    // 'deptno' is a common column in both the emp and dept table.
+    // We need to use emp.deptno or dept.deptno to make it unambiguous
+    final String qualifyReferencingAmbiguousCommonColumnInJoin = "SELECT *\n"
+        + "FROM emp\n"
+        + "NATURAL JOIN dept\n"
+        + "QUALIFY ROW_NUMBER() over (partition by ename order by ^deptno^) = 1";
+    f.withSql(qualifyReferencingAmbiguousCommonColumnInJoin)
+        .fails("Column 'DEPTNO' is ambiguous");
+
+    // Qualify must contain a window function. This matches the behavior where
+    // HAVING needs to have an aggregate or reference a group column.
+    final String qualifyOnNonWindowFunction = "SELECT * \n"
+        + "FROM emp\n"
+        + "QUALIFY ^SUM(deptno) = 1^";
+    f.withSql(qualifyOnNonWindowFunction)
+        .fails("QUALIFY expression 'SUM\\(`EMP`\\.`DEPTNO`\\) = 1' "
+            + "must contain a window function");
+
+    final String qualifyOnAliasedNonWindowFunction = ""
+        + "SELECT ^SUM(deptno) as sumDeptNo\n"
+        + "FROM emp\n"
+        + "QUALIFY sumDeptNo = 1^";
+    f.withSql(qualifyOnAliasedNonWindowFunction)
+        .fails("QUALIFY expression 'SUM\\(`EMP`\\.`DEPTNO`\\) = 1' "
+            + "must contain a window function");
+
+    // This query fails, since it's a mix of regular aggregates and window
+    // functions. This query needs to fail, since we assume that qualify filters
+    // on the result of a window function in SqlToRelConverter and that the
+    // input Rel is a LogicalProject and not a LogicalAggregate.
+    final String mixedNonAggregateAndWindowAggregate = "SELECT\n"
+        + "   SUM(deptno) as sumDeptNo, "
+        + "   RANK() OVER (PARTITION BY ^ename^ ORDER BY deptno) myRank\n"
+        + "FROM emp\n";
+    f.withSql(mixedNonAggregateAndWindowAggregate)
+        .fails("Expression 'ENAME' is not being grouped");
+  }
+
   /** Tests the {@code WITH} clause, also called common table expressions. */
   @Test void testWith() {
     // simplest possible
@@ -6648,6 +5474,17 @@ public boolean isBangEqualAllowed() {
     sql("select 'foo' as empno from emp order by empno + 5").ok();
   }
 
+  /** Tests that you can reference a column alias in the ORDER BY clause if
+   * {@link SqlConformance#isSortByAlias()}. */
+  @Test void testOrderByAlias() {
+    sql("select count(*) as total from emp order by ^total^")
+        .ok()
+        .withConformance(SqlConformanceEnum.BIG_QUERY)
+        .ok()
+        .withConformance(SqlConformanceEnum.STRICT_2003)
+        .fails("Column 'TOTAL' not found in any table");
+  }
+
   @Test void testOrderJoin() {
     sql("select * from emp as e, dept as d order by e.empno").ok();
   }
@@ -6939,6 +5776,21 @@ public boolean isBangEqualAllowed() {
         .withConformance(strict).ok();
   }
 
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5507">[CALCITE-5507]
+   * HAVING alias failed when aggregate function in condition</a>. */
+  @Test void testAggregateFunAndAliasInHaving() {
+    final SqlConformanceEnum lenient = SqlConformanceEnum.LENIENT;
+    final SqlConformanceEnum strict = SqlConformanceEnum.STRICT_2003;
+
+    sql("select count(empno) as e from emp having ^e^ > 10 and count(empno) > 10 ")
+        .withConformance(strict).fails("Column 'E' not found in any table")
+        .withConformance(lenient).ok();
+    sql("select count(empno) as e from emp having count(empno) > 10 and count(^e^) > 10")
+        .withConformance(strict).fails("Column 'E' not found in any table")
+        .withConformance(lenient).fails("Column 'E' not found in any table");
+  }
+
   /**
    * Tests validation of the aliases in HAVING.
    *
@@ -7165,6 +6017,13 @@ public boolean isBangEqualAllowed() {
         + "group by rollup(empno), deptno")
         .ok()
         .type("RecordType(INTEGER NOT NULL DEPTNO, INTEGER EMPNO) NOT NULL");
+
+    // empno becomes NULL because it is rolled up, and so does empno + 1.
+    sql("select empno, empno + 1 as e1\n"
+        + "from emp\n"
+        + "group by rollup(empno)")
+        .ok()
+        .type("RecordType(INTEGER EMPNO, INTEGER E1) NOT NULL");
   }
 
   @Test void testGroupByCorrelatedColumn() {
@@ -7210,8 +6069,8 @@ public boolean isBangEqualAllowed() {
         .fails("Expression 'EMP\\.EMPNO' is not being grouped");
   }
 
-  // todo: enable when correlating variables work
-  public void _testGroupExpressionEquivalenceCorrelated() {
+  @Disabled("todo: enable when correlating variables work")
+  void testGroupExpressionEquivalenceCorrelated() {
     // dname comes from dept, so it is constant within the sub-query, and
     // is so is a valid expr in a group-by query
     sql("select * from dept where exists ("
@@ -7220,8 +6079,8 @@ public void _testGroupExpressionEquivalenceCorrelated() {
         + "select dname + empno + 1 from emp group by empno, dept.deptno)").ok();
   }
 
-  // todo: enable when params are implemented
-  public void _testGroupExpressionEquivalenceParams() {
+  @Disabled("todo: enable when params are implemented")
+  void testGroupExpressionEquivalenceParams() {
     sql("select cast(? as integer) from emp group by cast(? as integer)").ok();
   }
 
@@ -7556,7 +6415,7 @@ public void _testGroupExpressionEquivalenceParams() {
         + "from emp\n"
         + "group by deptno";
     sql(sql)
-        .type("RecordType(DOUBLE NOT NULL C, DOUBLE NOT NULL D) NOT NULL");
+        .type("RecordType(INTEGER NOT NULL C, INTEGER NOT NULL D) NOT NULL");
   }
 
   /** Tests that {@code PERCENTILE_CONT} only allows numeric fields. */
@@ -8043,6 +6902,20 @@ public void _testGroupExpressionEquivalenceParams() {
         .columnType("CHAR(3) ARRAY NOT NULL");
   }
 
+  /**
+   * Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-4999">[CALCITE-4999]
+   * ARRAY, MULTISET functions should return a collection of scalars
+   * if a sub-query returns 1 column</a>.
+   */
+  @Test void testArrayQueryConstructor() {
+    sql("select array(select 1)")
+        .columnType("INTEGER NOT NULL ARRAY NOT NULL");
+    sql("select array(select ROW(1,2))")
+        .columnType(
+            "RecordType(INTEGER NOT NULL EXPR$0, INTEGER NOT NULL EXPR$1) NOT NULL ARRAY NOT NULL");
+  }
+
   @Test void testCastAsCollectionType() {
     sql("select cast(array[1,null,2] as int array) from (values (1))")
         .columnType("INTEGER NOT NULL ARRAY NOT NULL");
@@ -8126,6 +6999,20 @@ public void _testGroupExpressionEquivalenceParams() {
         .columnType("INTEGER MULTISET NOT NULL");
   }
 
+  /**
+   * Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-4999">[CALCITE-4999]
+   * ARRAY, MULTISET functions should return an collection of scalars
+   * if a sub-query returns 1 column</a>.
+   */
+  @Test void testMultisetQueryConstructor() {
+    sql("select multiset(select 1)")
+        .columnType("INTEGER NOT NULL MULTISET NOT NULL");
+    sql("select multiset(select ROW(1,2))")
+        .columnType(
+            "RecordType(INTEGER NOT NULL EXPR$0, INTEGER NOT NULL EXPR$1) NOT NULL MULTISET NOT NULL");
+  }
+
   @Test void testUnnestArrayColumn() {
     final String sql1 = "select d.deptno, e.*\n"
         + "from dept_nested as d,\n"
@@ -8167,6 +7054,8 @@ public void _testGroupExpressionEquivalenceParams() {
         .type("RecordType(INTEGER NOT NULL EXPR$0, INTEGER NOT NULL ORDINALITY) NOT NULL");
     sql("select*from unnest(array[43.2e1, cast(null as decimal(4,2))]) with ordinality")
         .type("RecordType(DOUBLE EXPR$0, INTEGER NOT NULL ORDINALITY) NOT NULL");
+    sql("select * from unnest(array(select deptno from dept)) with ordinality as t")
+        .type("RecordType(INTEGER NOT NULL T, INTEGER NOT NULL ORDINALITY) NOT NULL");
     sql("select*from ^unnest(1) with ordinality^")
         .fails("(?s).*Cannot apply 'UNNEST' to arguments of type 'UNNEST.<INTEGER>.'.*");
     sql("select deptno\n"
@@ -8175,14 +7064,14 @@ public void _testGroupExpressionEquivalenceParams() {
     sql("select c from unnest(\n"
         + "  array(select deptno from dept)) with ordinality as t(^c^)")
         .fails("List of column aliases must have same degree as table; table has 2 "
-            + "columns \\('DEPTNO', 'ORDINALITY'\\), "
+            + "columns \\('EXPR\\$0', 'ORDINALITY'\\), "
             + "whereas alias list has 1 columns");
     sql("select c from unnest(\n"
         + "  array(select deptno from dept)) with ordinality as t(c, d)").ok();
     sql("select c from unnest(\n"
         + "  array(select deptno from dept)) with ordinality as t(^c, d, e^)")
         .fails("List of column aliases must have same degree as table; table has 2 "
-            + "columns \\('DEPTNO', 'ORDINALITY'\\), "
+            + "columns \\('EXPR\\$0', 'ORDINALITY'\\), "
             + "whereas alias list has 3 columns");
     sql("select c\n"
         + "from unnest(array(select * from dept)) with ordinality as t(^c, d, e, f^)")
@@ -8210,6 +7099,10 @@ public void _testGroupExpressionEquivalenceParams() {
     // relation, that alias becomes the name of the column.
     sql("select fruit.* from UNNEST(array ['apple', 'banana']) as fruit")
         .type(expectedType);
+    sql("select fruit.* from UNNEST(array(select 'banana')) as fruit")
+        .type(expectedType);
+    sql("SELECT array(SELECT y + 1 FROM UNNEST(s.x) y) FROM (SELECT ARRAY[1,2,3] as x) s")
+        .ok();
 
     // The magic doesn't happen if the query is not an UNNEST.
     // In this case, the query is a SELECT.
@@ -8222,7 +7115,6 @@ public void _testGroupExpressionEquivalenceParams() {
     sql("select * from UNNEST(array [('apple', 1), ('banana', 2)]) as fruit")
         .type("RecordType(CHAR(6) NOT NULL EXPR$0, INTEGER NOT NULL EXPR$1) "
             + "NOT NULL");
-
     // VALUES gets the same treatment as ARRAY. (Unlike PostgreSQL.)
     sql("select * from (values ('apple'), ('banana')) as fruit")
         .type("RecordType(CHAR(6) NOT NULL FRUIT) NOT NULL");
@@ -8230,6 +7122,11 @@ public void _testGroupExpressionEquivalenceParams() {
     // UNNEST MULTISET gets the same treatment as UNNEST ARRAY.
     sql("select * from unnest(multiset [1, 2, 1]) as f")
         .type("RecordType(INTEGER NOT NULL F) NOT NULL");
+
+    // The magic doesn't happen if the UNNEST is used without AS operator.
+    sql("select * from (SELECT ARRAY['banana'] as fruits) as t, UNNEST(t.fruits)")
+        .type("RecordType(CHAR(6) NOT NULL ARRAY NOT NULL FRUITS, "
+            + "CHAR(6) NOT NULL EXPR$0) NOT NULL").ok();
   }
 
   @Test void testCorrelationJoin() {
@@ -8322,6 +7219,16 @@ public void _testGroupExpressionEquivalenceParams() {
     sql("SELECT MAX(5) FROM emp").ok();
   }
 
+  @Test void testArgMinMaxFunctions() {
+    sql("SELECT ARG_MIN(1, true) from emp").ok();
+    sql("SELECT ARG_MAX(2, false) from emp").ok();
+
+    sql("SELECT ARG_MIN(sal, deptno) FROM emp").ok();
+    sql("SELECT ARG_MAX(deptno, sal) FROM emp").ok();
+    sql("SELECT ARG_MIN('a', 5.5) FROM emp").ok();
+    sql("SELECT ARG_MAX('b', 5) FROM emp").ok();
+  }
+
   @Test void testModeFunction() {
     sql("select MODE(sal) from emp").ok();
     sql("select MODE(sal) over (order by empno) from emp").ok();
@@ -8681,6 +7588,11 @@ public void _testGroupExpressionEquivalenceParams() {
         + "select min(deptno) from dept as depts2)").ok();
   }
 
+  @Test void dynamicParameterType() {
+    expr("CAST(? AS INTEGER)")
+        .columnType("INTEGER");
+  }
+
   @Test void testRecordType() {
     // Have to qualify columns with table name.
     sql("SELECT ^coord^.x, coord.y FROM customer.contact")
@@ -8977,6 +7889,43 @@ public void _testGroupExpressionEquivalenceParams() {
         .rewritesTo(expected2);
   }
 
+  @Test void testDatePartWithRewrite() {
+    final String sql = "select week(date '2022-04-27'), year(date '2022-04-27')";
+    final String expected = "SELECT EXTRACT(WEEK FROM DATE '2022-04-27'),"
+        + " EXTRACT(YEAR FROM DATE '2022-04-27')";
+    sql(sql)
+        .withValidatorCallRewrite(true)
+        .rewritesTo(expected);
+
+    final String noParamSql = "select ^week()^";
+    sql(noParamSql)
+        .withValidatorCallRewrite(true)
+        .fails("Invalid number of arguments to function 'WEEK'. Was expecting 1 arguments");
+
+    final String multiParamsSql = "select ^week(date '2022-04-27', 1)^";
+    sql(multiParamsSql)
+        .withValidatorCallRewrite(true)
+        .fails("Invalid number of arguments to function 'WEEK'. Was expecting 1 arguments");
+  }
+
+  @Test void testDatePartWithoutRewrite() {
+    final String sql = "select week(date '2022-04-27'), year(date '2022-04-27')";
+    final String expected = "SELECT WEEK(DATE '2022-04-27'), YEAR(DATE '2022-04-27')";
+    sql(sql)
+        .withValidatorCallRewrite(false)
+        .rewritesTo(expected);
+
+    final String noParamSql = "select ^week()^";
+    sql(noParamSql)
+        .withValidatorCallRewrite(false)
+        .fails("Invalid number of arguments to function 'WEEK'. Was expecting 1 arguments");
+
+    final String multiParamsSql = "select ^week(date '2022-04-27', 1)^";
+    sql(multiParamsSql)
+        .withValidatorCallRewrite(false)
+        .fails("Invalid number of arguments to function 'WEEK'. Was expecting 1 arguments");
+  }
+
   @Disabled
   @Test void testValuesWithAggFuncs() {
     sql("values(^count(1)^)")
@@ -9007,6 +7956,19 @@ public void _testGroupExpressionEquivalenceParams() {
                 + " CATALOG.SALES.EMP.HIREDATE,"
                 + " null,"
                 + " null}"));
+
+    sql("select e.empno from dept_nested, unnest(employees) as e")
+        .assertFieldOrigin(
+            is("{CATALOG.SALES.DEPT_NESTED.EMPLOYEES.EMPNO}"));
+
+    sql("select * from UNNEST(ARRAY['a', 'b'])")
+        .assertFieldOrigin(is("{null}"));
+
+    sql("select * from UNNEST(ARRAY['a', 'b'], ARRAY['d', 'e'])")
+        .assertFieldOrigin(is("{null, null}"));
+
+    sql("select dpt.skill.desc from dept_nested as dpt")
+        .assertFieldOrigin(is("{CATALOG.SALES.DEPT_NESTED.SKILL.DESC}"));
   }
 
   @Test void testBrackets() {
@@ -9129,9 +8091,8 @@ public void _testGroupExpressionEquivalenceParams() {
 
   /** Tests using case-insensitive matching of user-defined functions. */
   @Test void testCaseInsensitiveUdfs() {
-    final MockSqlOperatorTable operatorTable =
-        new MockSqlOperatorTable(SqlStdOperatorTable.instance());
-    MockSqlOperatorTable.addRamp(operatorTable);
+    final SqlOperatorTable operatorTable =
+        MockSqlOperatorTable.standard().extend();
     final SqlValidatorFixture insensitive = fixture()
         .withCaseSensitive(false)
         .withQuoting(Quoting.BRACKET)
@@ -12059,6 +11020,30 @@ private void checkCustomColumnResolving(String table) {
         .fails("(?s).*Cannot apply.*");
   }
 
+  @Test public void testJsonInsert() {
+    expr("json_insert('{ \"a\": 1, \"b\": [2]}', '$.a', 10, '$.c', '[true]')").ok();
+    expr("json_insert('{ \"a\": 1, \"b\": [2]}', '$.a', 10, '$.c', '[true]')")
+        .columnType("VARCHAR(2000)");
+    expr("select ^json_insert('{\"foo\":\"bar\"}')^")
+        .fails("(?s).*Invalid number of arguments.*");
+  }
+
+  @Test public void testJsonReplace() {
+    expr("json_replace('{ \"a\": 1, \"b\": [2]}', '$.a', 10, '$.c', '[true]')").ok();
+    expr("json_replace('{ \"a\": 1, \"b\": [2]}', '$.a', 10, '$.c', '[true]')")
+        .columnType("VARCHAR(2000)");
+    expr("select ^json_replace('{\"foo\":\"bar\"}')^")
+        .fails("(?s).*Invalid number of arguments.*");
+  }
+
+  @Test public void testJsonSet() {
+    expr("json_set('{ \"a\": 1, \"b\": [2]}', '$.a', 10, '$.c', '[true]')").ok();
+    expr("json_set('{ \"a\": 1, \"b\": [2]}', '$.a', 10, '$.c', '[true]')")
+        .columnType("VARCHAR(2000)");
+    expr("select ^json_set('{\"foo\":\"bar\"}')^")
+        .fails("(?s).*Invalid number of arguments.*");
+  }
+
   @Test void testRegexpReplace() {
     final SqlOperatorTable opTable = operatorTableFor(SqlLibrary.ORACLE);
 
@@ -12098,9 +11083,8 @@ private void checkCustomColumnResolving(String table) {
   }
 
   @Test void testInvalidFunctionCall() {
-    final MockSqlOperatorTable operatorTable =
-        new MockSqlOperatorTable(SqlStdOperatorTable.instance());
-    MockSqlOperatorTable.addRamp(operatorTable);
+    final SqlOperatorTable operatorTable =
+        MockSqlOperatorTable.standard().extend();
 
     // With implicit type coercion.
     expr("^unknown_udf(1, 2)^")
@@ -12220,9 +11204,8 @@ private void checkCustomColumnResolving(String table) {
         .withExtendedCatalog()
         .type("RecordType(BIGINT EXPR$0) NOT NULL");
 
-    final MockSqlOperatorTable operatorTable =
-        new MockSqlOperatorTable(SqlStdOperatorTable.instance());
-    MockSqlOperatorTable.addRamp(operatorTable);
+    final SqlOperatorTable operatorTable =
+        MockSqlOperatorTable.standard().extend();
     sql("select * FROM TABLE(ROW_FUNC()) AS T(a, b)")
         .withOperatorTable(operatorTable)
         .type("RecordType(BIGINT NOT NULL A, BIGINT B) NOT NULL");
@@ -12237,25 +11220,12 @@ private static class UnexpandedToDeptValidator extends SqlValidatorImpl {
       super(opTab, catalogReader, typeFactory, config);
     }
 
-    @Override public SqlNode expand(SqlNode expr, SqlValidatorScope scope) {
-      SqlNode rewrittenNode = rewriteNode(expr);
-      return super.expand(rewrittenNode, scope);
-    }
-
-    @Override public SqlNode expandSelectExpr(SqlNode expr, SelectScope scope,
-        SqlSelect select) {
-      SqlNode rewrittenNode = rewriteNode(expr);
-      return super.expandSelectExpr(rewrittenNode, scope, select);
-    }
-
-    @Override public SqlNode expandGroupByOrHavingExpr(SqlNode expr,
-        SqlValidatorScope scope, SqlSelect select, boolean havingExpression) {
-      SqlNode rewrittenNode = rewriteNode(expr);
-      return super.expandGroupByOrHavingExpr(rewrittenNode, scope, select,
-          havingExpression);
+    @Override public SqlNode validate(SqlNode topNode) {
+      SqlNode rewrittenNode = rewriteNode(topNode);
+      return super.validate(rewrittenNode);
     }
 
-    private SqlNode rewriteNode(SqlNode sqlNode) {
+    private static SqlNode rewriteNode(SqlNode sqlNode) {
       return sqlNode.accept(new SqlShuttle() {
         @Override public SqlNode visit(SqlIdentifier id) {
           return rewriteIdentifier(id);
@@ -12263,8 +11233,11 @@ private SqlNode rewriteNode(SqlNode sqlNode) {
       });
     }
 
-    private SqlIdentifier rewriteIdentifier(SqlIdentifier sqlIdentifier) {
-      Preconditions.checkArgument(sqlIdentifier.names.size() == 2);
+    private static SqlIdentifier rewriteIdentifier(SqlIdentifier sqlIdentifier) {
+      if (sqlIdentifier.names.size() != 2) {
+        return sqlIdentifier;
+      }
+
       if (sqlIdentifier.names.get(0).equals("UNEXPANDED")) {
         return new SqlIdentifier(asList("DEPT", sqlIdentifier.names.get(1)),
             null, sqlIdentifier.getParserPosition(),
@@ -12274,7 +11247,7 @@ private SqlIdentifier rewriteIdentifier(SqlIdentifier sqlIdentifier) {
         //  Identifiers are expanded multiple times
         return sqlIdentifier;
       } else {
-        throw new RuntimeException("Unknown Identifier " + sqlIdentifier);
+        return sqlIdentifier;
       }
     }
   }
diff --git a/core/src/test/java/org/apache/calcite/test/SqlXmlFunctionsTest.java b/core/src/test/java/org/apache/calcite/test/SqlXmlFunctionsTest.java
index 1457ef69084..046d9357059 100644
--- a/core/src/test/java/org/apache/calcite/test/SqlXmlFunctionsTest.java
+++ b/core/src/test/java/org/apache/calcite/test/SqlXmlFunctionsTest.java
@@ -21,9 +21,13 @@
 import org.apache.calcite.runtime.XmlFunctions;
 import org.apache.calcite.util.BuiltInMethod;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
 import org.hamcrest.Matcher;
+import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 
+import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.function.Supplier;
 
 import static org.hamcrest.CoreMatchers.is;
@@ -36,6 +40,23 @@
  */
 class SqlXmlFunctionsTest {
 
+  private static final String XML = "<document>string</document>";
+  private static final String XSLT =
+      "<xsl:stylesheet xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\"></xsl:stylesheet>";
+  private static final String DOCUMENT_PATH = "/document";
+  private static @Nullable String xmlExternalEntity = null;
+  private static @Nullable String xsltExternalEntity = null;
+
+  @BeforeAll public static void setup() throws Exception {
+    final Path testFile = Files.createTempFile("foo", "temp");
+    testFile.toFile().deleteOnExit();
+    final String filePath = "file:///" + testFile.toAbsolutePath();
+    xmlExternalEntity = "<!DOCTYPE document [ <!ENTITY entity SYSTEM \"" + filePath
+        + "\"> ]><document>&entity;</document>";
+    xsltExternalEntity = "<!DOCTYPE document [ <!ENTITY entity SYSTEM \"" + filePath
+        + "\"> ]><xsl:stylesheet xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\">&entity;</xsl:stylesheet>";
+  }
+
   @Test void testExtractValue() {
     assertExtractValue("<a>ccc<b>ddd</b></a>", "/a", is("ccc"));
 
@@ -45,6 +66,33 @@ class SqlXmlFunctionsTest {
     assertExtractValueFailed(input, "#", Matchers.expectThrowable(expected));
   }
 
+  @Test void testExtractValueExternalEntity() {
+    String message = "Invalid input for EXTRACTVALUE: xml: '"
+        + xmlExternalEntity + "', xpath expression: '" + DOCUMENT_PATH + "'";
+    CalciteException expected = new CalciteException(message, null);
+    assertExtractValueFailed(xmlExternalEntity, DOCUMENT_PATH,
+        Matchers.expectThrowable(expected));
+  }
+
+  @Test void testExistsNodeExternalEntity() {
+    String message = "Invalid input for EXISTSNODE xpath: '"
+        + DOCUMENT_PATH + "', namespace: '" + null + "'";
+    CalciteException expected = new CalciteException(message, null);
+    assertExistsNodeFailed(xmlExternalEntity, DOCUMENT_PATH, null,
+        Matchers.expectThrowable(expected));
+  }
+
+  @Test void testXmlTransformExternalEntity() {
+    String message = "Invalid input for XMLTRANSFORM xml: '" + xmlExternalEntity + "'";
+    CalciteException expected = new CalciteException(message, null);
+    assertXmlTransformFailed(xmlExternalEntity, XSLT, Matchers.expectThrowable(expected));
+  }
+
+  @Test void testXmlTransformExternalEntityXslt() {
+    String message = "Illegal xslt specified : '" + xsltExternalEntity + "'";
+    CalciteException expected = new CalciteException(message, null);
+    assertXmlTransformFailed(XML, xsltExternalEntity, Matchers.expectThrowable(expected));
+  }
 
   @Test void testXmlTransform() {
     assertXmlTransform(null, "", nullValue());
diff --git a/core/src/test/java/org/apache/calcite/test/StreamTest.java b/core/src/test/java/org/apache/calcite/test/StreamTest.java
index 6192657bb4d..d2bf27f3727 100644
--- a/core/src/test/java/org/apache/calcite/test/StreamTest.java
+++ b/core/src/test/java/org/apache/calcite/test/StreamTest.java
@@ -114,9 +114,10 @@ private static String schemaFor(String name, Class<? extends TableFactory> clazz
         .query("select stream product from orders where units > 6")
         .convertContains(
             "LogicalDelta\n"
-                + "  LogicalProject(PRODUCT=[$2])\n"
-                + "    LogicalFilter(condition=[>($3, 6)])\n"
-                + "      LogicalTableScan(table=[[STREAMS, ORDERS]])\n")
+                + "  LogicalProject(PRODUCT=[$1])\n"
+                + "    LogicalFilter(condition=[>($2, 6)])\n"
+                + "      LogicalProject(ROWTIME=[$0], PRODUCT=[$2], UNITS=[$3])\n"
+                + "        LogicalTableScan(table=[[STREAMS, ORDERS]])\n")
         .explainContains(
             "EnumerableCalc(expr#0..3=[{inputs}], expr#4=[6], expr#5=[>($t3, $t4)], PRODUCT=[$t2], $condition=[$t5])\n"
                 + "  EnumerableInterpreter\n"
@@ -260,16 +261,16 @@ private static String schemaFor(String name, Class<? extends TableFactory> clazz
             + "orders.rowtime as rowtime, orders.id as orderId, products.supplier as supplierId "
             + "from orders join products on orders.product = products.id")
         .convertContains("LogicalDelta\n"
-            + "  LogicalProject(ROWTIME=[$0], ORDERID=[$1], SUPPLIERID=[$6])\n"
-            + "    LogicalJoin(condition=[=($4, $5)], joinType=[inner])\n"
-            + "      LogicalProject(ROWTIME=[$0], ID=[$1], PRODUCT=[$2], UNITS=[$3], PRODUCT0=[CAST($2):VARCHAR(32) NOT NULL])\n"
+            + "  LogicalProject(ROWTIME=[$0], ORDERID=[$1], SUPPLIERID=[$4])\n"
+            + "    LogicalJoin(condition=[=($2, $3)], joinType=[inner])\n"
+            + "      LogicalProject(ROWTIME=[$0], ID=[$1], PRODUCT0=[CAST($2):VARCHAR(32) NOT NULL])\n"
             + "        LogicalTableScan(table=[[STREAM_JOINS, ORDERS]])\n"
             + "      LogicalTableScan(table=[[STREAM_JOINS, PRODUCTS]])\n")
         .explainContains(""
-            + "EnumerableCalc(expr#0..6=[{inputs}], proj#0..1=[{exprs}], SUPPLIERID=[$t6])\n"
-            + "  EnumerableMergeJoin(condition=[=($4, $5)], joinType=[inner])\n"
-            + "    EnumerableSort(sort0=[$4], dir0=[ASC])\n"
-            + "      EnumerableCalc(expr#0..3=[{inputs}], expr#4=[CAST($t2):VARCHAR(32) NOT NULL], proj#0..4=[{exprs}])\n"
+            + "EnumerableCalc(expr#0..4=[{inputs}], proj#0..1=[{exprs}], SUPPLIERID=[$t4])\n"
+            + "  EnumerableMergeJoin(condition=[=($2, $3)], joinType=[inner])\n"
+            + "    EnumerableSort(sort0=[$2], dir0=[ASC])\n"
+            + "      EnumerableCalc(expr#0..3=[{inputs}], expr#4=[CAST($t2):VARCHAR(32) NOT NULL], proj#0..1=[{exprs}], PRODUCT0=[$t4])\n"
             + "        EnumerableInterpreter\n"
             + "          BindableTableScan(table=[[STREAM_JOINS, ORDERS, (STREAM)]])\n"
             + "    EnumerableSort(sort0=[$0], dir0=[ASC])\n"
diff --git a/core/src/test/java/org/apache/calcite/test/TableFunctionTest.java b/core/src/test/java/org/apache/calcite/test/TableFunctionTest.java
index 36d32295f89..ab50be530c7 100644
--- a/core/src/test/java/org/apache/calcite/test/TableFunctionTest.java
+++ b/core/src/test/java/org/apache/calcite/test/TableFunctionTest.java
@@ -547,4 +547,26 @@ private Connection getConnectionWithMultiplyFunction() throws SQLException {
       assertThat(CalciteAssert.toString(resultSet), equalTo(expected));
     }
   }
+
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-4448">[CALCITE-4448]
+   * Use TableMacro user-defined table functions with QueryableTable</a>. */
+  @Test void testQueryableTableWithTableMacro() throws SQLException {
+    try (Connection connection =
+        DriverManager.getConnection("jdbc:calcite:")) {
+      CalciteConnection calciteConnection =
+          connection.unwrap(CalciteConnection.class);
+      SchemaPlus rootSchema = calciteConnection.getRootSchema();
+      SchemaPlus schema = rootSchema.add("s", new AbstractSchema());
+      schema.add("simple", new Smalls.SimpleTableMacro());
+
+      String sql = "select * from table(\"s\".\"simple\"())";
+      ResultSet resultSet = connection.createStatement().executeQuery(sql);
+      String expected = "A=foo; B=5\n"
+          + "A=bar; B=4\n"
+          + "A=foo; B=3\n";
+      assertThat(CalciteAssert.toString(resultSet),
+          equalTo(expected));
+    }
+  }
 }
diff --git a/core/src/test/java/org/apache/calcite/test/TableInRootSchemaTest.java b/core/src/test/java/org/apache/calcite/test/TableInRootSchemaTest.java
index 5127fd87c2c..55b058a2f97 100644
--- a/core/src/test/java/org/apache/calcite/test/TableInRootSchemaTest.java
+++ b/core/src/test/java/org/apache/calcite/test/TableInRootSchemaTest.java
@@ -16,21 +16,8 @@
  */
 package org.apache.calcite.test;
 
-import org.apache.calcite.adapter.enumerable.EnumerableTableScan;
-import org.apache.calcite.adapter.java.AbstractQueryableTable;
 import org.apache.calcite.jdbc.CalciteConnection;
-import org.apache.calcite.linq4j.Enumerator;
-import org.apache.calcite.linq4j.Linq4j;
-import org.apache.calcite.linq4j.QueryProvider;
-import org.apache.calcite.linq4j.Queryable;
-import org.apache.calcite.plan.RelOptTable;
-import org.apache.calcite.rel.RelNode;
-import org.apache.calcite.rel.type.RelDataType;
-import org.apache.calcite.rel.type.RelDataTypeFactory;
-import org.apache.calcite.schema.SchemaPlus;
-import org.apache.calcite.schema.TranslatableTable;
-import org.apache.calcite.schema.impl.AbstractTableQueryable;
-import org.apache.calcite.util.Pair;
+import org.apache.calcite.util.Smalls;
 
 import com.google.common.collect.ImmutableMultiset;
 
@@ -41,10 +28,6 @@
 import java.sql.ResultSet;
 import java.sql.ResultSetMetaData;
 import java.sql.Statement;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Iterator;
-import java.util.List;
 
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.CoreMatchers.nullValue;
@@ -61,7 +44,7 @@ class TableInRootSchemaTest {
     CalciteConnection calciteConnection =
         connection.unwrap(CalciteConnection.class);
 
-    calciteConnection.getRootSchema().add("SAMPLE", new SimpleTable());
+    calciteConnection.getRootSchema().add("SAMPLE", new Smalls.SimpleTable());
     Statement statement = calciteConnection.createStatement();
     ResultSet resultSet =
         statement.executeQuery("select A, SUM(B) from SAMPLE group by A");
@@ -90,94 +73,4 @@ class TableInRootSchemaTest {
     connection.close();
   }
 
-  /** Table with columns (A, B). */
-  public static class SimpleTable extends AbstractQueryableTable
-      implements TranslatableTable {
-    private String[] columnNames = { "A", "B" };
-    private Class[] columnTypes = { String.class, Integer.class };
-    private Object[][] rows = new Object[3][];
-
-    SimpleTable() {
-      super(Object[].class);
-
-      rows[0] = new Object[] { "foo", 5 };
-      rows[1] = new Object[] { "bar", 4 };
-      rows[2] = new Object[] { "foo", 3 };
-    }
-
-    public RelDataType getRowType(RelDataTypeFactory typeFactory) {
-      int columnCount = columnNames.length;
-      final List<Pair<String, RelDataType>> columnDesc =
-          new ArrayList<>(columnCount);
-      for (int i = 0; i < columnCount; i++) {
-        final RelDataType colType = typeFactory
-            .createJavaType(columnTypes[i]);
-        columnDesc.add(Pair.of(columnNames[i], colType));
-      }
-      return typeFactory.createStructType(columnDesc);
-    }
-
-    public Iterator<Object[]> iterator() {
-      return Linq4j.enumeratorIterator(enumerator());
-    }
-
-    public Enumerator<Object[]> enumerator() {
-      return enumeratorImpl(null);
-    }
-
-    public <T> Queryable<T> asQueryable(QueryProvider queryProvider,
-        SchemaPlus schema, String tableName) {
-      return new AbstractTableQueryable<T>(queryProvider, schema, this,
-          tableName) {
-        public Enumerator<T> enumerator() {
-          //noinspection unchecked
-          return (Enumerator<T>) enumeratorImpl(null);
-        }
-      };
-    }
-
-    private Enumerator<Object[]> enumeratorImpl(final int[] fields) {
-      return new Enumerator<Object[]>() {
-        private Object[] current;
-        private Iterator<Object[]> iterator = Arrays.asList(rows)
-            .iterator();
-
-        public Object[] current() {
-          return current;
-        }
-
-        public boolean moveNext() {
-          if (iterator.hasNext()) {
-            Object[] full = iterator.next();
-            current = fields != null ? convertRow(full) : full;
-            return true;
-          } else {
-            current = null;
-            return false;
-          }
-        }
-
-        public void reset() {
-          throw new UnsupportedOperationException();
-        }
-
-        public void close() {
-          // noop
-        }
-
-        private Object[] convertRow(Object[] full) {
-          final Object[] objects = new Object[fields.length];
-          for (int i = 0; i < fields.length; i++) {
-            objects[i] = full[fields[i]];
-          }
-          return objects;
-        }
-      };
-    }
-
-    public RelNode toRel(RelOptTable.ToRelContext context,
-        RelOptTable relOptTable) {
-      return EnumerableTableScan.create(context.getCluster(), relOptTable);
-    }
-  }
 }
diff --git a/core/src/test/java/org/apache/calcite/test/TimeFrameTest.java b/core/src/test/java/org/apache/calcite/test/TimeFrameTest.java
new file mode 100644
index 00000000000..e3f6f959fa0
--- /dev/null
+++ b/core/src/test/java/org/apache/calcite/test/TimeFrameTest.java
@@ -0,0 +1,659 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.test;
+
+import org.apache.calcite.avatica.util.TimeUnit;
+import org.apache.calcite.rel.type.TimeFrame;
+import org.apache.calcite.rel.type.TimeFrameSet;
+import org.apache.calcite.rel.type.TimeFrames;
+import org.apache.calcite.util.Pair;
+
+import org.apache.commons.math3.fraction.BigFraction;
+
+import com.google.common.collect.ImmutableMap;
+
+import org.hamcrest.Matcher;
+import org.junit.jupiter.api.Test;
+
+import static org.apache.calcite.avatica.util.DateTimeUtils.dateStringToUnixDate;
+import static org.apache.calcite.avatica.util.DateTimeUtils.timestampStringToUnixDate;
+import static org.apache.calcite.avatica.util.DateTimeUtils.unixDateToString;
+import static org.apache.calcite.avatica.util.DateTimeUtils.unixTimestampToString;
+import static org.apache.calcite.avatica.util.TimeUnit.CENTURY;
+import static org.apache.calcite.avatica.util.TimeUnit.DAY;
+import static org.apache.calcite.avatica.util.TimeUnit.DECADE;
+import static org.apache.calcite.avatica.util.TimeUnit.HOUR;
+import static org.apache.calcite.avatica.util.TimeUnit.ISODOW;
+import static org.apache.calcite.avatica.util.TimeUnit.ISOYEAR;
+import static org.apache.calcite.avatica.util.TimeUnit.MICROSECOND;
+import static org.apache.calcite.avatica.util.TimeUnit.MILLENNIUM;
+import static org.apache.calcite.avatica.util.TimeUnit.MILLISECOND;
+import static org.apache.calcite.avatica.util.TimeUnit.MINUTE;
+import static org.apache.calcite.avatica.util.TimeUnit.MONTH;
+import static org.apache.calcite.avatica.util.TimeUnit.NANOSECOND;
+import static org.apache.calcite.avatica.util.TimeUnit.QUARTER;
+import static org.apache.calcite.avatica.util.TimeUnit.SECOND;
+import static org.apache.calcite.avatica.util.TimeUnit.WEEK;
+import static org.apache.calcite.avatica.util.TimeUnit.YEAR;
+
+import static org.hamcrest.CoreMatchers.notNullValue;
+import static org.hamcrest.CoreMatchers.nullValue;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.core.Is.is;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import static java.util.Objects.requireNonNull;
+
+/** Unit test for {@link org.apache.calcite.rel.type.TimeFrame}. */
+public class TimeFrameTest {
+  /** Unit test for {@link org.apache.calcite.rel.type.TimeFrames#CORE}. */
+  @Test void testAvaticaTimeFrame() {
+    final TimeFrameSet timeFrameSet = TimeFrames.CORE;
+    final TimeFrame year = timeFrameSet.get(TimeUnit.YEAR);
+    assertThat(year, notNullValue());
+    assertThat(year.name(), is("YEAR"));
+    assertThat(timeFrameSet.getUnit(year), is(YEAR));
+
+    final TimeFrame month = timeFrameSet.get(MONTH);
+    assertThat(month, notNullValue());
+    assertThat(month.name(), is("MONTH"));
+    assertThat(timeFrameSet.getUnit(month), is(MONTH));
+
+    final Number monthPerYear = month.per(year);
+    assertThat(monthPerYear, notNullValue());
+    assertThat(monthPerYear, is(new BigFraction(12)));
+    final Number yearPerMonth = year.per(month);
+    assertThat(yearPerMonth, notNullValue());
+    assertThat(yearPerMonth, is(BigFraction.ONE.divide(12)));
+    final Number monthPerMonth = month.per(month);
+    assertThat(monthPerMonth, notNullValue());
+    assertThat(monthPerMonth, is(BigFraction.ONE));
+
+    final TimeFrame second = timeFrameSet.get(TimeUnit.SECOND);
+    assertThat(second, notNullValue());
+    assertThat(second.name(), is("SECOND"));
+
+    final TimeFrame minute = timeFrameSet.get(TimeUnit.MINUTE);
+    assertThat(minute, notNullValue());
+    assertThat(minute.name(), is("MINUTE"));
+
+    final TimeFrame nano = timeFrameSet.get(TimeUnit.NANOSECOND);
+    assertThat(nano, notNullValue());
+    assertThat(nano.name(), is("NANOSECOND"));
+
+    final Number secondPerMonth = second.per(month);
+    assertThat(secondPerMonth, nullValue());
+    final Number nanoPerMinute = nano.per(minute);
+    assertThat(nanoPerMinute, notNullValue());
+    assertThat(nanoPerMinute,
+        is(BigFraction.ONE.multiply(1_000).multiply(1_000).multiply(1_000)
+            .multiply(60)));
+
+    // ISOWEEK is the only core time frame without a corresponding time unit.
+    // There is no TimeUnit.ISOWEEK.
+    final TimeFrame isoWeek = timeFrameSet.get("ISOWEEK");
+    assertThat(isoWeek, notNullValue());
+    assertThat(isoWeek.name(), is("ISOWEEK"));
+    assertThat(timeFrameSet.getUnit(isoWeek), nullValue());
+
+    // FRAC_SECOND is an alias.
+    final TimeFrame fracSecond = timeFrameSet.get("FRAC_SECOND");
+    assertThat(fracSecond, notNullValue());
+    assertThat(fracSecond.name(), is("MICROSECOND"));
+    assertThat(timeFrameSet.getUnit(fracSecond), is(MICROSECOND));
+
+    // SQL_TSI_QUARTER is an alias.
+    final TimeFrame sqlTsiQuarter = timeFrameSet.get("SQL_TSI_QUARTER");
+    assertThat(sqlTsiQuarter, notNullValue());
+    assertThat(sqlTsiQuarter.name(), is("QUARTER"));
+    assertThat(timeFrameSet.getUnit(sqlTsiQuarter), is(QUARTER));
+  }
+
+  @Test void testConflict() {
+    TimeFrameSet.Builder b = TimeFrameSet.builder();
+    b.addCore("SECOND");
+    b.addMultiple("MINUTE", 60, "SECOND");
+    b.addMultiple("HOUR", 60, "MINUTE");
+    b.addMultiple("DAY", 24, "SECOND");
+    b.addDivision("MILLISECOND", 1_000, "SECOND");
+
+    // It's important that TimeFrame.Builder throws when you attempt to add
+    // a frame with the same name. It prevents DAGs and cycles.
+    try {
+      b.addDivision("MILLISECOND", 10_000, "MINUTE");
+      fail("expected error");
+    } catch (IllegalArgumentException e) {
+      assertThat(e.getMessage(), is("duplicate frame: MILLISECOND"));
+    }
+
+    try {
+      b.addCore("SECOND");
+      fail("expected error");
+    } catch (IllegalArgumentException e) {
+      assertThat(e.getMessage(), is("duplicate frame: SECOND"));
+    }
+
+    try {
+      b.addQuotient("SECOND", "MINUTE", "HOUR");
+      fail("expected error");
+    } catch (IllegalArgumentException e) {
+      assertThat(e.getMessage(), is("duplicate frame: SECOND"));
+    }
+
+    try {
+      b.addQuotient("MINUTE_OF_WEEK", "MINUTE", "WEEK");
+      fail("expected error");
+    } catch (IllegalArgumentException e) {
+      assertThat(e.getMessage(), is("unknown frame: WEEK"));
+    }
+
+    try {
+      b.addQuotient("DAY_OF_WEEK", "DAY", "YEAR");
+      fail("expected error");
+    } catch (IllegalArgumentException e) {
+      assertThat(e.getMessage(), is("unknown frame: YEAR"));
+    }
+
+    try {
+      b.addAlias("SECOND", "DAY");
+      fail("expected error");
+    } catch (IllegalArgumentException e) {
+      assertThat(e.getMessage(), is("duplicate frame: SECOND"));
+    }
+
+    try {
+      b.addAlias("FOO", "BAZ");
+      fail("expected error");
+    } catch (IllegalArgumentException e) {
+      assertThat(e.getMessage(), is("unknown frame: BAZ"));
+    }
+
+    // Can't define NANOSECOND in terms of a frame that has not been defined
+    // yet.
+    try {
+      b.addDivision("NANOSECOND", 1_000, "MICROSECOND");
+      fail("expected error");
+    } catch (IllegalArgumentException e) {
+      assertThat(e.getMessage(), is("unknown frame: MICROSECOND"));
+    }
+
+    // We can define NANOSECOND and MICROSECOND as long as we define each frame
+    // in terms of previous frames.
+    b.addDivision("NANOSECOND", 1_000_000, "MILLISECOND");
+    b.addMultiple("MICROSECOND", 1_000, "NANOSECOND");
+
+    // Can't define a frame in terms of itself.
+    // (I guess you should use a core frame.)
+    try {
+      b.addDivision("PICOSECOND", 1, "PICOSECOND");
+      fail("expected error");
+    } catch (IllegalArgumentException e) {
+      assertThat(e.getMessage(), is("unknown frame: PICOSECOND"));
+    }
+
+    final TimeFrameSet timeFrameSet = b.build();
+
+    final TimeFrame second = timeFrameSet.get("SECOND");
+    final TimeFrame hour = timeFrameSet.get("HOUR");
+    assertThat(hour.per(second), is(BigFraction.ONE.divide(3_600)));
+    final TimeFrame millisecond = timeFrameSet.get("MILLISECOND");
+    assertThat(hour.per(millisecond), is(BigFraction.ONE.divide(3_600_000)));
+    final TimeFrame nanosecond = timeFrameSet.get("NANOSECOND");
+    assertThat(nanosecond.per(second),
+        is(BigFraction.ONE.multiply(1_000_000_000)));
+  }
+
+  @Test void testEvalFloor() {
+    final Fixture f = new Fixture();
+    f.checkDateFloor("1970-08-01", WEEK, is("1970-07-26")); // saturday
+    f.checkDateFloor("1970-08-02", WEEK, is("1970-08-02")); // sunday
+    f.checkDateFloor("1970-08-03", WEEK, is("1970-08-02")); // monday
+    f.checkDateFloor("1970-08-04", WEEK, is("1970-08-02")); // tuesday
+
+    f.checkDateFloor("1970-08-01", f.isoWeek, is("1970-07-27")); // saturday
+    f.checkDateFloor("1970-08-02", f.isoWeek, is("1970-07-27")); // sunday
+    f.checkDateFloor("1970-08-03", f.isoWeek, is("1970-08-03")); // monday
+    f.checkDateFloor("1970-08-04", f.isoWeek, is("1970-08-03")); // tuesday
+
+    f.checkDateFloor("1970-08-04", "WEEK_MONDAY", is("1970-08-03")); // tuesday
+    f.checkDateFloor("1970-08-04", "WEEK_TUESDAY", is("1970-08-04")); // tuesday
+
+    f.checkTimestampFloor("1970-01-01 01:23:45", HOUR,
+        0, is("1970-01-01 01:00:00"));
+    f.checkTimestampFloor("1970-01-01 01:23:45", MINUTE,
+        0, is("1970-01-01 01:23:00"));
+    f.checkTimestampFloor("1970-01-01 01:23:45.67", SECOND,
+        0, is("1970-01-01 01:23:45"));
+    f.checkTimestampFloor("1970-01-01 01:23:45.6789012345", MILLISECOND,
+        4, is("1970-01-01 01:23:45.6790"));
+    // Time frames can represent unlimited precision, but out representation of
+    // timestamp can't represent more than millisecond precision.
+    f.checkTimestampFloor("1970-01-01 01:23:45.6789012345", MICROSECOND,
+        7, is("1970-01-01 01:23:45.6790000"));
+
+    f.checkTimestampFloor("1971-12-25 01:23:45", DAY,
+        0, is("1971-12-25 00:00:00"));
+    f.checkTimestampFloor("1971-12-25 01:23:45", WEEK,
+        0, is("1971-12-19 00:00:00"));
+  }
+
+  @Test void testCanRollUp() {
+    final Fixture f = new Fixture();
+
+    // The rollup from DAY to MONTH is special. It provides the bridge between
+    // the frames in the SECOND family and those in the MONTH family.
+    f.checkCanRollUp(DAY, MONTH, true);
+    f.checkCanRollUp(MONTH, DAY, false);
+
+    // Note 0: when we pass TimeUnit.ISODOW to tests, we mean f.ISOWEEK.
+
+    f.checkCanRollUp(NANOSECOND, NANOSECOND, true);
+    f.checkCanRollUp(NANOSECOND, MICROSECOND, true);
+    f.checkCanRollUp(NANOSECOND, MILLISECOND, true);
+    f.checkCanRollUp(NANOSECOND, SECOND, true);
+    f.checkCanRollUp(NANOSECOND, MINUTE, true);
+    f.checkCanRollUp(NANOSECOND, HOUR, true);
+    f.checkCanRollUp(NANOSECOND, DAY, true);
+    f.checkCanRollUp(NANOSECOND, WEEK, true);
+    f.checkCanRollUp(NANOSECOND, f.isoWeek, true); // see note 0
+    f.checkCanRollUp(NANOSECOND, MONTH, true);
+    f.checkCanRollUp(NANOSECOND, QUARTER, true);
+    f.checkCanRollUp(NANOSECOND, YEAR, true);
+    f.checkCanRollUp(NANOSECOND, ISOYEAR, true);
+    f.checkCanRollUp(NANOSECOND, CENTURY, true);
+    f.checkCanRollUp(NANOSECOND, DECADE, true);
+    f.checkCanRollUp(NANOSECOND, MILLENNIUM, true);
+
+    f.checkCanRollUp(MICROSECOND, NANOSECOND, false);
+    f.checkCanRollUp(MICROSECOND, MICROSECOND, true);
+    f.checkCanRollUp(MICROSECOND, MILLISECOND, true);
+    f.checkCanRollUp(MICROSECOND, SECOND, true);
+    f.checkCanRollUp(MICROSECOND, MINUTE, true);
+    f.checkCanRollUp(MICROSECOND, HOUR, true);
+    f.checkCanRollUp(MICROSECOND, DAY, true);
+    f.checkCanRollUp(MICROSECOND, WEEK, true);
+    f.checkCanRollUp(MICROSECOND, f.isoWeek, true);
+    f.checkCanRollUp(MICROSECOND, MONTH, true);
+    f.checkCanRollUp(MICROSECOND, QUARTER, true);
+    f.checkCanRollUp(MICROSECOND, YEAR, true);
+    f.checkCanRollUp(MICROSECOND, ISOYEAR, true);
+    f.checkCanRollUp(MICROSECOND, CENTURY, true);
+    f.checkCanRollUp(MICROSECOND, DECADE, true);
+    f.checkCanRollUp(MICROSECOND, MILLENNIUM, true);
+
+    f.checkCanRollUp(MILLISECOND, NANOSECOND, false);
+    f.checkCanRollUp(MILLISECOND, MICROSECOND, false);
+    f.checkCanRollUp(MILLISECOND, MILLISECOND, true);
+    f.checkCanRollUp(MILLISECOND, SECOND, true);
+    f.checkCanRollUp(MILLISECOND, MINUTE, true);
+    f.checkCanRollUp(MILLISECOND, HOUR, true);
+    f.checkCanRollUp(MILLISECOND, DAY, true);
+    f.checkCanRollUp(MILLISECOND, WEEK, true);
+    f.checkCanRollUp(MILLISECOND, f.isoWeek, true);
+    f.checkCanRollUp(MILLISECOND, MONTH, true);
+    f.checkCanRollUp(MILLISECOND, QUARTER, true);
+    f.checkCanRollUp(MILLISECOND, YEAR, true);
+    f.checkCanRollUp(MILLISECOND, ISOYEAR, true);
+    f.checkCanRollUp(MILLISECOND, CENTURY, true);
+    f.checkCanRollUp(MILLISECOND, DECADE, true);
+    f.checkCanRollUp(MILLISECOND, MILLENNIUM, true);
+
+    f.checkCanRollUp(SECOND, NANOSECOND, false);
+    f.checkCanRollUp(SECOND, MICROSECOND, false);
+    f.checkCanRollUp(SECOND, MILLISECOND, false);
+    f.checkCanRollUp(SECOND, SECOND, true);
+    f.checkCanRollUp(SECOND, MINUTE, true);
+    f.checkCanRollUp(SECOND, HOUR, true);
+    f.checkCanRollUp(SECOND, DAY, true);
+    f.checkCanRollUp(SECOND, WEEK, true);
+    f.checkCanRollUp(SECOND, f.isoWeek, true);
+    f.checkCanRollUp(SECOND, MONTH, true);
+    f.checkCanRollUp(SECOND, QUARTER, true);
+    f.checkCanRollUp(SECOND, YEAR, true);
+    f.checkCanRollUp(SECOND, ISOYEAR, true);
+    f.checkCanRollUp(SECOND, CENTURY, true);
+    f.checkCanRollUp(SECOND, DECADE, true);
+    f.checkCanRollUp(SECOND, MILLENNIUM, true);
+
+    f.checkCanRollUp(MINUTE, NANOSECOND, false);
+    f.checkCanRollUp(MINUTE, MICROSECOND, false);
+    f.checkCanRollUp(MINUTE, MILLISECOND, false);
+    f.checkCanRollUp(MINUTE, SECOND, false);
+    f.checkCanRollUp(MINUTE, MINUTE, true);
+    f.checkCanRollUp(MINUTE, HOUR, true);
+    f.checkCanRollUp(MINUTE, DAY, true);
+    f.checkCanRollUp(MINUTE, WEEK, true);
+    f.checkCanRollUp(MINUTE, f.isoWeek, true);
+    f.checkCanRollUp(MINUTE, MONTH, true);
+    f.checkCanRollUp(MINUTE, QUARTER, true);
+    f.checkCanRollUp(MINUTE, YEAR, true);
+    f.checkCanRollUp(MINUTE, ISOYEAR, true);
+    f.checkCanRollUp(MINUTE, CENTURY, true);
+    f.checkCanRollUp(MINUTE, DECADE, true);
+    f.checkCanRollUp(MINUTE, MILLENNIUM, true);
+
+    f.checkCanRollUp(HOUR, NANOSECOND, false);
+    f.checkCanRollUp(HOUR, MICROSECOND, false);
+    f.checkCanRollUp(HOUR, MILLISECOND, false);
+    f.checkCanRollUp(HOUR, SECOND, false);
+    f.checkCanRollUp(HOUR, MINUTE, false);
+    f.checkCanRollUp(HOUR, HOUR, true);
+    f.checkCanRollUp(HOUR, DAY, true);
+    f.checkCanRollUp(HOUR, WEEK, true);
+    f.checkCanRollUp(HOUR, f.isoWeek, true);
+    f.checkCanRollUp(HOUR, MONTH, true);
+    f.checkCanRollUp(HOUR, QUARTER, true);
+    f.checkCanRollUp(HOUR, YEAR, true);
+    f.checkCanRollUp(HOUR, ISOYEAR, true);
+    f.checkCanRollUp(HOUR, DECADE, true);
+    f.checkCanRollUp(HOUR, CENTURY, true);
+    f.checkCanRollUp(HOUR, MILLENNIUM, true);
+
+    f.checkCanRollUp(DAY, NANOSECOND, false);
+    f.checkCanRollUp(DAY, MICROSECOND, false);
+    f.checkCanRollUp(DAY, MILLISECOND, false);
+    f.checkCanRollUp(DAY, SECOND, false);
+    f.checkCanRollUp(DAY, MINUTE, false);
+    f.checkCanRollUp(DAY, HOUR, false);
+    f.checkCanRollUp(DAY, DAY, true);
+    f.checkCanRollUp(DAY, WEEK, true);
+    f.checkCanRollUp(DAY, f.isoWeek, true);
+    f.checkCanRollUp(DAY, MONTH, true);
+    f.checkCanRollUp(DAY, QUARTER, true);
+    f.checkCanRollUp(DAY, YEAR, true);
+    f.checkCanRollUp(DAY, ISOYEAR, true);
+    f.checkCanRollUp(DAY, DECADE, true);
+    f.checkCanRollUp(DAY, CENTURY, true);
+    f.checkCanRollUp(DAY, MILLENNIUM, true);
+
+    // Note 1. WEEK cannot roll up to MONTH, YEAR or higher.
+    // Some weeks cross month, year, decade, century and millennium boundaries.
+
+    // Note 2. WEEK, MONTH, QUARTER, YEAR, DECADE, CENTURY, MILLENNIUM cannot
+    // roll up to ISOYEAR. Only f.ISOWEEK can roll up to ISOYEAR.
+
+    f.checkCanRollUp(WEEK, NANOSECOND, false);
+    f.checkCanRollUp(WEEK, MICROSECOND, false);
+    f.checkCanRollUp(WEEK, MILLISECOND, false);
+    f.checkCanRollUp(WEEK, SECOND, false);
+    f.checkCanRollUp(WEEK, MINUTE, false);
+    f.checkCanRollUp(WEEK, HOUR, false);
+    f.checkCanRollUp(WEEK, DAY, false);
+    f.checkCanRollUp(WEEK, WEEK, true);
+    f.checkCanRollUp(WEEK, f.isoWeek, false);
+    f.checkCanRollUp(WEEK, MONTH, false); // see note 1
+    f.checkCanRollUp(WEEK, QUARTER, false); // see note 1
+    f.checkCanRollUp(WEEK, YEAR, false); // see note 1
+    f.checkCanRollUp(WEEK, ISOYEAR, false); // see note 2
+    f.checkCanRollUp(WEEK, DECADE, false); // see note 1
+    f.checkCanRollUp(WEEK, CENTURY, false); // see note 1
+    f.checkCanRollUp(WEEK, MILLENNIUM, false); // see note 1
+
+    f.checkCanRollUp(f.isoWeek, NANOSECOND, false);
+    f.checkCanRollUp(f.isoWeek, MICROSECOND, false);
+    f.checkCanRollUp(f.isoWeek, MILLISECOND, false);
+    f.checkCanRollUp(f.isoWeek, SECOND, false);
+    f.checkCanRollUp(f.isoWeek, MINUTE, false);
+    f.checkCanRollUp(f.isoWeek, HOUR, false);
+    f.checkCanRollUp(f.isoWeek, DAY, false);
+    f.checkCanRollUp(f.isoWeek, WEEK, false);
+    f.checkCanRollUp(f.isoWeek, f.isoWeek, true);
+    f.checkCanRollUp(f.isoWeek, MONTH, false); // see note 1
+    f.checkCanRollUp(f.isoWeek, QUARTER, false); // see note 1
+    f.checkCanRollUp(f.isoWeek, YEAR, false); // see note 1
+    f.checkCanRollUp(f.isoWeek, ISOYEAR, true); // see note 2
+    f.checkCanRollUp(f.isoWeek, DECADE, false); // see note 1
+    f.checkCanRollUp(f.isoWeek, CENTURY, false); // see note 1
+    f.checkCanRollUp(f.isoWeek, MILLENNIUM, false); // see note 1
+
+    f.checkCanRollUp(MONTH, NANOSECOND, false);
+    f.checkCanRollUp(MONTH, MICROSECOND, false);
+    f.checkCanRollUp(MONTH, MILLISECOND, false);
+    f.checkCanRollUp(MONTH, SECOND, false);
+    f.checkCanRollUp(MONTH, MINUTE, false);
+    f.checkCanRollUp(MONTH, HOUR, false);
+    f.checkCanRollUp(MONTH, DAY, false);
+    f.checkCanRollUp(MONTH, WEEK, false);
+    f.checkCanRollUp(MONTH, f.isoWeek, false);
+    f.checkCanRollUp(MONTH, MONTH, true);
+    f.checkCanRollUp(MONTH, QUARTER, true);
+    f.checkCanRollUp(MONTH, YEAR, true);
+    f.checkCanRollUp(MONTH, ISOYEAR, false); // see note 2
+    f.checkCanRollUp(MONTH, DECADE, true);
+    f.checkCanRollUp(MONTH, CENTURY, true);
+    f.checkCanRollUp(MONTH, MILLENNIUM, true);
+
+    f.checkCanRollUp(QUARTER, NANOSECOND, false);
+    f.checkCanRollUp(QUARTER, MICROSECOND, false);
+    f.checkCanRollUp(QUARTER, MILLISECOND, false);
+    f.checkCanRollUp(QUARTER, SECOND, false);
+    f.checkCanRollUp(QUARTER, MINUTE, false);
+    f.checkCanRollUp(QUARTER, HOUR, false);
+    f.checkCanRollUp(QUARTER, DAY, false);
+    f.checkCanRollUp(QUARTER, WEEK, false);
+    f.checkCanRollUp(QUARTER, f.isoWeek, false);
+    f.checkCanRollUp(QUARTER, MONTH, false);
+    f.checkCanRollUp(QUARTER, QUARTER, true);
+    f.checkCanRollUp(QUARTER, YEAR, true);
+    f.checkCanRollUp(QUARTER, ISOYEAR, false); // see note 2
+    f.checkCanRollUp(QUARTER, DECADE, true);
+    f.checkCanRollUp(QUARTER, CENTURY, true);
+    f.checkCanRollUp(QUARTER, MILLENNIUM, true);
+
+    f.checkCanRollUp(YEAR, NANOSECOND, false);
+    f.checkCanRollUp(YEAR, MICROSECOND, false);
+    f.checkCanRollUp(YEAR, MILLISECOND, false);
+    f.checkCanRollUp(YEAR, SECOND, false);
+    f.checkCanRollUp(YEAR, MINUTE, false);
+    f.checkCanRollUp(YEAR, HOUR, false);
+    f.checkCanRollUp(YEAR, DAY, false);
+    f.checkCanRollUp(YEAR, WEEK, false);
+    f.checkCanRollUp(YEAR, f.isoWeek, false);
+    f.checkCanRollUp(YEAR, MONTH, false);
+    f.checkCanRollUp(YEAR, QUARTER, false);
+    f.checkCanRollUp(YEAR, YEAR, true);
+    f.checkCanRollUp(YEAR, ISOYEAR, false); // see note 2
+    f.checkCanRollUp(YEAR, DECADE, true);
+    f.checkCanRollUp(YEAR, CENTURY, true);
+    f.checkCanRollUp(YEAR, MILLENNIUM, true);
+
+    // Note 3. DECADE cannot roll up to CENTURY or MILLENNIUM
+    // because decade starts on year 0, the others start on year 1.
+    // For example, 2000 is start of a decade, but 2001 is start of a century
+    // and millennium.
+    f.checkCanRollUp(DECADE, NANOSECOND, false);
+    f.checkCanRollUp(DECADE, MICROSECOND, false);
+    f.checkCanRollUp(DECADE, MILLISECOND, false);
+    f.checkCanRollUp(DECADE, SECOND, false);
+    f.checkCanRollUp(DECADE, MINUTE, false);
+    f.checkCanRollUp(DECADE, HOUR, false);
+    f.checkCanRollUp(DECADE, DAY, false);
+    f.checkCanRollUp(DECADE, WEEK, false);
+    f.checkCanRollUp(DECADE, f.isoWeek, false);
+    f.checkCanRollUp(DECADE, MONTH, false);
+    f.checkCanRollUp(DECADE, QUARTER, false);
+    f.checkCanRollUp(DECADE, YEAR, false);
+    f.checkCanRollUp(DECADE, ISOYEAR, false); // see note 2
+    f.checkCanRollUp(DECADE, DECADE, true);
+    f.checkCanRollUp(DECADE, CENTURY, false); // see note 3
+    f.checkCanRollUp(DECADE, MILLENNIUM, false); // see note 3
+
+    f.checkCanRollUp(CENTURY, NANOSECOND, false);
+    f.checkCanRollUp(CENTURY, MICROSECOND, false);
+    f.checkCanRollUp(CENTURY, MILLISECOND, false);
+    f.checkCanRollUp(CENTURY, SECOND, false);
+    f.checkCanRollUp(CENTURY, MINUTE, false);
+    f.checkCanRollUp(CENTURY, HOUR, false);
+    f.checkCanRollUp(CENTURY, DAY, false);
+    f.checkCanRollUp(CENTURY, WEEK, false);
+    f.checkCanRollUp(CENTURY, f.isoWeek, false);
+    f.checkCanRollUp(CENTURY, MONTH, false);
+    f.checkCanRollUp(CENTURY, QUARTER, false);
+    f.checkCanRollUp(CENTURY, YEAR, false);
+    f.checkCanRollUp(CENTURY, ISOYEAR, false); // see note 2
+    f.checkCanRollUp(CENTURY, DECADE, false);
+    f.checkCanRollUp(CENTURY, CENTURY, true);
+    f.checkCanRollUp(CENTURY, MILLENNIUM, true);
+
+    f.checkCanRollUp(MILLENNIUM, NANOSECOND, false);
+    f.checkCanRollUp(MILLENNIUM, MICROSECOND, false);
+    f.checkCanRollUp(MILLENNIUM, MILLISECOND, false);
+    f.checkCanRollUp(MILLENNIUM, SECOND, false);
+    f.checkCanRollUp(MILLENNIUM, MINUTE, false);
+    f.checkCanRollUp(MILLENNIUM, HOUR, false);
+    f.checkCanRollUp(MILLENNIUM, DAY, false);
+    f.checkCanRollUp(MILLENNIUM, WEEK, false);
+    f.checkCanRollUp(MILLENNIUM, f.isoWeek, false);
+    f.checkCanRollUp(MILLENNIUM, MONTH, false);
+    f.checkCanRollUp(MILLENNIUM, QUARTER, false);
+    f.checkCanRollUp(MILLENNIUM, YEAR, false);
+    f.checkCanRollUp(MILLENNIUM, ISOYEAR, false); // see note 2
+    f.checkCanRollUp(MILLENNIUM, DECADE, false);
+    f.checkCanRollUp(MILLENNIUM, CENTURY, false);
+    f.checkCanRollUp(MILLENNIUM, MILLENNIUM, true);
+  }
+
+  /** Test fixture. Contains everything you need to write fluent tests. */
+  static class Fixture {
+    final TimeUnit isoWeek = TimeUnit.ISODOW;
+
+    final TimeFrameSet timeFrameSet = TimeFrames.CORE;
+
+    private static final ImmutableMap<String, Pair<String, String>> MAP;
+
+    static {
+      String[] values = {
+          "NANOSECOND", "2022-06-25 12:34:56.123234456",
+          "2022-06-25 12:34:56.123234456",
+          "MICROSECOND", "2022-06-25 12:34:56.123234",
+          "2022-06-25 12:34:56.123234",
+          "MILLISECOND", "2022-06-25 12:34:56.123", "2022-06-25 12:34:56.124",
+          "SECOND", "2022-06-25 12:34:56", "2022-06-25 12:34:57",
+          "MINUTE", "2022-06-25 12:34:00", "2022-06-25 12:35:00",
+          "HOUR", "2022-06-25 12:00:00", "2022-06-25 13:00:00",
+          "DAY", "2022-06-25 00:00:00", "2022-06-26 00:00:00",
+          "WEEK", "2022-06-19 00:00:00", "2022-06-26 00:00:00",
+          "ISOWEEK", "2022-06-20 00:00:00", "2022-06-27 00:00:00",
+          "MONTH", "2022-06-01 00:00:00", "2022-07-01 00:00:00",
+          "QUARTER", "2022-04-01 00:00:00", "2022-07-01 00:00:00",
+          "YEAR", "2022-01-01 00:00:00", "2023-01-01 00:00:00",
+          "ISOYEAR", "2022-01-03 00:00:00", "2023-01-02 00:00:00",
+          "DECADE", "2020-01-01 00:00:00", "2030-01-01 00:00:00",
+          "CENTURY", "2001-01-01 00:00:00", "2101-01-01 00:00:00",
+          "MILLENNIUM", "2001-01-01 00:00:00", "3001-01-01 00:00:00",
+      };
+      ImmutableMap.Builder<String, Pair<String, String>> b =
+          ImmutableMap.builder();
+      for (int i = 0; i < values.length;) {
+        b.put(values[i++], Pair.of(values[i++], values[i++]));
+      }
+      MAP = b.build();
+    }
+
+    private TimeFrame frame(TimeUnit unit) {
+      if (unit == ISODOW) {
+        // Just for testing. We want to test f.ISOWEEK but there is no TimeUnit
+        // for it, so we use ISODOW as a stand-in.
+        return timeFrameSet.get("ISOWEEK");
+      }
+      return timeFrameSet.get(unit);
+    }
+
+    void checkDateFloor(String in, TimeUnit unit, Matcher<String> matcher) {
+      int inDate = dateStringToUnixDate(in);
+      int outDate = timeFrameSet.floorDate(inDate, frame(unit));
+      assertThat("floor(" + in + " to " + unit + ")",
+          unixDateToString(outDate), matcher);
+    }
+
+    void checkDateFloor(String in, String timeFrameName, Matcher<String> matcher) {
+      int inDate = dateStringToUnixDate(in);
+      int outDate = timeFrameSet.floorDate(inDate, timeFrameSet.get(timeFrameName));
+      assertThat("floor(" + in + " to " + timeFrameName + ")",
+          unixDateToString(outDate), matcher);
+    }
+
+    void checkTimestampFloor(String in, TimeUnit unit, int precision,
+        Matcher<String> matcher) {
+      long inTs = timestampStringToUnixDate(in);
+      long outTs = timeFrameSet.floorTimestamp(inTs, frame(unit));
+      assertThat("floor(" + in + " to " + unit + ")",
+          unixTimestampToString(outTs, precision), matcher);
+    }
+
+    void checkTimestampCeil(String in, TimeUnit unit, int precision,
+        Matcher<String> matcher) {
+      long inTs = timestampStringToUnixDate(in);
+      long outTs = timeFrameSet.ceilTimestamp(inTs, frame(unit));
+      assertThat("ceil(" + in + " to " + unit + ")",
+          unixTimestampToString(outTs, precision), matcher);
+    }
+
+    void checkCanRollUp(TimeUnit fromUnit, TimeUnit toUnit, boolean can) {
+      TimeFrame fromFrame = frame(fromUnit);
+      TimeFrame toFrame = frame(toUnit);
+      if (can) {
+        assertThat("can roll up " + fromUnit + " to " + toUnit,
+            fromFrame.canRollUpTo(toFrame),
+            is(true));
+
+        final int precision;
+        switch (toUnit) {
+        case NANOSECOND:
+          precision = 9;
+          break;
+        case MICROSECOND:
+          precision = 6;
+          break;
+        case MILLISECOND:
+          precision = 3;
+          break;
+        default:
+          precision = 0;
+        }
+        if (precision <= 3) {
+          // Cannot test conversion to NANOSECOND or MICROSECOND because the
+          // representation is milliseconds.
+          final Pair<String, String> fromPair =
+              requireNonNull(MAP.get(fromFrame.name()));
+          final String timestampString = requireNonNull(fromPair.left);
+          final Pair<String, String> toPair =
+              requireNonNull(MAP.get(toFrame.name()));
+          final String floorTimestampString = requireNonNull(toPair.left);
+          final String ceilTimestampString = requireNonNull(toPair.right);
+          checkTimestampFloor(timestampString, toUnit, precision,
+              is(floorTimestampString));
+          checkTimestampCeil(timestampString, toUnit, precision,
+              is(ceilTimestampString));
+
+          final String dateString = timestampString.substring(0, 10);
+          final String floorDateString = floorTimestampString.substring(0, 10);
+          checkDateFloor(dateString, toUnit, is(floorDateString));
+        }
+
+        // The 'canRollUpTo' method should be a partial order.
+        // A partial order is reflexive (for all x, x = x)
+        // and antisymmetric (for all x, y, if x <= y and x != y, then !(y <= x))
+        assertThat(toFrame.canRollUpTo(fromFrame), is(fromUnit == toUnit));
+      } else {
+        assertThat("can roll up " + fromUnit + " to " + toUnit,
+            fromFrame.canRollUpTo(toFrame),
+            is(false));
+      }
+    }
+  }
+}
diff --git a/core/src/test/java/org/apache/calcite/test/TopDownOptTest.java b/core/src/test/java/org/apache/calcite/test/TopDownOptTest.java
index 1b933deb406..19b9d206391 100644
--- a/core/src/test/java/org/apache/calcite/test/TopDownOptTest.java
+++ b/core/src/test/java/org/apache/calcite/test/TopDownOptTest.java
@@ -24,6 +24,8 @@
 import org.apache.calcite.rel.rules.CoreRules;
 import org.apache.calcite.rel.rules.JoinPushThroughJoinRule;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.Test;
 
 import java.util.function.Consumer;
@@ -34,7 +36,7 @@
  * <p>As input, the test supplies a SQL statement and rules; the SQL is
  * translated into relational algebra and then fed into a
  * {@link VolcanoPlanner}. The plan before and after "optimization" is
- * diffed against a .ref file using {@link DiffRepository}.
+ * diffed against a reference file using {@link DiffRepository}.
  *
  * <p>Procedure for adding a new test case:
  *
@@ -51,8 +53,8 @@
  * <li>Verify that the "planBefore" is the correct
  * translation of your SQL, and that it contains the pattern on which your rule
  * is supposed to fire. If all is well, replace
- * {@code src/test/resources/.../TopDownOptTest.xml} and
- * with the new {@code build/resources/test/.../TopDownOptTest_actual.xml}.
+ * {@code src/test/resources/.../TopDownOptTest.xml} with
+ * the new {@code build/resources/test/.../TopDownOptTest_actual.xml}.
  *
  * <li>Run the test again. It should fail again, but this time it should contain
  * a "planAfter" entry for your rule. Verify that your rule applied its
@@ -63,9 +65,22 @@
  * </ol>
  */
 class TopDownOptTest {
+
+  @Nullable
+  private static DiffRepository diffRepos = null;
+
+  @AfterAll
+  public static void checkActualAndReferenceFiles() {
+    if (diffRepos != null) {
+      diffRepos.checkActualAndReferenceFiles();
+    }
+  }
+
   RelOptFixture fixture() {
-    return RelOptFixture.DEFAULT
+    RelOptFixture fixture = RelOptFixture.DEFAULT
         .withDiffRepos(DiffRepository.lookup(TopDownOptTest.class));
+    diffRepos = fixture.diffRepos();
+    return fixture;
   }
 
   RelOptFixture sql(String sql, Consumer<VolcanoPlanner> init) {
@@ -262,7 +277,7 @@ RelOptFixture sql(String sql, Consumer<VolcanoPlanner> init) {
       p.removeRule(EnumerableRules.ENUMERABLE_JOIN_RULE);
       p.removeRule(EnumerableRules.ENUMERABLE_MERGE_JOIN_RULE);
       p.removeRule(EnumerableRules.ENUMERABLE_SORT_RULE);
-    }).check();
+    }).withExpand(true).check();
   }
 
   // test if "order by mgr desc nulls last" can be pushed through the projection ("select mgr").
diff --git a/core/src/test/java/org/apache/calcite/test/TypeCoercionConverterTest.java b/core/src/test/java/org/apache/calcite/test/TypeCoercionConverterTest.java
index ac7fbb185e6..a0c33cde2b4 100644
--- a/core/src/test/java/org/apache/calcite/test/TypeCoercionConverterTest.java
+++ b/core/src/test/java/org/apache/calcite/test/TypeCoercionConverterTest.java
@@ -18,12 +18,15 @@
 
 import org.apache.calcite.sql.validate.implicit.TypeCoercion;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.Test;
 
 /**
- * Test cases for implicit type coercion converter. see {@link TypeCoercion} doc
+ * Test cases for implicit type coercion converter. See {@link TypeCoercion} doc
  * or <a href="https://docs.google.com/spreadsheets/d/1GhleX5h5W8-kJKh7NMJ4vtoE78pwfaZRJl88ULX_MgU/edit?usp=sharing">CalciteImplicitCasts</a>
  * for conversion details.
+ * See {@link RelOptRulesTest} for an explanation of how to add tests.
  */
 class TypeCoercionConverterTest extends SqlToRelTestBase {
 
@@ -33,7 +36,18 @@ class TypeCoercionConverterTest extends SqlToRelTestBase {
           .withFactory(f -> f.withCatalogReader(TCatalogReader::create))
           .withDecorrelate(false);
 
+  @Nullable
+  private static DiffRepository diffRepos = null;
+
+  @AfterAll
+  public static void checkActualAndReferenceFiles() {
+    if (diffRepos != null) {
+      diffRepos.checkActualAndReferenceFiles();
+    }
+  }
+
   @Override public SqlToRelFixture fixture() {
+    diffRepos = FIXTURE.diffRepos();
     return FIXTURE;
   }
 
@@ -126,6 +140,39 @@ class TypeCoercionConverterTest extends SqlToRelTestBase {
     sql(sql).ok();
   }
 
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-4897">[CALCITE-4897]
+   * Set operation in DML, implicit type conversion is not complete</a>. */
+  @Test void testInsertUnionQuerySourceCoercion() {
+    final String sql = "insert into t1 "
+        + "select 'a', 1, 1.0,"
+        + " 0, 0, 0, 0, TIMESTAMP '2021-11-28 00:00:00', date '2021-11-28', x'0A', false union "
+        + "select 'b', 2, 2,"
+        + " 0, 0, 0, 0, TIMESTAMP '2021-11-28 00:00:00', date '2021-11-28', x'0A', false union "
+        + "select 'c', CAST(3 AS SMALLINT), 3.0,"
+        + " 0, 0, 0, 0, TIMESTAMP '2021-11-28 00:00:00', date '2021-11-28', x'0A', false union "
+        + "select 'd', 4, 4.0,"
+        + " 0, 0, 0, 0, TIMESTAMP '2021-11-28 00:00:00', date '2021-11-28', x'0A', false union "
+        + "select 'e', 5, 5.0,"
+        + " 0, 0, 0, 0, TIMESTAMP '2021-11-28 00:00:00', date '2021-11-28', x'0A', false";
+    sql(sql).ok();
+  }
+
+  @Test void testInsertValuesQuerySourceCoercion() {
+    final String sql = "insert into t1 values "
+        + "('a', 1, 1.0,"
+        + " 0, 0, 0, 0, TIMESTAMP '2021-11-28 00:00:00', date '2021-11-28', x'0A', false), "
+        + "('b', 2,  2,"
+        + " 0, 0, 0, 0, TIMESTAMP '2021-11-28 00:00:00', date '2021-11-28', x'0A', false), "
+        + "('c', CAST(3 AS SMALLINT),  3.0,"
+        + " 0, 0, 0, 0, TIMESTAMP '2021-11-28 00:00:00', date '2021-11-28', x'0A', false), "
+        + "('d', 4, 4.0,"
+        + " 0, 0, 0, 0, TIMESTAMP '2021-11-28 00:00:00', date '2021-11-28', x'0A', false), "
+        + "('e', 5, 5.0,"
+        + " 0, 0, 0, 0, TIMESTAMP '2021-11-28 00:00:00', date '2021-11-28', x'0A', false)";
+    sql(sql).ok();
+  }
+
   @Test void testUpdateQuerySourceCoercion() {
     final String sql = "update t1 set t1_varchar20=123, "
         + "t1_date=TIMESTAMP '2020-01-03 10:14:34', t1_int=12.3";
diff --git a/core/src/test/java/org/apache/calcite/test/TypeCoercionTest.java b/core/src/test/java/org/apache/calcite/test/TypeCoercionTest.java
index 8310dc5497e..c53f4f48083 100644
--- a/core/src/test/java/org/apache/calcite/test/TypeCoercionTest.java
+++ b/core/src/test/java/org/apache/calcite/test/TypeCoercionTest.java
@@ -512,6 +512,7 @@ private static ImmutableList<RelDataType> combine(
         builder.add(type);
       }
     }
+    builder.addAll(f.geometryTypes);
     f.checkShouldCast(checkedType10, builder.build());
     f.shouldCast(checkedType10, SqlTypeFamily.DECIMAL,
         SqlTypeUtil.getMaxPrecisionScaleDecimal(f.typeFactory));
@@ -555,8 +556,10 @@ private static ImmutableList<RelDataType> combine(
     f.shouldCast(checkedType14, SqlTypeFamily.NUMERIC, f.intType);
 
     // INTERVAL
-    RelDataType checkedType15 = f.typeFactory.createSqlIntervalType(
-        new SqlIntervalQualifier(TimeUnit.YEAR, TimeUnit.MONTH, SqlParserPos.ZERO));
+    RelDataType checkedType15 =
+        f.typeFactory.createSqlIntervalType(
+            new SqlIntervalQualifier(TimeUnit.YEAR, TimeUnit.MONTH,
+                SqlParserPos.ZERO));
     f.checkShouldCast(checkedType15, ImmutableList.of(checkedType15));
     f.shouldNotCast(checkedType15, SqlTypeFamily.DECIMAL);
     f.shouldNotCast(checkedType15, SqlTypeFamily.NUMERIC);
@@ -630,6 +633,7 @@ static class Fixture {
     final ImmutableList<RelDataType> charTypes;
     final ImmutableList<RelDataType> binaryTypes;
     final ImmutableList<RelDataType> booleanTypes;
+    final ImmutableList<RelDataType> geometryTypes;
 
     // single types
     final RelDataType nullType;
@@ -649,6 +653,7 @@ static class Fixture {
     final RelDataType charType;
     final RelDataType varcharType;
     final RelDataType varchar20Type;
+    final RelDataType geometryType;
 
     /** Creates a Fixture. */
     public static Fixture create(SqlTestFactory testFactory) {
@@ -679,6 +684,7 @@ protected Fixture(RelDataTypeFactory typeFactory,
       charType = this.typeFactory.createSqlType(SqlTypeName.CHAR);
       varcharType = this.typeFactory.createSqlType(SqlTypeName.VARCHAR);
       varchar20Type = this.typeFactory.createSqlType(SqlTypeName.VARCHAR, 20);
+      geometryType = this.typeFactory.createSqlType(SqlTypeName.GEOMETRY);
 
       // Initialize category types
 
@@ -700,6 +706,9 @@ protected Fixture(RelDataTypeFactory typeFactory,
       for (SqlTypeName typeName : SqlTypeName.BOOLEAN_TYPES) {
         builder3.add(this.typeFactory.createSqlType(typeName));
       }
+      for (SqlTypeName typeName : SqlTypeName.GEOMETRY_TYPES) {
+        builder3.add(this.typeFactory.createSqlType(typeName));
+      }
       atomicTypes = builder3.build();
       // COMPLEX
       ImmutableList.Builder<RelDataType> builder4 = ImmutableList.builder();
@@ -714,8 +723,10 @@ protected Fixture(RelDataTypeFactory typeFactory,
       // ALL
       SqlIntervalQualifier intervalQualifier =
           new SqlIntervalQualifier(TimeUnit.DAY, TimeUnit.MINUTE, SqlParserPos.ZERO);
-      allTypes = combine(atomicTypes, complexTypes,
-          ImmutableList.of(nullType, this.typeFactory.createSqlIntervalType(intervalQualifier)));
+      allTypes =
+          combine(atomicTypes, complexTypes,
+              ImmutableList.of(nullType,
+                  this.typeFactory.createSqlIntervalType(intervalQualifier)));
 
       // CHARACTERS
       ImmutableList.Builder<RelDataType> builder6 = ImmutableList.builder();
@@ -735,6 +746,12 @@ protected Fixture(RelDataTypeFactory typeFactory,
         builder8.add(this.typeFactory.createSqlType(typeName));
       }
       booleanTypes = builder8.build();
+      // GEOMETRY
+      ImmutableList.Builder<RelDataType> builder9 = ImmutableList.builder();
+      for (SqlTypeName typeName : SqlTypeName.GEOMETRY_TYPES) {
+        builder9.add(this.typeFactory.createSqlType(typeName));
+      }
+      geometryTypes = builder9.build();
     }
 
     public Fixture withTypeFactory(RelDataTypeFactory typeFactory) {
diff --git a/core/src/test/java/org/apache/calcite/test/concurrent/ConcurrentTestCommandScript.java b/core/src/test/java/org/apache/calcite/test/concurrent/ConcurrentTestCommandScript.java
index 76ff9fc54de..e0e96aa6dda 100644
--- a/core/src/test/java/org/apache/calcite/test/concurrent/ConcurrentTestCommandScript.java
+++ b/core/src/test/java/org/apache/calcite/test/concurrent/ConcurrentTestCommandScript.java
@@ -231,7 +231,7 @@ public class ConcurrentTestCommandScript
   private static final char[] DASHES = fill(new char[BUF_SIZE], '-');
 
   // Special "thread ids" for setup & cleanup sections; actually setup &
-  // cleanup SQL is executed by the main thread, and neither are in the the
+  // cleanup SQL is executed by the main thread, and neither are in the
   // thread map.
   private static final Integer SETUP_THREAD_ID = -1;
   private static final Integer CLEANUP_THREAD_ID = -2;
@@ -1570,7 +1570,7 @@ protected void doExecute(ConcurrentTestCommandExecutor executor) {
       ProcessBuilder pb = new ProcessBuilder(argv);
       pb.directory(scriptDirectory);
       try {
-        // direct stdout & stderr to the the threadWriter
+        // direct stdout & stderr to the threadWriter
         int status = runAppProcess(pb, null, null, getThreadWriter(threadId));
         if (status != 0) {
           storeMessage(threadId,
diff --git a/core/src/test/java/org/apache/calcite/test/enumerable/EnumerableJoinTest.java b/core/src/test/java/org/apache/calcite/test/enumerable/EnumerableJoinTest.java
index e3a2c6d3882..ccd311c8312 100644
--- a/core/src/test/java/org/apache/calcite/test/enumerable/EnumerableJoinTest.java
+++ b/core/src/test/java/org/apache/calcite/test/enumerable/EnumerableJoinTest.java
@@ -313,17 +313,19 @@ class EnumerableJoinTest {
             + "    EnumerableCalc(expr#0..4=[{inputs}], expr#5=[2], expr#6=[=($t0, $t5)], empid=[$t0], name=[$t2], $condition=[$t6])\n"
             + "      EnumerableTableScan(table=[[s, emps]])\n"
             + "  EnumerableTableSpool(readType=[LAZY], writeType=[LAZY], table=[[#DELTA#]])\n"
-            + "    EnumerableCalc(expr#0..8=[{inputs}], empid=[$t4], name=[$t6])\n"
-            + "      EnumerableMergeJoin(condition=[=($3, $4)], joinType=[inner])\n"
-            + "        EnumerableSort(sort0=[$3], dir0=[ASC])\n"
-            + "          EnumerableMergeJoin(condition=[=($0, $2)], joinType=[inner])\n"
+            + "    EnumerableCalc(expr#0..4=[{inputs}], empid=[$t3], name=[$t4])\n"
+            + "      EnumerableMergeJoin(condition=[=($2, $3)], joinType=[inner])\n"
+            + "        EnumerableSort(sort0=[$2], dir0=[ASC])\n"
+            + "          EnumerableMergeJoin(condition=[=($0, $1)], joinType=[inner])\n"
             + "            EnumerableSort(sort0=[$0], dir0=[ASC])\n"
-            + "              EnumerableInterpreter\n"
-            + "                BindableTableScan(table=[[#DELTA#]])\n"
+            + "              EnumerableCalc(expr#0..1=[{inputs}], empid=[$t0])\n"
+            + "                EnumerableInterpreter\n"
+            + "                  BindableTableScan(table=[[#DELTA#]])\n"
             + "            EnumerableSort(sort0=[$0], dir0=[ASC])\n"
             + "              EnumerableTableScan(table=[[s, hierarchies]])\n"
             + "        EnumerableSort(sort0=[$0], dir0=[ASC])\n"
-            + "          EnumerableTableScan(table=[[s, emps]])\n")
+            + "          EnumerableCalc(expr#0..4=[{inputs}], empid=[$t0], name=[$t2])\n"
+            + "            EnumerableTableScan(table=[[s, emps]])\n")
         .returnsUnordered(""
             + "empid=2; name=Emp2\n"
             + "empid=3; name=Emp3\n"
diff --git a/core/src/test/java/org/apache/calcite/test/enumerable/EnumerableRepeatUnionTest.java b/core/src/test/java/org/apache/calcite/test/enumerable/EnumerableRepeatUnionTest.java
index f4a38781aa3..b7c18f4a336 100644
--- a/core/src/test/java/org/apache/calcite/test/enumerable/EnumerableRepeatUnionTest.java
+++ b/core/src/test/java/org/apache/calcite/test/enumerable/EnumerableRepeatUnionTest.java
@@ -302,16 +302,16 @@ class EnumerableRepeatUnionTest {
             + "    EnumerableCalc(expr#0..4=[{inputs}], expr#5=[2], expr#6=[=($t0, $t5)], empid=[$t0], name=[$t2], $condition=[$t6])\n"
             + "      EnumerableTableScan(table=[[s, emps]])\n"
             + "  EnumerableTableSpool(readType=[LAZY], writeType=[LAZY], table=[[#DELTA#]])\n"
-            + "    EnumerableCalc(expr#0..8=[{inputs}], empid=[$t4], name=[$t6])\n"
+            + "    EnumerableCalc(expr#0..4=[{inputs}], empid=[$t3], name=[$t4])\n"
             + "      EnumerableCorrelate(correlation=[$cor1], joinType=[inner], requiredColumns=[{1}])\n"
             // It is important to have EnumerableCorrelate + #DELTA# table scan on its right
             // to reproduce the issue CALCITE-4054
             + "        EnumerableCorrelate(correlation=[$cor0], joinType=[inner], requiredColumns=[{0}])\n"
             + "          EnumerableTableScan(table=[[s, hierarchies]])\n"
-            + "          EnumerableCalc(expr#0..1=[{inputs}], expr#2=[$cor0], expr#3=[$t2.managerid], expr#4=[=($t0, $t3)], proj#0..1=[{exprs}], $condition=[$t4])\n"
+            + "          EnumerableCalc(expr#0..1=[{inputs}], expr#2=[$cor0], expr#3=[$t2.managerid], expr#4=[=($t0, $t3)], empid=[$t0], $condition=[$t4])\n"
             + "            EnumerableInterpreter\n"
             + "              BindableTableScan(table=[[#DELTA#]])\n"
-            + "        EnumerableCalc(expr#0..4=[{inputs}], expr#5=[$cor1], expr#6=[$t5.subordinateid], expr#7=[=($t6, $t0)], proj#0..4=[{exprs}], $condition=[$t7])\n"
+            + "        EnumerableCalc(expr#0..4=[{inputs}], expr#5=[$cor1], expr#6=[$t5.subordinateid], expr#7=[=($t6, $t0)], empid=[$t0], name=[$t2], $condition=[$t7])\n"
             + "          EnumerableTableScan(table=[[s, emps]])\n")
         .returnsUnordered(""
             + "empid=2; name=Emp2\n"
diff --git a/core/src/test/java/org/apache/calcite/test/enumerable/EnumerableUncollectTest.java b/core/src/test/java/org/apache/calcite/test/enumerable/EnumerableUncollectTest.java
index 78f6ebfa6e1..0721fae2778 100644
--- a/core/src/test/java/org/apache/calcite/test/enumerable/EnumerableUncollectTest.java
+++ b/core/src/test/java/org/apache/calcite/test/enumerable/EnumerableUncollectTest.java
@@ -34,6 +34,13 @@ class EnumerableUncollectTest {
             "y=4");
   }
 
+  @Test void simpleUnnestNullArray() {
+    final String sql = "SELECT * FROM UNNEST(CAST(null AS INTEGER ARRAY))";
+    tester()
+        .query(sql)
+        .returnsCount(0);
+  }
+
   @Test void simpleUnnestArrayOfArrays() {
     final String sql = "select * from UNNEST(array[array[3], array[4]]) as T2(y)";
     tester()
diff --git a/core/src/test/java/org/apache/calcite/tools/FrameworksTest.java b/core/src/test/java/org/apache/calcite/tools/FrameworksTest.java
index dbfb2d0a635..6ee04722039 100644
--- a/core/src/test/java/org/apache/calcite/tools/FrameworksTest.java
+++ b/core/src/test/java/org/apache/calcite/tools/FrameworksTest.java
@@ -114,11 +114,10 @@ public RelDataType getRowType(RelDataTypeFactory typeFactory) {
           };
 
           // "SELECT * FROM myTable"
-          final RelOptAbstractTable relOptTable = new RelOptAbstractTable(
-              relOptSchema,
-              "myTable",
-              table.getRowType(typeFactory)) {
-          };
+          final RelOptAbstractTable relOptTable =
+              new RelOptAbstractTable(relOptSchema, "myTable",
+                  table.getRowType(typeFactory)) {
+              };
           final EnumerableTableScan tableRel =
               EnumerableTableScan.create(cluster, relOptTable);
 
@@ -137,8 +136,7 @@ public RelDataType getRowType(RelDataTypeFactory typeFactory) {
           final RelOptPlanner planner = cluster.getPlanner();
           RelTraitSet desiredTraits =
               cluster.traitSet().replace(EnumerableConvention.INSTANCE);
-          final RelNode rootRel2 = planner.changeTraits(rootRel,
-              desiredTraits);
+          final RelNode rootRel2 = planner.changeTraits(rootRel, desiredTraits);
           planner.setRoot(rootRel2);
 
           // Now, plan.
diff --git a/core/src/test/java/org/apache/calcite/tools/PlannerTest.java b/core/src/test/java/org/apache/calcite/tools/PlannerTest.java
index 64eacf9031d..5c49ef900c2 100644
--- a/core/src/test/java/org/apache/calcite/tools/PlannerTest.java
+++ b/core/src/test/java/org/apache/calcite/tools/PlannerTest.java
@@ -65,7 +65,6 @@
 import org.apache.calcite.sql.SqlFunctionCategory;
 import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.SqlNode;
-import org.apache.calcite.sql.SqlOperatorTable;
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
 import org.apache.calcite.sql.parser.SqlParseException;
 import org.apache.calcite.sql.parser.SqlParser;
@@ -73,7 +72,6 @@
 import org.apache.calcite.sql.type.OperandTypes;
 import org.apache.calcite.sql.type.ReturnTypes;
 import org.apache.calcite.sql.type.SqlTypeName;
-import org.apache.calcite.sql.util.ListSqlOperatorTable;
 import org.apache.calcite.sql.util.SqlOperatorTables;
 import org.apache.calcite.sql.validate.SqlValidator;
 import org.apache.calcite.sql.validate.SqlValidatorScope;
@@ -145,8 +143,8 @@ private void checkParseAndConvert(String query,
   }
 
   @Test void testParseIdentifierMaxLengthWithIncreased() throws Exception {
-    Planner planner = getPlanner(null,
-        SqlParser.config().withIdentifierMaxLength(512));
+    Planner planner =
+        getPlanner(null, SqlParser.config().withIdentifierMaxLength(512));
     planner.parse("select name as "
         + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa from \"emps\"");
   }
@@ -206,16 +204,13 @@ private String toString(RelNode rel) {
   }
 
   @Test void testValidateUserDefinedAggregate() throws Exception {
-    final SqlStdOperatorTable stdOpTab = SqlStdOperatorTable.instance();
-    SqlOperatorTable opTab =
-        SqlOperatorTables.chain(stdOpTab,
-            new ListSqlOperatorTable(
-                ImmutableList.of(new MyCountAggFunction())));
     final SchemaPlus rootSchema = Frameworks.createRootSchema(true);
     final FrameworkConfig config = Frameworks.newConfigBuilder()
         .defaultSchema(
             CalciteAssert.addSchema(rootSchema, CalciteAssert.SchemaSpec.HR))
-        .operatorTable(opTab)
+        .operatorTable(
+            SqlOperatorTables.chain(SqlStdOperatorTable.instance(),
+                SqlOperatorTables.of(new MyCountAggFunction())))
         .build();
     final Planner planner = Frameworks.getPlanner(config);
     SqlNode parse =
@@ -476,8 +471,8 @@ private void emptyUnions32(UnionMergeRule... extraRules)
 
   private void checkUnionPruning(String sql, String plan, RelOptRule... extraRules)
       throws SqlParseException, ValidationException, RelConversionException {
-    ImmutableList.Builder<RelOptRule> rules = ImmutableList.<RelOptRule>builder().add(
-        PruneEmptyRules.UNION_INSTANCE,
+    ImmutableList.Builder<RelOptRule> rules = ImmutableList.builder();
+    rules.add(PruneEmptyRules.UNION_INSTANCE,
         CoreRules.PROJECT_FILTER_VALUES_MERGE,
         EnumerableRules.ENUMERABLE_PROJECT_RULE,
         EnumerableRules.ENUMERABLE_FILTER_RULE,
@@ -519,8 +514,7 @@ private void checkUnionPruning(String sql, String plan, RelOptRule... extraRules
 
     RelOptPlanner planner = relNode.getCluster().getPlanner();
     RuleSet ruleSet =
-        RuleSets.ofList(
-            PruneEmptyRules.UNION_INSTANCE,
+        RuleSets.ofList(PruneEmptyRules.UNION_INSTANCE,
             CoreRules.FILTER_VALUES_MERGE,
             EnumerableRules.ENUMERABLE_PROJECT_RULE,
             EnumerableRules.ENUMERABLE_FILTER_RULE,
@@ -531,8 +525,9 @@ private void checkUnionPruning(String sql, String plan, RelOptRule... extraRules
     RelTraitSet toTraits = relNode.getTraitSet()
         .replace(EnumerableConvention.INSTANCE);
 
-    RelNode output = program.run(planner, relNode, toTraits,
-        ImmutableList.of(), ImmutableList.of());
+    RelNode output =
+        program.run(planner, relNode, toTraits,
+            ImmutableList.of(), ImmutableList.of());
 
     // Expected outcomes are:
     // 1) relation is optimized to simple VALUES
@@ -549,15 +544,13 @@ private void checkUnionPruning(String sql, String plan, RelOptRule... extraRules
    * plans for query using ORDER BY. */
   @Test void testSortPlan() throws Exception {
     RuleSet ruleSet =
-        RuleSets.ofList(
-            CoreRules.SORT_REMOVE,
+        RuleSets.ofList(CoreRules.SORT_REMOVE,
             EnumerableRules.ENUMERABLE_TABLE_SCAN_RULE,
             EnumerableRules.ENUMERABLE_PROJECT_RULE,
             EnumerableRules.ENUMERABLE_SORT_RULE);
     Planner planner = getPlanner(null, Programs.of(ruleSet));
-    SqlNode parse = planner.parse(
-        "select * from \"emps\" "
-            + "order by \"emps\".\"deptno\"");
+    final String sql = "select * from \"emps\" order by \"emps\".\"deptno\"";
+    SqlNode parse = planner.parse(sql);
     SqlNode validate = planner.validate(parse);
     RelNode convert = planner.rel(validate).project();
     RelTraitSet traitSet = convert.getTraitSet()
@@ -578,8 +571,7 @@ private void checkUnionPruning(String sql, String plan, RelOptRule... extraRules
    */
   @Test void testRedundantSortOnJoinPlan() throws Exception {
     RuleSet ruleSet =
-        RuleSets.ofList(
-            CoreRules.SORT_REMOVE,
+        RuleSets.ofList(CoreRules.SORT_REMOVE,
             CoreRules.SORT_JOIN_TRANSPOSE,
             CoreRules.SORT_PROJECT_TRANSPOSE,
             EnumerableRules.ENUMERABLE_TABLE_SCAN_RULE,
@@ -588,12 +580,12 @@ private void checkUnionPruning(String sql, String plan, RelOptRule... extraRules
             EnumerableRules.ENUMERABLE_PROJECT_RULE,
             EnumerableRules.ENUMERABLE_SORT_RULE);
     Planner planner = getPlanner(null, Programs.of(ruleSet));
-    SqlNode parse = planner.parse(
-        "select e.\"deptno\" from \"emps\" e "
-            + "left outer join \"depts\" d "
-            + " on e.\"deptno\" = d.\"deptno\" "
-            + "order by e.\"deptno\" "
-            + "limit 10");
+    final String sql = "select e.\"deptno\" from \"emps\" e "
+        + "left outer join \"depts\" d "
+        + " on e.\"deptno\" = d.\"deptno\" "
+        + "order by e.\"deptno\" "
+        + "limit 10";
+    SqlNode parse = planner.parse(sql);
     SqlNode validate = planner.validate(parse);
     RelNode convert = planner.rel(validate).rel;
     RelTraitSet traitSet = convert.getTraitSet()
@@ -685,15 +677,15 @@ private void checkUnionPruning(String sql, String plan, RelOptRule... extraRules
   // "Redundant throws: 'RelConversionException' listed more then one time"
   private void runDuplicateSortCheck(String sql, String plan) throws Exception {
     RuleSet ruleSet =
-        RuleSets.ofList(
-            CoreRules.SORT_REMOVE,
+        RuleSets.ofList(CoreRules.SORT_REMOVE,
             EnumerableRules.ENUMERABLE_TABLE_SCAN_RULE,
             EnumerableRules.ENUMERABLE_PROJECT_RULE,
             EnumerableRules.ENUMERABLE_WINDOW_RULE,
             EnumerableRules.ENUMERABLE_SORT_RULE,
             CoreRules.PROJECT_TO_LOGICAL_PROJECT_AND_WINDOW);
-    Planner planner = getPlanner(null, SqlParser.config().withLex(Lex.JAVA),
-        Programs.of(ruleSet));
+    Planner planner =
+        getPlanner(null, SqlParser.config().withLex(Lex.JAVA),
+            Programs.of(ruleSet));
     SqlNode parse = planner.parse(sql);
     SqlNode validate = planner.validate(parse);
     RelNode convert = planner.rel(validate).rel;
@@ -711,17 +703,16 @@ private void runDuplicateSortCheck(String sql, String plan) throws Exception {
    * plans for query using two duplicate order by.*/
   @Test void testDuplicateSortPlanWORemoveSortRule() throws Exception {
     RuleSet ruleSet =
-        RuleSets.ofList(
-            EnumerableRules.ENUMERABLE_TABLE_SCAN_RULE,
+        RuleSets.ofList(EnumerableRules.ENUMERABLE_TABLE_SCAN_RULE,
             EnumerableRules.ENUMERABLE_PROJECT_RULE,
             EnumerableRules.ENUMERABLE_SORT_RULE);
     Planner planner = getPlanner(null, Programs.of(ruleSet));
-    SqlNode parse = planner.parse(
-        "select \"empid\" from ( "
-            + "select * "
-            + "from \"emps\" "
-            + "order by \"emps\".\"deptno\") "
-            + "order by \"deptno\"");
+    final String sql = "select \"empid\" from ( "
+        + "select * "
+        + "from \"emps\" "
+        + "order by \"emps\".\"deptno\") "
+        + "order by \"deptno\"";
+    SqlNode parse = planner.parse(sql);
     SqlNode validate = planner.validate(parse);
     RelNode convert = planner.rel(validate).rel;
     RelTraitSet traitSet = convert.getTraitSet()
@@ -739,8 +730,8 @@ private void runDuplicateSortCheck(String sql, String plan) throws Exception {
    * SQL-oriented</a>. */
   @Test void testInsertSourceRelTypeWithNullValues() throws Exception {
     Planner planner = getPlanner(null, Programs.standard());
-    SqlNode parse = planner.parse(
-        "insert into \"emps\" values(1, 1, null, 1, 1)");
+    final String sql = "insert into \"emps\" values(1, 1, null, 1, 1)";
+    SqlNode parse = planner.parse(sql);
     SqlNode validate = planner.validate(parse);
     RelNode convert = planner.rel(validate).rel;
     RelDataType insertSourceType = convert.getInput(0).getRowType();
@@ -754,8 +745,7 @@ private void runDuplicateSortCheck(String sql, String plan) throws Exception {
    * provided with a list of RelTraitDefs to register. */
   @Test void testPlanWithExplicitTraitDefs() throws Exception {
     RuleSet ruleSet =
-        RuleSets.ofList(
-            CoreRules.FILTER_MERGE,
+        RuleSets.ofList(CoreRules.FILTER_MERGE,
             EnumerableRules.ENUMERABLE_TABLE_SCAN_RULE,
             EnumerableRules.ENUMERABLE_FILTER_RULE,
             EnumerableRules.ENUMERABLE_PROJECT_RULE);
@@ -780,8 +770,7 @@ private void runDuplicateSortCheck(String sql, String plan) throws Exception {
   /** Unit test that calls {@link Planner#transform} twice. */
   @Test void testPlanTransformTwice() throws Exception {
     RuleSet ruleSet =
-        RuleSets.ofList(
-            CoreRules.FILTER_MERGE,
+        RuleSets.ofList(CoreRules.FILTER_MERGE,
             EnumerableRules.ENUMERABLE_TABLE_SCAN_RULE,
             EnumerableRules.ENUMERABLE_FILTER_RULE,
             EnumerableRules.ENUMERABLE_PROJECT_RULE);
@@ -807,18 +796,15 @@ private void runDuplicateSortCheck(String sql, String plan) throws Exception {
     RelOptRule rule2 = MyFilterProjectRule.config("MYRULE").toRule();
 
     RuleSet ruleSet1 =
-        RuleSets.ofList(
-            rule1,
+        RuleSets.ofList(rule1,
             EnumerableRules.ENUMERABLE_TABLE_SCAN_RULE,
             EnumerableRules.ENUMERABLE_FILTER_RULE,
             EnumerableRules.ENUMERABLE_PROJECT_RULE);
 
-    RuleSet ruleSet2 =
-        RuleSets.ofList(
-            rule2);
+    RuleSet ruleSet2 = RuleSets.ofList(rule2);
 
-    Planner planner = getPlanner(null, Programs.of(ruleSet1),
-        Programs.of(ruleSet2));
+    Planner planner =
+        getPlanner(null, Programs.of(ruleSet1), Programs.of(ruleSet2));
     SqlNode parse = planner.parse("select * from \"emps\"");
     SqlNode validate = planner.validate(parse);
     RelNode convert = planner.rel(validate).rel;
@@ -835,9 +821,9 @@ private void runDuplicateSortCheck(String sql, String plan) throws Exception {
   /** Tests that Hive dialect does not generate "AS". */
   @Test void testHiveDialect() throws SqlParseException {
     Planner planner = getPlanner(null);
-    SqlNode parse = planner.parse(
-        "select * from (select * from \"emps\") as t\n"
-            + "where \"name\" like '%e%'");
+    final String sql = "select * from (select * from \"emps\") as t\n"
+        + "where \"name\" like '%e%'";
+    SqlNode parse = planner.parse(sql);
     final SqlDialect hiveDialect =
         SqlDialect.DatabaseProduct.HIVE.getDialect();
     assertThat(Util.toLinux(parse.toSqlString(hiveDialect).getSql()),
@@ -864,8 +850,9 @@ private void runDuplicateSortCheck(String sql, String plan) throws Exception {
             EnumerableRules.ENUMERABLE_PROJECT_RULE);
 
     JdbcConvention out = new JdbcConvention(null, null, "myjdbc");
-    Program program1 = Programs.ofRules(
-        MockJdbcProjectRule.create(out), MockJdbcTableRule.create(out));
+    Program program1 =
+        Programs.ofRules(MockJdbcProjectRule.create(out),
+            MockJdbcTableRule.create(out));
 
     Planner planner = getPlanner(null, program0, program1);
     SqlNode parse = planner.parse("select T1.\"name\" from \"emps\" as T1 ");
@@ -929,8 +916,8 @@ private void checkJoinNWay(int n) throws Exception {
       buf.append("\njoin \"depts\" as d").append(i);
       buf.append("\non d").append(i).append(".\"deptno\" = d").append(i - 1).append(".\"deptno\"");
     }
-    Planner planner = getPlanner(null,
-        Programs.heuristicJoinOrder(Programs.RULE_SET, false, 6));
+    Planner planner =
+        getPlanner(null, Programs.heuristicJoinOrder(Programs.RULE_SET, false, 6));
     SqlNode parse = planner.parse(buf.toString());
 
     SqlNode validate = planner.validate(parse);
@@ -1009,8 +996,8 @@ private void checkJoinNWay(int n) throws Exception {
   }
 
   private void checkHeuristic(String sql, String expected) throws Exception {
-    Planner planner = getPlanner(null,
-        Programs.heuristicJoinOrder(Programs.RULE_SET, false, 0));
+    Planner planner =
+        getPlanner(null, Programs.heuristicJoinOrder(Programs.RULE_SET, false, 0));
     SqlNode parse = planner.parse(sql);
     SqlNode validate = planner.validate(parse);
     RelNode convert = planner.rel(validate).rel;
@@ -1482,12 +1469,13 @@ public RelDataType deriveType(SqlValidator validator,
     final Program program = Programs.of(ruleSet);
     final RelTraitSet toTraits = relNode.getTraitSet()
         .replace(EnumerableConvention.INSTANCE);
-    final RelNode output = program.run(planner, relNode, toTraits,
-        ImmutableList.of(), ImmutableList.of());
+    final RelNode output =
+        program.run(planner, relNode, toTraits, ImmutableList.of(),
+            ImmutableList.of());
     final String plan = toString(output);
     assertThat(plan,
-        equalTo(
-            "EnumerableCorrelate(correlation=[$cor0], joinType=[inner], requiredColumns=[{7}])\n"
+        equalTo("EnumerableCorrelate(correlation=[$cor0], joinType=[inner], "
+            + "requiredColumns=[{7}])\n"
             + "  EnumerableUnion(all=[true])\n"
             + "    EnumerableTableScan(table=[[scott, EMP]])\n"
             + "    EnumerableTableScan(table=[[scott, EMP]])\n"
diff --git a/core/src/test/java/org/apache/calcite/util/FormatModelTest.java b/core/src/test/java/org/apache/calcite/util/FormatModelTest.java
new file mode 100644
index 00000000000..b313b652e0d
--- /dev/null
+++ b/core/src/test/java/org/apache/calcite/util/FormatModelTest.java
@@ -0,0 +1,67 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.util;
+
+import org.apache.calcite.util.format.FormatElement;
+import org.apache.calcite.util.format.FormatModel;
+import org.apache.calcite.util.format.FormatModels;
+
+import org.hamcrest.Matcher;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.is;
+
+/**
+ * Unit test for {@link FormatModel}.
+ */
+public class FormatModelTest {
+
+  private void assertThatFormatElementParse(String formatString,
+      Matcher<List<String>> matcher) {
+    List<FormatElement> elements = FormatModels.BIG_QUERY.parse(formatString);
+    List<String> stringResults = new ArrayList<>();
+    for (FormatElement element : elements) {
+      element.flatten(i -> stringResults.add(i.toString()));
+    }
+    assertThat(stringResults, matcher);
+  }
+
+  @Test void testSingleElement() {
+    assertThatFormatElementParse("%j", is(Collections.singletonList("DDD")));
+  }
+
+  @Test void testMultipleElements() {
+    assertThatFormatElementParse("%b-%d-%Y",
+        is(Arrays.asList("MON", "-", "DD", "-", "YYYY")));
+  }
+
+  @Test void testArbitraryText() {
+    assertThatFormatElementParse("%jtext%b",
+        is(Arrays.asList("DDD", "text", "MON")));
+  }
+
+  @Test void testAliasText() {
+    assertThatFormatElementParse("%R",
+        is(Arrays.asList("HH24", ":", "MI")));
+  }
+}
diff --git a/core/src/test/java/org/apache/calcite/util/PermutationTestCase.java b/core/src/test/java/org/apache/calcite/util/PermutationTestCase.java
index 3e091145a77..61b19a1d524 100644
--- a/core/src/test/java/org/apache/calcite/util/PermutationTestCase.java
+++ b/core/src/test/java/org/apache/calcite/util/PermutationTestCase.java
@@ -164,22 +164,25 @@ class PermutationTestCase {
         typeFactory.createSqlType(SqlTypeName.DOUBLE);
 
     // A project with [1, 1] is not a permutation, so should return null
-    final Permutation perm = Project.getPermutation(2,
-        ImmutableList.of(builder.makeInputRef(doubleType, 1),
-            builder.makeInputRef(doubleType, 1)));
+    final Permutation perm =
+        Project.getPermutation(2,
+            ImmutableList.of(builder.makeInputRef(doubleType, 1),
+                builder.makeInputRef(doubleType, 1)));
     assertThat(perm, nullValue());
 
     // A project with [0, 1, 0] is not a permutation, so should return null
-    final Permutation perm1 = Project.getPermutation(2,
-        ImmutableList.of(builder.makeInputRef(doubleType, 0),
-            builder.makeInputRef(doubleType, 1),
-            builder.makeInputRef(doubleType, 0)));
+    final Permutation perm1 =
+        Project.getPermutation(2,
+            ImmutableList.of(builder.makeInputRef(doubleType, 0),
+                builder.makeInputRef(doubleType, 1),
+                builder.makeInputRef(doubleType, 0)));
     assertThat(perm1, nullValue());
 
     // A project of [1, 0] is a valid permutation!
-    final Permutation perm2 = Project.getPermutation(2,
-        ImmutableList.of(builder.makeInputRef(doubleType, 1),
-            builder.makeInputRef(doubleType, 0)));
+    final Permutation perm2 =
+        Project.getPermutation(2,
+            ImmutableList.of(builder.makeInputRef(doubleType, 1),
+                builder.makeInputRef(doubleType, 0)));
     assertThat(perm2, is(new Permutation(new int[]{1, 0})));
   }
 }
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 6546dcbbb3a..683c561a5a3 100644
--- a/core/src/test/java/org/apache/calcite/util/SourceTest.java
+++ b/core/src/test/java/org/apache/calcite/util/SourceTest.java
@@ -82,11 +82,8 @@ static Stream<Arguments> relativePaths() {
         arguments("abc def.txt", "file:abc%20def.txt"),
         arguments("abc+def.txt", "file:abc+def.txt"),
         arguments("path 1/ subfolder 2/abc.t x t", "file:path%201/%20subfolder%202/abc.t%20x%20t"),
-        arguments(
-            "маленькой ёлочке холодно зимой.txt",
-            "file:маленькой%20ёлочке%20холодно%20зимой.txt"
-        )
-    );
+        arguments("маленькой ёлочке холодно зимой.txt",
+            "file:маленькой%20ёлочке%20холодно%20зимой.txt"));
   }
 
   private static String slashify(String path) {
diff --git a/core/src/test/java/org/apache/calcite/util/UtilTest.java b/core/src/test/java/org/apache/calcite/util/UtilTest.java
index 92078f2898d..f03eae6cfe6 100644
--- a/core/src/test/java/org/apache/calcite/util/UtilTest.java
+++ b/core/src/test/java/org/apache/calcite/util/UtilTest.java
@@ -47,12 +47,11 @@
 import com.google.common.collect.Lists;
 import com.google.common.primitives.Ints;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
 import org.hamcrest.Description;
 import org.hamcrest.Matcher;
 import org.hamcrest.StringDescription;
 import org.hamcrest.TypeSafeMatcher;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 import org.junit.jupiter.api.Test;
 
 import java.io.PrintWriter;
@@ -986,7 +985,7 @@ private List<Integer> makeConsList(int start, int end) {
 
     final List<Pair<String, Integer>> pairs =
         Pair.zip(strings, integers, false);
-    final Map<String, Integer> map = ImmutableMap.copyOf(pairs);
+    final Map<String, Integer> map = Compatible.copyOf(pairs);
 
     // shorter list on the right
     final AtomicInteger size = new AtomicInteger();
@@ -1206,8 +1205,7 @@ private List<Integer> makeConsList(int start, int end) {
     assertThat(list2.appendAll(list2), is(Arrays.asList(1, 3, 5, 1, 3, 5)));
     assertThat(
         Arrays.toString(ImmutableIntList.of(1).toArray(new Integer[]{5, 6, 7})),
-        is("[1, null, 7]")
-    );
+        is("[1, null, 7]"));
   }
 
   /** Unit test for {@link IdPair}. */
@@ -1641,12 +1639,10 @@ private <E> List<E> l3(E e0, E e1, E e2) {
     CompositeMap<String, Integer> map = CompositeMap.of(beatleMap);
     checkCompositeMap(beatles, map);
 
-    map = CompositeMap.of(
-        beatleMap, Collections.emptyMap());
+    map = CompositeMap.of(beatleMap, Collections.emptyMap());
     checkCompositeMap(beatles, map);
 
-    map = CompositeMap.of(
-        Collections.emptyMap(), beatleMap);
+    map = CompositeMap.of(Collections.emptyMap(), beatleMap);
     checkCompositeMap(beatles, map);
 
     map = CompositeMap.of(beatleMap, beatleMap);
@@ -2057,10 +2053,10 @@ private NavigableSet<String> checkNav(NavigableSet<String> set, String s) {
   /** Tests {@link ReflectUtil#mightBeAssignableFrom(Class, Class)}. */
   @Test void testMightBeAssignableFrom() {
     final Object myMap = new HashMap<String, Integer>() {
-      @Override public @NotNull Set<Entry<String, Integer>> entrySet() {
+      @Override public Set<Entry<String, Integer>> entrySet() {
         throw new UnsupportedOperationException();
       }
-      @Override public @Nullable Integer put(String key, Integer value) {
+      @Override public Integer put(String key, Integer value) {
         throw new UnsupportedOperationException();
       }
       @Override public int size() {
@@ -2345,7 +2341,8 @@ private void checkListToString(String... strings) {
     memo1.close();
     assertThat(local1.get(), is("foo"));
 
-    final TryThreadLocal<String> local2 = TryThreadLocal.of(null);
+    final TryThreadLocal<@Nullable String> local2 =
+        TryThreadLocal.of(null);
     assertThat(local2.get(), nullValue());
     TryThreadLocal.Memo memo2 = local2.push("a");
     assertThat(local2.get(), is("a"));
@@ -2738,6 +2735,49 @@ private void checkNameMultimap(String s, NameMultimap<Integer> map) {
     assertThat(map.containsKey("zyMurgy", false), is(true));
   }
 
+  /** Test {@link MonotonicSupplier}. */
+  @Test void testMonotonicSupplier() {
+    final MonotonicSupplier<String> monotonicSupplier =
+        new MonotonicSupplier<>();
+
+    // Cannot 'get' before 'accept'
+    try {
+      final String s = monotonicSupplier.get();
+      fail("expected error, got " + s);
+    } catch (IllegalArgumentException e) {
+      assertThat(e.getMessage(), is("accept has not been called"));
+    }
+
+    // Does not accept null
+    try {
+      //noinspection ConstantConditions
+      monotonicSupplier.accept(null);
+      fail("expected error");
+    } catch (NullPointerException e) {
+      assertThat(e.getMessage(), is("element must not be null"));
+    }
+
+    monotonicSupplier.accept("hello");
+
+    // After 'accept' we can call 'get' multiple times
+    final String s = monotonicSupplier.get();
+    assertThat(s, is("hello"));
+
+    final String s2 = monotonicSupplier.get();
+    assertThat(s2, is("hello"));
+
+    // Does not 'accept' twice
+    try {
+      monotonicSupplier.accept("goodbye");
+      fail("expected error");
+    } catch (IllegalArgumentException e) {
+      assertThat(e.getMessage(), is("accept has been called already"));
+    }
+
+    final String s3 = monotonicSupplier.get();
+    assertThat(s3, is("hello"));
+  }
+
   @Test void testNlsStringClone() {
     final NlsString s = new NlsString("foo", "LATIN1", SqlCollation.IMPLICIT);
     assertThat(s.toString(), is("_LATIN1'foo'"));
@@ -2976,6 +3016,7 @@ private void checkNameMultimap(String s, NameMultimap<Integer> map) {
       }
     }
   }
+
   private static <E> Matcher<Iterable<E>> isIterable(final Iterable<E> iterable) {
     final List<E> list = toList(iterable);
     return new TypeSafeMatcher<Iterable<E>>() {
diff --git a/core/src/test/resources/org/apache/calcite/rel/metadata/janino/GeneratedMetadata_ColumnOriginHandler.java b/core/src/test/resources/org/apache/calcite/rel/metadata/janino/GeneratedMetadata_ColumnOriginHandler.java
index d689d4a1157..6063a0e0060 100644
--- a/core/src/test/resources/org/apache/calcite/rel/metadata/janino/GeneratedMetadata_ColumnOriginHandler.java
+++ b/core/src/test/resources/org/apache/calcite/rel/metadata/janino/GeneratedMetadata_ColumnOriginHandler.java
@@ -90,6 +90,8 @@ private java.util.Set getColumnOrigins_(
       return provider0.getColumnOrigins((org.apache.calcite.rel.core.TableFunctionScan) r, mq, a2);
     } else if (r instanceof org.apache.calcite.rel.core.TableModify) {
       return provider0.getColumnOrigins((org.apache.calcite.rel.core.TableModify) r, mq, a2);
+    } else if (r instanceof org.apache.calcite.rel.core.TableScan) {
+      return provider0.getColumnOrigins((org.apache.calcite.rel.core.TableScan) r, mq, a2);
     } else if (r instanceof org.apache.calcite.rel.RelNode) {
       return provider0.getColumnOrigins((org.apache.calcite.rel.RelNode) r, mq, a2);
     } else {
diff --git a/core/src/test/resources/org/apache/calcite/rel/metadata/janino/GeneratedMetadata_DistinctRowCountHandler.java b/core/src/test/resources/org/apache/calcite/rel/metadata/janino/GeneratedMetadata_DistinctRowCountHandler.java
index 52bd502e3e7..52ad30b842e 100644
--- a/core/src/test/resources/org/apache/calcite/rel/metadata/janino/GeneratedMetadata_DistinctRowCountHandler.java
+++ b/core/src/test/resources/org/apache/calcite/rel/metadata/janino/GeneratedMetadata_DistinctRowCountHandler.java
@@ -80,6 +80,8 @@ private java.lang.Double getDistinctRowCount_(
       return provider0.getDistinctRowCount((org.apache.calcite.rel.core.Sort) r, mq, a2, a3);
     } else if (r instanceof org.apache.calcite.rel.core.TableModify) {
       return provider0.getDistinctRowCount((org.apache.calcite.rel.core.TableModify) r, mq, a2, a3);
+    } else if (r instanceof org.apache.calcite.rel.core.TableScan) {
+      return provider0.getDistinctRowCount((org.apache.calcite.rel.core.TableScan) r, mq, a2, a3);
     } else if (r instanceof org.apache.calcite.rel.core.Union) {
       return provider0.getDistinctRowCount((org.apache.calcite.rel.core.Union) r, mq, a2, a3);
     } else if (r instanceof org.apache.calcite.rel.core.Values) {
diff --git a/core/src/test/resources/org/apache/calcite/rel/metadata/janino/GeneratedMetadata_ExplainVisibilityHandler.java b/core/src/test/resources/org/apache/calcite/rel/metadata/janino/GeneratedMetadata_ExplainVisibilityHandler.java
index 62d898c2f3e..fb3ec846fbc 100644
--- a/core/src/test/resources/org/apache/calcite/rel/metadata/janino/GeneratedMetadata_ExplainVisibilityHandler.java
+++ b/core/src/test/resources/org/apache/calcite/rel/metadata/janino/GeneratedMetadata_ExplainVisibilityHandler.java
@@ -68,7 +68,9 @@ private java.lang.Boolean isVisibleInExplain_(
       org.apache.calcite.rel.RelNode r,
       org.apache.calcite.rel.metadata.RelMetadataQuery mq,
       org.apache.calcite.sql.SqlExplainLevel a2) {
-    if (r instanceof org.apache.calcite.rel.RelNode) {
+    if (r instanceof org.apache.calcite.rel.core.TableScan) {
+      return provider0.isVisibleInExplain((org.apache.calcite.rel.core.TableScan) r, mq, a2);
+    } else if (r instanceof org.apache.calcite.rel.RelNode) {
       return provider0.isVisibleInExplain((org.apache.calcite.rel.RelNode) r, mq, a2);
     } else {
             throw new java.lang.IllegalArgumentException("No handler for method [public abstract java.lang.Boolean org.apache.calcite.rel.metadata.BuiltInMetadata$ExplainVisibility$Handler.isVisibleInExplain(org.apache.calcite.rel.RelNode,org.apache.calcite.rel.metadata.RelMetadataQuery,org.apache.calcite.sql.SqlExplainLevel)] applied to argument of type [" + r.getClass() + "]; we recommend you create a catch-all (RelNode) handler");
diff --git a/core/src/test/resources/org/apache/calcite/rel/metadata/janino/GeneratedMetadata_ExpressionLineageHandler.java b/core/src/test/resources/org/apache/calcite/rel/metadata/janino/GeneratedMetadata_ExpressionLineageHandler.java
index 090bcffe979..ad340108b6d 100644
--- a/core/src/test/resources/org/apache/calcite/rel/metadata/janino/GeneratedMetadata_ExpressionLineageHandler.java
+++ b/core/src/test/resources/org/apache/calcite/rel/metadata/janino/GeneratedMetadata_ExpressionLineageHandler.java
@@ -76,6 +76,8 @@ private java.util.Set getExpressionLineage_(
       return provider0.getExpressionLineage((org.apache.calcite.rel.core.Join) r, mq, a2);
     } else if (r instanceof org.apache.calcite.rel.core.Project) {
       return provider0.getExpressionLineage((org.apache.calcite.rel.core.Project) r, mq, a2);
+    } else if (r instanceof org.apache.calcite.rel.core.Snapshot) {
+      return provider0.getExpressionLineage((org.apache.calcite.rel.core.Snapshot) r, mq, a2);
     } else if (r instanceof org.apache.calcite.rel.core.Sort) {
       return provider0.getExpressionLineage((org.apache.calcite.rel.core.Sort) r, mq, a2);
     } else if (r instanceof org.apache.calcite.rel.core.TableModify) {
diff --git a/core/src/test/resources/org/apache/calcite/rel/metadata/janino/GeneratedMetadata_PercentageOriginalRowsHandler.java b/core/src/test/resources/org/apache/calcite/rel/metadata/janino/GeneratedMetadata_PercentageOriginalRowsHandler.java
index 573ceb39e7c..d83e952a925 100644
--- a/core/src/test/resources/org/apache/calcite/rel/metadata/janino/GeneratedMetadata_PercentageOriginalRowsHandler.java
+++ b/core/src/test/resources/org/apache/calcite/rel/metadata/janino/GeneratedMetadata_PercentageOriginalRowsHandler.java
@@ -64,6 +64,8 @@ private java.lang.Double getPercentageOriginalRows_(
       return provider0.getPercentageOriginalRows((org.apache.calcite.rel.core.Aggregate) r, mq);
     } else if (r instanceof org.apache.calcite.rel.core.Join) {
       return provider0.getPercentageOriginalRows((org.apache.calcite.rel.core.Join) r, mq);
+    } else if (r instanceof org.apache.calcite.rel.core.TableScan) {
+      return provider0.getPercentageOriginalRows((org.apache.calcite.rel.core.TableScan) r, mq);
     } else if (r instanceof org.apache.calcite.rel.core.Union) {
       return provider0.getPercentageOriginalRows((org.apache.calcite.rel.core.Union) r, mq);
     } else if (r instanceof org.apache.calcite.rel.RelNode) {
diff --git a/core/src/test/resources/org/apache/calcite/rel/metadata/janino/GeneratedMetadata_PopulationSizeHandler.java b/core/src/test/resources/org/apache/calcite/rel/metadata/janino/GeneratedMetadata_PopulationSizeHandler.java
index 944a4eb7f3e..188fd5aa4dd 100644
--- a/core/src/test/resources/org/apache/calcite/rel/metadata/janino/GeneratedMetadata_PopulationSizeHandler.java
+++ b/core/src/test/resources/org/apache/calcite/rel/metadata/janino/GeneratedMetadata_PopulationSizeHandler.java
@@ -76,6 +76,8 @@ private java.lang.Double getPopulationSize_(
       return provider0.getPopulationSize((org.apache.calcite.rel.core.Sort) r, mq, a2);
     } else if (r instanceof org.apache.calcite.rel.core.TableModify) {
       return provider0.getPopulationSize((org.apache.calcite.rel.core.TableModify) r, mq, a2);
+    } else if (r instanceof org.apache.calcite.rel.core.TableScan) {
+      return provider0.getPopulationSize((org.apache.calcite.rel.core.TableScan) r, mq, a2);
     } else if (r instanceof org.apache.calcite.rel.core.Union) {
       return provider0.getPopulationSize((org.apache.calcite.rel.core.Union) r, mq, a2);
     } else if (r instanceof org.apache.calcite.rel.core.Values) {
diff --git a/core/src/test/resources/org/apache/calcite/rel/metadata/janino/GeneratedMetadata_PredicatesHandler.java b/core/src/test/resources/org/apache/calcite/rel/metadata/janino/GeneratedMetadata_PredicatesHandler.java
index 14149082a58..9ecec20edfd 100644
--- a/core/src/test/resources/org/apache/calcite/rel/metadata/janino/GeneratedMetadata_PredicatesHandler.java
+++ b/core/src/test/resources/org/apache/calcite/rel/metadata/janino/GeneratedMetadata_PredicatesHandler.java
@@ -64,6 +64,8 @@ private org.apache.calcite.plan.RelOptPredicateList getPredicates_(
       return provider0.getPredicates((org.apache.calcite.plan.volcano.RelSubset) r, mq);
     } else if (r instanceof org.apache.calcite.rel.core.Aggregate) {
       return provider0.getPredicates((org.apache.calcite.rel.core.Aggregate) r, mq);
+    } else if (r instanceof org.apache.calcite.rel.core.Correlate) {
+      return provider0.getPredicates((org.apache.calcite.rel.core.Correlate) r, mq);
     } else if (r instanceof org.apache.calcite.rel.core.Exchange) {
       return provider0.getPredicates((org.apache.calcite.rel.core.Exchange) r, mq);
     } else if (r instanceof org.apache.calcite.rel.core.Filter) {
diff --git a/core/src/test/resources/org/apache/calcite/rel/metadata/janino/GeneratedMetadata_SelectivityHandler.java b/core/src/test/resources/org/apache/calcite/rel/metadata/janino/GeneratedMetadata_SelectivityHandler.java
index 4eed8d7071f..7010ada5d3e 100644
--- a/core/src/test/resources/org/apache/calcite/rel/metadata/janino/GeneratedMetadata_SelectivityHandler.java
+++ b/core/src/test/resources/org/apache/calcite/rel/metadata/janino/GeneratedMetadata_SelectivityHandler.java
@@ -76,6 +76,8 @@ private java.lang.Double getSelectivity_(
       return provider0.getSelectivity((org.apache.calcite.rel.core.Sort) r, mq, a2);
     } else if (r instanceof org.apache.calcite.rel.core.TableModify) {
       return provider0.getSelectivity((org.apache.calcite.rel.core.TableModify) r, mq, a2);
+    } else if (r instanceof org.apache.calcite.rel.core.TableScan) {
+      return provider0.getSelectivity((org.apache.calcite.rel.core.TableScan) r, mq, a2);
     } else if (r instanceof org.apache.calcite.rel.core.Union) {
       return provider0.getSelectivity((org.apache.calcite.rel.core.Union) r, mq, a2);
     } else if (r instanceof org.apache.calcite.rel.RelNode) {
diff --git a/core/src/test/resources/org/apache/calcite/test/HepPlannerTest.xml b/core/src/test/resources/org/apache/calcite/test/HepPlannerTest.xml
index 4b99cba51a7..c92bd6803ca 100644
--- a/core/src/test/resources/org/apache/calcite/test/HepPlannerTest.xml
+++ b/core/src/test/resources/org/apache/calcite/test/HepPlannerTest.xml
@@ -16,6 +16,18 @@
   ~ limitations under the License.
   -->
 <Root>
+  <TestCase name="testCommonSubExpression">
+    <Resource name="sql">
+      <![CDATA[(select 1 from dept where abs(-1)=20)
+union all
+(select 1 from dept where abs(-1)=20)]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testGC">
+    <Resource name="sql">
+      <![CDATA[select upper(name) from dept where deptno=20]]>
+    </Resource>
+  </TestCase>
   <TestCase name="testGroup">
     <Resource name="sql">
       <![CDATA[select upper(name) from dept where deptno=20]]>
@@ -125,6 +137,21 @@ LogicalAggregate(group=[{0}])
 ]]>
     </Resource>
   </TestCase>
+  <TestCase name="testMaterialization">
+    <Resource name="sql">
+      <![CDATA[select * from dept]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testPlanToDot">
+    <Resource name="sql">
+      <![CDATA[select name from sales.dept]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testRelDigestLength">
+    <Resource name="sql">
+      <![CDATA[select * from (select name from sales.dept union all select name from sales.dept union all select name from sales.dept union all select name from sales.dept union all select name from sales.dept union all select name from sales.dept union all select name from sales.dept union all select name from sales.dept union all select name from sales.dept union all select name from sales.dept union all select name from sales.dept)]]>
+    </Resource>
+  </TestCase>
   <TestCase name="testRelNodeCacheWithDigest">
     <Resource name="sql">
       <![CDATA[(select n_nationkey from SALES.CUSTOMER) union all
@@ -164,6 +191,33 @@ LogicalProject(DEPTNO=[$0])
 ]]>
     </Resource>
   </TestCase>
+  <TestCase name="testRuleApplyCount">
+    <Resource name="sql">
+      <![CDATA[select * from (
+  select ENAME, 50011895 as cat_id, '1' as cat_name, 1 as require_free_postage, 0 as require_15return, 0 as require_48hour,1 as require_insurance from emp where EMPNO = 20171216 and MGR = 0 and ENAME = 'Y' and SAL = 50011895 union all
+  select ENAME, 50013023 as cat_id, '2' as cat_name, 0 as require_free_postage, 0 as require_15return, 0 as require_48hour,0 as require_insurance from emp where EMPNO = 20171216 and MGR = 0 and ENAME = 'Y' and SAL = 50013023 union all
+  select ENAME, 50013032 as cat_id, '3' as cat_name, 0 as require_free_postage, 0 as require_15return, 0 as require_48hour,0 as require_insurance from emp where EMPNO = 20171216 and MGR = 0 and ENAME = 'Y' and SAL = 50013032 union all
+  select ENAME, 50013024 as cat_id, '4' as cat_name, 0 as require_free_postage, 0 as require_15return, 0 as require_48hour,0 as require_insurance from emp where EMPNO = 20171216 and MGR = 0 and ENAME = 'Y' and SAL = 50013024 union all
+  select ENAME, 50004204 as cat_id, '5' as cat_name, 0 as require_free_postage, 0 as require_15return, 0 as require_48hour,0 as require_insurance from emp where EMPNO = 20171216 and MGR = 0 and ENAME = 'Y' and SAL = 50004204 union all
+  select ENAME, 50013043 as cat_id, '6' as cat_name, 0 as require_free_postage, 0 as require_15return, 0 as require_48hour,0 as require_insurance from emp where EMPNO = 20171216 and MGR = 0 and ENAME = 'Y' and SAL = 50013043 union all
+  select ENAME, 290903 as cat_id, '7' as cat_name, 1 as require_free_postage, 0 as require_15return, 0 as require_48hour,1 as require_insurance from emp where EMPNO = 20171216 and MGR = 0 and ENAME = 'Y' and SAL = 290903 union all
+  select ENAME, 50008261 as cat_id, '8' as cat_name, 1 as require_free_postage, 0 as require_15return, 0 as require_48hour,1 as require_insurance from emp where EMPNO = 20171216 and MGR = 0 and ENAME = 'Y' and SAL = 50008261 union all
+  select ENAME, 124478013 as cat_id, '9' as cat_name, 0 as require_free_postage, 0 as require_15return, 1 as require_48hour,0 as require_insurance from emp where EMPNO = 20171216 and MGR = 0 and ENAME = 'Y' and SAL = 124478013 union all
+  select ENAME, 124472005 as cat_id, '10' as cat_name, 0 as require_free_postage, 0 as require_15return, 1 as require_48hour,0 as require_insurance from emp where EMPNO = 20171216 and MGR = 0 and ENAME = 'Y' and SAL = 124472005 union all
+  select ENAME, 50013475 as cat_id, '11' as cat_name, 0 as require_free_postage, 1 as require_15return, 1 as require_48hour,0 as require_insurance from emp where EMPNO = 20171216 and MGR = 0 and ENAME = 'Y' and SAL = 50013475 union all
+  select ENAME, 50018263 as cat_id, '12' as cat_name, 0 as require_free_postage, 1 as require_15return, 1 as require_48hour,0 as require_insurance from emp where EMPNO = 20171216 and MGR = 0 and ENAME = 'Y' and SAL = 50018263 union all
+  select ENAME, 50013498 as cat_id, '13' as cat_name, 0 as require_free_postage, 1 as require_15return, 1 as require_48hour,0 as require_insurance from emp where EMPNO = 20171216 and MGR = 0 and ENAME = 'Y' and SAL = 50013498 union all
+  select ENAME, 350511 as cat_id, '14' as cat_name, 0 as require_free_postage, 1 as require_15return, 1 as require_48hour,0 as require_insurance from emp where EMPNO = 20171216 and MGR = 0 and ENAME = 'Y' and SAL = 350511 union all
+  select ENAME, 50019790 as cat_id, '15' as cat_name, 0 as require_free_postage, 1 as require_15return, 1 as require_48hour,0 as require_insurance from emp where EMPNO = 20171216 and MGR = 0 and ENAME = 'Y' and SAL = 50019790 union all
+  select ENAME, 50015382 as cat_id, '16' as cat_name, 0 as require_free_postage, 1 as require_15return, 1 as require_48hour,0 as require_insurance from emp where EMPNO = 20171216 and MGR = 0 and ENAME = 'Y' and SAL = 50015382 union all
+  select ENAME, 350503 as cat_id, '17' as cat_name, 0 as require_free_postage, 1 as require_15return, 1 as require_48hour,0 as require_insurance from emp where EMPNO = 20171216 and MGR = 0 and ENAME = 'Y' and SAL = 350503 union all
+  select ENAME, 350401 as cat_id, '18' as cat_name, 0 as require_free_postage, 1 as require_15return, 1 as require_48hour,0 as require_insurance from emp where EMPNO = 20171216 and MGR = 0 and ENAME = 'Y' and SAL = 350401 union all
+  select ENAME, 50015560 as cat_id, '19' as cat_name, 0 as require_free_postage, 0 as require_15return, 0 as require_48hour,0 as require_insurance from emp where EMPNO = 20171216 and MGR = 0 and ENAME = 'Y' and SAL = 50015560 union all
+  select ENAME, 122658003 as cat_id, '20' as cat_name, 0 as require_free_postage, 1 as require_15return, 1 as require_48hour,0 as require_insurance from emp where EMPNO = 20171216 and MGR = 0 and ENAME = 'Y' and SAL = 122658003 union all
+  select ENAME, 50022371 as cat_id, '100' as cat_name, 0 as require_free_postage, 0 as require_15return, 0 as require_48hour,0 as require_insurance from emp where EMPNO = 20171216 and MGR = 0 and ENAME = 'Y' and SAL = 50022371
+) a]]>
+    </Resource>
+  </TestCase>
   <TestCase name="testRuleClass">
     <Resource name="sql">
       <![CDATA[(select name from dept union select ename from emp)
diff --git a/core/src/test/resources/org/apache/calcite/test/RelOptRulesTest.xml b/core/src/test/resources/org/apache/calcite/test/RelOptRulesTest.xml
index c30ab69e9a1..5ae464f9066 100644
--- a/core/src/test/resources/org/apache/calcite/test/RelOptRulesTest.xml
+++ b/core/src/test/resources/org/apache/calcite/test/RelOptRulesTest.xml
@@ -1799,8 +1799,12 @@ and e1.sal > (select avg(sal) from emp e2 where e1.empno = e2.empno)]]>
   </TestCase>
   <TestCase name="testDecorrelateAggWithConstantGroupKey">
     <Resource name="sql">
-      <![CDATA[SELECT * FROM emp A where sal in
-(SELECT max(sal) FROM emp B where A.mgr = B.empno group by deptno, 'abc')]]>
+      <![CDATA[SELECT *
+FROM emp A
+where sal in (SELECT max(sal)
+  FROM emp B
+  where A.mgr = B.empno
+  group by deptno, 'abc')]]>
     </Resource>
     <Resource name="planBefore">
       <![CDATA[
@@ -1811,9 +1815,10 @@ LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$
       LogicalAggregate(group=[{0}])
         LogicalProject(EXPR$0=[$2])
           LogicalAggregate(group=[{0, 1}], EXPR$0=[MAX($2)])
-            LogicalProject(DEPTNO=[$7], $f1=['abc'], SAL=[$5])
+            LogicalProject(DEPTNO=[$2], $f1=['abc'], SAL=[$1])
               LogicalFilter(condition=[=($cor0.MGR, $0)])
-                LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+                LogicalProject(EMPNO=[$0], SAL=[$5], DEPTNO=[$7])
+                  LogicalTableScan(table=[[CATALOG, SALES, EMP]])
 ]]>
     </Resource>
     <Resource name="planMid">
@@ -1825,9 +1830,10 @@ LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$
       LogicalAggregate(group=[{0}])
         LogicalProject(EXPR$0=[$2])
           LogicalAggregate(group=[{0, 1}], EXPR$0=[MAX($2)])
-            LogicalProject(DEPTNO=[$7], $f1=['abc'], SAL=[$5])
+            LogicalProject(DEPTNO=[$2], $f1=['abc'], SAL=[$1])
               LogicalFilter(condition=[=($cor0.MGR, $0)])
-                LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+                LogicalProject(EMPNO=[$0], SAL=[$5], DEPTNO=[$7])
+                  LogicalTableScan(table=[[CATALOG, SALES, EMP]])
 ]]>
     </Resource>
     <Resource name="planAfter">
@@ -1835,11 +1841,10 @@ LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$
 LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8])
   LogicalJoin(condition=[AND(=($3, $10), =($5, $9))], joinType=[inner])
     LogicalTableScan(table=[[CATALOG, SALES, EMP]])
-    LogicalAggregate(group=[{0, 1}])
-      LogicalProject(EXPR$0=[$2], EMPNO=[$1])
-        LogicalAggregate(group=[{0, 1}], EXPR$0=[MAX($2)])
-          LogicalProject(DEPTNO=[$7], EMPNO=[$0], SAL=[$5])
-            LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+    LogicalProject(EXPR$0=[$2], EMPNO=[$1])
+      LogicalAggregate(group=[{0, 1}], EXPR$0=[MAX($2)])
+        LogicalProject(DEPTNO=[$7], EMPNO=[$0], SAL=[$5])
+          LogicalTableScan(table=[[CATALOG, SALES, EMP]])
 ]]>
     </Resource>
   </TestCase>
@@ -1850,22 +1855,20 @@ LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$
     </Resource>
     <Resource name="planBefore">
       <![CDATA[
-LogicalProject(C=[$0], S=[$1])
-  LogicalCorrelate(correlation=[$cor0], joinType=[inner], requiredColumns=[{0}])
-    LogicalAggregate(group=[{}], C=[MYAGG($0, $1)])
-      LogicalProject(SAL=[$5], $f1=[1])
-        LogicalTableScan(table=[[CATALOG, SALES, EMP]])
-    LogicalTableFunctionScan(invocation=[RAMP($cor0.C)], rowType=[RecordType(INTEGER I)])
+LogicalCorrelate(correlation=[$cor0], joinType=[inner], requiredColumns=[{0}])
+  LogicalAggregate(group=[{}], C=[MYAGG($0, $1)])
+    LogicalProject(SAL=[$5], $f1=[1])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+  LogicalTableFunctionScan(invocation=[RAMP($cor0.C)], rowType=[RecordType(INTEGER I)])
 ]]>
     </Resource>
     <Resource name="planMid">
       <![CDATA[
-LogicalProject(C=[$0], S=[$1])
-  LogicalCorrelate(correlation=[$cor0], joinType=[inner], requiredColumns=[{0}])
-    LogicalAggregate(group=[{}], C=[MYAGG($0, $1)])
-      LogicalProject(SAL=[$5], $f1=[1])
-        LogicalTableScan(table=[[CATALOG, SALES, EMP]])
-    LogicalTableFunctionScan(invocation=[RAMP($cor0.C)], rowType=[RecordType(INTEGER I)])
+LogicalCorrelate(correlation=[$cor0], joinType=[inner], requiredColumns=[{0}])
+  LogicalAggregate(group=[{}], C=[MYAGG($0, $1)])
+    LogicalProject(SAL=[$5], $f1=[1])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+  LogicalTableFunctionScan(invocation=[RAMP($cor0.C)], rowType=[RecordType(INTEGER I)])
 ]]>
     </Resource>
   </TestCase>
@@ -1876,24 +1879,22 @@ LogicalProject(C=[$0], S=[$1])
     </Resource>
     <Resource name="planBefore">
       <![CDATA[
-LogicalProject(C=[$0], S=[$1])
-  LogicalCorrelate(correlation=[$cor0], joinType=[inner], requiredColumns=[{0}])
-    LogicalProject(C=[$2])
-      LogicalAggregate(group=[{0, 1}], C=[MYAGG($2, $3)])
-        LogicalProject(EMPNO=[$0], $f1=['abc'], SAL=[$5], $f3=[1])
-          LogicalTableScan(table=[[CATALOG, SALES, EMP]])
-    LogicalTableFunctionScan(invocation=[RAMP($cor0.C)], rowType=[RecordType(INTEGER I)])
+LogicalCorrelate(correlation=[$cor0], joinType=[inner], requiredColumns=[{0}])
+  LogicalProject(C=[$2])
+    LogicalAggregate(group=[{0, 1}], C=[MYAGG($2, $3)])
+      LogicalProject(EMPNO=[$0], $f1=['abc'], SAL=[$5], $f3=[1])
+        LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+  LogicalTableFunctionScan(invocation=[RAMP($cor0.C)], rowType=[RecordType(INTEGER I)])
 ]]>
     </Resource>
     <Resource name="planMid">
       <![CDATA[
-LogicalProject(C=[$0], S=[$1])
-  LogicalCorrelate(correlation=[$cor0], joinType=[inner], requiredColumns=[{0}])
-    LogicalProject(C=[$2])
-      LogicalAggregate(group=[{0, 1}], C=[MYAGG($2, $3)])
-        LogicalProject(EMPNO=[$0], $f1=['abc'], SAL=[$5], $f3=[1])
-          LogicalTableScan(table=[[CATALOG, SALES, EMP]])
-    LogicalTableFunctionScan(invocation=[RAMP($cor0.C)], rowType=[RecordType(INTEGER I)])
+LogicalCorrelate(correlation=[$cor0], joinType=[inner], requiredColumns=[{0}])
+  LogicalProject(C=[$2])
+    LogicalAggregate(group=[{0, 1}], C=[MYAGG($2, $3)])
+      LogicalProject(EMPNO=[$0], $f1=['abc'], SAL=[$5], $f3=[1])
+        LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+  LogicalTableFunctionScan(invocation=[RAMP($cor0.C)], rowType=[RecordType(INTEGER I)])
 ]]>
     </Resource>
   </TestCase>
@@ -2763,7 +2764,8 @@ LogicalAggregate(group=[{0}], EXPR$1=[SUM($3)], EXPR$2=[MIN($4)], EXPR$3=[COUNT(
   </TestCase>
   <TestCase name="testDynamicStarWithUnion">
     <Resource name="sql">
-      <![CDATA[(select n_nationkey from SALES.CUSTOMER) union all
+      <![CDATA[(select n_nationkey from SALES.CUSTOMER)
+union all
 (select n_name from CUSTOMER_MODIFIABLEVIEW)]]>
     </Resource>
     <Resource name="planBefore">
@@ -3056,6 +3058,50 @@ LogicalSort(sort0=[$7], dir0=[ASC], fetch=[0])
     <Resource name="planAfter">
       <![CDATA[
 LogicalValues(tuples=[[]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testEmptyTable">
+    <Resource name="sql">
+      <![CDATA[select * from EMPTY_PRODUCTS
+]]>
+    </Resource>
+    <Resource name="planBefore">
+      <![CDATA[
+LogicalProject(PRODUCTID=[$0], NAME=[$1], SUPPLIERID=[$2])
+  LogicalTableScan(table=[[CATALOG, SALES, EMPTY_PRODUCTS]])
+]]>
+    </Resource>
+    <Resource name="planAfter">
+      <![CDATA[
+LogicalValues(tuples=[[]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testEmptyTableTransformsComplexQueryToSingleTableScan">
+    <Resource name="sql">
+      <![CDATA[select products.PRODUCTID, products.NAME from products left join
+(select * from products as e
+ inner join EMPTY_PRODUCTS as d on e.PRODUCTID = d.PRODUCTID
+ where e.SUPPLIERID > 10) dt
+ on products.PRODUCTID = dt.PRODUCTID]]>
+    </Resource>
+    <Resource name="planBefore">
+      <![CDATA[
+LogicalProject(PRODUCTID=[$0], NAME=[$1])
+  LogicalJoin(condition=[=($0, $3)], joinType=[left])
+    LogicalTableScan(table=[[CATALOG, SALES, PRODUCTS]])
+    LogicalProject(PRODUCTID=[$0], NAME=[$1], SUPPLIERID=[$2], PRODUCTID0=[$3], NAME0=[$4], SUPPLIERID0=[$5])
+      LogicalFilter(condition=[>($2, 10)])
+        LogicalJoin(condition=[=($0, $3)], joinType=[inner])
+          LogicalTableScan(table=[[CATALOG, SALES, PRODUCTS]])
+          LogicalTableScan(table=[[CATALOG, SALES, EMPTY_PRODUCTS]])
+]]>
+    </Resource>
+    <Resource name="planAfter">
+      <![CDATA[
+LogicalProject(PRODUCTID=[$0], NAME=[$1])
+  LogicalTableScan(table=[[CATALOG, SALES, PRODUCTS]])
 ]]>
     </Resource>
   </TestCase>
@@ -3103,7 +3149,8 @@ LogicalSortExchange(distribution=[hash[1]], collation=[[1]])
   <TestCase name="testExistsWithAtLeastOneRowSubQuery">
     <Resource name="sql">
       <![CDATA[select * from dept as d
-where EXISTS(select count(*) from emp e where d.deptno = e.deptno)]]>
+where EXISTS (
+  select count(*) from emp e where d.deptno = e.deptno)]]>
     </Resource>
     <Resource name="planBefore">
       <![CDATA[
@@ -3133,7 +3180,8 @@ LogicalProject(DEPTNO=[$0], NAME=[$1])
   <TestCase name="testExistsWithNoRowSubQuery">
     <Resource name="sql">
       <![CDATA[select * from dept as d
-where NOT EXISTS(select count(*) from emp e having false)]]>
+where NOT EXISTS (
+  select count(*) from emp e having false)]]>
     </Resource>
     <Resource name="planBefore">
       <![CDATA[
@@ -3787,6 +3835,46 @@ LogicalProject($0=[$3], $1=[$4])
       <![CDATA[
 LogicalProject(SUM1=[SUM($7) OVER (PARTITION BY $7 ORDER BY $5)], SUM2=[SUM(+($7, $5)) OVER (PARTITION BY $7 ORDER BY $5)])
   LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testExpressionSimplification1">
+    <Resource name="sql">
+      <![CDATA[select * from emp
+where ename <> '' and ename <> '3']]>
+    </Resource>
+    <Resource name="planBefore">
+      <![CDATA[
+LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8])
+  LogicalFilter(condition=[AND(<>($1, ''), <>($1, '3'))])
+    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+    <Resource name="planAfter">
+      <![CDATA[
+LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8])
+  LogicalFilter(condition=[SEARCH($1, Sarg[(-∞..'':VARCHAR(20)), ('':VARCHAR(20)..'3':VARCHAR(20)), ('3':VARCHAR(20)..+∞)]:VARCHAR(20))])
+    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testExpressionSimplification2">
+    <Resource name="sql">
+      <![CDATA[select * from emp
+where (ename < '' or ename > '') and (ename < '3' or ename > '3')]]>
+    </Resource>
+    <Resource name="planBefore">
+      <![CDATA[
+LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8])
+  LogicalFilter(condition=[AND(OR(<($1, ''), >($1, '')), OR(<($1, '3'), >($1, '3')))])
+    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+    <Resource name="planAfter">
+      <![CDATA[
+LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8])
+  LogicalFilter(condition=[SEARCH($1, Sarg[(-∞..'':CHAR(1)), ('':CHAR(1)..'3'), ('3'..+∞)]:CHAR(1))])
+    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
 ]]>
     </Resource>
   </TestCase>
@@ -3872,6 +3960,62 @@ MyProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], C
 MultiJoin(joinFilter=[true], isFullOuterJoin=[false], joinTypes=[[INNER, LEFT]], outerJoinConditions=[[NULL, =($7, $9)]], projFields=[[{0, 1, 2, 3, 4, 5, 6, 7, 8}, {0, 1}]], postJoinFilter=[>($9, 3)])
   LogicalTableScan(table=[[CATALOG, SALES, EMP]])
   LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testFilterJoinRuleAndIsNotNull">
+    <Resource name="sql">
+      <![CDATA[select * from
+emp LHS
+left join dept RHS on LHS.EMPNO = RHS.DEPTNO
+where
+RHS.DEPTNO is not null
+AND RHS.NAME is not null]]>
+    </Resource>
+    <Resource name="planBefore">
+      <![CDATA[
+LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8], DEPTNO0=[$9], NAME=[$10])
+  LogicalFilter(condition=[AND(IS NOT NULL($9), IS NOT NULL($10))])
+    LogicalJoin(condition=[=($0, $9)], joinType=[left])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+      LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
+]]>
+    </Resource>
+    <Resource name="planAfter">
+      <![CDATA[
+LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8], DEPTNO0=[$9], NAME=[$10])
+  LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8], DEPTNO0=[CAST($9):INTEGER], NAME=[CAST($10):VARCHAR(10)])
+    LogicalJoin(condition=[=($0, $9)], joinType=[inner])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+      LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testFilterJoinRuleOrIsNotNull">
+    <Resource name="sql">
+      <![CDATA[select * from
+emp LHS
+left join dept RHS on LHS.EMPNO = RHS.DEPTNO
+where
+RHS.DEPTNO is not null
+OR RHS.NAME is not null]]>
+    </Resource>
+    <Resource name="planBefore">
+      <![CDATA[
+LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8], DEPTNO0=[$9], NAME=[$10])
+  LogicalFilter(condition=[OR(IS NOT NULL($9), IS NOT NULL($10))])
+    LogicalJoin(condition=[=($0, $9)], joinType=[left])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+      LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
+]]>
+    </Resource>
+    <Resource name="planAfter">
+      <![CDATA[
+LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8], DEPTNO0=[$9], NAME=[$10])
+  LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8], DEPTNO0=[CAST($9):INTEGER], NAME=[CAST($10):VARCHAR(10)])
+    LogicalJoin(condition=[=($0, $9)], joinType=[inner])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+      LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
 ]]>
     </Resource>
   </TestCase>
@@ -4383,61 +4527,430 @@ LogicalJoin(condition=[=($2, $12)], joinType=[inner])
   LogicalTableScan(table=[[scott, BONUS]])
 ]]>
     </Resource>
-  </TestCase>
-  <TestCase name="testJoinAssociateRuleWithTopAlwaysTrueConditionAllowed">
+  </TestCase>
+  <TestCase name="testJoinAssociateRuleWithTopAlwaysTrueConditionAllowed">
+    <Resource name="planBefore">
+      <![CDATA[
+LogicalJoin(condition=[=($7, $12)], joinType=[inner])
+  LogicalJoin(condition=[true], joinType=[inner])
+    LogicalTableScan(table=[[scott, EMP]])
+    LogicalTableScan(table=[[scott, BONUS]])
+  LogicalTableScan(table=[[scott, DEPT]])
+]]>
+    </Resource>
+    <Resource name="planAfter">
+      <![CDATA[
+LogicalJoin(condition=[=($7, $12)], joinType=[inner])
+  LogicalTableScan(table=[[scott, EMP]])
+  LogicalJoin(condition=[true], joinType=[inner])
+    LogicalTableScan(table=[[scott, BONUS]])
+    LogicalTableScan(table=[[scott, DEPT]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testJoinAssociateRuleWithTopAlwaysTrueConditionDisallowed">
+    <Resource name="planBefore">
+      <![CDATA[
+LogicalJoin(condition=[=($7, $12)], joinType=[inner])
+  LogicalJoin(condition=[true], joinType=[inner])
+    LogicalTableScan(table=[[scott, EMP]])
+    LogicalTableScan(table=[[scott, BONUS]])
+  LogicalTableScan(table=[[scott, DEPT]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testJoinCommuteRuleWithAlwaysTrueConditionAllowed">
+    <Resource name="planBefore">
+      <![CDATA[
+LogicalJoin(condition=[true], joinType=[inner])
+  LogicalTableScan(table=[[scott, EMP]])
+  LogicalTableScan(table=[[scott, DEPT]])
+]]>
+    </Resource>
+    <Resource name="planAfter">
+      <![CDATA[
+LogicalProject(EMPNO=[$3], ENAME=[$4], JOB=[$5], MGR=[$6], HIREDATE=[$7], SAL=[$8], COMM=[$9], DEPTNO=[$10], DEPTNO0=[$0], DNAME=[$1], LOC=[$2])
+  LogicalJoin(condition=[true], joinType=[inner])
+    LogicalTableScan(table=[[scott, DEPT]])
+    LogicalTableScan(table=[[scott, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testJoinCommuteRuleWithAlwaysTrueConditionDisallowed">
+    <Resource name="planBefore">
+      <![CDATA[
+LogicalJoin(condition=[true], joinType=[inner])
+  LogicalTableScan(table=[[scott, EMP]])
+  LogicalTableScan(table=[[scott, DEPT]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testJoinConditionPushdown1">
+    <Resource name="sql">
+      <![CDATA[select *
+from emp e1, emp e2, dept d2
+where e1.deptno = d2.deptno and e2.deptno = d2.deptno]]>
+    </Resource>
+    <Resource name="planBefore">
+      <![CDATA[
+LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8], EMPNO0=[$9], ENAME0=[$10], JOB0=[$11], MGR0=[$12], HIREDATE0=[$13], SAL0=[$14], COMM0=[$15], DEPTNO0=[$16], SLACKER0=[$17], DEPTNO1=[$18], NAME=[$19])
+  LogicalFilter(condition=[AND(=($7, $18), =($16, $18))])
+    LogicalJoin(condition=[true], joinType=[inner])
+      LogicalJoin(condition=[true], joinType=[inner])
+        LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+        LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+      LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
+]]>
+    </Resource>
+    <Resource name="planAfter">
+      <![CDATA[
+LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8], EMPNO0=[$9], ENAME0=[$10], JOB0=[$11], MGR0=[$12], HIREDATE0=[$13], SAL0=[$14], COMM0=[$15], DEPTNO0=[$16], SLACKER0=[$17], DEPTNO1=[$18], NAME=[$19])
+  LogicalJoin(condition=[=($7, $18)], joinType=[inner])
+    LogicalJoin(condition=[=($7, $16)], joinType=[inner])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+    LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testJoinConditionPushdown2">
+    <Resource name="sql">
+      <![CDATA[select *
+from emp e, dept d
+where e.deptno = d.deptno and e.empno = d.deptno]]>
+    </Resource>
+    <Resource name="planBefore">
+      <![CDATA[
+LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8], DEPTNO0=[$9], NAME=[$10])
+  LogicalFilter(condition=[AND(=($7, $9), =($0, $9))])
+    LogicalJoin(condition=[true], joinType=[inner])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+      LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
+]]>
+    </Resource>
+    <Resource name="planAfter">
+      <![CDATA[
+LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8], DEPTNO0=[$9], NAME=[$10])
+  LogicalJoin(condition=[=($7, $9)], joinType=[inner])
+    LogicalFilter(condition=[=($7, $0)])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+    LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testJoinConditionPushdown3">
+    <Resource name="sql">
+      <![CDATA[select *
+from emp e full join dept d
+on e.deptno = d.deptno and e.empno = d.deptno]]>
+    </Resource>
+    <Resource name="planBefore">
+      <![CDATA[
+LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8], DEPTNO0=[$9], NAME=[$10])
+  LogicalJoin(condition=[AND(=($7, $9), =($0, $9))], joinType=[full])
+    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+    LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testJoinConditionPushdown4">
+    <Resource name="sql">
+      <![CDATA[select *
+from emp e semi join dept d
+on e.deptno = d.deptno and e.empno = d.deptno
+]]>
+    </Resource>
+    <Resource name="planBefore">
+      <![CDATA[
+LogicalProject(DEPTNO=[$0])
+  LogicalJoin(condition=[AND(=($0, $2), =($0, $3))], joinType=[semi])
+    LogicalProject(DEPTNO=[$7], ENAME=[$1])
+      LogicalTableScan(table=[[scott, EMP]])
+    LogicalProject(DEPTNO=[$0], DNAME=[$1])
+      LogicalTableScan(table=[[scott, DEPT]])
+]]>
+    </Resource>
+    <Resource name="planAfter">
+      <![CDATA[
+LogicalProject(DEPTNO=[$0])
+  LogicalProject(DEPTNO=[$7], ENAME=[$1])
+    LogicalJoin(condition=[=($7, $8)], joinType=[semi])
+      LogicalTableScan(table=[[scott, EMP]])
+      LogicalFilter(condition=[=($0, $1)])
+        LogicalProject(DEPTNO=[$0], DNAME=[$1])
+          LogicalTableScan(table=[[scott, DEPT]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testJoinConditionPushdown5">
+    <Resource name="sql">
+      <![CDATA[select *
+from emp e left join dept d
+on e.deptno = d.deptno and e.empno = d.deptno]]>
+    </Resource>
+    <Resource name="planBefore">
+      <![CDATA[
+LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8], DEPTNO0=[$9], NAME=[$10])
+  LogicalJoin(condition=[AND(=($7, $9), =($0, $9))], joinType=[left])
+    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+    LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testJoinConditionPushdown6">
+    <Resource name="sql">
+      <![CDATA[select *
+from emp e right join dept d
+on e.deptno = d.deptno and e.empno = d.deptno]]>
+    </Resource>
+    <Resource name="planBefore">
+      <![CDATA[
+LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8], DEPTNO0=[$9], NAME=[$10])
+  LogicalJoin(condition=[AND(=($7, $9), =($0, $9))], joinType=[right])
+    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+    LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
+]]>
+    </Resource>
+    <Resource name="planAfter">
+      <![CDATA[
+LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8], DEPTNO0=[$9], NAME=[$10])
+  LogicalJoin(condition=[=($7, $9)], joinType=[right])
+    LogicalFilter(condition=[=($7, $0)])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+    LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testJoinDeriveIsNotNullFilterRule1">
+    <Resource name="sql">
+      <![CDATA[select t1.deptno from emp t1 inner join emp t2 on t1.mgr = t2.mgr]]>
+    </Resource>
+    <Resource name="planBefore">
+      <![CDATA[
+LogicalProject(DEPTNO=[$7])
+  LogicalJoin(condition=[=($3, $12)], joinType=[inner])
+    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+    <Resource name="planAfter">
+      <![CDATA[
+LogicalProject(DEPTNO=[$7])
+  LogicalJoin(condition=[=($3, $12)], joinType=[inner])
+    LogicalFilter(condition=[IS NOT NULL($3)])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+    LogicalFilter(condition=[IS NOT NULL($3)])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testJoinDeriveIsNotNullFilterRule10">
+    <Resource name="sql">
+      <![CDATA[select t1.deptno from emp t1 inner join emp t2
+on t1.mgr is not distinct from t2.mgr]]>
+    </Resource>
+    <Resource name="planBefore">
+      <![CDATA[
+LogicalProject(DEPTNO=[$7])
+  LogicalJoin(condition=[IS NOT DISTINCT FROM($3, $12)], joinType=[inner])
+    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testJoinDeriveIsNotNullFilterRule11">
+    <Resource name="sql">
+      <![CDATA[select t1.deptno from empnullables t1 inner join
+empnullables t2 on t1.ename = t2.ename or 1 = 1]]>
+    </Resource>
+    <Resource name="planBefore">
+      <![CDATA[
+LogicalProject(DEPTNO=[$7])
+  LogicalJoin(condition=[true], joinType=[inner])
+    LogicalTableScan(table=[[CATALOG, SALES, EMPNULLABLES]])
+    LogicalTableScan(table=[[CATALOG, SALES, EMPNULLABLES]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testJoinDeriveIsNotNullFilterRule12">
+    <Resource name="sql">
+      <![CDATA[select t1.deptno from empnullables t1 inner join
+empnullables t2 on t1.ename = t2.ename and t1.mgr is not distinct from t2.mgr]]>
+    </Resource>
+    <Resource name="planBefore">
+      <![CDATA[
+LogicalProject(DEPTNO=[$7])
+  LogicalJoin(condition=[AND(=($1, $10), IS NOT DISTINCT FROM($3, $12))], joinType=[inner])
+    LogicalTableScan(table=[[CATALOG, SALES, EMPNULLABLES]])
+    LogicalTableScan(table=[[CATALOG, SALES, EMPNULLABLES]])
+]]>
+    </Resource>
+    <Resource name="planAfter">
+      <![CDATA[
+LogicalProject(DEPTNO=[$7])
+  LogicalJoin(condition=[AND(=($1, $10), IS NOT DISTINCT FROM($3, $12))], joinType=[inner])
+    LogicalFilter(condition=[IS NOT NULL($1)])
+      LogicalTableScan(table=[[CATALOG, SALES, EMPNULLABLES]])
+    LogicalFilter(condition=[IS NOT NULL($1)])
+      LogicalTableScan(table=[[CATALOG, SALES, EMPNULLABLES]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testJoinDeriveIsNotNullFilterRule2">
+    <Resource name="sql">
+      <![CDATA[select t1.deptno from (select * from emp where mgr is not null) t1 join emp t2 on t1.mgr = t2.mgr]]>
+    </Resource>
+    <Resource name="planBefore">
+      <![CDATA[
+LogicalProject(DEPTNO=[$7])
+  LogicalJoin(condition=[=($3, $12)], joinType=[inner])
+    LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8])
+      LogicalFilter(condition=[IS NOT NULL($3)])
+        LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+    <Resource name="planAfter">
+      <![CDATA[
+LogicalProject(DEPTNO=[$7])
+  LogicalJoin(condition=[=($3, $12)], joinType=[inner])
+    LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8])
+      LogicalFilter(condition=[IS NOT NULL($3)])
+        LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+    LogicalFilter(condition=[IS NOT NULL($3)])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testJoinDeriveIsNotNullFilterRule3">
+    <Resource name="sql">
+      <![CDATA[select t1.deptno from emp t1 inner join emp t2 on t1.mgr > t2.mgr]]>
+    </Resource>
+    <Resource name="planBefore">
+      <![CDATA[
+LogicalProject(DEPTNO=[$7])
+  LogicalJoin(condition=[>($3, $12)], joinType=[inner])
+    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+    <Resource name="planAfter">
+      <![CDATA[
+LogicalProject(DEPTNO=[$7])
+  LogicalJoin(condition=[>($3, $12)], joinType=[inner])
+    LogicalFilter(condition=[IS NOT NULL($3)])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+    LogicalFilter(condition=[IS NOT NULL($3)])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testJoinDeriveIsNotNullFilterRule4">
+    <Resource name="sql">
+      <![CDATA[select t1.deptno from empnullables t1 inner join
+empnullables t2 on t1.ename = t2.ename and t1.mgr > t2.mgr]]>
+    </Resource>
+    <Resource name="planBefore">
+      <![CDATA[
+LogicalProject(DEPTNO=[$7])
+  LogicalJoin(condition=[AND(=($1, $10), >($3, $12))], joinType=[inner])
+    LogicalTableScan(table=[[CATALOG, SALES, EMPNULLABLES]])
+    LogicalTableScan(table=[[CATALOG, SALES, EMPNULLABLES]])
+]]>
+    </Resource>
+    <Resource name="planAfter">
+      <![CDATA[
+LogicalProject(DEPTNO=[$7])
+  LogicalJoin(condition=[AND(=($1, $10), >($3, $12))], joinType=[inner])
+    LogicalFilter(condition=[AND(IS NOT NULL($1), IS NOT NULL($3))])
+      LogicalTableScan(table=[[CATALOG, SALES, EMPNULLABLES]])
+    LogicalFilter(condition=[AND(IS NOT NULL($1), IS NOT NULL($3))])
+      LogicalTableScan(table=[[CATALOG, SALES, EMPNULLABLES]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testJoinDeriveIsNotNullFilterRule5">
+    <Resource name="sql">
+      <![CDATA[select t1.deptno from (select ename, deptno+1 as deptno from
+empnullables where ename is not null) t1 inner join
+empnullables t2 on t1.ename = t2.ename]]>
+    </Resource>
     <Resource name="planBefore">
       <![CDATA[
-LogicalJoin(condition=[=($7, $12)], joinType=[inner])
-  LogicalJoin(condition=[true], joinType=[inner])
-    LogicalTableScan(table=[[scott, EMP]])
-    LogicalTableScan(table=[[scott, BONUS]])
-  LogicalTableScan(table=[[scott, DEPT]])
+LogicalProject(DEPTNO=[$1])
+  LogicalJoin(condition=[=($0, $3)], joinType=[inner])
+    LogicalProject(ENAME=[$1], DEPTNO=[+($7, 1)])
+      LogicalFilter(condition=[IS NOT NULL($1)])
+        LogicalTableScan(table=[[CATALOG, SALES, EMPNULLABLES]])
+    LogicalTableScan(table=[[CATALOG, SALES, EMPNULLABLES]])
 ]]>
     </Resource>
     <Resource name="planAfter">
       <![CDATA[
-LogicalJoin(condition=[=($7, $12)], joinType=[inner])
-  LogicalTableScan(table=[[scott, EMP]])
-  LogicalJoin(condition=[true], joinType=[inner])
-    LogicalTableScan(table=[[scott, BONUS]])
-    LogicalTableScan(table=[[scott, DEPT]])
+LogicalProject(DEPTNO=[$1])
+  LogicalJoin(condition=[=($0, $3)], joinType=[inner])
+    LogicalProject(ENAME=[$1], DEPTNO=[+($7, 1)])
+      LogicalFilter(condition=[IS NOT NULL($1)])
+        LogicalTableScan(table=[[CATALOG, SALES, EMPNULLABLES]])
+    LogicalFilter(condition=[IS NOT NULL($1)])
+      LogicalTableScan(table=[[CATALOG, SALES, EMPNULLABLES]])
 ]]>
     </Resource>
   </TestCase>
-  <TestCase name="testJoinAssociateRuleWithTopAlwaysTrueConditionDisallowed">
+  <TestCase name="testJoinDeriveIsNotNullFilterRule6">
+    <Resource name="sql">
+      <![CDATA[select t1.deptno from emp t1 full join emp t2 on t1.mgr = t2.mgr]]>
+    </Resource>
     <Resource name="planBefore">
       <![CDATA[
-LogicalJoin(condition=[=($7, $12)], joinType=[inner])
-  LogicalJoin(condition=[true], joinType=[inner])
-    LogicalTableScan(table=[[scott, EMP]])
-    LogicalTableScan(table=[[scott, BONUS]])
-  LogicalTableScan(table=[[scott, DEPT]])
+LogicalProject(DEPTNO=[$7])
+  LogicalJoin(condition=[=($3, $12)], joinType=[full])
+    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
 ]]>
     </Resource>
   </TestCase>
-  <TestCase name="testJoinCommuteRuleWithAlwaysTrueConditionAllowed">
+  <TestCase name="testJoinDeriveIsNotNullFilterRule7">
+    <Resource name="sql">
+      <![CDATA[select t1.deptno from emp t1 left join emp t2 on t1.mgr = t2.mgr]]>
+    </Resource>
     <Resource name="planBefore">
       <![CDATA[
-LogicalJoin(condition=[true], joinType=[inner])
-  LogicalTableScan(table=[[scott, EMP]])
-  LogicalTableScan(table=[[scott, DEPT]])
+LogicalProject(DEPTNO=[$7])
+  LogicalJoin(condition=[=($3, $12)], joinType=[left])
+    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
 ]]>
     </Resource>
-    <Resource name="planAfter">
+  </TestCase>
+  <TestCase name="testJoinDeriveIsNotNullFilterRule8">
+    <Resource name="sql">
+      <![CDATA[select t1.deptno from emp t1 right join emp t2 on t1.mgr = t2.mgr]]>
+    </Resource>
+    <Resource name="planBefore">
       <![CDATA[
-LogicalProject(EMPNO=[$3], ENAME=[$4], JOB=[$5], MGR=[$6], HIREDATE=[$7], SAL=[$8], COMM=[$9], DEPTNO=[$10], DEPTNO0=[$0], DNAME=[$1], LOC=[$2])
-  LogicalJoin(condition=[true], joinType=[inner])
-    LogicalTableScan(table=[[scott, DEPT]])
-    LogicalTableScan(table=[[scott, EMP]])
+LogicalProject(DEPTNO=[$7])
+  LogicalJoin(condition=[=($3, $12)], joinType=[right])
+    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
 ]]>
     </Resource>
   </TestCase>
-  <TestCase name="testJoinCommuteRuleWithAlwaysTrueConditionDisallowed">
+  <TestCase name="testJoinDeriveIsNotNullFilterRule9">
+    <Resource name="sql">
+      <![CDATA[select t1.deptno from (select * from emp where mgr is not null) t1
+join (select * from emp where mgr is not null) t2 on t1.mgr = t2.mgr]]>
+    </Resource>
     <Resource name="planBefore">
       <![CDATA[
-LogicalJoin(condition=[true], joinType=[inner])
-  LogicalTableScan(table=[[scott, EMP]])
-  LogicalTableScan(table=[[scott, DEPT]])
+LogicalProject(DEPTNO=[$7])
+  LogicalJoin(condition=[=($3, $12)], joinType=[inner])
+    LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8])
+      LogicalFilter(condition=[IS NOT NULL($3)])
+        LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+    LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8])
+      LogicalFilter(condition=[IS NOT NULL($3)])
+        LogicalTableScan(table=[[CATALOG, SALES, EMP]])
 ]]>
     </Resource>
   </TestCase>
@@ -4860,8 +5373,7 @@ LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$
     <Resource name="planAfter">
       <![CDATA[
 LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8], DEPTNO0=[$9], NAME=[$10])
-  LogicalJoin(condition=[=($7, $9)], joinType=[full])
-    LogicalValues(tuples=[[]])
+  LogicalProject(EMPNO=[null:INTEGER], ENAME=[null:VARCHAR(20)], JOB=[null:VARCHAR(10)], MGR=[null:INTEGER], HIREDATE=[null:TIMESTAMP(0)], SAL=[null:INTEGER], COMM=[null:INTEGER], DEPTNO=[null:INTEGER], SLACKER=[null:BOOLEAN], DEPTNO0=[CAST($0):INTEGER], NAME=[CAST($1):VARCHAR(10)])
     LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
 ]]>
     </Resource>
@@ -4931,8 +5443,7 @@ LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$
     <Resource name="planAfter">
       <![CDATA[
 LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8], DEPTNO0=[$9], NAME=[$10])
-  LogicalJoin(condition=[=($7, $9)], joinType=[right])
-    LogicalValues(tuples=[[]])
+  LogicalProject(EMPNO=[null:INTEGER], ENAME=[null:VARCHAR(20)], JOB=[null:VARCHAR(10)], MGR=[null:INTEGER], HIREDATE=[null:TIMESTAMP(0)], SAL=[null:INTEGER], COMM=[null:INTEGER], DEPTNO=[null:INTEGER], SLACKER=[null:BOOLEAN], DEPTNO0=[$0], NAME=[$1])
     LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
 ]]>
     </Resource>
@@ -5818,6 +6329,37 @@ LogicalProject(EXPR$0=[+(+($1, $3), $2)])
   LogicalAggregate(group=[{0, 1}], MS=[MIN($2)], SS=[SUM($2)])
     LogicalProject(JOB=[$2], DEPTNO=[$7], SAL=[$5])
       LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testProjectAggregateMergeNoOpForNonSum">
+    <Resource name="sql">
+      <![CDATA[select coalesce(m, 0)
+from (
+  select max(deptno) as m
+  from sales.emp
+)]]>
+    </Resource>
+    <Resource name="planBefore">
+      <![CDATA[
+LogicalProject(EXPR$0=[CASE(IS NOT NULL($0), CAST($0):INTEGER NOT NULL, 0)])
+  LogicalAggregate(group=[{}], M=[MAX($0)])
+    LogicalProject(DEPTNO=[$7])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testProjectAggregateMergeNonNumericLiteral">
+    <Resource name="sql">
+      <![CDATA[select hiredate, coalesce(hiredate, {ts '1969-12-31 00:00:00'}) as c1
+from sales.nullable
+group by hiredate]]>
+    </Resource>
+    <Resource name="planBefore">
+      <![CDATA[
+LogicalProject(HIREDATE=[$0], C1=[CASE(IS NOT NULL($0), CAST($0):TIMESTAMP(0) NOT NULL, 1969-12-31 00:00:00)])
+  LogicalAggregate(group=[{0}])
+    LogicalTableScan(table=[[CATALOG, SALES, NULLABLE]])
 ]]>
     </Resource>
   </TestCase>
@@ -6712,7 +7254,8 @@ LogicalProject(EMPNO=[10], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$
   <TestCase name="testPullConstantIntoProject">
     <Resource name="sql">
       <![CDATA[select deptno, deptno + 1, empno + deptno
-from sales.emp where deptno = 10]]>
+from sales.emp
+where deptno = 10]]>
     </Resource>
     <Resource name="planBefore">
       <![CDATA[
@@ -6747,6 +7290,22 @@ LogicalProject(DEPTNO=[$7], EXPR$1=[+($7, 1)], EXPR$2=[+($0, $7)])
 LogicalProject(DEPTNO=[10], EXPR$1=[11], EXPR$2=[+($0, 10)])
   LogicalFilter(condition=[OR(AND(IS NULL($7), IS NULL(10)), IS TRUE(=($7, 10)))])
     LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testPullConstantIntoProjectWithIsNotDistinctFromDate">
+    <Resource name="planBefore">
+      <![CDATA[
+LogicalProject(HIREDATE=[$4])
+  LogicalFilter(condition=[IS NOT DISTINCT FROM($4, 2020-12-11)])
+    LogicalTableScan(table=[[scott, EMP]])
+]]>
+    </Resource>
+    <Resource name="planAfter">
+      <![CDATA[
+LogicalProject(HIREDATE=[CAST(2020-12-11):DATE])
+  LogicalFilter(condition=[IS NOT DISTINCT FROM($4, 2020-12-11)])
+    LogicalTableScan(table=[[scott, EMP]])
 ]]>
     </Resource>
   </TestCase>
@@ -7013,6 +7572,40 @@ LogicalProject(EXPR$0=[2], EXPR$1=[3])
       LogicalTableScan(table=[[CATALOG, SALES, EMP]])
     LogicalProject(EXPR$0=[2])
       LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testPullConstantThroughUnionSameTypeNullableField">
+    <Resource name="sql">
+      <![CDATA[select deptno, ename from empnullables where deptno = 1
+union all
+select deptno, ename from empnullables where deptno = 1]]>
+    </Resource>
+    <Resource name="planBefore">
+      <![CDATA[
+LogicalUnion(all=[true])
+  LogicalProject(DEPTNO=[$1], ENAME=[$0])
+    LogicalFilter(condition=[=($1, 1)])
+      LogicalProject(ENAME=[$1], DEPTNO=[$7])
+        LogicalTableScan(table=[[CATALOG, SALES, EMPNULLABLES]])
+  LogicalProject(DEPTNO=[$1], ENAME=[$0])
+    LogicalFilter(condition=[=($1, 1)])
+      LogicalProject(ENAME=[$1], DEPTNO=[$7])
+        LogicalTableScan(table=[[CATALOG, SALES, EMPNULLABLES]])
+]]>
+    </Resource>
+    <Resource name="planAfter">
+      <![CDATA[
+LogicalProject(DEPTNO=[CAST(1):INTEGER], ENAME=[$0])
+  LogicalUnion(all=[true])
+    LogicalProject(ENAME=[$0])
+      LogicalFilter(condition=[=($1, 1)])
+        LogicalProject(ENAME=[$1], DEPTNO=[$7])
+          LogicalTableScan(table=[[CATALOG, SALES, EMPNULLABLES]])
+    LogicalProject(ENAME=[$0])
+      LogicalFilter(condition=[=($1, 1)])
+        LogicalProject(ENAME=[$1], DEPTNO=[$7])
+          LogicalTableScan(table=[[CATALOG, SALES, EMPNULLABLES]])
 ]]>
     </Resource>
   </TestCase>
@@ -9295,6 +9888,38 @@ LogicalProject(EXPR$0=[$1], EXPR$1=[$0])
           LogicalTableScan(table=[[CATALOG, SALES, BONUS]])
         LogicalProject(ENAME=[$1], EXPR$1=[CASE(<($5, 11), *(-1, $5), $5)])
           LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testPushProjectPastOutJoinWithCastNonNullExpr">
+    <Resource name="sql">
+      <![CDATA[select e.empno + 1 as c1, coalesce(d.name, b.job, '') as c2
+from emp e
+left join bonus b on e.ename = b.ename
+left join dept d on e.deptno = d.deptno]]>
+    </Resource>
+    <Resource name="planBefore">
+      <![CDATA[
+LogicalProject(C1=[+($0, 1)], C2=[CASE(IS NOT NULL($14), CAST($14):VARCHAR(10) NOT NULL, IS NOT NULL($10), CAST($10):VARCHAR(10) NOT NULL, '':VARCHAR(10))])
+  LogicalJoin(condition=[=($7, $13)], joinType=[left])
+    LogicalJoin(condition=[=($1, $9)], joinType=[left])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+      LogicalTableScan(table=[[CATALOG, SALES, BONUS]])
+    LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
+]]>
+    </Resource>
+    <Resource name="planAfter">
+      <![CDATA[
+LogicalProject(C1=[$2], C2=[CASE(IS NOT NULL($5), CAST($5):VARCHAR(10) NOT NULL, $3, CAST($1):VARCHAR(10) NOT NULL, '':VARCHAR(10))])
+  LogicalJoin(condition=[=($0, $4)], joinType=[left])
+    LogicalProject(DEPTNO=[$1], JOB0=[$4], C1=[$2], EXPR$1=[IS NOT NULL($4)])
+      LogicalJoin(condition=[=($0, $3)], joinType=[left])
+        LogicalProject(ENAME=[$1], DEPTNO=[$7], C1=[+($0, 1)])
+          LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+        LogicalProject(ENAME=[$0], JOB=[$1])
+          LogicalTableScan(table=[[CATALOG, SALES, BONUS]])
+    LogicalProject(DEPTNO=[$0], NAME=[$1])
+      LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
 ]]>
     </Resource>
   </TestCase>
@@ -11157,6 +11782,43 @@ LogicalProject(EXPR$0=[$0], EXPR$1=[CAST(/($1, $2)):INTEGER])
     LogicalAggregate(group=[{}], EXPR$0=[AVG($0)], agg#1=[$SUM0($0) WITHIN DISTINCT ($1)], agg#2=[COUNT() WITHIN DISTINCT ($1)])
       LogicalProject(SAL=[$5], DEPTNO=[$7])
         LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testReducingConstantsInferredFromCorrelate">
+    <Resource name="sql">
+      <![CDATA[SELECT ename,
+  empno,
+  T.empno_r,
+  CASE
+    WHEN __source__type__ = 'bounded'
+      THEN 1
+    ELSE 2
+    END AS type
+FROM (
+  SELECT ename,
+    empno,
+    'bounded' AS __source__type__
+  FROM emp
+  ) a,
+  lateral TABLE (ramp(empno)) AS T(empno_r)]]>
+    </Resource>
+    <Resource name="planBefore">
+      <![CDATA[
+LogicalProject(ENAME=[$0], EMPNO=[$1], EMPNO_R=[$3], TYPE=[CASE(=($2, 'bounded'), 1, 2)])
+  LogicalCorrelate(correlation=[$cor0], joinType=[inner], requiredColumns=[{1}])
+    LogicalProject(ENAME=[$1], EMPNO=[$0], __SOURCE__TYPE__=['bounded'])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+    LogicalTableFunctionScan(invocation=[RAMP($cor0.EMPNO)], rowType=[RecordType(INTEGER I)])
+]]>
+    </Resource>
+    <Resource name="planAfter">
+      <![CDATA[
+LogicalProject(ENAME=[$0], EMPNO=[$1], EMPNO_R=[$3], TYPE=[1])
+  LogicalCorrelate(correlation=[$cor0], joinType=[inner], requiredColumns=[{1}])
+    LogicalProject(ENAME=[$1], EMPNO=[$0], __SOURCE__TYPE__=['bounded'])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+    LogicalTableFunctionScan(invocation=[RAMP($cor0.EMPNO)], rowType=[RecordType(INTEGER I)])
 ]]>
     </Resource>
   </TestCase>
@@ -11334,9 +11996,8 @@ LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$
     <Resource name="planAfter">
       <![CDATA[
 LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8], DEPTNO0=[$9], NAME=[$10])
-  LogicalJoin(condition=[=($7, $9)], joinType=[full])
+  LogicalProject(EMPNO=[CAST($0):INTEGER], ENAME=[CAST($1):VARCHAR(20)], JOB=[CAST($2):VARCHAR(10)], MGR=[$3], HIREDATE=[CAST($4):TIMESTAMP(0)], SAL=[CAST($5):INTEGER], COMM=[CAST($6):INTEGER], DEPTNO=[CAST($7):INTEGER], SLACKER=[CAST($8):BOOLEAN], DEPTNO0=[null:INTEGER], NAME=[null:VARCHAR(10)])
     LogicalTableScan(table=[[CATALOG, SALES, EMP]])
-    LogicalValues(tuples=[[]])
 ]]>
     </Resource>
   </TestCase>
@@ -11382,9 +12043,8 @@ LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$
     <Resource name="planAfter">
       <![CDATA[
 LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8], DEPTNO0=[$9], NAME=[$10])
-  LogicalJoin(condition=[=($7, $9)], joinType=[left])
+  LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8], DEPTNO0=[null:INTEGER], NAME=[null:VARCHAR(10)])
     LogicalTableScan(table=[[CATALOG, SALES, EMP]])
-    LogicalValues(tuples=[[]])
 ]]>
     </Resource>
   </TestCase>
@@ -11462,7 +12122,7 @@ from emp
     </Resource>
     <Resource name="planBefore">
       <![CDATA[
-LogicalProject(EXPR$0=[> SOME($0, {
+LogicalProject(variablesSet=[[$cor0]], EXPR$0=[> SOME($0, {
 LogicalProject(DEPTNO=[$0])
   LogicalFilter(condition=[=($cor0.JOB, $1)])
     LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
@@ -11504,7 +12164,7 @@ LogicalProject(EXPR$0=[CAST(OR(AND(IS TRUE(>($0, $9)), IS NOT TRUE(OR(IS NULL($1
     </Resource>
     <Resource name="planBefore">
       <![CDATA[
-LogicalProject(SAL=[$5], EXPR$1=[NOT(IN($0, {
+LogicalProject(variablesSet=[[$cor0]], SAL=[$5], EXPR$1=[NOT(IN($0, {
 LogicalProject(DEPTNO=[$0])
   LogicalFilter(condition=[=($cor0.JOB, $1)])
     LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
@@ -11620,6 +12280,23 @@ LogicalJoin(condition=[=($0, $2)], joinType=[semi])
   LogicalProject(DEPTNO=[$7])
     LogicalFilter(condition=[>($5, 100)])
       LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testSemiJoinRuleDoNotMatchAggregate">
+    <Resource name="sql">
+      <![CDATA[select *
+from emp
+where exists(select * from dept where emp.deptno = dept.deptno)]]>
+    </Resource>
+    <Resource name="planBefore">
+      <![CDATA[
+LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8])
+  LogicalJoin(condition=[=($7, $9)], joinType=[inner])
+    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+    LogicalAggregate(group=[{0}], agg#0=[MIN($1)])
+      LogicalProject(DEPTNO=[$0], $f0=[true])
+        LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
 ]]>
     </Resource>
   </TestCase>
@@ -11729,6 +12406,57 @@ LogicalProject(DNAME=[$1])
     LogicalTableScan(table=[[scott, DEPT]])
     LogicalProject(DEPTNO=[$7])
       LogicalTableScan(table=[[scott, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testSemiJoinRuleWithJoinOnUniqueInput">
+    <Resource name="sql">
+      <![CDATA[select *
+from emp
+where exists(select * from dept where emp.deptno = dept.deptno)]]>
+    </Resource>
+    <Resource name="planBefore">
+      <![CDATA[
+LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8])
+  LogicalJoin(condition=[=($7, $9)], joinType=[inner])
+    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+    LogicalProject(DEPTNO=[$0])
+      LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
+]]>
+    </Resource>
+    <Resource name="planAfter">
+      <![CDATA[
+LogicalJoin(condition=[=($7, $9)], joinType=[semi])
+  LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+  LogicalProject(DEPTNO=[$0])
+    LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testSemiJoinRuleWithJoinOnUniqueInputWithAlias">
+    <Resource name="sql">
+      <![CDATA[select emp.deptno as department_id, emp.sal as salary
+from emp
+where exists(select * from dept where emp.deptno = dept.deptno)]]>
+    </Resource>
+    <Resource name="planBefore">
+      <![CDATA[
+LogicalProject(DEPARTMENT_ID=[$1], SALARY=[$0])
+  LogicalJoin(condition=[=($1, $2)], joinType=[inner])
+    LogicalProject(SAL=[$5], DEPTNO=[$7])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+    LogicalProject(DEPTNO=[$0])
+      LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
+]]>
+    </Resource>
+    <Resource name="planAfter">
+      <![CDATA[
+LogicalProject(DEPARTMENT_ID=[$1], SALARY=[$0])
+  LogicalJoin(condition=[=($1, $2)], joinType=[semi])
+    LogicalProject(SAL=[$5], DEPTNO=[$7])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+    LogicalProject(DEPTNO=[$0])
+      LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
 ]]>
     </Resource>
   </TestCase>
@@ -12351,16 +13079,18 @@ order by cast(d.deptno as integer) offset 1]]>
     </Resource>
     <Resource name="planBefore">
       <![CDATA[
-LogicalSort(sort0=[$1], dir0=[ASC], offset=[1])
-  LogicalProject(DEPTNO=[$0], EXPR$1=[$0])
-    LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
+LogicalProject(DEPTNO=[$0])
+  LogicalSort(sort0=[$1], dir0=[ASC], offset=[1])
+    LogicalProject(DEPTNO=[$0], EXPR$1=[$0])
+      LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
 ]]>
     </Resource>
     <Resource name="planAfter">
       <![CDATA[
-LogicalProject(DEPTNO=[$0], EXPR$1=[$0])
-  LogicalSort(sort0=[$0], dir0=[ASC], offset=[1])
-    LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
+LogicalProject(DEPTNO=[$0])
+  LogicalProject(DEPTNO=[$0], EXPR$1=[$0])
+    LogicalSort(sort0=[$0], dir0=[ASC], offset=[1])
+      LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
 ]]>
     </Resource>
   </TestCase>
@@ -12371,16 +13101,18 @@ order by cast(d.deptno as double) offset 1]]>
     </Resource>
     <Resource name="planBefore">
       <![CDATA[
-LogicalSort(sort0=[$1], dir0=[ASC], offset=[1])
-  LogicalProject(DEPTNO=[$0], EXPR$1=[CAST($0):DOUBLE NOT NULL])
-    LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
+LogicalProject(DEPTNO=[$0])
+  LogicalSort(sort0=[$1], dir0=[ASC], offset=[1])
+    LogicalProject(DEPTNO=[$0], EXPR$1=[CAST($0):DOUBLE NOT NULL])
+      LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
 ]]>
     </Resource>
     <Resource name="planAfter">
       <![CDATA[
-LogicalProject(DEPTNO=[$0], EXPR$1=[CAST($0):DOUBLE NOT NULL])
-  LogicalSort(sort0=[$0], dir0=[ASC], offset=[1])
-    LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
+LogicalProject(DEPTNO=[$0])
+  LogicalProject(DEPTNO=[$0], EXPR$1=[CAST($0):DOUBLE NOT NULL])
+    LogicalSort(sort0=[$0], dir0=[ASC], offset=[1])
+      LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
 ]]>
     </Resource>
   </TestCase>
@@ -12391,9 +13123,10 @@ order by cast(d.deptno as varchar(10)) offset 1]]>
     </Resource>
     <Resource name="planBefore">
       <![CDATA[
-LogicalSort(sort0=[$1], dir0=[ASC], offset=[1])
-  LogicalProject(DEPTNO=[$0], EXPR$1=[CAST($0):VARCHAR(10) NOT NULL])
-    LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
+LogicalProject(DEPTNO=[$0])
+  LogicalSort(sort0=[$1], dir0=[ASC], offset=[1])
+    LogicalProject(DEPTNO=[$0], EXPR$1=[CAST($0):VARCHAR(10) NOT NULL])
+      LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
 ]]>
     </Resource>
     <Resource name="planAfter">
@@ -12414,21 +13147,23 @@ order by deptno desc nulls last]]>
     </Resource>
     <Resource name="planBefore">
       <![CDATA[
-LogicalSort(sort0=[$1], dir0=[DESC-nulls-last])
+LogicalProject(C=[$0])
+  LogicalSort(sort0=[$1], dir0=[DESC-nulls-last])
+    LogicalProject(C=[$2], DEPTNO=[$0])
+      LogicalAggregate(group=[{0, 1}], C=[COUNT()])
+        LogicalProject(DEPTNO=[$7], SAL=[$5])
+          LogicalFilter(condition=[=($7, 10)])
+            LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+    <Resource name="planAfter">
+      <![CDATA[
+LogicalProject(C=[$0])
   LogicalProject(C=[$2], DEPTNO=[$0])
     LogicalAggregate(group=[{0, 1}], C=[COUNT()])
       LogicalProject(DEPTNO=[$7], SAL=[$5])
         LogicalFilter(condition=[=($7, 10)])
           LogicalTableScan(table=[[CATALOG, SALES, EMP]])
-]]>
-    </Resource>
-    <Resource name="planAfter">
-      <![CDATA[
-LogicalProject(C=[$2], DEPTNO=[$0])
-  LogicalAggregate(group=[{0, 1}], C=[COUNT()])
-    LogicalProject(DEPTNO=[$7], SAL=[$5])
-      LogicalFilter(condition=[=($7, 10)])
-        LogicalTableScan(table=[[CATALOG, SALES, EMP]])
 ]]>
     </Resource>
   </TestCase>
@@ -12442,22 +13177,24 @@ order by deptno, sal desc nulls first]]>
     </Resource>
     <Resource name="planBefore">
       <![CDATA[
-LogicalSort(sort0=[$1], sort1=[$2], dir0=[ASC], dir1=[DESC])
-  LogicalProject(C=[$2], DEPTNO=[$0], SAL=[$1])
-    LogicalAggregate(group=[{0, 1}], C=[COUNT()])
-      LogicalProject(DEPTNO=[$7], SAL=[$5])
-        LogicalFilter(condition=[=($7, 10)])
-          LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+LogicalProject(C=[$0])
+  LogicalSort(sort0=[$1], sort1=[$2], dir0=[ASC], dir1=[DESC])
+    LogicalProject(C=[$2], DEPTNO=[$0], SAL=[$1])
+      LogicalAggregate(group=[{0, 1}], C=[COUNT()])
+        LogicalProject(DEPTNO=[$7], SAL=[$5])
+          LogicalFilter(condition=[=($7, 10)])
+            LogicalTableScan(table=[[CATALOG, SALES, EMP]])
 ]]>
     </Resource>
     <Resource name="planAfter">
       <![CDATA[
-LogicalSort(sort0=[$2], dir0=[DESC])
-  LogicalProject(C=[$2], DEPTNO=[$0], SAL=[$1])
-    LogicalAggregate(group=[{0, 1}], C=[COUNT()])
-      LogicalProject(DEPTNO=[$7], SAL=[$5])
-        LogicalFilter(condition=[=($7, 10)])
-          LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+LogicalProject(C=[$0])
+  LogicalSort(sort0=[$2], dir0=[DESC])
+    LogicalProject(C=[$2], DEPTNO=[$0], SAL=[$1])
+      LogicalAggregate(group=[{0, 1}], C=[COUNT()])
+        LogicalProject(DEPTNO=[$7], SAL=[$5])
+          LogicalFilter(condition=[=($7, 10)])
+            LogicalTableScan(table=[[CATALOG, SALES, EMP]])
 ]]>
     </Resource>
   </TestCase>
@@ -12572,7 +13309,7 @@ LogicalProject(NAME=[$0], LATITUDE=[$1], LONGITUDE=[$2], CUISINE=[$3], HILBERT=[
     <Resource name="planAfter">
       <![CDATA[
 LogicalProject(NAME=[$0], LATITUDE=[$1], LONGITUDE=[$2], CUISINE=[$3], HILBERT=[$4])
-  LogicalFilter(condition=[AND(SEARCH($4, Sarg[[33033..33035], [33050..33053], [33055..33080], [33092..33100], [33112..33156], [33164..33176], [33236..33244], [33252..33254], [36456..36464], [36496..36520]]), ST_CONTAINS(MULTIPOLYGON (((16 20, 15.987153539431617 20.39241877538086, 15.948669168242859 20.78315715332031, 15.884711682419379 21.17054193209677, 15.795554957734407 21.552914270615126, 15.68158077697063 21.92863679181897, 15.543277195067716 22.296100594190538, 15.381236449196127 22.65373214131401, 15.196152422706628 23, 14.98881767381527 23.333421398117615, 14.76012004174741 23.652568574052324, 14.511038844873863 23.956074890600412, 14.242640687119284 24.242640687119284, 13.956074890600412 24.511038844873866, 13.652568574052323 24.760120041747413, 13.333421398117613 24.988817673815273, 13 25.196152422706632, 12.653732141314007 25.38123644919613, 12.296100594190538 25.54327719506772, 11.928636791818969 25.681580776970634, 11.552914270615124 25.79555495773441, 11.17054193209677 25.884711682419383, 10.78315715332031 25.948669168242862, 10.392418775380857 25.98715353943162, 10 26, 9.60758122461914 25.987153539431617, 9.21684284667969 25.94866916824286, 8.82945806790323 25.88471168241938, 8.447085729384876 25.795554957734407, 8.07136320818103 25.68158077697063, 7.703899405809461 25.543277195067716, 7.346267858685993 25.381236449196127, 7 25.19615242270663, 6.666578601882387 24.98881767381527, 6.347431425947676 24.76012004174741, 6.043925109399586 24.511038844873863, 5.757359312880714 24.242640687119284, 5.488961155126135 23.956074890600412, 5.239879958252589 23.652568574052324, 5.011182326184728 23.33342139811761, 4.803847577293368 23, 4.6187635508038705 22.653732141314006, 4.45672280493228 22.296100594190538, 4.318419223029367 21.92863679181897, 4.204445042265591 21.552914270615123, 4.115288317580618 21.170541932096768, 4.051330831757139 20.78315715332031, 4.01284646056838 20.392418775380857, 4 20, 4.012846460568384 19.60758122461914, 4.051330831757142 19.21684284667969, 4.115288317580622 18.82945806790323, 4.204445042265594 18.447085729384874, 4.31841922302937 18.07136320818103, 4.456722804932283 17.703899405809462, 4.618763550803873 17.34626785868599, 4.803847577293371 17, 5.011182326184731 16.666578601882385, 5.239879958252591 16.347431425947676, 5.4889611551261375 16.043925109399588, 5.757359312880716 15.757359312880714, 6.043925109399588 15.488961155126134, 6.347431425947677 15.239879958252589, 6.666578601882387 15.011182326184727, 7.000000000000001 14.803847577293368, 7.346267858685993 14.61876355080387, 7.703899405809462 14.45672280493228, 8.071363208181031 14.318419223029366, 8.447085729384876 14.20444504226559, 8.82945806790323 14.115288317580617, 9.21684284667969 14.051330831757138, 9.607581224619143 14.01284646056838, 10 14, 10.39241877538086 14.012846460568383, 10.78315715332031 14.051330831757141, 11.17054193209677 14.115288317580621, 11.552914270615124 14.204445042265593, 11.92863679181897 14.31841922302937, 12.296100594190538 14.456722804932284, 12.653732141314007 14.618763550803873, 13 14.803847577293372, 13.333421398117613 15.01118232618473, 13.652568574052324 15.23987995825259, 13.956074890600414 15.488961155126137, 14.242640687119286 15.757359312880716, 14.511038844873866 16.043925109399588, 14.760120041747411 16.347431425947676, 14.988817673815273 16.66657860188239, 15.196152422706632 17, 15.38123644919613 17.346267858685994, 15.54327719506772 17.703899405809462, 15.681580776970634 18.07136320818103, 15.79555495773441 18.447085729384877, 15.884711682419383 18.829458067903232, 15.948669168242862 19.21684284667969, 15.98715353943162 19.607581224619143, 16 20))):GEOMETRY, ST_POINT($2, $1)))])
+  LogicalFilter(condition=[AND(SEARCH($4, Sarg[[33033..33035], [33050..33053], [33055..33080], [33092..33100], [33112..33156], [33164..33176], [33236..33244], [33252..33254], [36456..36464], [36496..36520]]), ST_CONTAINS(POLYGON ((16 20, 15.884711682419383 18.829458067903232, 15.54327719506772 17.703899405809462, 14.988817673815271 16.666578601882385, 14.242640687119286 15.757359312880716, 13.333421398117615 15.011182326184729, 12.29610059419054 14.45672280493228, 11.17054193209677 14.115288317580617, 10 14, 8.82945806790323 14.115288317580617, 7.703899405809461 14.45672280493228, 6.666578601882389 15.011182326184727, 5.757359312880715 15.757359312880714, 5.011182326184728 16.666578601882385, 4.45672280493228 17.70389940580946, 4.115288317580617 18.82945806790323, 4 20, 4.115288317580617 21.17054193209677, 4.456722804932279 22.296100594190538, 5.011182326184727 23.33342139811761, 5.757359312880714 24.242640687119284, 6.666578601882387 24.98881767381527, 7.703899405809458 25.54327719506772, 8.829458067903229 25.884711682419383, 9.999999999999998 26, 11.17054193209677 25.884711682419383, 12.29610059419054 25.54327719506772, 13.333421398117611 24.988817673815273, 14.242640687119284 24.242640687119284, 14.988817673815271 23.333421398117615, 15.54327719506772 22.29610059419054, 15.884711682419383 21.17054193209677, 16 20)):GEOMETRY, ST_POINT($2, $1)))])
     LogicalTableScan(table=[[CATALOG, GEO, RESTAURANTS]])
 ]]>
     </Resource>
@@ -12595,7 +13332,7 @@ LogicalProject(NAME=[$0], LATITUDE=[$1], LONGITUDE=[$2], CUISINE=[$3], HILBERT=[
     <Resource name="planAfter">
       <![CDATA[
 LogicalProject(NAME=[$0], LATITUDE=[$1], LONGITUDE=[$2], CUISINE=[$3], HILBERT=[$4])
-  LogicalFilter(condition=[AND(SEARCH($4, Sarg[[33064..33076], [33092..33100], [33112..33156], [33164..33176], [33236..33240], [36457..36459], [36501..36503], [36505..36507], [36517..36519]]), ST_DWITHIN(MULTILINESTRING ((8 20, 12 20)):GEOMETRY, ST_POINT($2, $1), 4))])
+  LogicalFilter(condition=[AND(SEARCH($4, Sarg[[33064..33076], [33092..33100], [33112..33156], [33164..33176], [33236..33240], [36457..36459], [36501..36503], [36505..36507], [36517..36519]]), ST_DWITHIN(LINESTRING (8 20, 12 20):GEOMETRY, ST_POINT($2, $1), 4))])
     LogicalTableScan(table=[[CATALOG, GEO, RESTAURANTS]])
 ]]>
     </Resource>
@@ -12690,18 +13427,18 @@ LogicalProject(NAME=[$0], LATITUDE=[$1], LONGITUDE=[$2], CUISINE=[$3], HILBERT=[
   <TestCase name="testSpatialReduce">
     <Resource name="sql">
       <![CDATA[select
-  ST_Buffer(ST_Point(0.0, 1.0), 2) as b
+  ST_Buffer(ST_Point(0.0, 0.0), 1, 4) as b
 from GEO.Restaurants as r]]>
     </Resource>
     <Resource name="planBefore">
       <![CDATA[
-LogicalProject(B=[ST_BUFFER(ST_POINT(0.0:DECIMAL(2, 1), 1.0:DECIMAL(2, 1)), 2)])
+LogicalProject(B=[ST_BUFFER(ST_POINT(0.0:DECIMAL(2, 1), 0.0:DECIMAL(2, 1)), 1, 4)])
   LogicalTableScan(table=[[CATALOG, GEO, RESTAURANTS]])
 ]]>
     </Resource>
     <Resource name="planAfter">
       <![CDATA[
-LogicalProject(B=[CAST(MULTIPOLYGON (((2 1, 1.9957178464772056 1.1308062584602858, 1.9828897227476194 1.2610523844401027, 1.9615705608064595 1.3901806440322562, 1.9318516525781353 1.517638090205041, 1.8938602589902103 1.6428789306063227, 1.8477590650225726 1.7653668647301788, 1.7937454830653756 1.8845773804380017, 1.7320508075688765 1.9999999999999991, 1.6629392246050898 2.1111404660392035, 1.5867066805824699 2.217522858017441, 1.5036796149579543 2.318691630200137, 1.4142135623730947 2.4142135623730945, 1.3186916302001375 2.5036796149579543, 1.217522858017441 2.58670668058247, 1.1111404660392044 2.66293922460509, 0.9999999999999999 2.7320508075688767, 0.8845773804380025 2.7937454830653765, 0.7653668647301795 2.847759065022573, 0.6428789306063231 2.893860258990211, 0.5176380902050415 2.9318516525781364, 0.3901806440322565 2.961570560806461, 0.26105238444010315 2.982889722747621, 0.13080625846028612 2.995717846477207, 0 3, -0.13080625846028585 2.9957178464772056, -0.2610523844401028 2.982889722747619, -0.3901806440322561 2.9615705608064595, -0.517638090205041 2.9318516525781355, -0.6428789306063226 2.8938602589902103, -0.7653668647301789 2.8477590650225726, -0.8845773804380018 2.7937454830653756, -0.9999999999999992 2.7320508075688767, -1.1111404660392037 2.66293922460509, -1.2175228580174406 2.58670668058247, -1.318691630200137 2.5036796149579543, -1.4142135623730945 2.414213562373095, -1.5036796149579543 2.3186916302001377, -1.5867066805824699 2.217522858017441, -1.66293922460509 2.1111404660392044, -1.732050807568877 2, -1.7937454830653763 1.8845773804380026, -1.8477590650225733 1.7653668647301795, -1.8938602589902112 1.6428789306063232, -1.9318516525781366 1.5176380902050415, -1.9615705608064609 1.3901806440322564, -1.9828897227476208 1.2610523844401031, -1.995717846477207 1.130806258460286, -2 1, -1.9957178464772056 0.8691937415397142, -1.9828897227476194 0.7389476155598972, -1.9615705608064595 0.6098193559677438, -1.9318516525781353 0.48236190979495897, -1.8938602589902103 0.3571210693936774, -1.8477590650225726 0.2346331352698211, -1.7937454830653756 0.11542261956199817, -1.7320508075688765 7.7715611723760960e-16, -1.6629392246050898 -0.11114046603920369, -1.5867066805824699 -0.21752285801744065, -1.5036796149579543 -0.318691630200137, -1.4142135623730947 -0.4142135623730945, -1.3186916302001375 -0.5036796149579543, -1.217522858017441 -0.5867066805824699, -1.1111404660392044 -0.66293922460509, -0.9999999999999999 -0.732050807568877, -0.8845773804380025 -0.7937454830653763, -0.7653668647301795 -0.8477590650225733, -0.6428789306063231 -0.8938602589902112, -0.5176380902050415 -0.9318516525781366, -0.3901806440322565 -0.9615705608064609, -0.26105238444010315 -0.9828897227476208, -0.13080625846028612 -0.995717846477207, 0 -1, 0.13080625846028585 -0.9957178464772056, 0.2610523844401028 -0.9828897227476194, 0.3901806440322561 -0.9615705608064595, 0.517638090205041 -0.9318516525781353, 0.6428789306063226 -0.8938602589902103, 0.7653668647301789 -0.8477590650225726, 0.8845773804380018 -0.7937454830653756, 0.9999999999999992 -0.7320508075688765, 1.1111404660392037 -0.6629392246050898, 1.2175228580174406 -0.5867066805824699, 1.318691630200137 -0.5036796149579543, 1.4142135623730945 -0.4142135623730947, 1.5036796149579543 -0.31869163020013747, 1.5867066805824699 -0.2175228580174411, 1.66293922460509 -0.11114046603920436, 1.732050807568877 1.1102230246251565e-16, 1.7937454830653763 0.11542261956199751, 1.8477590650225733 0.23463313526982055, 1.8938602589902112 0.35712106939367694, 1.9318516525781366 0.4823619097949585, 1.9615705608064609 0.6098193559677435, 1.9828897227476208 0.7389476155598969, 1.995717846477207 0.8691937415397138, 2 1))):GEOMETRY):GEOMETRY])
+LogicalProject(B=[CAST(POLYGON ((1 0, 0.9238795325112867 -0.3826834323650898, 0.7071067811865476 -0.7071067811865475, 0.3826834323650898 -0.9238795325112867, 0.0000000000000001 -1, -0.3826834323650897 -0.9238795325112867, -0.7071067811865475 -0.7071067811865476, -0.9238795325112867 -0.3826834323650899, -1 -0.0000000000000001, -0.9238795325112868 0.3826834323650897, -0.7071067811865477 0.7071067811865475, -0.3826834323650903 0.9238795325112865, -0.0000000000000002 1, 0.38268343236509 0.9238795325112866, 0.7071067811865474 0.7071067811865477, 0.9238795325112865 0.3826834323650904, 1 0)):GEOMETRY):GEOMETRY])
   LogicalTableScan(table=[[CATALOG, GEO, RESTAURANTS]])
 ]]>
     </Resource>
@@ -12734,7 +13471,11 @@ LogicalProject(DEPTNO=[$0], NAME=[$1], EMPNO=[$2], ENAME=[$3], JOB=[$4], MGR=[$5
   </TestCase>
   <TestCase name="testSubQueryWithDynamicStarHang">
     <Resource name="sql">
-      <![CDATA[select n.n_regionkey from (select * from (select * from sales.customer) t) n where n.n_nationkey >1]]>
+      <![CDATA[select n.n_regionkey
+from (select *
+  from (select *
+    from sales.customer) t) n
+where n.n_nationkey > 1]]>
     </Resource>
     <Resource name="planBefore">
       <![CDATA[
@@ -13581,8 +14322,8 @@ LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$
     <Resource name="planAfter">
       <![CDATA[
 LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8])
-  LogicalFilter(condition=[OR(AND(>($0, $9), IS NOT TRUE(OR(IS NULL($12), =($10, 0)))), AND(>($0, $9), IS NOT TRUE(OR(IS NULL($12), =($10, 0))), IS NOT TRUE(>($0, $9)), IS NOT TRUE(>($10, $11))))])
-    LogicalJoin(condition=[=($2, $13)], joinType=[left])
+  LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8], m=[CAST($9):INTEGER], c=[CAST($10):BIGINT], d=[CAST($11):BIGINT], trueLiteral=[CAST($12):BOOLEAN], NAME=[CAST($13):VARCHAR(10)])
+    LogicalJoin(condition=[AND(=($2, $13), OR(AND(>($0, $9), IS NOT TRUE(OR(IS NULL($12), =($10, 0)))), AND(>($0, $9), IS NOT TRUE(OR(IS NULL($12), =($10, 0))), IS NOT TRUE(>($0, $9)), IS NOT TRUE(>($10, $11)))))], joinType=[inner])
       LogicalTableScan(table=[[CATALOG, SALES, EMP]])
       LogicalProject(m=[$1], c=[$2], d=[$2], trueLiteral=[true], NAME=[$0])
         LogicalAggregate(group=[{0}], m=[MIN($1)], c=[COUNT()])
diff --git a/core/src/test/resources/org/apache/calcite/test/SqlHintsConverterTest.xml b/core/src/test/resources/org/apache/calcite/test/SqlHintsConverterTest.xml
index 052a6b72a0c..7c422656d27 100644
--- a/core/src/test/resources/org/apache/calcite/test/SqlHintsConverterTest.xml
+++ b/core/src/test/resources/org/apache/calcite/test/SqlHintsConverterTest.xml
@@ -89,6 +89,11 @@ TableScan:[[INDEX inheritPath:[] options:[EMPNO]], [INDEX inheritPath:[0, 1, 0,
 ]]>
     </Resource>
   </TestCase>
+  <TestCase name="testHintExcludeRules">
+    <Resource name="sql">
+      <![CDATA[select empno from (select * from (select /*+ preserved_project */ empno, ename, deptno from emp) where deptno = 20)]]>
+    </Resource>
+  </TestCase>
   <TestCase name="testHintsInSubQueryWithDecorrelation">
     <Resource name="sql">
       <![CDATA[select /*+ resource(parallelism='3'), AGG_STRATEGY(TWO_PHASE) */
@@ -195,6 +200,70 @@ EnumerableProject(ENAME=[$3], JOB=[$4], SAL=[$7], NAME=[$1])
   EnumerableHashJoin(condition=[=($0, $9)], joinType=[inner])
     EnumerableTableScan(table=[[CATALOG, SALES, DEPT]])
     EnumerableTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testHintsPropagationInVolcanoPlannerRules2">
+    <Resource name="sql">
+      <![CDATA[select /*+ no_hash_join */ ename, job
+from emp where not exists (select 1 from dept where emp.deptno = dept.deptno)]]>
+    </Resource>
+    <Resource name="planBefore">
+      <![CDATA[
+LogicalProject(ENAME=[$0], JOB=[$1])
+  LogicalFilter(condition=[IS NULL($4)])
+    LogicalJoin(condition=[=($2, $3)], joinType=[left])
+      LogicalProject(ENAME=[$1], JOB=[$2], DEPTNO=[$7])
+        LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+      LogicalAggregate(group=[{0}], agg#0=[MIN($1)])
+        LogicalProject(DEPTNO=[$0], $f0=[true])
+          LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
+]]>
+    </Resource>
+    <Resource name="planAfter">
+      <![CDATA[
+EnumerableProject(ENAME=[$0], JOB=[$1])
+  EnumerableFilter(condition=[IS NULL($4)])
+    EnumerableMergeJoin(condition=[=($2, $3)], joinType=[left])
+      EnumerableSort(sort0=[$2], dir0=[ASC])
+        EnumerableProject(ENAME=[$1], JOB=[$2], DEPTNO=[$7])
+          EnumerableTableScan(table=[[CATALOG, SALES, EMP]])
+      EnumerableSort(sort0=[$0], dir0=[ASC])
+        EnumerableProject(DEPTNO=[$0], $f0=[true])
+          EnumerableTableScan(table=[[CATALOG, SALES, DEPT]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testHintsPropagationInVolcanoPlannerRules3">
+    <Resource name="sql">
+      <![CDATA[select /*+ no_hash_join */ ename, job
+from emp where not exists (select 1 from dept where emp.deptno = dept.deptno) order by ename]]>
+    </Resource>
+    <Resource name="planBefore">
+      <![CDATA[
+LogicalSort(sort0=[$0], dir0=[ASC])
+  LogicalProject(ENAME=[$0], JOB=[$1])
+    LogicalFilter(condition=[IS NULL($4)])
+      LogicalJoin(condition=[=($2, $3)], joinType=[left])
+        LogicalProject(ENAME=[$1], JOB=[$2], DEPTNO=[$7])
+          LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+        LogicalAggregate(group=[{0}], agg#0=[MIN($1)])
+          LogicalProject(DEPTNO=[$0], $f0=[true])
+            LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
+]]>
+    </Resource>
+    <Resource name="planAfter">
+      <![CDATA[
+EnumerableSort(sort0=[$0], dir0=[ASC])
+  EnumerableProject(ENAME=[$0], JOB=[$1])
+    EnumerableFilter(condition=[IS NULL($4)])
+      EnumerableMergeJoin(condition=[=($2, $3)], joinType=[left])
+        EnumerableSort(sort0=[$2], dir0=[ASC])
+          EnumerableProject(ENAME=[$1], JOB=[$2], DEPTNO=[$7])
+            EnumerableTableScan(table=[[CATALOG, SALES, EMP]])
+        EnumerableSort(sort0=[$0], dir0=[ASC])
+          EnumerableProject(DEPTNO=[$0], $f0=[true])
+            EnumerableTableScan(table=[[CATALOG, SALES, DEPT]])
 ]]>
     </Resource>
   </TestCase>
@@ -292,6 +361,19 @@ on emp.deptno = dept.deptno]]>
 Project:[[PROPERTIES inheritPath:[] options:{K1=v1, K2=v2}]]
 TableScan:[[INDEX inheritPath:[] options:[IDX1, IDX2]], [PROPERTIES inheritPath:[0, 0] options:{K1=v1, K2=v2}]]
 TableScan:[[PROPERTIES inheritPath:[] options:{K1=v1, K2=v2}], [PROPERTIES inheritPath:[0, 1] options:{K1=v1, K2=v2}]]
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testSnapshotHints">
+    <Resource name="sql">
+      <![CDATA[select /*+ fast_snapshot(products_temporal) */ stream * from
+ orders join products_temporal for system_time as of timestamp '2022-08-11 15:00:00'
+ on orders.productid = products_temporal.productid]]>
+    </Resource>
+    <Resource name="hints">
+      <![CDATA[
+Project:[[FAST_SNAPSHOT inheritPath:[] options:[PRODUCTS_TEMPORAL]]]
+Snapshot:[[FAST_SNAPSHOT inheritPath:[0, 1] options:[PRODUCTS_TEMPORAL]]]
 ]]>
     </Resource>
   </TestCase>
diff --git a/core/src/test/resources/org/apache/calcite/test/SqlToRelConverterTest.xml b/core/src/test/resources/org/apache/calcite/test/SqlToRelConverterTest.xml
index 3cf56aa3330..25c1a3c302e 100644
--- a/core/src/test/resources/org/apache/calcite/test/SqlToRelConverterTest.xml
+++ b/core/src/test/resources/org/apache/calcite/test/SqlToRelConverterTest.xml
@@ -161,6 +161,36 @@ LogicalProject(DEPTNO=[$0], B=[>($1, $2)])
     LogicalAggregate(group=[{}], EXPR$0=[MIN($0)])
       LogicalProject(EMPNO=[$0])
         LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testAggregateFunAndAliasInHaving1">
+    <Resource name="sql">
+      <![CDATA[select count(empno) as e
+from emp
+having e > 10 and count(empno) > 10]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalFilter(condition=[>($0, 10)])
+  LogicalAggregate(group=[{}], E=[COUNT()])
+    LogicalProject(EMPNO=[$0])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testAggregateFunAndAliasInHaving2">
+    <Resource name="sql">
+      <![CDATA[select count(empno) as e
+from emp
+having e > 10 or count(empno) < 5]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalFilter(condition=[SEARCH($0, Sarg[(-∞..5), (10..+∞)])])
+  LogicalAggregate(group=[{}], E=[COUNT()])
+    LogicalProject(EMPNO=[$0])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
 ]]>
     </Resource>
   </TestCase>
@@ -315,6 +345,20 @@ from dept_nested_expanded as d,
  UNNEST(d.employees) as t(employee)]]>
     </Resource>
   </TestCase>
+  <TestCase name="testAliasWithinGroupingSets">
+    <Resource name="sql">
+      <![CDATA[SELECT empno / 2 AS x
+FROM emp
+GROUP BY ROLLUP(x)]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalAggregate(group=[{0}], groups=[[{0}, {}]])
+  LogicalProject(X=[/($0, 2)])
+    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
   <TestCase name="testAllValueList">
     <Resource name="sql">
       <![CDATA[select empno from emp where deptno > all (10, 20)]]>
@@ -349,6 +393,58 @@ LogicalProject(ANYEMPNO=[$1])
 LogicalAggregate(group=[{}], ANYEMPNO=[ANY_VALUE($0)])
   LogicalProject(EMPNO=[$0])
     LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testArgMaxFunction">
+    <Resource name="sql">
+      <![CDATA[select arg_max(ename, deptno)
+from emp]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalAggregate(group=[{}], EXPR$0=[ARG_MAX($0, $1)])
+  LogicalProject(ENAME=[$1], DEPTNO=[$7])
+    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testArgMaxFunctionWithWinAgg">
+    <Resource name="sql">
+      <![CDATA[select job,
+  arg_max(ename, deptno) over (partition by job order by sal)
+from emp]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(JOB=[$2], EXPR$1=[ARG_MAX($1, $7) OVER (PARTITION BY $2 ORDER BY $5)])
+  LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testArgMinFunction">
+    <Resource name="sql">
+      <![CDATA[select arg_min(ename, deptno)
+from emp]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalAggregate(group=[{}], EXPR$0=[ARG_MIN($0, $1)])
+  LogicalProject(ENAME=[$1], DEPTNO=[$7])
+    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testArgMinFunctionWithWinAgg">
+    <Resource name="sql">
+      <![CDATA[select job,
+  arg_min(ename, deptno) over (partition by job order by sal)
+from emp]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(JOB=[$2], EXPR$1=[ARG_MIN($1, $7) OVER (PARTITION BY $2 ORDER BY $5)])
+  LogicalTableScan(table=[[CATALOG, SALES, EMP]])
 ]]>
     </Resource>
   </TestCase>
@@ -421,6 +517,42 @@ LogicalValues(tuples=[[{ 1 }]])
       <![CDATA[values (case 'a' when 'a' then 1 end)]]>
     </Resource>
   </TestCase>
+  <TestCase name="testCaseAliasWithinGroupingSets">
+    <Resource name="sql">
+      <![CDATA[SELECT empno,
+CASE
+WHEN ename in ('Fred','Eric') THEN 'CEO'
+ELSE 'Other'
+END AS derived_col
+FROM emp
+GROUP BY GROUPING SETS ((empno, derived_col),(empno))]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalAggregate(group=[{0, 1}], groups=[[{0, 1}, {0}]])
+  LogicalProject(EMPNO=[$0], DERIVED_COL=[CASE(SEARCH($1, Sarg['Eric', 'Fred']:CHAR(4)), 'CEO  ', 'Other')])
+    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testCaseWithinGroupingSets">
+    <Resource name="sql">
+      <![CDATA[SELECT empno,
+CASE WHEN ename IN ('Fred','Eric') THEN 'Manager' ELSE 'Other' END
+FROM emp
+GROUP BY GROUPING SETS (
+(empno, CASE WHEN ename IN ('Fred','Eric') THEN 'Manager' ELSE 'Other' END),
+(empno)
+)]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalAggregate(group=[{0, 1}], groups=[[{0, 1}, {0}]])
+  LogicalProject(EMPNO=[$0], EXPR$1=[CASE(SEARCH($1, Sarg['Eric', 'Fred']:CHAR(4)), 'Manager', 'Other  ')])
+    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
   <TestCase name="testCharLength">
     <Resource name="plan">
       <![CDATA[
@@ -624,6 +756,26 @@ LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$
     LogicalTableScan(table=[[CATALOG, SALES, EMP]])
 })])
   LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testCorrelatedForOuterFields">
+    <Resource name="sql">
+      <![CDATA[SELECT ARRAY(SELECT dept.deptno)
+FROM emp
+LEFT OUTER JOIN dept
+ON emp.empno = dept.deptno]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(EXPR$0=[$11])
+  LogicalCorrelate(correlation=[$cor0], joinType=[inner], requiredColumns=[{9}])
+    LogicalJoin(condition=[=($0, $9)], joinType=[left])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+      LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
+    Collect(field=[EXPR$0])
+      LogicalProject(DEPTNO=[$cor0.DEPTNO0])
+        LogicalValues(tuples=[[{ 0 }]])
 ]]>
     </Resource>
   </TestCase>
@@ -664,6 +816,46 @@ LogicalProject(EMPNO=[$0], JOB=[$2])
 ]]>
     </Resource>
   </TestCase>
+  <TestCase name="testCorrelatedScalarSubQueryInSelectList">
+    <Resource name="planNotExpanded">
+      <![CDATA[
+LogicalProject(variablesSet=[[$cor0]], DEPTNO=[$0], I0=[$SCALAR_QUERY({
+LogicalAggregate(group=[{}], EXPR$0=[MIN($0)])
+  LogicalProject($f0=[1])
+    LogicalFilter(condition=[>($0, $cor0.DEPTNO)])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+})], I1=[$SCALAR_QUERY({
+LogicalAggregate(group=[{}], EXPR$0=[MIN($0)])
+  LogicalProject($f0=[0])
+    LogicalFilter(condition=[AND(=($7, $cor0.DEPTNO), =($1, 'SMITH'), >($cor0.DEPTNO, 0))])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+})])
+  LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
+]]>
+    </Resource>
+    <Resource name="planExpanded">
+      <![CDATA[
+LogicalProject(DEPTNO=[$0], I0=[$2], I1=[$3])
+  LogicalCorrelate(correlation=[$cor1], joinType=[left], requiredColumns=[{0}])
+    LogicalCorrelate(correlation=[$cor0], joinType=[left], requiredColumns=[{0}])
+      LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
+      LogicalAggregate(group=[{}], EXPR$0=[MIN($0)])
+        LogicalProject($f0=[1])
+          LogicalFilter(condition=[>($0, $cor0.DEPTNO)])
+            LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+    LogicalAggregate(group=[{}], EXPR$0=[MIN($0)])
+      LogicalProject($f0=[0])
+        LogicalFilter(condition=[AND(=($7, $cor1.DEPTNO), =($1, 'SMITH'), >($cor1.DEPTNO, 0))])
+          LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+    <Resource name="sql">
+      <![CDATA[select deptno,
+  (select min(1) from emp where empno > d.deptno) as i0,
+  (select min(0) from emp where deptno = d.deptno                             and ename = 'SMITH'                            and d.deptno > 0) as i1
+from dept as d]]>
+    </Resource>
+  </TestCase>
   <TestCase name="testCorrelatedSubQueryInAggregate">
     <Resource name="sql">
       <![CDATA[SELECT SUM(
@@ -747,7 +939,7 @@ LogicalProject(DEPTNO=[$7], EXPR$1=[$9])
     </Resource>
     <Resource name="planNotExpanded">
       <![CDATA[
-LogicalProject(DEPTNO=[$7], EXPR$1=[$SCALAR_QUERY({
+LogicalProject(variablesSet=[[$cor0]], DEPTNO=[$7], EXPR$1=[$SCALAR_QUERY({
 LogicalProject(NAME=[$0])
   LogicalTableFunctionScan(invocation=[DEDUP($cor0.DEPTNO, $cor0.DEPTNO)], rowType=[RecordType(VARCHAR(1024) NAME)])
 })])
@@ -859,6 +1051,53 @@ where exists (select * from emp
   and emp.deptno in (dept.deptno, dept.deptno))]]>
     </Resource>
   </TestCase>
+  <TestCase name="testCorrelationInProjectionWithCorrelatedProjection">
+    <Resource name="sql">
+      <![CDATA[select cardinality(arr) from (
+  select array(select e.deptno) arr from (
+    select deptno, ename from emp) e)]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(variablesSet=[[$cor0]], EXPR$0=[CARDINALITY(ARRAY({
+LogicalProject(DEPTNO=[$cor0.DEPTNO])
+  LogicalValues(tuples=[[{ 0 }]])
+}))])
+  LogicalProject(DEPTNO=[$7], ENAME=[$1])
+    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testCorrelationInProjectionWithProjection">
+    <Resource name="sql">
+      <![CDATA[select array(select e.deptno)
+from (select deptno, ename from emp) e]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(variablesSet=[[$cor0]], EXPR$0=[ARRAY({
+LogicalProject(DEPTNO=[$cor0.DEPTNO])
+  LogicalValues(tuples=[[{ 0 }]])
+})])
+  LogicalProject(DEPTNO=[$7], ENAME=[$1])
+    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testCorrelationInProjectionWithScan">
+    <Resource name="sql">
+      <![CDATA[select array(select e.deptno) from emp e]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(variablesSet=[[$cor0]], EXPR$0=[ARRAY({
+LogicalProject(DEPTNO=[$cor0.DEPTNO])
+  LogicalValues(tuples=[[{ 0 }]])
+})])
+  LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
   <TestCase name="testCorrelationInWithSubQuery">
     <Resource name="plan">
       <![CDATA[
@@ -1350,6 +1589,17 @@ LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$
   LogicalJoin(condition=[=(+($7, 20), /($9, 2))], joinType=[inner])
     LogicalTableScan(table=[[CATALOG, SALES, EMP]])
     LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testDotAfterParenthesizedIdentifier">
+    <Resource name="sql">
+      <![CDATA[select (home_address).city from emp_address]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(EXPR$0=[$1.CITY])
+  LogicalTableScan(table=[[CATALOG, SALES, EMP_ADDRESS]])
 ]]>
     </Resource>
   </TestCase>
@@ -1437,6 +1687,30 @@ from (
       <![CDATA[
 LogicalProject(FAKE2=[ITEM($0, 'fake_col2')])
   LogicalTableScan(table=[[CATALOG, SALES, CUSTOMER]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testDynamicParameterDoubleCast">
+    <Resource name="sql">
+      <![CDATA[SELECT CAST(CAST(? AS INTEGER) AS CHAR)]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(EXPR$0=[CAST(?0):CHAR(1)])
+  LogicalValues(tuples=[[{ 0 }]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testDynamicParameterSortWithTrim">
+    <Resource name="sql">
+      <![CDATA[select ename from (select * from emp order by sal limit ? offset ?) a]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(ENAME=[$0])
+  LogicalSort(sort0=[$1], dir0=[ASC], offset=[?1], fetch=[?0])
+    LogicalProject(ENAME=[$1], SAL=[$5])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
 ]]>
     </Resource>
   </TestCase>
@@ -1444,7 +1718,7 @@ LogicalProject(FAKE2=[ITEM($0, 'fake_col2')])
     <Resource name="sql">
       <![CDATA[select t1.c_nationkey, t3.fake_col3
 from SALES.CUSTOMER as t1,
-lateral (select t2."$unnest" as fake_col3
+lateral (select t2 as fake_col3
          from unnest(t1.fake_col) as t2) as t3]]>
     </Resource>
     <Resource name="plan">
@@ -1839,6 +2113,41 @@ LogicalProject(D=[$0], EXPR$1=[+($0, $1)])
 from emp group by d,mgr]]>
     </Resource>
   </TestCase>
+  <TestCase name="testGroupByAll">
+    <Resource name="sql">
+      <![CDATA[SELECT deptno, job, count(*)
+FROM emp
+GROUP BY ALL
+CUBE (deptno, job),
+ROLLUP (deptno, job)]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalUnion(all=[true])
+  LogicalAggregate(group=[{0, 1}], groups=[[{0, 1}, {0}, {1}, {}]], EXPR$2=[COUNT()])
+    LogicalProject(DEPTNO=[$7], JOB=[$2])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+  LogicalAggregate(group=[{0, 1}], groups=[[{0, 1}, {0}]], EXPR$2=[COUNT()])
+    LogicalProject(DEPTNO=[$7], JOB=[$2])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+  LogicalAggregate(group=[{0, 1}], groups=[[{0, 1}, {0}]], EXPR$2=[COUNT()])
+    LogicalProject(DEPTNO=[$7], JOB=[$2])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+  LogicalAggregate(group=[{0, 1}], EXPR$2=[COUNT()])
+    LogicalProject(DEPTNO=[$7], JOB=[$2])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+  LogicalAggregate(group=[{0, 1}], EXPR$2=[COUNT()])
+    LogicalProject(DEPTNO=[$7], JOB=[$2])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+  LogicalAggregate(group=[{0, 1}], EXPR$2=[COUNT()])
+    LogicalProject(DEPTNO=[$7], JOB=[$2])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+  LogicalAggregate(group=[{0, 1}], EXPR$2=[COUNT()])
+    LogicalProject(DEPTNO=[$7], JOB=[$2])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
   <TestCase name="testGroupByCaseIn">
     <Resource name="sql">
       <![CDATA[select
@@ -1918,6 +2227,22 @@ group by
   cube (coord_ne.sub.a, coord.x, coord."unit")]]>
     </Resource>
   </TestCase>
+  <TestCase name="testGroupByDistinct">
+    <Resource name="sql">
+      <![CDATA[SELECT deptno, job, count(*)
+FROM emp
+GROUP BY DISTINCT
+CUBE (deptno, job),
+ROLLUP (deptno, job)]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalAggregate(group=[{0, 1}], groups=[[{0, 1}, {0}, {1}, {}]], EXPR$2=[COUNT()])
+  LogicalProject(DEPTNO=[$7], JOB=[$2])
+    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
   <TestCase name="testGroupByExpression">
     <Resource name="sql">
       <![CDATA[select count(*)
@@ -3407,7 +3732,8 @@ LogicalProject(EXPR$0=[COALESCE(ROW($4, $5, $6), ROW($14, $15, $16)).X])
     <Resource name="sql">
       <![CDATA[SELECT emp.deptno, emp.sal
 FROM dept
-         LEFT JOIN emp ON (SELECT AVG(emp.sal) > 0 FROM emp)]]>
+JOIN emp
+ON (SELECT AVG(emp.sal) > 0 FROM emp)]]>
     </Resource>
     <Resource name="plan">
       <![CDATA[
@@ -3564,8 +3890,7 @@ json_object(
     json_object(
       ename :
       deptno)))
-from emp
-]]>
+from emp]]>
     </Resource>
     <Resource name="plan">
       <![CDATA[
@@ -3586,8 +3911,7 @@ json_array(
       'key2' :
        ename)),
   json_array(12, 'hello', deptno))
-from emp
-]]>
+from emp]]>
     </Resource>
     <Resource name="plan">
       <![CDATA[
@@ -3606,8 +3930,7 @@ json_object(
     json_object(
       'k1' :
       deptno)))
-from emp
-]]>
+from emp]]>
     </Resource>
     <Resource name="plan">
       <![CDATA[
@@ -3629,8 +3952,7 @@ json_object(
   json_object(
     'key3' :
     json_array(12, 'hello', deptno))
-from emp
-]]>
+from emp]]>
     </Resource>
     <Resource name="plan">
       <![CDATA[
@@ -4111,6 +4433,20 @@ LogicalProject(START_MGR=[$0], BOTTOM_MGR=[$1], END_MGR=[$2])
 LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8])
   LogicalMatch(partition=[[]], order=[[]], outputFields=[[EMPNO, ENAME, JOB, MGR, HIREDATE, SAL, COMM, DEPTNO, SLACKER]], allRows=[false], after=[SKIP TO LAST('DOWN')], pattern=[(('STRT', PATTERN_QUANTIFIER('DOWN', 1, -1, false)), PATTERN_QUANTIFIER('UP', 1, -1, false))], isStrictStarts=[false], isStrictEnds=[false], subsets=[[[DOWN, STRT]]], patternDefinitions=[[<(PREV(DOWN.$3, 0), PREV(DOWN.$3, 1)), >(PREV(UP.$3, 0), NEXT(PREV(UP.$3, 0), 1))]], inputFields=[[EMPNO, ENAME, JOB, MGR, HIREDATE, SAL, COMM, DEPTNO, SLACKER]])
     LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testMeasureRef">
+    <Resource name="sql">
+      <![CDATA[select deptno, aggregate(count_plus_100) as c
+from empm
+group by deptno]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalAggregate(group=[{0}], C=[AGGREGATE($1)])
+  LogicalProject(DEPTNO=[$7], COUNT_PLUS_100=[$9])
+    LogicalTableScan(table=[[CATALOG, SALES, EMPM]])
 ]]>
     </Resource>
   </TestCase>
@@ -4199,6 +4535,25 @@ and (deptno = 8 or empno < 100)]]>
 LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8])
   LogicalFilter(condition=[AND(<($7, 10), >($7, 5), OR(=($7, 8), <($0, 100)))])
     LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testMultiCorrelationInProjectionWithProjection">
+    <Resource name="sql">
+      <![CDATA[select cardinality(array(select e.deptno)), array(select e.ename)[0]
+from (select deptno, ename from emp) e]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(variablesSet=[[$cor0]], EXPR$0=[CARDINALITY(ARRAY({
+LogicalProject(DEPTNO=[$cor0.DEPTNO])
+  LogicalValues(tuples=[[{ 0 }]])
+}))], EXPR$1=[ITEM(ARRAY({
+LogicalProject(ENAME=[$cor0.ENAME])
+  LogicalValues(tuples=[[{ 0 }]])
+}), 0)])
+  LogicalProject(DEPTNO=[$7], ENAME=[$1])
+    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
 ]]>
     </Resource>
   </TestCase>
@@ -4421,6 +4776,20 @@ from sales.dept_nested dn]]>
       <![CDATA[
 LogicalProject(EXPR$0=[$2.OTHERS.A])
   LogicalTableScan(table=[[CATALOG, SALES, DEPT_NESTED]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testNestedStructSingleFieldAccessWhere">
+    <Resource name="sql">
+      <![CDATA[select dn.skill
+from sales.dept_single dn WHERE dn.skill.type = '']]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(SKILL=[ROW($0)])
+  LogicalFilter(condition=[=($0, '')])
+    LogicalProject(TYPE=[$0.TYPE])
+      LogicalTableScan(table=[[CATALOG, SALES, DEPT_SINGLE]])
 ]]>
     </Resource>
   </TestCase>
@@ -5023,13 +5392,49 @@ LogicalProject(EMPNO=[$0])
 ]]>
     </Resource>
   </TestCase>
-  <TestCase name="testOrderDescNullsLast">
+  <TestCase name="testOrderByWithIn">
     <Resource name="sql">
-      <![CDATA[select empno from emp order by empno desc nulls last]]>
+      <![CDATA[SELECT empno
+FROM emp
+ORDER BY
+CASE WHEN empno IN (1,2) THEN 0 ELSE 1 END]]>
     </Resource>
     <Resource name="plan">
       <![CDATA[
-LogicalSort(sort0=[$0], dir0=[DESC-nulls-last])
+LogicalProject(EMPNO=[$0])
+  LogicalSort(sort0=[$1], dir0=[ASC])
+    LogicalProject(EMPNO=[$0], EXPR$1=[CASE(SEARCH($0, Sarg[1, 2]), 0, 1)])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testOrderByWithSubQuery">
+    <Resource name="sql">
+      <![CDATA[SELECT empno
+FROM emp
+ORDER BY
+(SELECT empno FROM emp LIMIT 1)]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(EMPNO=[$0])
+  LogicalSort(sort0=[$1], dir0=[ASC])
+    LogicalProject(EMPNO=[$0], EXPR$1=[$9])
+      LogicalJoin(condition=[true], joinType=[left])
+        LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+        LogicalSort(fetch=[1])
+          LogicalProject(EMPNO=[$0])
+            LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testOrderDescNullsLast">
+    <Resource name="sql">
+      <![CDATA[select empno from emp order by empno desc nulls last]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalSort(sort0=[$0], dir0=[DESC-nulls-last])
   LogicalProject(EMPNO=[$0])
     LogicalTableScan(table=[[CATALOG, SALES, EMP]])
 ]]>
@@ -5497,6 +5902,222 @@ LogicalProject(EMPNO=[$0], DEPTNO=[$1], DEPTNO0=[$3], NAME=[$4])
     LogicalProject(EMPNO=[$0], DEPTNO=[$7], $f2=[+($7, 20)])
       LogicalTableScan(table=[[CATALOG, SALES, EMP]])
     LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testQualifyInCorrelatedSubQuery">
+    <Resource name="sql">
+      <![CDATA[SELECT *
+FROM emp
+WHERE EXISTS(
+ SELECT name
+ FROM dept
+ QUALIFY RANK() OVER (PARTITION BY name
+                      ORDER BY dept.deptno DESC) = emp.deptno
+)]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8])
+  LogicalFilter(condition=[IS NOT NULL($9)])
+    LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8], $f0=[$11])
+      LogicalJoin(condition=[=($9, $10)], joinType=[left])
+        LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8], DEPTNO0=[CAST($7):BIGINT NOT NULL])
+          LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+        LogicalAggregate(group=[{0}], agg#0=[MIN($1)])
+          LogicalProject(DEPTNO0=[$2], $f0=[true])
+            LogicalFilter(condition=[$1])
+              LogicalProject(NAME=[$1], QualifyExpression=[=(RANK() OVER (PARTITION BY $1 ORDER BY $0 DESC), $2)], DEPTNO0=[$2])
+                LogicalJoin(condition=[true], joinType=[inner])
+                  LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
+                  LogicalAggregate(group=[{0}])
+                    LogicalProject(DEPTNO0=[CAST($7):BIGINT NOT NULL])
+                      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testQualifyInDdl">
+    <Resource name="sql">
+      <![CDATA[INSERT INTO dept(deptno, name)
+SELECT DISTINCT empno, ename
+FROM emp
+WHERE deptno > 5
+QUALIFY RANK() OVER (PARTITION BY ename
+                     ORDER BY slacker DESC) = 1]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalTableModify(table=[[CATALOG, SALES, DEPT]], operation=[INSERT], flattened=[true])
+  LogicalAggregate(group=[{0, 1}])
+    LogicalProject(EMPNO=[$0], ENAME=[$1])
+      LogicalFilter(condition=[$2])
+        LogicalProject(EMPNO=[$0], ENAME=[$1], QualifyExpression=[=(RANK() OVER (PARTITION BY $1 ORDER BY $8 DESC), 1)])
+          LogicalFilter(condition=[>($7, 5)])
+            LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testQualifyInSubQuery">
+    <Resource name="sql">
+      <![CDATA[SELECT *
+FROM (
+ SELECT DISTINCT empno, ename, deptno
+ FROM emp
+ QUALIFY RANK() OVER (PARTITION BY ename
+                      ORDER BY deptno DESC) = 1)]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(EMPNO=[$0], ENAME=[$1], DEPTNO=[$2])
+  LogicalAggregate(group=[{0, 1, 2}])
+    LogicalProject(EMPNO=[$0], ENAME=[$1], DEPTNO=[$2])
+      LogicalFilter(condition=[$3])
+        LogicalProject(EMPNO=[$0], ENAME=[$1], DEPTNO=[$7], QualifyExpression=[=(RANK() OVER (PARTITION BY $1 ORDER BY $7 DESC), 1)])
+          LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testQualifyWithDerivedColumn">
+    <Resource name="sql">
+      <![CDATA[SELECT empno, ename, deptno, SUBSTRING(ename,1,1) as DERIVED_COLUMN FROM emp QUALIFY ROW_NUMBER() OVER (PARTITION BY deptno
+                           ORDER BY DERIVED_COLUMN) = 1]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(EMPNO=[$0], ENAME=[$1], DEPTNO=[$2], DERIVED_COLUMN=[$3])
+  LogicalFilter(condition=[$4])
+    LogicalProject(EMPNO=[$0], ENAME=[$1], DEPTNO=[$7], DERIVED_COLUMN=[SUBSTRING($1, 1, 1)], QualifyExpression=[=(ROW_NUMBER() OVER (PARTITION BY $7 ORDER BY SUBSTRING($1, 1, 1)), 1)])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testQualifyWithEverything">
+    <Resource name="sql">
+      <![CDATA[SELECT DISTINCT empno, ename, deptno,
+    RANK() OVER (PARTITION BY ename
+                 ORDER BY deptno DESC) as rank_val
+FROM emp
+WHERE sal > 1000
+QUALIFY rank_val = (SELECT COUNT(*) FROM emp)
+ORDER BY deptno
+LIMIT 5]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalSort(sort0=[$2], dir0=[ASC], fetch=[5])
+  LogicalAggregate(group=[{0, 1, 2, 3}])
+    LogicalProject(EMPNO=[$0], ENAME=[$1], DEPTNO=[$2], RANK_VAL=[$3])
+      LogicalFilter(condition=[$5])
+        LogicalProject(EMPNO=[$0], ENAME=[$1], DEPTNO=[$2], RANK_VAL=[$3], EXPR$0=[$4], QualifyExpression=[=($3, $4)])
+          LogicalJoin(condition=[true], joinType=[left])
+            LogicalProject(EMPNO=[$0], ENAME=[$1], DEPTNO=[$7], RANK_VAL=[RANK() OVER (PARTITION BY $1 ORDER BY $7 DESC)])
+              LogicalFilter(condition=[>($5, 1000)])
+                LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+            LogicalAggregate(group=[{}], EXPR$0=[COUNT()])
+              LogicalProject($f0=[0])
+                LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testQualifyWithMultipleReferences">
+    <Resource name="sql">
+      <![CDATA[SELECT empno, ename, deptno + 1 as derived_deptno,
+   ROW_NUMBER() over (partition by ename order by deptno) as row_num
+FROM emp
+QUALIFY row_num = derived_deptno]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(EMPNO=[$0], ENAME=[$1], DERIVED_DEPTNO=[$2], ROW_NUM=[$3])
+  LogicalFilter(condition=[$4])
+    LogicalProject(EMPNO=[$0], ENAME=[$1], DERIVED_DEPTNO=[+($7, 1)], ROW_NUM=[ROW_NUMBER() OVER (PARTITION BY $1 ORDER BY $7)], QualifyExpression=[=(ROW_NUMBER() OVER (PARTITION BY $1 ORDER BY $7), CAST(+($7, 1)):BIGINT NOT NULL)])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testQualifyWithReferences">
+    <Resource name="sql">
+      <![CDATA[SELECT empno, ename, deptno,
+   ROW_NUMBER() over (partition by ename order by deptno) as row_num
+FROM emp
+QUALIFY row_num = 1]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(EMPNO=[$0], ENAME=[$1], DEPTNO=[$2], ROW_NUM=[$3])
+  LogicalFilter(condition=[$4])
+    LogicalProject(EMPNO=[$0], ENAME=[$1], DEPTNO=[$7], ROW_NUM=[ROW_NUMBER() OVER (PARTITION BY $1 ORDER BY $7)], QualifyExpression=[=(ROW_NUMBER() OVER (PARTITION BY $1 ORDER BY $7), 1)])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testQualifyWithSubQueryFilter">
+    <Resource name="sql">
+      <![CDATA[SELECT empno, ename, deptno,
+    RANK() OVER (PARTITION BY ename
+                 ORDER BY deptno DESC) as rank_val
+FROM emp
+QUALIFY rank_val = (SELECT COUNT(*) FROM emp)]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(EMPNO=[$0], ENAME=[$1], DEPTNO=[$2], RANK_VAL=[$3])
+  LogicalFilter(condition=[$5])
+    LogicalProject(EMPNO=[$0], ENAME=[$1], DEPTNO=[$2], RANK_VAL=[$3], EXPR$0=[$4], QualifyExpression=[=($3, $4)])
+      LogicalJoin(condition=[true], joinType=[left])
+        LogicalProject(EMPNO=[$0], ENAME=[$1], DEPTNO=[$7], RANK_VAL=[RANK() OVER (PARTITION BY $1 ORDER BY $7 DESC)])
+          LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+        LogicalAggregate(group=[{}], EXPR$0=[COUNT()])
+          LogicalProject($f0=[0])
+            LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testQualifyWithWindowClause">
+    <Resource name="sql">
+      <![CDATA[SELECT empno, ename, SUM(deptno) OVER myWindow as sumDeptNo
+FROM emp
+WINDOW myWindow AS (PARTITION BY ename ORDER BY empno)
+QUALIFY sumDeptNo = 1]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(EMPNO=[$0], ENAME=[$1], SUMDEPTNO=[$2])
+  LogicalFilter(condition=[$3])
+    LogicalProject(EMPNO=[$0], ENAME=[$1], SUMDEPTNO=[SUM($7) OVER (PARTITION BY $1 ORDER BY $0)], QualifyExpression=[=(SUM($7) OVER (PARTITION BY $1 ORDER BY $0), 1)])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testQualifyWithoutReferences">
+    <Resource name="sql">
+      <![CDATA[SELECT empno, ename, deptno
+FROM emp
+QUALIFY ROW_NUMBER() over (partition by ename order by deptno) = 1]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(EMPNO=[$0], ENAME=[$1], DEPTNO=[$2])
+  LogicalFilter(condition=[$3])
+    LogicalProject(EMPNO=[$0], ENAME=[$1], DEPTNO=[$7], QualifyExpression=[=(ROW_NUMBER() OVER (PARTITION BY $1 ORDER BY $7), 1)])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testQualifyWithoutReferencesAndFilter">
+    <Resource name="sql">
+      <![CDATA[SELECT empno, ename, deptno
+FROM emp
+WHERE deptno > 5
+QUALIFY ROW_NUMBER() over (partition by ename order by deptno) = 1]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(EMPNO=[$0], ENAME=[$1], DEPTNO=[$2])
+  LogicalFilter(condition=[$3])
+    LogicalProject(EMPNO=[$0], ENAME=[$1], DEPTNO=[$7], QualifyExpression=[=(ROW_NUMBER() OVER (PARTITION BY $1 ORDER BY $7), 1)])
+      LogicalFilter(condition=[>($7, 5)])
+        LogicalTableScan(table=[[CATALOG, SALES, EMP]])
 ]]>
     </Resource>
   </TestCase>
@@ -5583,7 +6204,7 @@ LogicalProject(EXPR$0=[1])
 ]]>
     </Resource>
   </TestCase>
-  <TestCase name="testRowValueConstructorWithSubquery">
+  <TestCase name="testRowValueConstructorWithSubQuery">
     <Resource name="sql">
       <![CDATA[select ROW((select deptno
 from dept
@@ -6235,7 +6856,7 @@ LogicalProject(ENAME=[$1])
     <Resource name="sql">
       <![CDATA[select *
 from SALES.CUSTOMER as t1,
-lateral (select t2."$unnest" as fake_col3
+lateral (select t2 as fake_col3
          from unnest(t1.fake_col) as t2) as t3]]>
     </Resource>
     <Resource name="plan">
@@ -6258,7 +6879,7 @@ unnest(t1.fake_col) as t2]]>
     </Resource>
     <Resource name="plan">
       <![CDATA[
-LogicalProject(**=[$1], $unnest=[$2])
+LogicalProject(**=[$1], T2=[$2])
   LogicalCorrelate(correlation=[$cor0], joinType=[inner], requiredColumns=[{0}])
     LogicalTableScan(table=[[CATALOG, SALES, CUSTOMER]])
     Uncollect
@@ -6745,6 +7366,204 @@ LogicalProject(ORDERID=[$0], ROWTIME=[$1], window_start=[$2], window_end=[$3])
   LogicalTableFunctionScan(invocation=[TUMBLE(DESCRIPTOR($1), 60000:INTERVAL MINUTE)], rowType=[RecordType(INTEGER ORDERID, TIMESTAMP(0) ROWTIME, TIMESTAMP(3) window_start, TIMESTAMP(3) window_end)])
     LogicalProject(ORDERID=[$0], ROWTIME=[$1])
       LogicalTableScan(table=[[CATALOG, SALES, SHIPMENTS]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testTableFunctionWithComplexOrderBy">
+    <Resource name="sql">
+      <![CDATA[select *
+from table(topn(table orders order by (orderId desc, productid desc nulls last), 3))]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(ROWTIME=[$0], PRODUCTID=[$1], ORDERID=[$2], RANK_NUMBER=[$3])
+  LogicalTableFunctionScan(invocation=[TOPN(3)], rowType=[RecordType(TIMESTAMP(0) ROWTIME, INTEGER PRODUCTID, INTEGER ORDERID, BIGINT RANK_NUMBER)])
+    LogicalSortExchange(distribution=[single], collation=[[2 DESC, 1 DESC-nulls-last]])
+      LogicalProject(ROWTIME=[$0], PRODUCTID=[$1], ORDERID=[$2])
+        LogicalTableScan(table=[[CATALOG, SALES, ORDERS]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testTableFunctionWithMultipleInputTables">
+    <Resource name="sql">
+      <![CDATA[select *
+from table(
+similarlity(
+  table emp partition by deptno order by empno nulls first,
+  table emp_b partition by deptno order by empno nulls first))]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(VAL=[$0])
+  LogicalTableFunctionScan(invocation=[SIMILARLITY()], rowType=[RecordType(DECIMAL(5, 2) VAL)])
+    LogicalSortExchange(distribution=[hash[7]], collation=[[0 ASC-nulls-first]])
+      LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8])
+        LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+    LogicalSortExchange(distribution=[hash[7]], collation=[[0 ASC-nulls-first]])
+      LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8], BIRTHDATE=[$9])
+        LogicalTableScan(table=[[CATALOG, SALES, EMP_B]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testTableFunctionWithMultipleInputTablesWithParamNames">
+    <Resource name="sql">
+      <![CDATA[select *
+from table(
+similarlity(
+  LTABLE => table emp partition by deptno order by empno nulls first,
+  RTABLE => table emp_b partition by deptno order by empno nulls first))]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(VAL=[$0])
+  LogicalTableFunctionScan(invocation=[SIMILARLITY()], rowType=[RecordType(DECIMAL(5, 2) VAL)])
+    LogicalSortExchange(distribution=[hash[7]], collation=[[0 ASC-nulls-first]])
+      LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8])
+        LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+    LogicalSortExchange(distribution=[hash[7]], collation=[[0 ASC-nulls-first]])
+      LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8], BIRTHDATE=[$9])
+        LogicalTableScan(table=[[CATALOG, SALES, EMP_B]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testTableFunctionWithMultipleOrderKeys">
+    <Resource name="sql">
+      <![CDATA[select *
+from table(topn(table orders order by (orderId, productid), 3))]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(ROWTIME=[$0], PRODUCTID=[$1], ORDERID=[$2], RANK_NUMBER=[$3])
+  LogicalTableFunctionScan(invocation=[TOPN(3)], rowType=[RecordType(TIMESTAMP(0) ROWTIME, INTEGER PRODUCTID, INTEGER ORDERID, BIGINT RANK_NUMBER)])
+    LogicalSortExchange(distribution=[single], collation=[[2, 1]])
+      LogicalProject(ROWTIME=[$0], PRODUCTID=[$1], ORDERID=[$2])
+        LogicalTableScan(table=[[CATALOG, SALES, ORDERS]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testTableFunctionWithMultiplePartitionKeys">
+    <Resource name="sql">
+      <![CDATA[select *
+from table(topn(table orders partition by (orderId, productid), 3))]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(ROWTIME=[$0], PRODUCTID=[$1], ORDERID=[$2], RANK_NUMBER=[$3])
+  LogicalTableFunctionScan(invocation=[TOPN(3)], rowType=[RecordType(TIMESTAMP(0) ROWTIME, INTEGER PRODUCTID, INTEGER ORDERID, BIGINT RANK_NUMBER)])
+    LogicalExchange(distribution=[hash[1, 2]])
+      LogicalProject(ROWTIME=[$0], PRODUCTID=[$1], ORDERID=[$2])
+        LogicalTableScan(table=[[CATALOG, SALES, ORDERS]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testTableFunctionWithOrderByWithNullLast">
+    <Resource name="sql">
+      <![CDATA[select *
+from table(topn(table orders order by orderId desc nulls last, 3))]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(ROWTIME=[$0], PRODUCTID=[$1], ORDERID=[$2], RANK_NUMBER=[$3])
+  LogicalTableFunctionScan(invocation=[TOPN(3)], rowType=[RecordType(TIMESTAMP(0) ROWTIME, INTEGER PRODUCTID, INTEGER ORDERID, BIGINT RANK_NUMBER)])
+    LogicalSortExchange(distribution=[single], collation=[[2 DESC-nulls-last]])
+      LogicalProject(ROWTIME=[$0], PRODUCTID=[$1], ORDERID=[$2])
+        LogicalTableScan(table=[[CATALOG, SALES, ORDERS]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testTableFunctionWithOrderKey">
+    <Resource name="sql">
+      <![CDATA[select *
+from table(topn(table orders order by orderId, 3))]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(ROWTIME=[$0], PRODUCTID=[$1], ORDERID=[$2], RANK_NUMBER=[$3])
+  LogicalTableFunctionScan(invocation=[TOPN(3)], rowType=[RecordType(TIMESTAMP(0) ROWTIME, INTEGER PRODUCTID, INTEGER ORDERID, BIGINT RANK_NUMBER)])
+    LogicalSortExchange(distribution=[single], collation=[[2]])
+      LogicalProject(ROWTIME=[$0], PRODUCTID=[$1], ORDERID=[$2])
+        LogicalTableScan(table=[[CATALOG, SALES, ORDERS]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testTableFunctionWithParamNames">
+    <Resource name="sql">
+      <![CDATA[select *
+from table(
+topn(
+  DATA => table orders partition by productid order by orderId,
+  COL => 3))]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(ROWTIME=[$0], PRODUCTID=[$1], ORDERID=[$2], RANK_NUMBER=[$3])
+  LogicalTableFunctionScan(invocation=[TOPN(3)], rowType=[RecordType(TIMESTAMP(0) ROWTIME, INTEGER PRODUCTID, INTEGER ORDERID, BIGINT RANK_NUMBER)])
+    LogicalSortExchange(distribution=[hash[1]], collation=[[2]])
+      LogicalProject(ROWTIME=[$0], PRODUCTID=[$1], ORDERID=[$2])
+        LogicalTableScan(table=[[CATALOG, SALES, ORDERS]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testTableFunctionWithPartitionKey">
+    <Resource name="sql">
+      <![CDATA[select *
+from table(topn(table orders partition by productid, 3))]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(ROWTIME=[$0], PRODUCTID=[$1], ORDERID=[$2], RANK_NUMBER=[$3])
+  LogicalTableFunctionScan(invocation=[TOPN(3)], rowType=[RecordType(TIMESTAMP(0) ROWTIME, INTEGER PRODUCTID, INTEGER ORDERID, BIGINT RANK_NUMBER)])
+    LogicalExchange(distribution=[hash[1]])
+      LogicalProject(ROWTIME=[$0], PRODUCTID=[$1], ORDERID=[$2])
+        LogicalTableScan(table=[[CATALOG, SALES, ORDERS]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testTableFunctionWithPartitionKeyAndOrderKey">
+    <Resource name="sql">
+      <![CDATA[select *
+from table(topn(table orders partition by productid order by orderId, 3))]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(ROWTIME=[$0], PRODUCTID=[$1], ORDERID=[$2], RANK_NUMBER=[$3])
+  LogicalTableFunctionScan(invocation=[TOPN(3)], rowType=[RecordType(TIMESTAMP(0) ROWTIME, INTEGER PRODUCTID, INTEGER ORDERID, BIGINT RANK_NUMBER)])
+    LogicalSortExchange(distribution=[hash[1]], collation=[[2]])
+      LogicalProject(ROWTIME=[$0], PRODUCTID=[$1], ORDERID=[$2])
+        LogicalTableScan(table=[[CATALOG, SALES, ORDERS]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testTableFunctionWithSubQuery">
+    <Resource name="sql">
+      <![CDATA[select *
+from table(topn(select * from orders partition by productid order by orderId desc nulls last, 3))]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(ROWTIME=[$0], PRODUCTID=[$1], ORDERID=[$2], RANK_NUMBER=[$3])
+  LogicalTableFunctionScan(invocation=[TOPN(3)], rowType=[RecordType(TIMESTAMP(0) ROWTIME, INTEGER PRODUCTID, INTEGER ORDERID, BIGINT RANK_NUMBER)])
+    LogicalSortExchange(distribution=[hash[1]], collation=[[2 DESC-nulls-last]])
+      LogicalProject(ROWTIME=[$0], PRODUCTID=[$1], ORDERID=[$2])
+        LogicalTableScan(table=[[CATALOG, SALES, ORDERS]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testTableFunctionWithSubQueryWithParamNames">
+    <Resource name="sql">
+      <![CDATA[select *
+from table(
+topn(
+  DATA => select * from orders partition by productid order by orderId nulls first,
+  COL => 3))]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(ROWTIME=[$0], PRODUCTID=[$1], ORDERID=[$2], RANK_NUMBER=[$3])
+  LogicalTableFunctionScan(invocation=[TOPN(3)], rowType=[RecordType(TIMESTAMP(0) ROWTIME, INTEGER PRODUCTID, INTEGER ORDERID, BIGINT RANK_NUMBER)])
+    LogicalSortExchange(distribution=[hash[1]], collation=[[2 ASC-nulls-first]])
+      LogicalProject(ROWTIME=[$0], PRODUCTID=[$1], ORDERID=[$2])
+        LogicalTableScan(table=[[CATALOG, SALES, ORDERS]])
 ]]>
     </Resource>
   </TestCase>
@@ -7207,11 +8026,11 @@ LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$
     LogicalTableScan(table=[[CATALOG, SALES, EMP]])
 })], EMP_MULTISET=[MULTISET({
 LogicalProject(EMPNO=[$0], ENAME=[$1], JOB=[$2], MGR=[$3], HIREDATE=[$4], SAL=[$5], COMM=[$6], DEPTNO=[$7], SLACKER=[$8])
-  LogicalFilter(condition=[=($7, $cor1.DEPTNO)])
+  LogicalFilter(condition=[=($7, $cor0.DEPTNO)])
     LogicalTableScan(table=[[CATALOG, SALES, EMP]])
 })], JOB_MAP=[MAP({
 LogicalProject(EMPNO=[$0], JOB=[$2])
-  LogicalFilter(condition=[=($7, $cor2.DEPTNO)])
+  LogicalFilter(condition=[=($7, $cor0.DEPTNO)])
     LogicalTableScan(table=[[CATALOG, SALES, EMP]])
 })])
   LogicalTableScan(table=[[CATALOG, SALES, DEPT]])
@@ -7608,18 +8427,66 @@ LogicalTableModify(table=[[CATALOG, STRUCT, T]], operation=[UPDATE], updateColum
 ]]>
     </Resource>
   </TestCase>
-  <TestCase name="testUserDefinedOrderByOver">
+  <TestCase name="testUserDefinedOrderByOverFirst">
     <Resource name="sql">
       <![CDATA[select deptno,
-  rank() over(partition by empno order by deptno)
+  rank() over (partition by empno order by comm desc)
 from emp
-order by row_number() over(partition by empno order by deptno)]]>
+order by row_number() over (partition by empno order by comm)]]>
     </Resource>
     <Resource name="plan">
       <![CDATA[
 LogicalProject(DEPTNO=[$0], EXPR$1=[$1])
   LogicalSort(sort0=[$2], dir0=[ASC-nulls-first])
-    LogicalProject(DEPTNO=[$7], EXPR$1=[RANK() OVER (PARTITION BY $0 ORDER BY $7)], EXPR$2=[ROW_NUMBER() OVER (PARTITION BY $0 ORDER BY $7)])
+    LogicalProject(DEPTNO=[$7], EXPR$1=[RANK() OVER (PARTITION BY $0 ORDER BY $6 DESC)], EXPR$2=[ROW_NUMBER() OVER (PARTITION BY $0 ORDER BY $6 NULLS FIRST)])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testUserDefinedOrderByOverHigh">
+    <Resource name="sql">
+      <![CDATA[select deptno,
+  rank() over (partition by empno order by comm desc)
+from emp
+order by row_number() over (partition by empno order by comm)]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(DEPTNO=[$0], EXPR$1=[$1])
+  LogicalSort(sort0=[$2], dir0=[ASC])
+    LogicalProject(DEPTNO=[$7], EXPR$1=[RANK() OVER (PARTITION BY $0 ORDER BY $6 DESC)], EXPR$2=[ROW_NUMBER() OVER (PARTITION BY $0 ORDER BY $6)])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testUserDefinedOrderByOverLast">
+    <Resource name="sql">
+      <![CDATA[select deptno,
+  rank() over (partition by empno order by comm desc)
+from emp
+order by row_number() over (partition by empno order by comm)]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(DEPTNO=[$0], EXPR$1=[$1])
+  LogicalSort(sort0=[$2], dir0=[ASC])
+    LogicalProject(DEPTNO=[$7], EXPR$1=[RANK() OVER (PARTITION BY $0 ORDER BY $6 DESC NULLS LAST)], EXPR$2=[ROW_NUMBER() OVER (PARTITION BY $0 ORDER BY $6)])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testUserDefinedOrderByOverLow">
+    <Resource name="sql">
+      <![CDATA[select deptno,
+  rank() over (partition by empno order by comm desc)
+from emp
+order by row_number() over (partition by empno order by comm)]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalProject(DEPTNO=[$0], EXPR$1=[$1])
+  LogicalSort(sort0=[$2], dir0=[ASC-nulls-first])
+    LogicalProject(DEPTNO=[$7], EXPR$1=[RANK() OVER (PARTITION BY $0 ORDER BY $6 DESC NULLS LAST)], EXPR$2=[ROW_NUMBER() OVER (PARTITION BY $0 ORDER BY $6 NULLS FIRST)])
       LogicalTableScan(table=[[CATALOG, SALES, EMP]])
 ]]>
     </Resource>
diff --git a/core/src/test/resources/org/apache/calcite/test/TopDownOptTest.xml b/core/src/test/resources/org/apache/calcite/test/TopDownOptTest.xml
index b84bee83edc..dc58bfac90d 100644
--- a/core/src/test/resources/org/apache/calcite/test/TopDownOptTest.xml
+++ b/core/src/test/resources/org/apache/calcite/test/TopDownOptTest.xml
@@ -933,16 +933,18 @@ EnumerableSort(sort0=[$0], sort1=[$1], sort2=[$2], dir0=[DESC], dir1=[DESC], dir
     </Resource>
     <Resource name="planBefore">
       <![CDATA[
-LogicalSort(sort0=[$1], dir0=[DESC])
-  LogicalProject(EXPR$0=[CAST($7):FLOAT NOT NULL], DEPTNO=[$7])
-    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+LogicalProject(EXPR$0=[$0])
+  LogicalSort(sort0=[$1], dir0=[DESC])
+    LogicalProject(EXPR$0=[CAST($7):FLOAT NOT NULL], DEPTNO=[$7])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
 ]]>
     </Resource>
     <Resource name="planAfter">
       <![CDATA[
-EnumerableSort(sort0=[$1], dir0=[DESC])
-  EnumerableCalc(expr#0..8=[{inputs}], expr#9=[CAST($t7):FLOAT NOT NULL], EXPR$0=[$t9], DEPTNO=[$t7])
-    EnumerableTableScan(table=[[CATALOG, SALES, EMP]])
+EnumerableCalc(expr#0..1=[{inputs}], EXPR$0=[$t0])
+  EnumerableSort(sort0=[$1], dir0=[DESC])
+    EnumerableCalc(expr#0..8=[{inputs}], expr#9=[CAST($t7):FLOAT NOT NULL], EXPR$0=[$t9], DEPTNO=[$t7])
+      EnumerableTableScan(table=[[CATALOG, SALES, EMP]])
 ]]>
     </Resource>
   </TestCase>
@@ -952,16 +954,18 @@ EnumerableSort(sort0=[$1], dir0=[DESC])
     </Resource>
     <Resource name="planBefore">
       <![CDATA[
-LogicalSort(sort0=[$1], dir0=[DESC])
-  LogicalProject(DEPTNO=[$7], EXPR$1=[CAST($7):VARCHAR NOT NULL])
-    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+LogicalProject(DEPTNO=[$0])
+  LogicalSort(sort0=[$1], dir0=[DESC])
+    LogicalProject(DEPTNO=[$7], EXPR$1=[CAST($7):VARCHAR NOT NULL])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
 ]]>
     </Resource>
     <Resource name="planAfter">
       <![CDATA[
-EnumerableSort(sort0=[$1], dir0=[DESC])
-  EnumerableCalc(expr#0..8=[{inputs}], expr#9=[CAST($t7):VARCHAR NOT NULL], DEPTNO=[$t7], EXPR$1=[$t9])
-    EnumerableTableScan(table=[[CATALOG, SALES, EMP]])
+EnumerableCalc(expr#0..1=[{inputs}], DEPTNO=[$t0])
+  EnumerableSort(sort0=[$1], dir0=[DESC])
+    EnumerableCalc(expr#0..8=[{inputs}], expr#9=[CAST($t7):VARCHAR NOT NULL], DEPTNO=[$t7], EXPR$1=[$t9])
+      EnumerableTableScan(table=[[CATALOG, SALES, EMP]])
 ]]>
     </Resource>
   </TestCase>
@@ -1564,16 +1568,18 @@ EnumerableSort(sort0=[$0], sort1=[$1], sort2=[$2], dir0=[DESC], dir1=[DESC], dir
     </Resource>
     <Resource name="planBefore">
       <![CDATA[
-LogicalSort(sort0=[$1], dir0=[DESC])
-  LogicalProject(DEPTNO=[$7], EXPR$1=[CAST($7):FLOAT NOT NULL])
-    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+LogicalProject(DEPTNO=[$0])
+  LogicalSort(sort0=[$1], dir0=[DESC])
+    LogicalProject(DEPTNO=[$7], EXPR$1=[CAST($7):FLOAT NOT NULL])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
 ]]>
     </Resource>
     <Resource name="planAfter">
       <![CDATA[
-EnumerableSort(sort0=[$1], dir0=[DESC])
-  EnumerableProject(DEPTNO=[$7], EXPR$1=[CAST($7):FLOAT NOT NULL])
-    EnumerableTableScan(table=[[CATALOG, SALES, EMP]])
+EnumerableProject(DEPTNO=[$0])
+  EnumerableSort(sort0=[$1], dir0=[DESC])
+    EnumerableProject(DEPTNO=[$7], EXPR$1=[CAST($7):FLOAT NOT NULL])
+      EnumerableTableScan(table=[[CATALOG, SALES, EMP]])
 ]]>
     </Resource>
   </TestCase>
@@ -1583,16 +1589,18 @@ EnumerableSort(sort0=[$1], dir0=[DESC])
     </Resource>
     <Resource name="planBefore">
       <![CDATA[
-LogicalSort(sort0=[$1], dir0=[DESC])
-  LogicalProject(DEPTNO=[$7], EXPR$1=[CAST($7):VARCHAR NOT NULL])
-    LogicalTableScan(table=[[CATALOG, SALES, EMP]])
+LogicalProject(DEPTNO=[$0])
+  LogicalSort(sort0=[$1], dir0=[DESC])
+    LogicalProject(DEPTNO=[$7], EXPR$1=[CAST($7):VARCHAR NOT NULL])
+      LogicalTableScan(table=[[CATALOG, SALES, EMP]])
 ]]>
     </Resource>
     <Resource name="planAfter">
       <![CDATA[
-EnumerableSort(sort0=[$1], dir0=[DESC])
-  EnumerableProject(DEPTNO=[$7], EXPR$1=[CAST($7):VARCHAR NOT NULL])
-    EnumerableTableScan(table=[[CATALOG, SALES, EMP]])
+EnumerableProject(DEPTNO=[$0])
+  EnumerableSort(sort0=[$1], dir0=[DESC])
+    EnumerableProject(DEPTNO=[$7], EXPR$1=[CAST($7):VARCHAR NOT NULL])
+      EnumerableTableScan(table=[[CATALOG, SALES, EMP]])
 ]]>
     </Resource>
   </TestCase>
diff --git a/core/src/test/resources/org/apache/calcite/test/TypeCoercionConverterTest.xml b/core/src/test/resources/org/apache/calcite/test/TypeCoercionConverterTest.xml
index 7e3fc66395a..f381bbb05e7 100644
--- a/core/src/test/resources/org/apache/calcite/test/TypeCoercionConverterTest.xml
+++ b/core/src/test/resources/org/apache/calcite/test/TypeCoercionConverterTest.xml
@@ -114,6 +114,36 @@ t2_double, t2_decimal, t2_int, t2_date, t2_timestamp, t2_varchar20, t2_int from
 LogicalTableModify(table=[[CATALOG, SALES, T1]], operation=[INSERT], flattened=[false])
   LogicalProject(t1_varchar20=[CAST($1):VARCHAR(20) NOT NULL], t1_smallint=[CAST($2):SMALLINT NOT NULL], t1_int=[CAST($3):INTEGER NOT NULL], t1_bigint=[CAST($4):BIGINT NOT NULL], t1_float=[CAST($5):FLOAT NOT NULL], t1_double=[CAST($6):DOUBLE NOT NULL], t1_decimal=[CAST($2):DECIMAL(19, 0) NOT NULL], t1_timestamp=[CAST($8):TIMESTAMP(0) NOT NULL], t1_date=[CAST($7):DATE NOT NULL], t1_binary=[CAST($0):BINARY(1) NOT NULL], t1_boolean=[<>($2, 0)])
     LogicalTableScan(table=[[CATALOG, SALES, T2]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testInsertUnionQuerySourceCoercion">
+    <Resource name="sql">
+      <![CDATA[insert into t1 select 'a', 1, 1.0, 0, 0, 0, 0, TIMESTAMP '2021-11-28 00:00:00', date '2021-11-28', x'0A', false union select 'b', 2, 2, 0, 0, 0, 0, TIMESTAMP '2021-11-28 00:00:00', date '2021-11-28', x'0A', false union select 'c', CAST(3 AS SMALLINT), 3.0, 0, 0, 0, 0, TIMESTAMP '2021-11-28 00:00:00', date '2021-11-28', x'0A', false union select 'd', 4, 4.0, 0, 0, 0, 0, TIMESTAMP '2021-11-28 00:00:00', date '2021-11-28', x'0A', false union select 'e', 5, 5.0, 0, 0, 0, 0, TIMESTAMP '2021-11-28 00:00:00', date '2021-11-28', x'0A', false]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalTableModify(table=[[CATALOG, SALES, T1]], operation=[INSERT], flattened=[false])
+  LogicalUnion(all=[false])
+    LogicalUnion(all=[false])
+      LogicalUnion(all=[false])
+        LogicalUnion(all=[false])
+          LogicalValues(tuples=[[{ 'a', 1, 1, 0, 0, 0, 0, 2021-11-28 00:00:00, 2021-11-28, X'0a', false }]])
+          LogicalValues(tuples=[[{ 'b', 2, 2, 0, 0, 0, 0, 2021-11-28 00:00:00, 2021-11-28, X'0a', false }]])
+        LogicalValues(tuples=[[{ 'c', 3, 3, 0, 0, 0, 0, 2021-11-28 00:00:00, 2021-11-28, X'0a', false }]])
+      LogicalValues(tuples=[[{ 'd', 4, 4, 0, 0, 0, 0, 2021-11-28 00:00:00, 2021-11-28, X'0a', false }]])
+    LogicalValues(tuples=[[{ 'e', 5, 5, 0, 0, 0, 0, 2021-11-28 00:00:00, 2021-11-28, X'0a', false }]])
+]]>
+    </Resource>
+  </TestCase>
+  <TestCase name="testInsertValuesQuerySourceCoercion">
+    <Resource name="sql">
+      <![CDATA[insert into t1 values ('a', 1, 1.0, 0, 0, 0, 0, TIMESTAMP '2021-11-28 00:00:00', date '2021-11-28', x'0A', false), ('b', 2,  2, 0, 0, 0, 0, TIMESTAMP '2021-11-28 00:00:00', date '2021-11-28', x'0A', false), ('c', CAST(3 AS SMALLINT),  3.0, 0, 0, 0, 0, TIMESTAMP '2021-11-28 00:00:00', date '2021-11-28', x'0A', false), ('d', 4, 4.0, 0, 0, 0, 0, TIMESTAMP '2021-11-28 00:00:00', date '2021-11-28', x'0A', false), ('e', 5, 5.0, 0, 0, 0, 0, TIMESTAMP '2021-11-28 00:00:00', date '2021-11-28', x'0A', false)]]>
+    </Resource>
+    <Resource name="plan">
+      <![CDATA[
+LogicalTableModify(table=[[CATALOG, SALES, T1]], operation=[INSERT], flattened=[false])
+  LogicalValues(tuples=[[{ 'a', 1, 1, 0, 0, 0, 0, 2021-11-28 00:00:00, 2021-11-28, X'0a', false }, { 'b', 2, 2, 0, 0, 0, 0, 2021-11-28 00:00:00, 2021-11-28, X'0a', false }, { 'c', 3, 3, 0, 0, 0, 0, 2021-11-28 00:00:00, 2021-11-28, X'0a', false }, { 'd', 4, 4, 0, 0, 0, 0, 2021-11-28 00:00:00, 2021-11-28, X'0a', false }, { 'e', 5, 5, 0, 0, 0, 0, 2021-11-28 00:00:00, 2021-11-28, X'0a', false }]])
 ]]>
     </Resource>
   </TestCase>
diff --git a/core/src/test/resources/sql/agg.iq b/core/src/test/resources/sql/agg.iq
index f7688e712ea..1210727959a 100644
--- a/core/src/test/resources/sql/agg.iq
+++ b/core/src/test/resources/sql/agg.iq
@@ -566,6 +566,24 @@ having count(*) > 3;
 
 !ok
 
+# ROLLUP column used in expression; see [CALCITE-5296]
+# In a query with ROLLUP, validator wrongly infers that a column is NOT NULL
+select deptno, deptno + 1 as d1 from emp group by rollup(deptno);
++--------+----+
+| DEPTNO | D1 |
++--------+----+
+|     10 | 11 |
+|     20 | 21 |
+|     30 | 31 |
+|     50 | 51 |
+|     60 | 61 |
+|        |    |
+|        |    |
++--------+----+
+(7 rows)
+
+!ok
+
 # CUBE and DISTINCT
 select distinct count(*) from emp group by cube(deptno, gender);
 +--------+
@@ -581,6 +599,75 @@ select distinct count(*) from emp group by cube(deptno, gender);
 
 !ok
 
+# CUBE and ROLLUP cartesian product over same columns
+select deptno, gender, count(*) from emp where deptno = 20 group by cube(deptno, gender), rollup(deptno, gender);
++--------+--------+--------+
+| DEPTNO | GENDER | EXPR$2 |
++--------+--------+--------+
+|     20 | M      |      1 |
+|     20 | M      |      1 |
+|     20 | M      |      1 |
+|     20 | M      |      1 |
+|     20 | M      |      1 |
+|     20 | M      |      1 |
+|     20 | M      |      1 |
+|     20 |        |      1 |
+|     20 |        |      1 |
+|     20 |        |      1 |
+|        | M      |      1 |
+|        |        |      1 |
++--------+--------+--------+
+(12 rows)
+
+!ok
+
+# GROUP BY DISTINCT CUBE and ROLLUP cartesian product over same columns
+select deptno, gender, count(*) from emp where deptno = 20 group by distinct cube(deptno, gender), rollup(deptno, gender);
++--------+--------+--------+
+| DEPTNO | GENDER | EXPR$2 |
++--------+--------+--------+
+|     20 | M      |      1 |
+|     20 |        |      1 |
+|        | M      |      1 |
+|        |        |      1 |
++--------+--------+--------+
+(4 rows)
+
+!ok
+
+# GROUP BY over empty columns
+select count(*) from emp where deptno = 20 group by ();
++--------+
+| EXPR$0 |
++--------+
+|      1 |
++--------+
+(1 row)
+
+!ok
+
+# GROUP BY DISTINCT over empty columns
+select count(*) from emp where deptno = 20 group by distinct ();
++--------+
+| EXPR$0 |
++--------+
+|      1 |
++--------+
+(1 row)
+
+!ok
+
+# GROUP BY DISTINCT x + y
+select deptno + 1, count(*) from emp where deptno = 20 group by distinct deptno + 1;
++--------+--------+
+| EXPR$0 | EXPR$1 |
++--------+--------+
+|     21 |      1 |
++--------+--------+
+(1 row)
+
+!ok
+
 # CUBE and JOIN
 select e.deptno, e.gender, min(e.ename) as min_name
 from emp as e join dept as d using (deptno)
@@ -896,7 +983,6 @@ group by rollup(1);
 select deptno, group_id() as g, count(*) as c
 from "scott".emp
 group by grouping sets (deptno, (), ());
-
 +--------+---+----+
 | DEPTNO | G | C  |
 +--------+---+----+
@@ -927,7 +1013,6 @@ select deptno
    order by deptno
        , job
        , empno;
-
 +--------+-----------+-------+--------+----------+-----------------------------------+
 | DEPTNO | JOB       | EMPNO | ENAME  | SUMSAL   | GR_TEXT                           |
 +--------+-----------+-------+--------+----------+-----------------------------------+
@@ -987,7 +1072,6 @@ select deptno
    order by deptno
        , job
        , empno;
-
 +--------+-----------+-------+--------+----------+-----------------------------------+
 | DEPTNO | JOB       | EMPNO | ENAME  | SUMSAL   | GR_TEXT                           |
 +--------+-----------+-------+--------+----------+-----------------------------------+
@@ -1265,12 +1349,17 @@ GROUP BY deptno;
 !ok
 
 # As above, but with correlation
-!if (fixed.calcite1045) {
 SELECT SUM(
   (select char_length(dname) from "scott".dept where dept.deptno = emp.empno)) as s
 FROM "scott".emp;
++---+
+| S |
++---+
+|   |
++---+
+(1 row)
+
 !ok
-!}
 
 # FUSION rolled up using CARDINALITY
 select cardinality(fusion(empnos)) as f_empnos_length
@@ -1736,12 +1825,12 @@ from "scott".emp join "scott".dept using (deptno);
 (1 row)
 
 !ok
-EnumerableAggregate(group=[{}], EXPR$0=[SUM($2)])
-  EnumerableHashJoin(condition=[=($0, $3)], joinType=[inner])
-    EnumerableCalc(expr#0..2=[{inputs}], DEPTNO=[$t0])
-      EnumerableTableScan(table=[[scott, DEPT]])
+EnumerableAggregate(group=[{}], EXPR$0=[SUM($1)])
+  EnumerableHashJoin(condition=[=($2, $3)], joinType=[semi])
     EnumerableCalc(expr#0..7=[{inputs}], EMPNO=[$t0], SAL=[$t5], DEPTNO=[$t7])
       EnumerableTableScan(table=[[scott, EMP]])
+    EnumerableCalc(expr#0..2=[{inputs}], DEPTNO=[$t0])
+      EnumerableTableScan(table=[[scott, DEPT]])
 !plan
 
 # Push sum; no aggregate needed after join
@@ -1782,12 +1871,12 @@ group by emp.deptno;
 
 !ok
 EnumerableCalc(expr#0..1=[{inputs}], EXPR$0=[$t1])
-  EnumerableAggregate(group=[{3}], EXPR$0=[SUM($2)])
-    EnumerableHashJoin(condition=[=($0, $3)], joinType=[inner])
-      EnumerableCalc(expr#0..2=[{inputs}], DEPTNO=[$t0])
-        EnumerableTableScan(table=[[scott, DEPT]])
+  EnumerableAggregate(group=[{2}], EXPR$0=[SUM($1)])
+    EnumerableHashJoin(condition=[=($2, $3)], joinType=[semi])
       EnumerableCalc(expr#0..7=[{inputs}], EMPNO=[$t0], SAL=[$t5], DEPTNO=[$t7])
         EnumerableTableScan(table=[[scott, EMP]])
+      EnumerableCalc(expr#0..2=[{inputs}], DEPTNO=[$t0])
+        EnumerableTableScan(table=[[scott, DEPT]])
 !plan
 
 # Push min; Join-Aggregate is optimized to SemiJoin
@@ -1805,12 +1894,12 @@ group by emp.deptno;
 
 !ok
 EnumerableCalc(expr#0..1=[{inputs}], EXPR$0=[$t1])
-  EnumerableAggregate(group=[{3}], EXPR$0=[MIN($2)])
-    EnumerableHashJoin(condition=[=($0, $3)], joinType=[inner])
-      EnumerableCalc(expr#0..2=[{inputs}], DEPTNO=[$t0])
-        EnumerableTableScan(table=[[scott, DEPT]])
+  EnumerableAggregate(group=[{2}], EXPR$0=[MIN($1)])
+    EnumerableHashJoin(condition=[=($2, $3)], joinType=[semi])
       EnumerableCalc(expr#0..7=[{inputs}], EMPNO=[$t0], SAL=[$t5], DEPTNO=[$t7])
         EnumerableTableScan(table=[[scott, EMP]])
+      EnumerableCalc(expr#0..2=[{inputs}], DEPTNO=[$t0])
+        EnumerableTableScan(table=[[scott, DEPT]])
 !plan
 
 # Push sum and count
@@ -1824,12 +1913,12 @@ from "scott".emp join "scott".dept using (deptno);
 (1 row)
 
 !ok
-EnumerableAggregate(group=[{}], C=[COUNT()], S=[SUM($2)])
-  EnumerableHashJoin(condition=[=($0, $3)], joinType=[inner])
-    EnumerableCalc(expr#0..2=[{inputs}], DEPTNO=[$t0])
-      EnumerableTableScan(table=[[scott, DEPT]])
+EnumerableAggregate(group=[{}], C=[COUNT()], S=[SUM($1)])
+  EnumerableHashJoin(condition=[=($2, $3)], joinType=[semi])
     EnumerableCalc(expr#0..7=[{inputs}], EMPNO=[$t0], SAL=[$t5], DEPTNO=[$t7])
       EnumerableTableScan(table=[[scott, EMP]])
+    EnumerableCalc(expr#0..2=[{inputs}], DEPTNO=[$t0])
+      EnumerableTableScan(table=[[scott, DEPT]])
 !plan
 
 # Push sum and count, group by join key
@@ -1847,12 +1936,12 @@ from "scott".emp join "scott".dept using (deptno) group by emp.deptno;
 !ok
 # No aggregate on top, because output of join is unique
 EnumerableCalc(expr#0..2=[{inputs}], C=[$t1], S=[$t2])
-  EnumerableAggregate(group=[{3}], C=[COUNT()], S=[SUM($2)])
-    EnumerableHashJoin(condition=[=($0, $3)], joinType=[inner])
-      EnumerableCalc(expr#0..2=[{inputs}], DEPTNO=[$t0])
-        EnumerableTableScan(table=[[scott, DEPT]])
+  EnumerableAggregate(group=[{2}], C=[COUNT()], S=[SUM($1)])
+    EnumerableHashJoin(condition=[=($2, $3)], joinType=[semi])
       EnumerableCalc(expr#0..7=[{inputs}], EMPNO=[$t0], SAL=[$t5], DEPTNO=[$t7])
         EnumerableTableScan(table=[[scott, EMP]])
+      EnumerableCalc(expr#0..2=[{inputs}], DEPTNO=[$t0])
+        EnumerableTableScan(table=[[scott, DEPT]])
 !plan
 
 # Push sum and count, group by join key plus another column
@@ -1899,12 +1988,12 @@ from "scott".emp join "scott".dept using (deptno) group by emp.job;
 
 !ok
 EnumerableCalc(expr#0..2=[{inputs}], C=[$t1], S=[$t2])
-  EnumerableAggregate(group=[{2}], C=[COUNT()], S=[SUM($3)])
-    EnumerableHashJoin(condition=[=($0, $4)], joinType=[inner])
-      EnumerableCalc(expr#0..2=[{inputs}], DEPTNO=[$t0])
-        EnumerableTableScan(table=[[scott, DEPT]])
+  EnumerableAggregate(group=[{1}], C=[COUNT()], S=[SUM($2)])
+    EnumerableHashJoin(condition=[=($3, $4)], joinType=[semi])
       EnumerableCalc(expr#0..7=[{inputs}], EMPNO=[$t0], JOB=[$t2], SAL=[$t5], DEPTNO=[$t7])
         EnumerableTableScan(table=[[scott, EMP]])
+      EnumerableCalc(expr#0..2=[{inputs}], DEPTNO=[$t0])
+        EnumerableTableScan(table=[[scott, DEPT]])
 !plan
 
 # Push count and sum, group by superset of join key
@@ -1958,12 +2047,12 @@ from "scott".emp join "scott".dept using (deptno) group by emp.sal;
 
 !ok
 EnumerableCalc(expr#0..2=[{inputs}], C=[$t1], S=[$t2])
-  EnumerableAggregate(group=[{2}], C=[COUNT()], S=[SUM($2)])
-    EnumerableHashJoin(condition=[=($0, $3)], joinType=[inner])
-      EnumerableCalc(expr#0..2=[{inputs}], DEPTNO=[$t0])
-        EnumerableTableScan(table=[[scott, DEPT]])
+  EnumerableAggregate(group=[{1}], C=[COUNT()], S=[SUM($1)])
+    EnumerableHashJoin(condition=[=($2, $3)], joinType=[semi])
       EnumerableCalc(expr#0..7=[{inputs}], EMPNO=[$t0], SAL=[$t5], DEPTNO=[$t7])
         EnumerableTableScan(table=[[scott, EMP]])
+      EnumerableCalc(expr#0..2=[{inputs}], DEPTNO=[$t0])
+        EnumerableTableScan(table=[[scott, DEPT]])
 !plan
 
 # Push sum, self-join, returning one row with a null value
@@ -2059,7 +2148,6 @@ from
 ) sq(x,y,z)
 group by z
 order by sum_cnt;
-
 +---------+----------+
 | SUM_CNT | CNT_DIST |
 +---------+----------+
@@ -2726,7 +2814,6 @@ group by MONTH(HIREDATE);
 select deptno, collect(empno) within group (order by empno asc) as empnos
 from "scott".emp
 group by deptno;
-
 +--------+--------------------------------------+
 | DEPTNO | EMPNOS                               |
 +--------+--------------------------------------+
@@ -2744,7 +2831,6 @@ EnumerableAggregate(group=[{7}], EMPNOS=[COLLECT($0) WITHIN GROUP ([0])])
 select deptno, collect(empno) within group (order by empno desc) as empnos
 from "scott".emp
 group by deptno;
-
 +--------+--------------------------------------+
 | DEPTNO | EMPNOS                               |
 +--------+--------------------------------------+
@@ -2765,7 +2851,6 @@ collect(empno) as empnos_1,
 collect(empno) within group (order by empno desc) as empnos_2
 from "scott".emp
 group by deptno;
-
 +--------+--------------------------------------+--------------------------------------+
 | DEPTNO | EMPNOS_1                             | EMPNOS_2                             |
 +--------+--------------------------------------+--------------------------------------+
@@ -2784,7 +2869,6 @@ select deptno, collect(empno) within group (order by empno desc)
 filter (where empno > 7500) as empnos
 from "scott".emp
 group by deptno;
-
 +--------+--------------------------------+
 | DEPTNO | EMPNOS                         |
 +--------+--------------------------------+
@@ -2804,7 +2888,6 @@ select deptno, collect(empno) within group (order by empno desc) as empnos1,
 collect(empno) within group (order by empno asc) as empnos2
 from "scott".emp
 group by deptno;
-
 +--------+--------------------------------------+--------------------------------------+
 | DEPTNO | EMPNOS1                              | EMPNOS2                              |
 +--------+--------------------------------------+--------------------------------------+
@@ -2827,7 +2910,6 @@ select dept.deptno,
 from "scott".emp
 join "scott".dept using (deptno)
 group by dept.deptno;
-
 +--------+-------------------------------------------------------+-------------------------------------------------------+-----------------------------+
 | DEPTNO | S                                                     | S1                                                    | S2                          |
 +--------+-------------------------------------------------------+-------------------------------------------------------+-----------------------------+
@@ -2850,7 +2932,6 @@ EnumerableAggregate(group=[{0}], S=[COLLECT($1) WITHIN GROUP ([1 DESC])], S1=[CO
 select deptno, collect(empno + 1) within group (order by 1) as empnos
 from "scott".emp
 group by deptno;
-
 +--------+--------------------------------------+
 | DEPTNO | EMPNOS                               |
 +--------+--------------------------------------+
@@ -2868,7 +2949,6 @@ EnumerableAggregate(group=[{0}], EMPNOS=[COLLECT($1) WITHIN GROUP ([2])])
 
 # BIT_AND, BIT_OR, BIT_XOR aggregate functions
 select bit_and(deptno), bit_or(deptno), bit_xor(deptno) from "scott".emp;
-
 +--------+--------+--------+
 | EXPR$0 | EXPR$1 | EXPR$2 |
 +--------+--------+--------+
@@ -2879,7 +2959,6 @@ select bit_and(deptno), bit_or(deptno), bit_xor(deptno) from "scott".emp;
 !ok
 
 select deptno, bit_and(empno), bit_or(empno), bit_xor(empno) from "scott".emp group by deptno;
-
 +--------+--------+--------+--------+
 | DEPTNO | EXPR$1 | EXPR$2 | EXPR$3 |
 +--------+--------+--------+--------+
@@ -3375,4 +3454,136 @@ order by ename, deptno;
 
 !ok
 
+# Test cases for [CALCITE-5209] Proper sub-query handling if it is used inside select list and group by
+!use scott
+select
+    case when deptno in (1, 2, 3, 4, 5) THEN 1 else 0 end
+from emp
+group by
+    case when deptno in (1, 2, 3, 4, 5) THEN 1 else 0 end;
++--------+
+| EXPR$0 |
++--------+
+|      0 |
++--------+
+(1 row)
+
+!ok
+
+!set insubquerythreshold 5
+select
+    case when deptno in (1, 2, 3, 4, 5) THEN 1 else 0 end
+from emp
+group by
+    case when deptno in (1, 2, 3, 4, 5) THEN 1 else 0 end;
++--------+
+| EXPR$0 |
++--------+
+|      0 |
++--------+
+(1 row)
+
+!ok
+
+# Test case for [CALCITE-5388] tempList expression inside EnumerableWindow.getPartitionIterator should be unoptimized
+with
+    CTE1(rownr1, val1) as ( select ROW_NUMBER() OVER(ORDER BY id ASC), id from (values (1), (2)) as Vals1(id) ),
+    CTE2(rownr2, val2) as ( select ROW_NUMBER() OVER(ORDER BY id ASC), id from (values (1), (2)) as Vals2(id) )
+select
+    CTE1.rownr1, CTE1.val1, CTE2.rownr2, CTE2.val2
+from
+    CTE1,CTE2
+where
+    CTE1.val1 = CTE2.val2;
++--------+------+--------+------+
+| ROWNR1 | VAL1 | ROWNR2 | VAL2 |
++--------+------+--------+------+
+|      1 |    1 |      1 |    1 |
+|      2 |    2 |      2 |    2 |
++--------+------+--------+------+
+(2 rows)
+
+!ok
+
+# [CALCITE-5283] Add ARG_MIN, ARG_MAX aggregate function
+
+# ARG_MIN, ARG_MAX without GROUP BY
+select arg_min(ename, deptno) as mi, arg_max(ename, deptno) as ma
+from emp;
++-------+-------+
+| MI    | MA    |
++-------+-------+
+| CLARK | ALLEN |
++-------+-------+
+(1 row)
+
+!ok
+
+# ARG_MIN, ARG_MAX with DISTINCT
+select arg_min(distinct ename, deptno) as mi, arg_max(distinct ename, deptno) as ma
+from emp;
++-------+-------+
+| MI    | MA    |
++-------+-------+
+| CLARK | ALLEN |
++-------+-------+
+(1 row)
+
+!ok
+
+# ARG_MIN, ARG_MAX function with WHERE.
+select arg_min(ename, deptno) as mi, arg_max(ename, deptno) as ma
+from emp
+where deptno <= 20;
++-------+-------+
+| MI    | MA    |
++-------+-------+
+| CLARK | SMITH |
++-------+-------+
+(1 row)
+
+!ok
+
+# ARG_MIN, ARG_MAX function with WHERE that removes all rows.
+# Result is NULL even though ARG_MIN, ARG_MAX is applied to a not-NULL column.
+select arg_min(ename, deptno) as mi, arg_max(ename, deptno) as ma
+from emp
+where deptno > 60;
++----+----+
+| MI | MA |
++----+----+
+|    |    |
++----+----+
+(1 row)
+
+!ok
+
+# ARG_MIN, ARG_MAX function with GROUP BY. note that key is NULL but result is not NULL.
+select deptno, arg_min(ename, ename) as mi, arg_max(ename, ename) as ma
+from emp
+group by deptno;
++--------+-------+--------+
+| DEPTNO | MI    | MA     |
++--------+-------+--------+
+|     10 | CLARK | MILLER |
+|     20 | ADAMS | SMITH  |
+|     30 | ALLEN | WARD   |
++--------+-------+--------+
+(3 rows)
+
+!ok
+
+# ARG_MIN, ARG_MAX applied to an integer.
+select arg_min(deptno, empno) as mi,
+  arg_max(deptno, empno) as ma,
+  arg_max(deptno, empno) filter (where job = 'MANAGER') as mamgr
+from emp;
++----+----+-------+
+| MI | MA | MAMGR |
++----+----+-------+
+| 20 | 10 |    10 |
++----+----+-------+
+(1 row)
+
+!ok
 # End agg.iq
diff --git a/core/src/test/resources/sql/cast-with-format.iq b/core/src/test/resources/sql/cast-with-format.iq
new file mode 100644
index 00000000000..403aea2ee12
--- /dev/null
+++ b/core/src/test/resources/sql/cast-with-format.iq
@@ -0,0 +1,2884 @@
+# cast-with-format.iq - Tests for CAST(value AS type FORMAT formatString)
+#
+# 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.
+#
+# Copied from
+# https://github.com/apache/impala/blob/master/tests/query_test/test_cast_with_format.py
+# (as of 2022/01/10)
+#
+!use post
+!set outputformat csv
+
+### basic_inputs_without_row ###############################
+#
+
+# Cast without format clause to cover the default format
+select cast('2017-05-01 01:23:45.678912345' as
+    timestamp);
+EXPR$0
+2017-05-01 01:23:45
+!ok
+!if (false) {
+
+# Basic input to cover a datetime with timezone scenario
+select cast('2017-05-03 08:59:01.123456789PM 01:30'
+    as timestamp FORMAT 'YYYY-MM-DD HH12:MI:SS.FF9PM TZH:TZM');
+EXPR$0
+2017-05-03 20:59:01.123456789
+!ok
+
+# Input that contains shuffled date without time
+select cast('12-2010-05' as timestamp format
+    'DD-YYYY-MM');
+EXPR$0
+2010-05-12 00:00:00
+!ok
+
+# Shuffle the input timestamp and the format clause
+select cast('59 04-30-2017-05 01PM 01:08.123456789'
+    as timestamp FORMAT 'MI DD-TZM-YYYY-MM TZHPM SS:HH12.FF9');
+EXPR$0
+2017-05-04 20:59:01.123456789
+!ok
+
+# Input and format without separators
+# Note, 12:01 HH12 AM is 00:01 with the internal 0-23 representation.
+select cast('20170501120159123456789AM-0130' as
+    timestamp FORMAT 'YYYYDDMMHH12MISSFFAMTZHTZM');
+EXPR$0
+2017-01-05 00:01:59.123456789
+!ok
+
+# Shuffled input without separators
+select cast('59043020170501PM0108123456789'
+    as timestamp FORMAT 'MIDDTZMYYYYMMTZHPMSSHH12FF9');
+EXPR$0
+2017-05-04 20:59:01.123456789
+!ok
+
+# Separator section lengths differ between input and format
+select cast('--2017----05-01-' as
+    timestamp FORMAT '-YYYY--MM---DD---');
+EXPR$0
+2017-05-01 00:00:00
+!ok
+
+# Loose separator type matching. Checking if the input/format is surrounded by
+# either single or double quotes.
+select cast("2017-./,';: 06-01" as
+    timestamp FORMAT "YYYY', -MM;:.DD");
+EXPR$0
+2017-06-01 00:00:00
+!ok
+
+select cast('2017-./,\';: 07-01' as
+    timestamp FORMAT "YYYY', -MM;:.DD");
+EXPR$0
+2017-07-01 00:00:00
+!ok
+
+select cast("2017-./,';: 08-01" as
+    timestamp FORMAT 'YYYY\', -MM;:.DD');
+EXPR$0
+2017-08-01 00:00:00
+!ok
+
+select cast('2017-./,\';: 09-01' as
+    timestamp FORMAT 'YYYY\', -MM;:.DD');
+EXPR$0
+2017-09-01 00:00:00
+!ok
+
+# Escaped double quotes in the input are not taken as the escaping character for the
+# following single quote.
+select cast("2013\\'09-01" as
+    timestamp FORMAT "YYYY'MM-DD");
+EXPR$0
+NULL
+!ok
+
+select cast("2013\\\'09-02" as
+    timestamp FORMAT "YYYY'MM-DD");
+EXPR$0
+NULL
+!ok
+
+select cast("2013\\\\'09-03" as
+    timestamp FORMAT "YYYY'MM-DD");
+EXPR$0
+NULL
+!ok
+
+# If the input string has unprocessed tokens
+select cast('2017-05-01 12:30' as
+    timestamp FORMAT 'YYYY-MM-DD');
+EXPR$0
+NULL
+!ok
+select cast('2017-05-01-12:30' as
+    timestamp FORMAT 'YYYY-MM-DD-');
+EXPR$0
+NULL
+!ok
+
+# If the format string has unprocessed tokens
+select cast('2017-05-01' as
+    timestamp FORMAT 'YYYY-MM-DD HH12:MI');
+EXPR$0
+NULL
+!ok
+select cast('2017-05-01-' as
+    timestamp FORMAT 'YYYY-MM-DD-HH12');
+EXPR$0
+NULL
+!ok
+
+# Timestamp to string types formatting
+select cast(cast('2012-11-04 13:02:59.123456' as timestamp)
+    as string format 'DD-MM-YYYY MI:HH12:SS A.M. FF9 DDD SSSSS HH12 HH24');
+EXPR$0
+04-11-2012 02:01:59 P.M. 123456000 309 46979 01 13
+!ok
+
+select cast(cast('2012-11-04 13:02:59.123456' as timestamp)
+    as varchar format 'DD-MM-YYYY MI:HH12:SS A.M. FF9 DDD SSSSS HH12 HH24');
+EXPR$0
+04-11-2012 02:01:59 P.M. 123456000 309 46979 01 13
+!ok
+
+select cast(cast('2012-11-04 13:02:59.123456' as timestamp)
+    as char(50) format 'DD-MM-YYYY MI:HH12:SS A.M. FF9 DDD SSSSS HH12 HH24');
+EXPR$0
+04-11-2012 02:01:59 P.M. 123456000 309 46979 01 13
+!ok
+
+# Cast NULL string to timestamp
+select cast(cast(NULL as string) as timestamp
+    FORMAT 'YYYY-MM-DD');
+EXPR$0
+NULL
+!ok
+
+# Cast NULL timestamp to string
+select cast(cast(NULL as timestamp) as string
+    FORMAT 'YYYY-MM-DD');
+EXPR$0
+NULL
+!ok
+
+### iso8601_format #################################################
+#
+
+# Basic string to timestamp scenario
+select cast('2018-11-10T15:11:04Z' as
+    timestamp FORMAT 'YYYY-MM-DDTHH24:MI:SSZ');
+EXPR$0
+2018-11-10 15:11:04
+!ok
+
+# ISO 8601 format elements are case-insensitive
+select cast('2018-11-09t15:11:04Z' as
+    timestamp FORMAT 'YYYY-MM-DDTHH24:MI:SSz');
+EXPR$0
+2018-11-09 15:11:04
+!ok
+
+select cast('2018-11-08T15:11:04z' as
+    timestamp FORMAT 'YYYY-MM-DDtHH24:MI:SSZ');
+EXPR$0
+2018-11-08 15:11:04
+!ok
+
+# Format path
+select cast(cast('2018-11-10 15:11:04' as
+    timestamp) as string format 'YYYY-MM-DDTHH24:MI:SSZ');
+EXPR$0
+2018-11-10T15:11:04Z
+!ok
+
+### lowercase_format_elements #################################################
+#
+select cast('2019-11-20 15:59:44.123456789 01:01' as
+    timestamp format 'yyyy-mm-dd hh24:mi:ss.ff9 tzh-tzm');
+EXPR$0
+2019-11-20 15:59:44.123456789
+!ok
+
+select cast('2019-300 15:59:44.123456789 01:01' as
+    timestamp format 'yyyy-ddd hh24:mi:ss.ff9 tzh-tzm');
+EXPR$0
+2019-10-27 15:59:44.123456789
+!ok
+
+select cast('2019-11-21 11:59:44.123456789 p.m. 01:01'
+    as timestamp format 'yyyy-mm-dd hh12:mi:ss.ff9 am tzh-tzm');
+EXPR$0
+2019-11-21 23:59:44.123456789
+!ok
+
+select cast('2019-11-22 10000.123456789 02:02'
+    as timestamp format 'yyyy-mm-dd sssss ff9 tzh-tzm');
+EXPR$0
+2019-11-22 02:46:40.123456789
+!ok
+
+### year #################################################
+#
+# Test lower boundary of year
+select cast('1399-05-01' as
+    timestamp FORMAT 'YYYY-MM-DD');
+EXPR$0
+NULL
+!ok
+
+# YYYY with less than 4 digits in the input
+!set now_string '2019-01-01 11:11:11'
+
+select cast('095-01-31' as
+    timestamp FORMAT 'YYYY-MM-DD');
+EXPR$0
+2095-01-31 00:00:00
+!ok
+
+select cast('95-02-28' as
+    timestamp FORMAT 'YYYY-MM-DD');
+EXPR$0
+2095-02-28 00:00:00
+!ok
+
+select cast('5-03-31' as
+    timestamp FORMAT 'YYYY-MM-DD');
+EXPR$0
+2015-03-31 00:00:00
+!ok
+
+# YYY with less than 3 digits in the input
+select cast('95-04-30' as
+    timestamp FORMAT 'YYY-MM-DD');
+EXPR$0
+2095-04-30 00:00:00
+!ok
+
+select cast('5-05-31' as
+    timestamp FORMAT 'YYY-MM-DD');
+EXPR$0
+2015-05-31 00:00:00
+!ok
+
+# YY with 1 digits in the input
+select cast('5-06-30' as
+    timestamp FORMAT 'YY-MM-DD');
+EXPR$0
+2015-06-30 00:00:00
+!ok
+
+# YYY, YY, Y tokens without separators
+select cast('0950731' as
+    timestamp FORMAT 'YYYMMDD');
+EXPR$0
+2095-07-31 00:00:00
+!ok
+
+select cast('950831' as
+    timestamp FORMAT 'YYMMDD');
+EXPR$0
+2095-08-31 00:00:00
+!ok
+
+select cast('50930' as
+    timestamp FORMAT 'YMMDD');
+EXPR$0
+2015-09-30 00:00:00
+!ok
+
+# Timestamp to string formatting
+select cast(cast('2019-01-01' as timestamp) as string
+    format 'YYYY');
+EXPR$0
+2019
+!ok
+
+select cast(cast('2019-01-01' as timestamp) as string
+    format 'YYY');
+EXPR$0
+019
+!ok
+
+select cast(cast('2019-01-01' as timestamp) as string
+    format 'YY');
+EXPR$0
+19
+!ok
+
+select cast(cast('2019-01-01' as timestamp) as string
+    format 'Y');
+EXPR$0
+9
+!ok
+!set now_string null
+
+### round_year #################################################
+#
+
+# Test lower boundar of round year
+select cast('1399-05-01' as
+    timestamp FORMAT 'RRRR-MM-DD');
+EXPR$0
+NULL
+!ok
+
+select cast('1400-05-21' as
+    timestamp FORMAT 'RRRR-MM-DD');
+EXPR$0
+1400-05-21 00:00:00
+!ok
+
+# RRRR with 4-digit year falls back to YYYY
+!set now_string '2019-01-01 11:11:11'
+select cast('2017-05-31' as
+    timestamp FORMAT 'RRRR-MM-DD');
+EXPR$0
+2017-05-31 00:00:00
+!ok
+
+# RRRR with 3-digit year fills digits from current year
+select cast('017-01-31' as
+    timestamp FORMAT 'RRRR-MM-DD');
+EXPR$0
+2017-01-31 00:00:00
+!ok
+
+# RRRR wit 1-digit year fills digits from current year
+select cast('0-07-31' as
+    timestamp FORMAT 'RRRR-MM-DD');
+EXPR$0
+2010-07-31 00:00:00
+!ok
+
+# RR with 1-digit year fills digits from current year
+select cast('9-08-31' as
+    timestamp FORMAT 'RR-MM-DD');
+EXPR$0
+2019-08-31 00:00:00
+!ok
+
+# Round year when last 2 digits of current year is less than 50
+!set now_string '2049-01-01 11:11:11'
+select cast('49-03-31' as
+    timestamp FORMAT 'RRRR-MM-DD');
+EXPR$0
+2049-03-31 00:00:00
+!ok
+
+select cast('50-03-31' as
+    timestamp FORMAT 'RRRR-MM-DD');
+EXPR$0
+1950-03-31 00:00:00
+!ok
+
+!set now_string '2000-01-01 11:11:11'
+select cast('49-03-31' as
+    timestamp FORMAT 'RR-MM-DD');
+EXPR$0
+2049-03-31 00:00:00
+!ok
+
+select cast('50-03-31' as
+    timestamp FORMAT 'RR-MM-DD');
+EXPR$0
+1950-03-31 00:00:00
+!ok
+
+# Round year when last 2 digits of current year is greater than 49
+!set now_string '2050-01-01 11:11:11'
+select cast('49-03-31' as
+    timestamp FORMAT 'RRRR-MM-DD');
+EXPR$0
+2149-03-31 00:00:00
+!ok
+
+select cast('50-03-31' as
+    timestamp FORMAT 'RRRR-MM-DD');
+EXPR$0
+2050-03-31 00:00:00
+!ok
+
+!set now_string '2099-01-01 11:11:11'
+select cast('49-03-31' as
+    timestamp FORMAT 'RR-MM-DD');
+EXPR$0
+2149-03-31 00:00:00
+!ok
+
+select cast('50-03-31' as
+    timestamp FORMAT 'RR-MM-DD');
+EXPR$0
+2050-03-31 00:00:00
+!ok
+
+# In a datetime to sting cast round year act like regular 'YYYY' or 'YY' tokens.
+select cast(cast('2019-01-01' as timestamp) as string
+    format 'RRRR');
+EXPR$0
+2019
+!ok
+
+select cast(cast('2019-01-01' as timestamp) as string
+    format 'RR');
+EXPR$0
+19
+!ok
+!set now_string null
+
+### month_name #################################################
+#
+# Test different lowercase vs uppercase scenarios with the string to datetime path.
+select cast('2010-February-11' as timestamp FORMAT
+    'YYYY-MONTH-DD');
+EXPR$0
+2010-02-11 00:00:00
+!ok
+
+select cast('2010-march-12' as timestamp FORMAT
+    'YYYY-MONTH-DD');
+EXPR$0
+2010-03-12 00:00:00
+!ok
+
+select cast('APRIL 13 2010' as date FORMAT
+    'MONTH DD YYYY');
+EXPR$0
+2010-04-13
+!ok
+
+select cast('2010 14 MAY' as timestamp FORMAT
+    'YYYY DD MONTH');
+EXPR$0
+2010-05-14 00:00:00
+!ok
+
+select cast('2010 14 June' as timestamp FORMAT
+    'YYYY DD MONTH');
+EXPR$0
+2010-06-14 00:00:00
+!ok
+
+select cast('2010 14 july' as timestamp FORMAT
+    'YYYY DD MONTH');
+EXPR$0
+2010-07-14 00:00:00
+!ok
+
+select cast('2010 14 AUGUST' as timestamp FORMAT
+    'YYYY DD MONTH');
+EXPR$0
+2010-08-14 00:00:00
+!ok
+
+select cast('2010 14 September' as date FORMAT
+    'YYYY DD month');
+EXPR$0
+2010-09-14
+!ok
+
+select cast('2010 14 october' as date FORMAT
+    'YYYY DD month');
+EXPR$0
+2010-10-14
+!ok
+
+select cast('2010 14 NOVEMBER' as date FORMAT
+    'YYYY DD month');
+EXPR$0
+2010-11-14
+!ok
+
+select cast('2010 14 December' as date FORMAT
+    'YYYY DD month');
+EXPR$0
+2010-12-14
+!ok
+
+select cast('2010 14 january' as date FORMAT
+    'YYYY DD month');
+EXPR$0
+2010-01-14
+!ok
+
+# Test different lowercase vs uppercase scenarios with the datetime to string path.
+select cast(date'2010-10-18' as string FORMAT
+    'MONTH Month month');
+EXPR$0
+OCTOBER   October   october
+!ok
+
+select cast(cast('2010-11-18' as timestamp) as string
+    FORMAT 'MONTH Month month');
+EXPR$0
+NOVEMBER  November  november
+!ok
+
+select cast(date'2010-12-19' as string FORMAT
+    'MONTH Month month');
+EXPR$0
+DECEMBER  December  december
+!ok
+
+select cast(date'2010-01-19' as string FORMAT
+    'MONTH Month month');
+EXPR$0
+JANUARY   January   january
+!ok
+
+select cast(date'2010-02-19' as string FORMAT
+    'MONTH Month month');
+EXPR$0
+FEBRUARY  February  february
+!ok
+
+select cast(date'2010-03-19' as string FORMAT
+    'MONTH Month month');
+EXPR$0
+MARCH     March     march
+!ok
+
+select cast(date'2010-04-19' as string FORMAT
+    'MONTH Month month');
+EXPR$0
+APRIL     April     april
+!ok
+
+select cast(date'2010-05-19' as string FORMAT
+    'MONTH Month month');
+EXPR$0
+MAY       May       may
+!ok
+
+select cast(date'2010-06-19' as string FORMAT
+    'MONTH Month month');
+EXPR$0
+JUNE      June      june
+!ok
+
+select cast(date'2010-07-19' as string FORMAT
+    'MONTH Month month');
+EXPR$0
+JULY      July      july
+!ok
+
+select cast(date'2010-08-19' as string FORMAT
+    'MONTH Month month');
+EXPR$0
+AUGUST    August    august
+!ok
+
+select cast(date'2010-09-19' as string FORMAT
+    'MONTH Month month');
+EXPR$0
+SEPTEMBER September september
+!ok
+
+# Test odd casing of month token.
+select cast(date'2010-09-20' as string FORMAT
+    'MOnth MONth MONTh');
+EXPR$0
+SEPTEMBER SEPTEMBER SEPTEMBER
+!ok
+
+select cast(date'2010-09-21' as string FORMAT
+    'montH monTH moNTH moNTH');
+EXPR$0
+september september september september
+!ok
+
+# Test different lowercase vs uppercase scenarios with the datetime to string path
+# when FM is provided.
+select cast(date'2010-10-18' as string FORMAT
+    'FMMONTH FMMonth FMmonth');
+EXPR$0
+OCTOBER October october
+!ok
+
+select cast(cast('2010-11-18' as timestamp) as string
+    FORMAT 'FMMONTH FMMonth FMmonth');
+EXPR$0
+NOVEMBER November november
+!ok
+
+select cast(date'2010-12-19' as string FORMAT
+    'FMMONTH FMMonth FMmonth');
+EXPR$0
+DECEMBER December december
+!ok
+
+select cast(date'2010-01-19' as string FORMAT
+    'FMMONTH FMMonth FMmonth');
+EXPR$0
+JANUARY January january
+!ok
+
+select cast(date'2010-02-19' as string FORMAT
+    'FMMONTH FMMonth FMmonth');
+EXPR$0
+FEBRUARY February february
+!ok
+
+select cast(date'2010-03-19' as string FORMAT
+    'FMMONTH FMMonth FMmonth');
+EXPR$0
+MARCH March march
+!ok
+
+select cast(date'2010-04-19' as string FORMAT
+    'FMMONTH FMMonth FMmonth');
+EXPR$0
+APRIL April april
+!ok
+
+select cast(date'2010-05-19' as string FORMAT
+    'FMMONTH FMMonth FMmonth');
+EXPR$0
+MAY May may
+!ok
+
+select cast(date'2010-06-19' as string FORMAT
+    'FMMONTH FMMonth FMmonth');
+EXPR$0
+JUNE June june
+!ok
+
+select cast(date'2010-07-19' as string FORMAT
+    'FMMONTH FMMonth FMmonth');
+EXPR$0
+JULY July july
+!ok
+
+select cast(date'2010-08-19' as string FORMAT
+    'FMMONTH FMMonth FMmonth');
+EXPR$0
+AUGUST August august
+!ok
+
+select cast(date'2010-09-19' as string FORMAT
+    'FMMONTH FMMonth FMmonth');
+EXPR$0
+SEPTEMBER September september
+!ok
+
+# Incorrect month name.
+select cast('2010 15 JU' as timestamp FORMAT
+    'YYYY DD MONTH');
+EXPR$0
+NULL
+!ok
+
+# MONTH token without surrounding separators.
+select cast('2010SEPTEMBER17' as date FORMAT
+    'YYYYMONTHDD');
+EXPR$0
+2010-09-17
+!ok
+
+select cast('2010OCTOBER17' as timestamp FORMAT
+    'YYYYMONTHDD');
+EXPR$0
+2010-10-17 00:00:00
+!ok
+
+# Applying FX and FM modifiers on Month token.
+select cast(cast('2010-07-20' as timestamp) as string
+    FORMAT 'YYYYmonthDD');
+EXPR$0
+2010july     20
+!ok
+
+select cast(date'2010-09-20' as string
+    FORMAT 'YYYYmonthDD');
+EXPR$0
+2010september20
+!ok
+
+select cast(cast('2010-08-20' as timestamp) as string
+    FORMAT 'YYYYFMMonthDD');
+EXPR$0
+2010August20
+!ok
+
+select cast(cast('2010-10-20' as timestamp) as string
+    FORMAT 'FXYYYYFMMONTHDD');
+EXPR$0
+2010OCTOBER20
+!ok
+
+select cast('2010-February-19' as timestamp FORMAT
+    'FXYYYY-MONTH-DD');
+EXPR$0
+NULL
+!ok
+
+select cast('2010-February -21' as timestamp FORMAT
+    'FXYYYY-MONTH-DD');
+EXPR$0
+2010-02-21 00:00:00
+!ok
+
+select cast('2010-February 22' as date FORMAT
+    'FXYYYY-MONTHDD');
+EXPR$0
+2010-02-22
+!ok
+
+select cast('2010-February-20' as timestamp FORMAT
+    'FXYYYY-FMMONTH-DD');
+EXPR$0
+2010-02-20 00:00:00
+!ok
+
+### short_month_name #################################################
+#
+# Test different lowercase vs uppercase scenarios with the string to datetime path.
+select cast('2015-Feb-11' as timestamp FORMAT
+    'YYYY-MON-DD');
+EXPR$0
+2015-02-11 00:00:00
+!ok
+
+select cast('2015-mar-12' as timestamp FORMAT
+    'YYYY-MON-DD');
+EXPR$0
+2015-03-12 00:00:00
+!ok
+
+select cast('APR 13 2015' as timestamp FORMAT
+    'MON DD YYYY');
+EXPR$0
+2015-04-13 00:00:00
+!ok
+
+select cast('2015 14 MAY' as timestamp FORMAT
+    'YYYY DD MON');
+EXPR$0
+2015-05-14 00:00:00
+!ok
+
+select cast('2015 14 jun' as timestamp FORMAT
+    'YYYY DD MON');
+EXPR$0
+2015-06-14 00:00:00
+!ok
+
+select cast('2015 14 Jul' as timestamp FORMAT
+    'YYYY DD MON');
+EXPR$0
+2015-07-14 00:00:00
+!ok
+
+select cast('2015 14 AUG' as timestamp FORMAT
+    'YYYY DD MON');
+EXPR$0
+2015-08-14 00:00:00
+!ok
+
+select cast('2015 14 Sep' as timestamp FORMAT
+    'YYYY DD mon');
+EXPR$0
+2015-09-14 00:00:00
+!ok
+
+select cast('2015 14 oct' as timestamp FORMAT
+    'YYYY DD mon');
+EXPR$0
+2015-10-14 00:00:00
+!ok
+
+select cast('2015 14 nov' as timestamp FORMAT
+    'YYYY DD mon');
+EXPR$0
+2015-11-14 00:00:00
+!ok
+
+select cast('2015 14 DEC' as timestamp FORMAT
+    'YYYY DD mon');
+EXPR$0
+2015-12-14 00:00:00
+!ok
+
+select cast('2015 14 Jan' as timestamp FORMAT
+    'YYYY DD mon');
+EXPR$0
+2015-01-14 00:00:00
+!ok
+
+# Test different lowercase vs uppercase scenarios with the datetime to string path.
+select cast(date'2015-10-18' as string FORMAT
+    'MON Mon mon');
+EXPR$0
+OCT Oct oct
+!ok
+
+select cast(cast('2015-11-18' as timestamp) as string
+    FORMAT 'MON Mon mon');
+EXPR$0
+NOV Nov nov
+!ok
+
+select cast(date'2015-12-19' as string FORMAT
+    'MON Mon mon');
+EXPR$0
+DEC Dec dec
+!ok
+
+select cast(date'2015-01-19' as string FORMAT
+    'MON Mon mon');
+EXPR$0
+JAN Jan jan
+!ok
+
+select cast(date'2015-02-19' as string FORMAT
+    'MON Mon mon');
+EXPR$0
+FEB Feb feb
+!ok
+
+select cast(date'2015-03-19' as string FORMAT
+    'MON Mon mon');
+EXPR$0
+MAR Mar mar
+!ok
+
+select cast(date'2015-04-19' as string FORMAT
+    'MON Mon mon');
+EXPR$0
+APR Apr apr
+!ok
+
+select cast(date'2015-05-19' as string FORMAT
+    'MON Mon mon');
+EXPR$0
+MAY May may
+!ok
+
+select cast(date'2015-06-19' as string FORMAT
+    'MON Mon mon');
+EXPR$0
+JUN Jun jun
+!ok
+
+select cast(date'2015-07-19' as string FORMAT
+    'MON Mon mon');
+EXPR$0
+JUL Jul jul
+!ok
+
+select cast(date'2015-08-19' as string FORMAT
+    'MON Mon mon');
+EXPR$0
+AUG Aug aug
+!ok
+
+select cast(date'2015-09-19' as string FORMAT
+    'MON Mon mon');
+EXPR$0
+SEP Sep sep
+!ok
+
+# Test odd casing of short month token.
+select cast(date'2010-09-22' as string FORMAT
+    'MOn mON moN');
+EXPR$0
+SEP sep sep
+!ok
+
+# Incorrect month name.
+select cast('2015 15 JU' as timestamp FORMAT
+    'YYYY DD MON');
+EXPR$0
+NULL
+!ok
+
+# MON token without separators in the format.
+select cast('2015AUG17' as date FORMAT
+    'YYYYMONDD');
+EXPR$0
+2015-08-17
+!ok
+
+select cast(cast('2015-07-20' as timestamp) as string
+    FORMAT 'YYYYmonDD');
+EXPR$0
+2015jul20
+!ok
+
+# FX/FM has no effect on MON.
+select cast(cast('2015-08-21' as timestamp) as string
+    FORMAT 'FXYYYYmonDD');
+EXPR$0
+2015aug21
+!ok
+
+select cast(date'2015-09-22' as string
+    FORMAT 'FXYYYYFMMonDD');
+EXPR$0
+2015Sep22
+!ok
+
+### week_of_year #################################################
+#
+select cast(cast('2019-01-01' as timestamp) as string
+    FORMAT 'WW');
+EXPR$0
+01
+!ok
+
+select cast(date'2019-01-07' as string
+    FORMAT 'WW');
+EXPR$0
+01
+!ok
+
+select cast(cast('2019-01-08' as timestamp) as string
+    FORMAT 'WW');
+EXPR$0
+02
+!ok
+
+select cast(date'2019-02-01' as string
+    FORMAT 'WW');
+EXPR$0
+05
+!ok
+
+select cast(cast('2019-02-05' as timestamp) as string
+    FORMAT 'WW');
+EXPR$0
+06
+!ok
+
+select cast(date'2019-12-01' as string
+    FORMAT 'WW');
+EXPR$0
+48
+!ok
+
+select cast(cast('2019-12-02' as timestamp) as string
+    FORMAT 'WW');
+EXPR$0
+48
+!ok
+
+select cast(date'2019-12-03' as string
+    FORMAT 'WW');
+EXPR$0
+49
+!ok
+
+select cast(cast('2019-12-30' as timestamp) as string
+    FORMAT 'WW');
+EXPR$0
+52
+!ok
+
+select cast(date'2019-12-31' as string
+    FORMAT 'WW');
+EXPR$0
+53
+!ok
+
+select cast(cast('2020-01-01' as timestamp) as string
+    FORMAT 'WW');
+EXPR$0
+01
+!ok
+
+### week_of_month #################################################
+#
+select cast(cast('2019-01-01' as timestamp) as string
+    FORMAT 'W');
+EXPR$0
+1
+!ok
+
+select cast(date'2019-01-07' as string
+    FORMAT 'W');
+EXPR$0
+1
+!ok
+
+select cast(cast('2019-01-08' as timestamp) as string
+    FORMAT 'W');
+EXPR$0
+2
+!ok
+
+select cast(date'2019-01-14' as string
+    FORMAT 'W');
+EXPR$0
+2
+!ok
+
+select cast(cast('2019-01-15' as timestamp) as string
+    FORMAT 'W');
+EXPR$0
+3
+!ok
+
+select cast(date'2019-01-21' as string
+    FORMAT 'W');
+EXPR$0
+3
+!ok
+
+select cast(cast('2019-01-22' as timestamp) as string
+    FORMAT 'W');
+EXPR$0
+4
+!ok
+
+select cast(date'2019-01-28' as string
+    FORMAT 'W');
+EXPR$0
+4
+!ok
+
+select cast(cast('2019-01-29' as timestamp) as string
+    FORMAT 'W');
+EXPR$0
+5
+!ok
+
+select cast(date'2019-02-01' as string
+    FORMAT 'W');
+EXPR$0
+1
+!ok
+
+### day_in_year #################################################
+#
+# Test "day in year" token in a non leap year scenario
+select cast('2019 1' as timestamp FORMAT 'YYYY DDD');
+EXPR$0
+2019-01-01 00:00:00
+!ok
+
+select cast('2019 31' as timestamp FORMAT 'YYYY DDD');
+EXPR$0
+2019-01-31 00:00:00
+!ok
+
+select cast('2019 32' as timestamp FORMAT 'YYYY DDD');
+EXPR$0
+2019-02-01 00:00:00
+!ok
+
+select cast('2019 60' as timestamp FORMAT 'YYYY DDD');
+EXPR$0
+2019-03-01 00:00:00
+!ok
+
+select cast('2019 365' as timestamp FORMAT 'YYYY DDD');
+EXPR$0
+2019-12-31 00:00:00
+!ok
+
+select cast('2019 366' as timestamp FORMAT 'YYYY DDD');
+EXPR$0
+NULL
+!ok
+
+# Test "day in year" token in a leap year scenario
+select cast('2000 60' as timestamp FORMAT 'YYYY DDD');
+EXPR$0
+2000-02-29 00:00:00
+!ok
+
+select cast('2000 61' as timestamp FORMAT 'YYYY DDD');
+EXPR$0
+2000-03-01 00:00:00
+!ok
+
+select cast('2000 366' as timestamp FORMAT 'YYYY DDD');
+EXPR$0
+2000-12-31 00:00:00
+!ok
+
+select cast('2000 367' as timestamp FORMAT 'YYYY DDD');
+EXPR$0
+NULL
+!ok
+
+# Test "day in year" token without separators
+select cast('20190011120' as timestamp
+    FORMAT 'YYYYDDDHH12MI');
+EXPR$0
+2019-01-01 11:20:00
+!ok
+
+# Timestamp to string formatting
+select cast(cast('2019-01-01' as timestamp) as string
+    format'DDD');
+EXPR$0
+001
+!ok
+
+select cast(cast('2019-12-31' as timestamp) as string
+    format'DDD');
+EXPR$0
+365
+!ok
+
+select cast(cast('2000-12-31' as timestamp) as string
+    format'DDD');
+EXPR$0
+366
+!ok
+
+select cast(cast('2019 123' as timestamp
+    format 'YYYY DDD') as string format'DDD');
+EXPR$0
+123
+!ok
+
+### day_name #################################################
+#
+# String to datetime: Test different lowercase vs uppercase scenarios.
+select cast('2010-08-Tuesday' as timestamp FORMAT 'IYYY-IW-DAY'),
+           cast('2010-monday-08' as timestamp FORMAT 'IYYY-DAY-IW'),
+           cast('2010-Wednesday-08' as date FORMAT 'IYYY-DAY-IW'),
+           cast('2010 08 THURSDAY' as timestamp FORMAT 'IYYY IW DAY'),
+           cast('2010 08 Friday' as date FORMAT 'IYYY IW DAY'),
+           cast('2010 08 saturday' as timestamp FORMAT 'IYYY IW DAY'),
+           cast('sUnDay 2010 08' as date FORMAT 'DAY IYYY IW'),
+           cast('Monday 2010 09' as date FORMAT 'DAY IYYY IW');
+EXPR$0, EXPR$1, EXPR$2, EXPR$3, EXPR$4, EXPR$5, EXPR$6, EXPR$7
+2010-02-23 00:00:00, 2010-02-22 00:00:00, 2010-02-24, 2010-02-25 00:00:00, 2010-02-26, 2010-02-27 00:00:00, 2010-02-28, 2010-03-01
+!ok
+# And now with short day names.
+select cast('2010-08-Tue' as timestamp FORMAT 'IYYY-IW-DY'),
+           cast('2010-mon-08' as timestamp FORMAT 'IYYY-DY-IW'),
+           cast('2010-Wed-08' as date FORMAT 'IYYY-DY-IW'),
+           cast('2010 08 THU' as timestamp FORMAT 'IYYY IW DY'),
+           cast('2010 08 Fri' as date FORMAT 'IYYY IW DY'),
+           cast('2010 08 sat' as timestamp FORMAT 'IYYY IW DY'),
+           cast('sUn 2010 08' as date FORMAT 'DY IYYY IW'),
+           cast('Mon 2010 09' as date FORMAT 'DY IYYY IW');
+EXPR$0, EXPR$1, EXPR$2, EXPR$3, EXPR$4, EXPR$5, EXPR$6, EXPR$7
+2010-02-23 00:00:00, 2010-02-22 00:00:00, 2010-02-24, 2010-02-25 00:00:00, 2010-02-26, 2010-02-27 00:00:00, 2010-02-28, 2010-03-01
+!ok
+
+# String to datetime: Incorrect day name.
+select cast('2010 09 Mondau' as timestamp FORMAT
+    'IYYY IW DAY');
+EXPR$0
+NULL
+!ok
+
+# String to datetime: DAY token without surrounding separators.
+select cast('2010MONDAY09' as date FORMAT 'IYYYDAYIW'),
+           cast('2010WEDNESDAY9' as timestamp FORMAT 'IYYYDAYIW');
+EXPR$0, EXPR$1
+2010-03-01, 2010-03-03 00:00:00
+!ok
+# And now with short day names.
+select cast('2010MON09' as date FORMAT 'IYYYDYIW'),
+           cast('2010WED9' as timestamp FORMAT 'IYYYDYIW');
+EXPR$0, EXPR$1
+2010-03-01, 2010-03-03 00:00:00
+!ok
+
+# String to datetime: FX and FM modifiers.
+select cast('2010-Monday-09' as timestamp FORMAT 'FXIYYY-DAY-IW'),
+           cast('2010-Monday  X-09' as timestamp FORMAT 'FXIYYY-DAY-IW');
+EXPR$0, EXPR$1
+NULL, NULL
+!ok
+
+select cast('2010-Monday   -09' as timestamp FORMAT 'FXIYYY-DAY-IW'),
+           cast('2010-Monday   09' as date FORMAT 'FXIYYY-DAYIW');
+EXPR$0, EXPR$1
+2010-03-01 00:00:00, 2010-03-01
+!ok
+
+select cast('2010-Monday-09' as timestamp FORMAT 'FXIYYY-FMDAY-IW'),
+           cast('2010-Monday09' as timestamp FORMAT 'FXIYYY-FMDAYIW'),
+           cast('2010Monday09' as date FORMAT 'FXIYYYFMDAYIW');
+EXPR$0, EXPR$1, EXPR$2
+2010-03-01 00:00:00, 2010-03-01 00:00:00, 2010-03-01
+!ok
+
+# Datetime to string: Different lowercase and uppercase scenarios.
+select cast(date'2019-11-13' as string
+    format 'DAY Day day DY Dy dy');
+EXPR$0
+WEDNESDAY Wednesday wednesday WED Wed wed
+!ok
+
+select cast(cast('2019-11-14' as timestamp) as string
+    format 'DAY Day day DY Dy dy');
+EXPR$0
+THURSDAY  Thursday  thursday  THU Thu thu
+!ok
+
+select cast(date'2019-11-15' as string
+    format 'DAY Day day DY Dy dy');
+EXPR$0
+FRIDAY    Friday    friday    FRI Fri fri
+!ok
+
+select cast(cast('2019-11-16' as timestamp) as string
+    format 'DAY Day day DY Dy dy');
+EXPR$0
+SATURDAY  Saturday  saturday  SAT Sat sat
+!ok
+
+select cast(date'2019-11-17' as string
+    format 'DAY Day day DY Dy dy');
+EXPR$0
+SUNDAY    Sunday    sunday    SUN Sun sun
+!ok
+
+select cast(cast('2019-11-18' as timestamp) as string
+    format 'DAY Day day DY Dy dy');
+EXPR$0
+MONDAY    Monday    monday    MON Mon mon
+!ok
+
+select cast(date'2019-11-19' as string
+    format 'DAY Day day DY Dy dy');
+EXPR$0
+TUESDAY   Tuesday   tuesday   TUE Tue tue
+!ok
+
+# Datetime to string: Different lowercase and uppercase scenarios when FM is provided.
+select cast(cast('2019-11-13' as timestamp) as string
+    format 'FMDAY FMDay FMday FMDY FMDy FMdy');
+EXPR$0
+WEDNESDAY Wednesday wednesday WED Wed wed
+!ok
+
+select cast(date'2019-11-14' as string
+    format 'FMDAY FMDay FMday FMDY FMDy FMdy');
+EXPR$0
+THURSDAY Thursday thursday THU Thu thu
+!ok
+
+select cast(cast('2019-11-15' as timestamp) as string
+    format 'FMDAY FMDay FMday FMDY FMDy FMdy');
+EXPR$0
+FRIDAY Friday friday FRI Fri fri
+!ok
+
+select cast(date'2019-11-16' as string
+    format 'FMDAY FMDay FMday FMDY FMDy FMdy');
+EXPR$0
+SATURDAY Saturday saturday SAT Sat sat
+!ok
+
+select cast(cast('2019-11-17' as timestamp) as string
+    format 'FMDAY FMDay FMday FMDY FMDy FMdy');
+EXPR$0
+SUNDAY Sunday sunday SUN Sun sun
+!ok
+
+select cast(date'2019-11-18' as string
+    format 'FMDAY FMDay FMday FMDY FMDy FMdy');
+EXPR$0
+MONDAY Monday monday MON Mon mon
+!ok
+
+select cast(cast('2019-11-19' as timestamp) as string
+    format 'FMDAY FMDay FMday FMDY FMDy FMdy');
+EXPR$0
+TUESDAY Tuesday tuesday TUE Tue tue
+!ok
+
+# Datetime to string: Test odd casing of day token.
+select cast(date'2010-01-20' as string FORMAT
+    'DAy dAY daY dY');
+EXPR$0
+WEDNESDAY wednesday wednesday wed
+!ok
+
+# Datetime to string: Day token without surrounding separators.
+select cast(date'2019-11-11' as string
+    format 'YYYYDayMonth');
+EXPR$0
+2019Monday   November
+!ok
+
+select cast(cast('2019-11-12' as timestamp) as string
+    format 'YYYYDYDD');
+EXPR$0
+2019TUE12
+!ok
+
+select cast(date'2019-11-11' as string
+    format 'YYYYDayMonth');
+EXPR$0
+2019Monday   November
+!ok
+
+select cast(cast('2019-11-12' as timestamp) as string
+    format 'YYYYDYDD');
+EXPR$0
+2019TUE12
+!ok
+
+# Datetime to string: Day token with FM and FX modifiers.
+select cast(cast('2019-01-01' as timestamp) as string
+    format 'FXYYYY DAY DD');
+EXPR$0
+2019 TUESDAY   01
+!ok
+
+select cast(date'2019-01-01' as string
+    format 'FXYYYY FMDAY DD');
+EXPR$0
+2019 TUESDAY 01
+!ok
+
+select cast(cast('2019-02-02' as timestamp) as string
+    format 'FXYYYY DY DD');
+EXPR$0
+2019 SAT 02
+!ok
+
+select cast(date'2019-02-02' as string
+    format 'FXYYYY FMDY DD');
+EXPR$0
+2019 SAT 02
+!ok
+
+### second_of_day #################################################
+#
+# Check boundaries
+select cast('2019-11-10 86399.11' as
+    timestamp FORMAT 'YYYY-MM-DD SSSSS.FF2');
+EXPR$0
+2019-11-10 23:59:59.110000000
+!ok
+
+select cast('2019-11-10 0' as
+    timestamp FORMAT 'YYYY-MM-DD SSSSS');
+EXPR$0
+2019-11-10 00:00:00
+!ok
+
+# Without separators full 5-digit "second of day" has to be given
+select cast('11-10 036612019' as
+    timestamp FORMAT 'MM-DD SSSSSYYYY');
+EXPR$0
+2019-11-10 01:01:01
+!ok
+
+# Check timezone offsets with "second of day"
+select cast('2019-11-10 036611010' as
+    timestamp FORMAT 'YYYY-MM-DD SSSSSTZHTZM');
+EXPR$0
+2019-11-10 01:01:01
+!ok
+
+# Timestamp to string formatting
+select cast(cast('2019-01-01 01:01:01' as timestamp)
+    as string format 'SSSSS');
+EXPR$0
+03661
+!ok
+
+select cast(cast('2019-01-01' as timestamp) as string
+    format 'SSSSS');
+EXPR$0
+00000
+!ok
+
+select cast(cast('2019-01-01 23:59:59' as timestamp)
+    as string format 'SSSSS');
+EXPR$0
+86399
+!ok
+
+### day_of_week #################################################
+#
+# Sunday is 1
+select cast(cast('2019-11-03' as timestamp) as string
+    FORMAT 'D');
+EXPR$0
+1
+!ok
+
+select cast(cast('2019-11-03' as date) as string
+    FORMAT 'D');
+EXPR$0
+1
+!ok
+
+# Wednesday is 4
+select cast(cast('2019-11-06' as timestamp) as string
+    FORMAT 'D');
+EXPR$0
+4
+!ok
+
+select cast(cast('2019-11-06' as date) as string
+    FORMAT 'D');
+EXPR$0
+4
+!ok
+
+# Saturday is 7
+select cast(cast('2019-11-09' as timestamp) as string
+    FORMAT 'D');
+EXPR$0
+7
+!ok
+
+select cast(cast('2019-11-09' as date) as string
+    FORMAT 'D');
+EXPR$0
+7
+!ok
+
+# FX and FM modifier does not pad day of week values with zeros.
+select cast(cast('2019-12-01' as date) as string
+    FORMAT 'FXD');
+EXPR$0
+1
+!ok
+
+select cast(cast('2019-12-02' as date) as string
+    FORMAT 'FXFMD');
+EXPR$0
+2
+!ok
+
+### fraction_seconds #################################################
+#
+select cast('2019-11-08 123456789' as
+    timestamp FORMAT 'YYYY-MM-DD FF9');
+EXPR$0
+2019-11-08 00:00:00.123456789
+!ok
+
+select cast('2019-11-08 1' as
+    timestamp FORMAT 'YYYY-MM-DD FF');
+EXPR$0
+2019-11-08 00:00:00.100000000
+!ok
+
+select cast('2019-11-08 1234567890' as
+    timestamp FORMAT 'YYYY-MM-DD FF');
+EXPR$0
+NULL
+!ok
+
+select cast('2019-11-08' as
+    timestamp FORMAT 'YYYY-MM-DD FF');
+EXPR$0
+NULL
+!ok
+
+# TODO: expand the following code
+#  self.run_fraction_test(1)
+#  self.run_fraction_test(2)
+#  self.run_fraction_test(3)
+#  self.run_fraction_test(4)
+#  self.run_fraction_test(5)
+#  self.run_fraction_test(6)
+#  self.run_fraction_test(7)
+#  self.run_fraction_test(8)
+#  self.run_fraction_test(9)
+#
+#  def run_fraction_test(self, length):
+#    MAX_LENGTH = 9
+#    fraction_part = ""
+#    for x in range(length):
+#      fraction_part += str(x + 1)
+#    template_input = "select cast('2019-11-08 %s' as timestamp FORMAT 'YYYY-MM-DD FF%s')"
+#    input_str = template_input % (fraction_part, length)
+#
+#    expected = "2019-11-08 00:00:00." + fraction_part + ("0" * (MAX_LENGTH - length))
+#    result = self.execute_query(input_str)
+#    assert result.data == [expected]
+#
+#    input2_str = template_input % (fraction_part + str(length + 1), length)
+#    result = self.execute_query(input2_str)
+#    assert result.data == ["NULL"]
+
+### meridiem_indicator #################################################
+#
+# Check 12 hour diff between AM and PM
+select cast('2017-05-03 08 AM' as
+    timestamp FORMAT 'YYYY-MM-DD HH12 AM');
+EXPR$0
+2017-05-03 08:00:00
+!ok
+
+select cast('2017-05-04 08 PM' as
+    timestamp FORMAT 'YYYY-MM-DD HH12 PM');
+EXPR$0
+2017-05-04 20:00:00
+!ok
+
+# Check that any meridiem indicator in the pattern matches any meridiem indicator in
+# the input
+select cast('2017-05-05 12AM' as
+    timestamp FORMAT 'YYYY-MM-DD HH12PM');
+EXPR$0
+2017-05-05 00:00:00
+!ok
+
+select cast('2017-05-06 P.M.12' as
+    timestamp FORMAT 'YYYY-MM-DD AMHH12');
+EXPR$0
+2017-05-06 12:00:00
+!ok
+
+select cast('2017-05-07 PM 01' as
+    timestamp FORMAT 'YYYY-MM-DD A.M. HH12');
+EXPR$0
+2017-05-07 13:00:00
+!ok
+
+# Test lowercase indicator in input
+select cast('2017-05-08 pm09' as
+    timestamp FORMAT 'YYYY-MM-DD P.M.HH12');
+EXPR$0
+2017-05-08 21:00:00
+!ok
+
+select cast('2017-05-09 10a.m.' as
+    timestamp FORMAT 'YYYY-MM-DD HH12PM');
+EXPR$0
+2017-05-09 10:00:00
+!ok
+
+# Test that '.' in indicator doesn't conflict with '.' as separator
+select cast('2017-05-11 9.AM.10' as
+    timestamp FORMAT 'YYYY-MM-DD HH12.P.M..MI');
+EXPR$0
+2017-05-11 09:10:00
+!ok
+
+select cast('2017-05-10.P.M..10' as
+    timestamp FORMAT 'YYYY-MM-DD.AM.HH12');
+EXPR$0
+2017-05-10 22:00:00
+!ok
+
+# Timestamp to string formatting
+select cast(cast('2019-01-01 00:15:10' as timestamp)
+    as string format 'HH12 P.M.');
+EXPR$0
+12 A.M.
+!ok
+
+select cast(cast('2019-01-01 12:15:10' as timestamp)
+    as string format 'HH12 AM');
+EXPR$0
+12 PM
+!ok
+
+select cast(cast('2019-01-01 13:15:10' as timestamp)
+    as string format 'HH12 a.m.');
+EXPR$0
+01 p.m.
+!ok
+
+select cast(cast('2019-01-01 23:15:10' as timestamp)
+    as string format 'HH12 p.m.');
+EXPR$0
+11 p.m.
+!ok
+
+### timezone_offsets #################################################
+#
+# Test positive timezone offset.
+select cast('2018-01-01 10:00 AM +15:59' as
+    timestamp FORMAT 'YYYY-MM-DD HH12:MI A.M. TZH:TZM');
+EXPR$0
+2018-01-01 10:00:00
+!ok
+
+# Test negative timezone offset.
+select cast('2018-12-31 08:00 PM -15:59' as
+    timestamp FORMAT 'YYYY-MM-DD HH12:MI A.M. TZH:TZM');
+EXPR$0
+2018-12-31 20:00:00
+!ok
+
+# Minus sign before TZM.
+select cast('2018-12-31 08:00 AM 01:-59' as
+    timestamp FORMAT 'YYYY-MM-DD HH12:MI A.M. TZH:TZM');
+EXPR$0
+2018-12-31 08:00:00
+!ok
+
+# Minus sign right before one digit TZH.
+select cast('2018-12-31 08:00 AM--1:10' as
+    timestamp FORMAT 'YYYY-MM-DD HH12:MI A.M. TZH:TZM');
+EXPR$0
+2018-12-31 08:00:00
+!ok
+
+select cast('2018-12-31 08:00 AM-5:00' as
+    timestamp FORMAT 'YYYY-MM-DD HH12:MI A.M.TZH:TZM');
+EXPR$0
+2018-12-31 08:00:00
+!ok
+
+select cast('2018-12-31 08:00 AM-+1:10' as
+    timestamp FORMAT 'YYYY-MM-DD HH12:MI A.M. TZH:TZM');
+EXPR$0
+2018-12-31 08:00:00
+!ok
+
+# Invalid TZH and TZM
+select cast('2016-01-01 10:00 AM +16:00' as
+    timestamp FORMAT 'YYYY-MM-DD HH12:MI A.M. TZH:TZM');
+EXPR$0
+NULL
+!ok
+
+select cast('2016-01-01 11:00 AM -16:00' as
+    timestamp FORMAT 'YYYY-MM-DD HH12:MI A.M. TZH:TZM');
+EXPR$0
+NULL
+!ok
+
+select cast('2016-01-01 10:00 AM 16:00' as
+    timestamp FORMAT 'YYYY-MM-DD HH12:MI A.M. TZH:TZM');
+EXPR$0
+NULL
+!ok
+
+select cast('2016-01-01 10:00 AM +15:60' as
+    timestamp FORMAT 'YYYY-MM-DD HH12:MI A.M. TZH:TZM');
+EXPR$0
+NULL
+!ok
+
+# One digit negative TZH at the end of the input string.
+select cast('2018-12-31 12:01 -1' as timestamp
+    FORMAT 'YYYY-MM-DD HH24:MI TZH');
+EXPR$0
+2018-12-31 12:01:00
+!ok
+
+# Test timezone offset parsing without separators
+select cast('201812310800AM+0515' as
+    timestamp FORMAT 'YYYYMMDDHH12MIA.M.TZHTZM');
+EXPR$0
+2018-12-31 08:00:00
+!ok
+
+select cast('201812310800AM0515' as
+    timestamp FORMAT 'YYYYMMDDHH12MIA.M.TZHTZM');
+EXPR$0
+2018-12-31 08:00:00
+!ok
+
+select cast('201812310800AM-0515' as
+    timestamp FORMAT 'YYYYMMDDHH12MIA.M.TZHTZM');
+EXPR$0
+2018-12-31 08:00:00
+!ok
+
+# Test signed zero TZH with not null TZM
+select cast('2018-01-01 10:00 AM +00:59' as
+    timestamp FORMAT 'YYYY-MM-DD HH12:MI A.M. TZH:TZM');
+EXPR$0
+2018-01-01 10:00:00
+!ok
+
+select cast('2018-01-01 10:00 AM -00:59' as
+    timestamp FORMAT 'YYYY-MM-DD HH12:MI A.M. TZH:TZM');
+EXPR$0
+2018-01-01 10:00:00
+!ok
+
+# Shuffle TZH and TZM into other elements
+select cast('2018-01-01 15 10:00 1 AM' as
+    timestamp FORMAT 'YYYY-MM-DD TZM HH12:MI TZH A.M.');
+EXPR$0
+2018-01-01 10:00:00
+!ok
+
+select cast('2018-01-011510:00-01AM' as
+    timestamp FORMAT 'YYYY-MM-DDTZMHH12:MITZHA.M.');
+EXPR$0
+2018-01-01 10:00:00
+!ok
+
+# Timezone offset with default time
+select cast('2018-01-01 01:30' as timestamp
+    FORMAT 'YYYY-MM-DD TZH:TZM');
+EXPR$0
+2018-01-01 00:00:00
+!ok
+
+# Single minus sign before two digit TZH.
+select cast('2018-09-11 15:30:10-10' as timestamp
+    FORMAT 'YYYY-MM-DD HH24:MI:SS-TZH');
+EXPR$0
+2018-09-11 15:30:10
+!ok
+
+# Non-digit TZH and TZM.
+select cast('2018-09-11 17:30:10 ab:10' as timestamp
+    FORMAT 'YYYY-MM-DD HH24:MI:SS TZH:TZM');
+EXPR$0
+NULL
+!ok
+
+select cast('2018-09-11 17:30:10 -ab:10' as timestamp
+    FORMAT 'YYYY-MM-DD HH24:MI:SS TZH:TZM');
+EXPR$0
+NULL
+!ok
+
+select cast('2018-09-11 17:30:10 +ab:10' as timestamp
+    FORMAT 'YYYY-MM-DD HH24:MI:SS TZH:TZM');
+EXPR$0
+NULL
+!ok
+
+select cast('2018-09-11 18:30:10 10:ab' as timestamp
+    FORMAT 'YYYY-MM-DD HH24:MI:SS TZH:TZM');
+EXPR$0
+NULL
+!ok
+
+### text_token #################################################
+#
+# Parse ISO:8601 tokens using the text token.
+select cast('1985-11-19T01:02:03Z' as timestamp
+    format 'YYYY-MM-DD"T"HH24:MI:SS"Z"');
+EXPR$0
+1985-11-19 01:02:03
+!ok
+
+# Free text at the end of the input
+select cast('1985-11-19text' as timestamp
+    format 'YYYY-MM-DD"text"');
+EXPR$0
+1985-11-19 00:00:00
+!ok
+
+# Free text at the beginning of the input
+select cast('19801985-11-20' as timestamp
+    format '"1980"YYYY-MM-DD');
+EXPR$0
+1985-11-20 00:00:00
+!ok
+
+# Empty text in format
+select cast('1985-11-21' as timestamp
+    format '""YYYY""-""MM""-""DD""');
+EXPR$0
+1985-11-21 00:00:00
+!ok
+
+select cast('1985-11-22' as timestamp
+    format 'YYYY-MM-DD""""""');
+EXPR$0
+1985-11-22 00:00:00
+!ok
+
+select cast('1985-12-09-' as timestamp
+    format 'YYYY-MM-DD-""');
+EXPR$0
+1985-12-09 00:00:00
+!ok
+
+select cast('1985-12-10-' as date
+    format 'FXYYYY-MM-DD-""');
+EXPR$0
+1985-12-10
+!ok
+
+select cast('1985-11-23' as timestamp
+    format 'YYYY-MM-DD""""""HH24');
+EXPR$0
+NULL
+!ok
+
+# Text in input doesn't match with the text in format
+select cast('1985-11-24Z01:02:03Z' as timestamp
+    format 'YYYY-MM-DD"T"HH24:MI:SS"Z"');
+EXPR$0
+NULL
+!ok
+
+select cast('1985-11-24T01:02:04T' as timestamp
+    format 'YYYY-MM-DD"T"HH24:MI:SS"Z"');
+EXPR$0
+NULL
+!ok
+
+select cast('1985-11-2401:02:05Z' as timestamp
+    format 'YYYY-MM-DD"T"HH24:MI:SS"Z"');
+EXPR$0
+NULL
+!ok
+
+select cast('1985-11-24T01:02:06' as timestamp
+    format 'YYYY-MM-DD"T"HH24:MI:SS"Z"');
+EXPR$0
+NULL
+!ok
+
+select cast('1985-11-24 01:02:07te' as timestamp
+    format 'YYYY-MM-DD HH24:MI:SS"text"');
+EXPR$0
+NULL
+!ok
+
+select cast('1985-11-24 01:02:08text' as
+    timestamp format 'YYYY-MM-DD HH24:MI:SS"te"');
+EXPR$0
+NULL
+!ok
+
+# Consecutive text tokens
+select cast('1985-11text1text2-25' as timestamp
+    format 'YYYY-MM"text1""text2"-DD');
+EXPR$0
+1985-11-25 00:00:00
+!ok
+
+# Separators in text token
+select cast("1985-11 -'./,:-25" as date
+    format "YYYY-MM\" -'./,:\"-DD");
+EXPR$0
+1985-11-25
+!ok
+
+# Known limitation: If a text token containing separator characters at the beginning
+# is right after a separator token sequence then parsing can't find where to stop when
+# parsing the consecutive separators. Use FX modifier in this case for strict
+# matching.
+select cast("1986-11'25" as date
+    format "YYYY-MM\"'\"DD");
+EXPR$0
+1986-11-25
+!ok
+
+select cast("1986-11-'25" as timestamp
+    format "YYYY-MM-\"'\"DD");
+EXPR$0
+NULL
+!ok
+
+select cast("1986-10-'25" as timestamp
+    format "FXYYYY-MM-\"'\"DD");
+EXPR$0
+1986-10-25 00:00:00
+!ok
+
+# Escaped quotation mark is in the text token.
+select cast('1985-11a"b26' as timestamp
+    format 'YYYY-MM"a\"b"DD');
+EXPR$0
+1985-11-26 00:00:00
+!ok
+
+# Format part is surrounded by double quotes so the quotes indicating the start and
+# end of the text token has to be escaped.
+select cast("year: 1985, month: 11, day: 27" as date
+    r''' format "\"year: \"YYYY\", month: \"MM\", day: \"DD")'';
+EXPR$0
+1985-11-27
+!ok
+
+# Scenario when there is an escaped double quote inside a text token that is itself
+# surrounded by escaped double quotes.
+select cast("1985 some \"text 11-28" as date
+     format "YYYY\" some \\\"text \"MM-DD");
+EXPR$0
+1985-11-28
+!ok
+
+# When format is surrounded by single quotes and there is a single quote inside the
+# text token that has to be escaped.
+select cast("1985 some 'text 11-29" as date
+     format 'YYYY" some \'text "MM-DD');
+EXPR$0
+1985-11-29
+!ok
+select cast("1985 some 'text 11-29" as timestamp
+     format 'YYYY" some \'text "MM-DD');
+EXPR$0
+1985-11-29 00:00:00
+!ok
+
+# Datetime to string path: Simple text token.
+select cast(cast("1985-11-30" as date) as string
+    format "YYYY-\"text\"MM-DD");
+EXPR$0
+1985-text11-30
+!ok
+
+# Datetime to string path: Consecutive text tokens.
+select cast(cast("1985-12-01" as date) as string
+    format "YYYY-\"text1\"\"text2\"MM-DD");
+EXPR$0
+1985-text1text212-01
+!ok
+select cast(cast("1985-12-01" as timestamp) as
+    string format "YYYY-\"text1\"\"text2\"MM-DD");
+EXPR$0
+1985-text1text212-01
+!ok
+
+# Datetime to string path: Text token containing separators.
+select cast(cast("1985-12-02" as date) as
+    string format "YYYY-\" -'./,:\"MM-DD");
+EXPR$0
+1985- -'./,:12-02
+!ok
+select cast(cast("1985-12-02" as timestamp) as
+    string format "YYYY-\" -'./,:\"MM-DD");
+EXPR$0
+1985- -'./,:12-02
+!ok
+
+# Datetime to string path: Text token containing a double quote.
+select cast(cast('1985-12-03' as date) as string
+    format 'YYYY-"some \"text"MM-DD');
+EXPR$0
+1985-some "text12-03
+!ok
+select cast(cast('1985-12-03' as timestamp) as
+    string format 'YYYY-"some \"text"MM-DD');
+EXPR$0
+1985-some "text12-03
+!ok
+
+# Datetime to string path: Text token containing a double quote where the text token
+# itself is covered by escaped double quotes.
+select cast(cast("1985-12-04" as date) as string
+    format "YYYY-\"some \\\"text\"MM-DD");
+EXPR$0
+1985-some "text12-04
+!ok
+select cast(cast("1985-12-04" as timestamp) as
+    string format "YYYY-\"some \\\"text\"MM-DD");
+EXPR$0
+1985-some "text12-04
+!ok
+
+# Backslash in format that escapes non-special chars.
+select cast("1985- some \ text12-05" as date
+    format 'YYYY-"some \ text"MM-DD');
+EXPR$0
+1985-12-05
+!ok
+select cast(cast("1985-12-06" as date) as string
+    format 'YYYY-"some \ text"MM-DD');
+EXPR$0
+1985-some  text12-06
+!ok
+
+select cast("1985-some text12-07" as date
+    format 'YYYY-"\some text"MM-DD');
+EXPR$0
+1985-12-07
+!ok
+select cast(cast("1985-12-08" as date) as string
+    format 'YYYY-"\some text"MM-DD');
+EXPR$0
+1985-some text12-08
+!ok
+
+# Backslash in format that escapes special chars.
+select cast("1985-\b\n\r\t12-09" as
+    date format 'YYYY-"\b\n\r\t"MM-DD');
+EXPR$0
+1985-12-09
+!ok
+select cast(cast("1985-12-10" as date) as string
+    format 'YYYY"\ttext\n"MM-DD');
+EXPR$0
+1985	text
+12-10
+!ok
+select cast(cast("1985-12-11" as date) as string
+    format "YYYY\"\ttext\n\"MM-DD");
+EXPR$0
+1985	text
+12-11
+!ok
+select cast(cast("1985-12-12" as timestamp) as
+    string format 'YYYY"\ttext\n"MM-DD');
+EXPR$0
+1985	text
+12-12
+!ok
+select cast(cast("1985-12-13" as timestamp) as
+    string format "YYYY\"\ttext\n\"MM-DD");
+EXPR$0
+1985	text
+12-13
+!ok
+
+# Escaped backslash in text token.
+select cast(cast("1985-12-14" as date) as string
+    format 'YYYY"some\\text"MM-DD');
+EXPR$0
+1985some\text12-14
+!ok
+select cast(cast("1985-12-15" as timestamp) as
+    string format 'YYYY"\\"MM"\\"DD');
+EXPR$0
+1985\12\15
+!ok
+select cast("1985\\12\\14 01:12:10" as timestamp
+    format 'YYYY"\\"MM"\\"DD HH12:MI:SS');
+EXPR$0
+1985-12-14 01:12:10
+!ok
+# Known limitation: When the format token is surrounded by escaped quotes then an
+# escaped backslash at the end of the token together with the closing double quote is
+# taken as a double escaped quote.
+select cast(cast("1985-12-16" as timestamp) as string format
+    "YYYY\"\\\"MM\"\\\"DD");
+Bad date/time conversion format
+!error
+
+# Free text token where an escaped backslash precedes an escaped single quote.
+select cast("2010-\\'-02-01" as date format
+     'FXYYYY-"\\\'"-MM-DD') ;
+EXPR$0
+2010-02-01
+!ok
+
+# Test error message where format contains text token with escaped double quote.
+select cast('1985-AB"CD11-23' as date format 'YYYY-"AB\"C"MM-DD');
+String to Date parse failed. Input '1985-AB"CD11-23' doesn't match with format 'YYYY-"AB\"C"MM-DD'
+!error
+
+### iso8601_week_based_date_tokens #################################################
+#
+# Format 0001-01-01 and 9999-12-31 dates.
+# 0001-01-01 is Monday, belongs to the 1st week of year 1.
+# 9999-12-31 is Friday, belongs to the 52nd week of year 9999.
+select cast(date'0001-01-01' as string format 'IYYY/IW/ID'),
+           cast(date'9999-12-31' as string format 'IYYY/IW/ID');
+EXPR$0, EXPR$1
+0001/01/01, 9999/52/05
+!ok
+
+# Parse 0001-01-01 and 9999-12-31 dates.
+select cast('0001/01/01' as date format 'IYYY/IW/ID'),
+           cast('9999/52/05' as date format 'IYYY/IW/ID');
+EXPR$0, EXPR$1
+0001-01-01, 9999-12-31
+!ok
+
+# Parse out-of-range dates.
+# Year 9999 has 52 weeks. 9999-12-31 is Friday.
+select cast('9999/52/06' as date format 'IYYY/IW/ID');
+String to Date parse failed. Input '9999/52/06' doesn't match with format 'IYYY/IW/ID'
+!error
+select cast('9999/53/01' as date format 'IYYY/IW/ID');
+String to Date parse failed. Input '9999/53/01' doesn't match with format 'IYYY/IW/ID'
+!error
+
+# Format 1400-01-01 and 9999-12-31 timestamps.
+# 1400-01-01 is Wednesday, belongs to the 1st week of year 1400.
+# 9999-12-31 is Friday, belongs to the 52nd week of year 9999.
+select cast(cast('1400-01-01' as timestamp) as string format 'IYYY/IW/ID'),
+           cast(cast('9999-12-31' as timestamp) as string format 'IYYY/IW/ID');
+EXPR$0, EXPR$1
+1400/01/03, 9999/52/05
+!ok
+
+# Parse 1400-01-01 and 9999-12-31 timestamps.
+select cast('1400/01/03' as timestamp format 'IYYY/IW/ID'),
+           cast('9999/52/05' as timestamp format 'IYYY/IW/ID');
+EXPR$0, EXPR$1
+1400-01-01 00:00:00, 9999-12-31 00:00:00
+!ok
+
+# Parse out-of-range timestamps.
+# - Tuesday of the 1st week of year 1400 is 1399-12-31, which is out of the valid
+# timestamp range.
+# - Year 9999 has 52 weeks. 9999-12-31 is Friday.
+select cast('1400/01/02' as timestamp format 'IYYY/IW/ID'),
+           cast('9999/52/06' as timestamp format 'IYYY/IW/ID'),
+           cast('9999/53/01' as timestamp format 'IYYY/IW/ID');
+EXPR$0, EXPR$1, EXPR$2
+NULL, NULL, NULL
+!ok
+
+# Formatting dates arond Dec 31.
+# 2019-12-31 is Tuesday, belongs to 1st week of year 2020.
+# 2020-12-31 is Thursday, belongs to 53rd week of year 2020.
+select cast(date'2019-12-29' as string format 'IYYY/IW/ID'),
+           cast(date'2019-12-30' as string format 'IYYY/IW/ID'),
+           cast(date'2019-12-31' as string format 'IYYY/IW/ID'),
+           cast(date'2020-01-01' as string format 'IYYY/IW/ID'),
+           cast(date'2020-12-31' as string format 'IYYY/IW/ID'),
+           cast(date'2021-01-01' as string format 'IYYY/IW/ID');
+EXPR$0, EXPR$1, EXPR$2, EXPR$3, EXPR$4, EXPR$5
+2019/52/07, 2020/01/01, 2020/01/02, 2020/01/03, 2020/53/04, 2020/53/05
+!ok
+
+# Parsing dates around Dec 31.
+select cast('2019/52/07' as date format 'IYYY/IW/ID'),
+           cast('2020/01/01' as date format 'IYYY/IW/ID'),
+           cast('2020/01/02' as date format 'IYYY/IW/ID'),
+           cast('2020/01/03' as date format 'IYYY/IW/ID'),
+           cast('2020/53/04' as date format 'IYYY/IW/ID'),
+           cast('2020/53/05' as date format 'IYYY/IW/ID');
+EXPR$0, EXPR$1, EXPR$2, EXPR$3, EXPR$4, EXPR$5
+2019-12-29, 2019-12-30, 2019-12-31, 2020-01-01, 2020-12-31, 2021-01-01
+!ok
+
+select cast('2019/53/01' as date format 'IYYY/IW/ID');
+String to Date parse failed. Input '2019/53/01' doesn't match with format 'IYYY/IW/ID'
+!error
+
+# Format 4, 3, 2, 1-digit week numbering year.
+# 2020-01-01 is Wednesday, belongs to week 1 of year 2020.
+!set now_string '2019-01-01 11:11:11'
+
+select cast(date'2020-01-01' as string format 'IYYY/IW/ID'),
+           cast(date'2020-01-01' as string format 'IYY/IW/ID'),
+           cast(date'2020-01-01' as string format 'IY/IW/ID'),
+           cast(date'2020-01-01' as string format 'I/IW/ID');
+EXPR$0, EXPR$1, EXPR$2, EXPR$3
+2020/01/03, 020/01/03, 20/01/03, 0/01/03
+!ok
+
+# Parse 4, 3, 2, 1-digit week numbering year.
+select cast('2020/01/03' as date format 'IYYY/IW/ID'),
+           cast('020/01/03' as date format 'IYYY/IW/ID'),
+           cast('20/01/03' as date format 'IYYY/IW/ID'),
+           cast('0/01/03' as date format 'IYYY/IW/ID'),
+           cast('020/01/03' as date format 'IYY/IW/ID'),
+           cast('20/01/03' as date format 'IYY/IW/ID'),
+           cast('0/01/03' as date format 'IYY/IW/ID'),
+           cast('20/01/03' as date format 'IY/IW/ID'),
+           cast('0/01/03' as date format 'IY/IW/ID'),
+           cast('0/01/03' as date format 'I/IW/ID');
+EXPR$0, EXPR$1, EXPR$2, EXPR$3, EXPR$4, EXPR$5, EXPR$6, EXPR$7, EXPR$8, EXPR$9
+2020-01-01, 2020-01-01, 2020-01-01, 2010-01-06, 2020-01-01, 2020-01-01, 2010-01-06, 2020-01-01, 2010-01-06, 2010-01-06
+!ok
+
+# 2000-01-01 is Saturday, so it belongs to the 1999 ISO 8601 week-numbering year.
+# Test that 1999 is used for prefixing 3, 2, 1-digit week numbering year.
+!set now_string '2000-01-01 11:11:11'
+
+select cast('2005/01/01' as date format 'IYYY/IW/ID'),
+           cast('005/01/01' as date format 'IYYY/IW/ID'),
+           cast('05/01/01' as date format 'IYYY/IW/ID'),
+           cast('5/01/01' as date format 'IYYY/IW/ID'),
+           cast('05/01/01' as date format 'IY/IW/ID'),
+           cast('5/01/01' as date format 'IY/IW/ID'),
+           cast('5/01/01' as date format 'I/IW/ID');
+EXPR$0, EXPR$1, EXPR$2, EXPR$3, EXPR$4, EXPR$5, EXPR$6
+2005-01-03, 1004-12-31, 1905-01-02, 1995-01-02, 1905-01-02, 1995-01-02, 1995-01-02
+!ok
+
+!set now_string null
+
+# Parse 1-digit week of year and 1-digit week day.
+select cast('2020/53/4' as date format 'IYYY/IW/ID'),
+           cast('2020/1/3' as date format 'IYYY/IW/ID');
+EXPR$0, EXPR$1
+2020-12-31, 2020-01-01
+!ok
+
+# Parse dayname with week-based tokens
+select cast('2020/wed/1' as date format 'IYYY/DY/IW'),
+           cast('2020/wed1' as date format 'iyyy/dyiw'),
+           cast('2020wed1' as date format 'IYYYDYIW'),
+           cast('2020WEd1' as date format 'iyyydyiw'),
+           cast('2020/wednesday/1' as date format 'IYYY/DAY/IW'),
+           cast('2020/wednesday1' as date format 'iyyy/dayiw'),
+           cast('2020wednesday1' as date format 'IYYYDAYIW'),
+           cast('2020wEdnESday1' as date format 'iyyydayiw');
+EXPR$0, EXPR$1, EXPR$2, EXPR$3, EXPR$4, EXPR$5, EXPR$6, EXPR$7
+2020-01-01, 2020-01-01, 2020-01-01, 2020-01-01, 2020-01-01, 2020-01-01, 2020-01-01, 2020-01-01
+!ok
+
+### fm_fx_modifiers #################################################
+#
+# Exact mathcing for the whole format.
+select cast('2001-03-01 03:10:15.123456 -01:30' as
+    timestamp format 'FXYYYY-MM-DD HH12:MI:SS.FF6 TZH:TZM');
+EXPR$0
+2001-03-01 03:10:15.123456000
+!ok
+
+# Strict separator matching.
+select cast('2001-03-02 03:10:15' as timestamp format
+    'FXYYYY MM-DD HH12:MI:SS');
+EXPR$0
+NULL
+!ok
+
+select cast('2001-03-03 03:10:15' as timestamp format
+    'FXYYYY-MM-DD HH12::MI:SS');
+EXPR$0
+NULL
+!ok
+
+select cast('2001-03-04    ' as timestamp format
+    'FXYYYY-MM-DD ');
+EXPR$0
+NULL
+!ok
+
+# Strict matching of single quote separator.
+select cast('2001\'04-01' as timestamp format
+     'FXYYYY\'MM-DD');
+EXPR$0
+2001-04-01 00:00:00
+!ok
+
+select cast("2001'04-02" as date format
+     'FXYYYY\'MM-DD');
+EXPR$0
+2001-04-02
+!ok
+
+select cast('2001\'04-03' as timestamp format
+     "FXYYYY'MM-DD");
+EXPR$0
+2001-04-03 00:00:00
+!ok
+
+select cast("2001'04-04" as date format
+     "FXYYYY'MM-DD");
+EXPR$0
+2001-04-04
+!ok
+
+# Strict token length matching.
+select cast('2001-3-05' as timestamp format
+    'FXYYYY-MM-DD');
+EXPR$0
+NULL
+!ok
+
+select cast('15-03-06' as timestamp format
+    'FXYYYY-MM-DD');
+EXPR$0
+NULL
+!ok
+
+select cast('15-03-07' as date format 'FXYY-MM-DD');
+EXPR$0
+2015-03-07
+!ok
+
+select cast('2001-03-08 03:15:00 AM' as timestamp
+    format 'FXYYYY-MM-DD HH12:MI:SS PM');
+EXPR$0
+2001-03-08 03:15:00
+!ok
+
+select cast('2001-03-08 03:15:00 AM' as timestamp
+    format 'FXYYYY-MM-DD HH12:MI:SS P.M.');
+EXPR$0
+NULL
+!ok
+
+select cast('2001-03-09 03:15:00.1234' as timestamp
+    format 'FXYYYY-MM-DD HH12:MI:SS.FF4');
+EXPR$0
+2001-03-09 03:15:00.123400000
+!ok
+
+select cast('2001-03-09 03:15:00.12345' as timestamp
+    format 'FXYYYY-MM-DD HH12:MI:SS.FF4');
+EXPR$0
+NULL
+!ok
+
+select cast('2001-03-09 03:15:00.12345' as timestamp
+    format 'FXYYYY-MM-DD HH12:MI:SS.FF');
+EXPR$0
+NULL
+!ok
+
+# Strict week-based token length matching.
+select cast('2015/3/05' as timestamp format 'FXIYYY/IW/ID'),
+           cast('2015/03/5' as timestamp format 'FXIYYY/IW/ID'),
+           cast('015/03/05' as timestamp format 'FXIYYY/IW/ID'),
+           cast('15/03/05' as timestamp format 'FXIYYY/IW/ID'),
+           cast('5/03/05' as timestamp format 'FXIYYY/IW/ID');
+EXPR$0, EXPR$1, EXPR$2, EXPR$3, EXPR$4
+NULL, NULL, NULL, NULL, NULL
+!ok
+select cast('2015/3/05' as date format 'FXIYYY/IW/ID');
+String to Date parse failed. Input '2015/3/05' doesn't match with format 'FXIYYY/IW/ID'
+!error
+
+!set now_string '2019-01-01 11:11:11'
+select cast('2015/03/05' as timestamp format 'FXIYYY/IW/ID'),
+           cast('015/03/05' as timestamp format 'FXIYY/IW/ID'),
+           cast('15/03/05' as timestamp format 'FXIY/IW/ID'),
+           cast('5/03/05' as timestamp format 'FXI/IW/ID'),
+           cast('2015/03/05' as date format 'FXIYYY/IW/ID'),
+           cast('015/03/05' as date format 'FXIYY/IW/ID'),
+           cast('15/03/05' as date format 'FXIY/IW/ID'),
+           cast('5/03/05' as date format 'FXI/IW/ID');
+EXPR$0, EXPR$1, EXPR$2, EXPR$3, EXPR$4, EXPR$5, EXPR$6, EXPR$7
+2015-01-16 00:00:00, 2015-01-16 00:00:00, 2015-01-16 00:00:00, 2015-01-16 00:00:00, 2015-01-16, 2015-01-16, 2015-01-16, 2015-01-16
+!ok
+!set now_string null
+
+# Strict token length matching with text token containing escaped double quote.
+select cast('2001-03-09 some "text03:25:00'
+    as timestamp format "FXYYYY-MM-DD \"some \\\"text\"HH12:MI:SS");
+EXPR$0
+2001-03-09 03:25:00
+!ok
+
+# Use FM to ignore FX modifier for some of the tokens.
+select cast('2001-03-10 03:15:00.12345' as timestamp
+    format 'FXYYYY-MM-DD HH12:MI:SS.FMFF');
+EXPR$0
+2001-03-10 03:15:00.123450000
+!ok
+
+select cast('019-03-10 04:15:00' as timestamp
+    format 'FXFMYYYY-MM-DD HH12:MI:SS');
+EXPR$0
+2019-03-10 04:15:00
+!ok
+
+select cast('2004-03-08 03:15:00 AM' as timestamp
+    format 'FXYYYY-MM-DD HH12:MI:SS FMP.M.');
+EXPR$0
+2004-03-08 03:15:00
+!ok
+
+# Multiple FM modifiers in a format.
+select cast('2001-3-11 3:15:00.12345' as timestamp
+    format 'FXYYYY-FMMM-DD FMHH12:MI:SS.FMFF');
+EXPR$0
+2001-03-11 03:15:00.123450000
+!ok
+
+select cast('2001-3-11 3:15:30' as timestamp
+    format 'FXYYYY-FMMM-DD FMFMHH12:MI:SS');
+EXPR$0
+2001-03-11 03:15:30
+!ok
+
+# FM modifier effects only the next token.
+select cast('2001-3-12 3:1:00.12345' as timestamp
+    format 'FXYYYY-FMMM-DD FMHH12:MI:SS.FMFF');
+EXPR$0
+NULL
+!ok
+
+# FM modifier before text token is valid for the text token and not for the token
+# right after the text token.
+select cast('1999-10text1' as timestamp format
+    ''' 'FXYYYY-MMFM"text"DD');
+EXPR$0
+NULL
+!ok
+
+# FM modifier skips the separators and affects the next non-separator token.
+select cast('1999-10-2' as timestamp format
+    ''' 'FXYYYY-MMFM-DD');
+EXPR$0
+1999-10-02 00:00:00
+!ok
+
+# FM modifier at the end has no effect.
+select cast('2001-03-13 03:01:00' as timestamp
+    format 'FXYYYY-MM-DD HH12:MI:SSFM');
+EXPR$0
+2001-03-13 03:01:00
+!ok
+
+select cast('2001-03-13 03:01:0' as timestamp
+    format 'FXYYYY-MM-DD HH12:MI:SSFM');
+EXPR$0
+NULL
+!ok
+
+# In a datetime to string path FX is the default so it works with FX as it would
+# without.
+select cast(cast('2001-03-05 03:10:15.123456' as
+    timestamp) as string format 'FXYYYY-MM-DD HH24:MI:SS.FF7');
+EXPR$0
+2001-03-05 03:10:15.1234560
+!ok
+
+select cast(date'0001-01-10' as string format 'FXIYYY-IW-ID'),
+           cast(date'0001-10-10' as string format 'FXIYYY-IW-ID');
+EXPR$0, EXPR$1
+0001-02-03, 0001-41-03
+!ok
+
+# Datetime to string path: Tokens with FM modifier don't pad output to a given
+# length.
+select cast(cast('2001-03-14 03:06:08' as timestamp)
+    as string format 'YYYY-MM-DD FMHH24:FMMI:FMSS');
+EXPR$0
+2001-03-14 3:6:8
+!ok
+
+select cast(cast('0001-03-09' as date)
+    as string format 'FMYYYY-FMMM-FMDD');
+EXPR$0
+1-3-9
+!ok
+
+select cast(date'0001-03-10' as string format
+    'FMYY-FMMM-FMDD');
+EXPR$0
+1-3-10
+!ok
+
+select cast(date'0001-01-10' as string format 'FMIYYY-FMIW-FMID'),
+           cast(date'0001-10-10' as string format 'FMIYYY-FMIW-FMID');
+EXPR$0, EXPR$1
+1-2-3, 1-41-3
+!ok
+
+# Datetime to string path: FM modifier is effective even if FX modifier is also
+# given.
+select cast(cast('2001-03-15 03:06:08' as
+    timestamp) as string format 'FXYYYY-MM-DD FMHH24:FMMI:FMSS');
+EXPR$0
+2001-03-15 3:6:8
+!ok
+
+select cast(cast('0001-04-09' as date)
+    as string format 'FXYYYY-FMMM-FMDD');
+EXPR$0
+0001-4-9
+!ok
+
+select cast(cast('0001-04-10' as date)
+    as string format 'FXFMYYYY-FMMM-FMDD');
+EXPR$0
+1-4-10
+!ok
+
+select cast(date'0001-01-10' as string format 'FXFMIYYY-FMIW-FMID'),
+           cast(date'0001-10-10' as string format 'FXFMIYYY-FMIW-FMID');
+EXPR$0, EXPR$1
+1-2-3, 1-41-3
+!ok
+
+# FX and FM modifiers are case-insensitive.
+select cast('2019-5-10' as date format
+    'fxYYYY-fmMM-DD');
+EXPR$0
+2019-05-10
+!ok
+
+
+### quarter #################################################
+#
+select cast(date'2001-01-01' as string
+    FORMAT 'YYYY Q MM');
+EXPR$0
+2001 1 01
+!ok
+
+select cast(date'2001-03-31' as string
+    FORMAT 'YYYY Q MM');
+EXPR$0
+2001 1 03
+!ok
+
+select cast(date'2001-4-1' as string
+    FORMAT 'YYYY Q MM');
+EXPR$0
+2001 2 04
+!ok
+
+select cast(date'2001-6-30' as string
+    FORMAT 'YYYY Q MM');
+EXPR$0
+2001 2 06
+!ok
+
+select cast(date'2001-7-1' as string
+    FORMAT 'YYYY Q MM');
+EXPR$0
+2001 3 07
+!ok
+
+select cast(date'2001-9-30' as string
+    FORMAT 'YYYY Q MM');
+EXPR$0
+2001 3 09
+!ok
+
+select cast(date'2001-10-1' as string
+    FORMAT 'YYYY Q MM');
+EXPR$0
+2001 4 10
+!ok
+
+select cast(date'2001-12-31' as string
+    FORMAT 'YYYY Q MM');
+EXPR$0
+2001 4 12
+!ok
+
+### format_parse_errors #################################################
+#
+# Invalid format
+select cast('2017-05-01' as timestamp format 'XXXX-dd-MM');
+Bad date/time conversion format: XXXX-dd-MM
+!error
+
+# Invalid use of SimpleDateFormat
+select cast('2017-05-01 15:10' as timestamp format 'yyyy-MM-dd +hh:mm');
+Bad date/time conversion format: yyyy-MM-dd +hh:mm
+!error
+
+# Duplicate format element
+select cast('2017-05-01' as timestamp format 'YYYY-MM-DD MM');
+Invalid duplication of format element
+!error
+
+select cast('2017-05-01' as timestamp format 'YYYY-MM-DD-YYYY');
+Invalid duplication of format element
+!error
+
+# Multiple year tokens provided
+select cast('2017-05-01' as timestamp format 'YYYY-MM-DD-YY');
+Multiple year tokens provided
+!error
+
+select cast('2017-05-01' as timestamp format 'YYY-MM-DD-Y');
+Multiple year tokens provided
+!error
+
+# Year and round year conflict
+select cast('2017-05-01' as timestamp format 'YY-MM-DD-RRRR');
+Both year and round year are provided
+!error
+
+select cast('2017-05-01' as timestamp format 'RR-MM-DD-YYY');
+Both year and round year are provided
+!error
+
+# Quarter token not allowed in a string to datetime conversion.
+select cast('2017-1-01' as timestamp format 'YYYY-Q-DDD');
+Quarter token is not allowed in a string to datetime conversion
+!error
+
+# Conflict between MM, MONTH and MON tokens
+select cast('2017-05-01' as timestamp format 'YYYY-MM-DD-MONTH');
+Multiple month tokens provided
+!error
+
+select cast('2017-05-01' as timestamp format 'YYYY-MM-DD-MON');
+Multiple month tokens provided
+!error
+
+select cast('2017-05-01' as timestamp format 'YYYY-MONTH-DD-MON');
+Multiple month tokens provided
+!error
+
+# Conflict between DAY, DY and ID tokens.
+select cast('2017-05-01-Monday' as timestamp format 'IYYY-IW-ID-DAY');
+Multiple day of week tokens provided
+!error
+
+select cast('2017-05-01-Mon' as timestamp format 'IYYY-IW-ID-DY');
+Multiple day of week tokens provided
+!error
+
+select cast('2017-05-Monday-Mon' as timestamp format 'IYYY-IW-DAY-DY');
+Multiple day of week tokens provided
+!error
+
+# Week of year token not allowed in a string to datetime conversion.
+select cast('2017-1-01' as timestamp format 'YYYY-WW-DD');
+Week number token is not allowed in a string to datetime conversion
+!error
+
+# Week of month token not allowed in a string to datetime conversion.
+select cast('2017-1-01' as timestamp format 'YYYY-W-DD');
+Week number token is not allowed in a string to datetime conversion
+!error
+
+# Day of year conflict
+select cast('2017-05-01' as timestamp format 'YYYY-MM-DDD');
+Day of year provided with day or month token
+!error
+
+select cast('2017-05-01' as timestamp format 'YYYY-DD-DDD');
+Day of year provided with day or month token
+!error
+
+select cast('2017-MAY-01' as timestamp format 'YYYY-MONTH-DDD');
+Day of year provided with day or month token
+!error
+
+select cast('2017-JUN-01' as timestamp format 'YYYY-MON-DDD');
+Day of year provided with day or month token
+!error
+
+# Day of week token not allowed in a string to datetime conversion.
+select cast('2017-1-02' as timestamp format 'YYYY-D-MM');
+Day of week token is not allowed in a string to datetime conversion
+!error
+
+# Day name token not allowed in a string to datetime conversion.
+select cast('2017-1-02 Monday' as timestamp format 'YYYY-DD-MM DAY');
+Day name token is not allowed in a string to datetime conversion except with IYYY|IYY|IY|I and IW tokens
+!error
+
+# Conflict between hour tokens
+select cast('2017-05-01' as timestamp format 'YYYY-MM-DD HH:HH24');
+Multiple hour tokens provided
+!error
+
+select cast('2017-05-01' as timestamp format 'YYYY-MM-DD HH12:HH24');
+Multiple hour tokens provided
+!error
+
+select cast('2017-05-01' as timestamp format 'YYYY-MM-DD HH12:HH');
+Multiple hour tokens provided
+!error
+
+# Conflict with median indicator
+select cast('2017-05-01' as timestamp format 'YYYY-MM-DD AM HH:MI A.M.');
+Multiple median indicator tokens provided
+!error
+
+select cast('2017-05-01' as timestamp format 'YYYY-MM-DD PM HH:MI am');
+Multiple median indicator tokens provided
+!error
+
+select cast('2017-05-01' as timestamp format 'YYYY-MM-DD HH24:MI a.m.');
+Conflict between median indicator and hour token
+!error
+
+select cast('2017-05-01' as timestamp format 'YYYY-MM-DD p.m.');
+Missing hour token
+!error
+
+# Conflict with second of day
+select cast('2017-05-01' as timestamp format 'YYYY-MM-DD SSSSS HH');
+Second of day token conflicts with other token(s)
+!error
+
+select cast('2017-05-01' as timestamp format 'YYYY-MM-DD HH12:SSSSS');
+Second of day token conflicts with other token(s)
+!error
+
+select cast('2017-05-01' as timestamp format 'YYYY-MM-DD HH24SSSSS');
+Second of day token conflicts with other token(s)
+!error
+
+select cast('2017-05-01' as timestamp format 'YYYY-MM-DD MI SSSSS');
+Second of day token conflicts with other token(s)
+!error
+
+select cast('2017-05-01' as timestamp format 'YYYY-MM-DD SS SSSSS');
+Second of day token conflicts with other token(s)
+!error
+
+# Too long format
+# (Format string consists of 's' 101 times)
+select cast('2017-05-01' as timestamp
+    format 'sssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss');
+The input format is too long
+!error
+
+# Timezone offsets in a datetime to string formatting
+select cast(cast('2017-05-01 01:15' as timestamp format 'YYYY-MM-DD TZH:TZM')
+    as string format 'TZH');
+Timezone offset not allowed in a datetime to string conversion
+!error
+
+select cast(cast('2017-05-01 01:15' as timestamp format 'YYYY-MM-DD TZH:TZM')
+    as string format 'TZM');
+Timezone offset not allowed in a datetime to string conversion
+!error
+
+select cast(cast('2017-05-01 01:15' as timestamp format 'YYYY-MM-DD TZH:TZM')
+    as string format 'YYYY-MM-DD HH24:MI:SS TZH:TZM');
+Timezone offset not allowed in a datetime to string conversion
+!error
+
+# TZM requires TZH
+select cast('2018-12-31 08:00 AM 59' as timestamp FORMAT
+    'YYYY-MM-DD HH12:MI A.M. TZM');
+TZH token is required for TZM
+!error
+
+select cast('2018-12-31 08:00 AM -59' as timestamp FORMAT
+    'YYYY-MM-DD HH12:MI A.M. TZM');
+TZH token is required for TZM
+!error
+
+# Multiple fraction second token conflict
+select cast('2018-10-10' as timestamp format 'YYYY-MM-DD FF FF1');
+Multiple fractional second tokens provided.
+!error
+
+select cast('2018-10-10' as timestamp format 'YYYY-MM-DD FF2 FF3');
+Multiple fractional second tokens provided.
+!error
+
+select cast('2018-10-10' as timestamp format 'YYYY-MM-DD FF4 FF5');
+Multiple fractional second tokens provided.
+!error
+
+select cast('2018-10-10' as timestamp format 'YYYY-MM-DD FF6 FF7');
+Multiple fractional second tokens provided.
+!error
+
+select cast('2018-10-10' as timestamp format 'YYYY-MM-DD FF8 FF9');
+Multiple fractional second tokens provided.
+!error
+
+# No date token
+select cast('2020-05-05' as timestamp format 'FF1');
+No date tokens provided.
+!error
+
+select cast('2020-05-05' as timestamp format 'SSSSS');
+No date tokens provided.
+!error
+
+select cast('2020-05-05' as timestamp format 'HH:MI:SS');
+No date tokens provided.
+!error
+
+# ISO 8601 Week-based and normal date pattern tokens must not be mixed.
+select cast('2018-10-01' as date format 'IYYY-MM-ID');
+ISO 8601 week-based date tokens (i.e. IYYY, IW, ID) are not allowed to be used with regular date tokens.
+!error
+select cast('2018-10-01 01:00' as timestamp format 'IYYY-MM-ID HH24:MI');
+ISO 8601 week-based date tokens (i.e. IYYY, IW, ID) are not allowed to be used with regular date tokens.
+!error
+
+select cast('2018-10-01' as date format 'YYYY-IW-DD');
+ISO 8601 week-based date tokens (i.e. IYYY, IW, ID) are not allowed to be used with regular date tokens.
+!error
+select cast('2018-10-01' as timestamp format 'IYYY-IW-DD');
+ISO 8601 week-based date tokens (i.e. IYYY, IW, ID) are not allowed to be used with regular date tokens.
+!error
+
+# Missing ISO 8601 week-based pattern tokens.
+select cast('2018-10' as date format 'IYYY-IW');
+One or more required ISO 8601 week-based date tokens (i.e. IYYY, IW, ID) are missing.
+!error
+select cast('2018-10 01:00' as timestamp format 'IYYY-IW HH24:MI');
+One or more required ISO 8601 week-based date tokens (i.e. IYYY, IW, ID) are missing.
+!error
+
+select cast('18-07' as date format 'IY-ID');
+One or more required ISO 8601 week-based date tokens (i.e. IYYY, IW, ID) are missing.
+!error
+select cast('18-07 01:00' as timestamp format 'IY-ID HH24:MI');
+One or more required ISO 8601 week-based date tokens (i.e. IYYY, IW, ID) are missing.
+!error
+
+# ISO 8601 Week numbering year conflict
+select cast('2018-018-10-01' as date format 'IYYY-IYY-IW-DD');
+Multiple year tokens provided
+!error
+select cast('2018-018-10-01 01:00' as timestamp format
+    'IYYY-IYY-IW-DD HH24:MI');
+Multiple year tokens provided
+!error
+
+select cast('018-8-10-01' as date format 'IYY-I-IW-DD');
+Multiple year tokens provided
+!error
+select cast('018-8-10-01 01:00' as timestamp format 'IYY-I-IW-DD HH24:MI');
+Multiple year tokens provided
+!error
+
+# Verify that conflict check is not skipped when format ends with separators.
+select cast('2017-05-01' as timestamp format 'YYYY-MM-DD-RR--');
+Both year and round year are provided
+!error
+
+# Unclosed quotation in text pattern
+select cast('1985-11-20text' as timestamp format 'YYYY-MM-DD"text');
+Missing closing quotation mark.
+!error
+
+select cast('1985-11-21text' as timestamp format 'YYYY-MM-DD\"text"');
+Missing closing quotation mark.
+!error
+
+select cast(date"1985-12-08" as string format 'YYYY-MM-DD \"X"');;
+Missing closing quotation mark.
+!error
+
+select cast(date"1985-12-09" as string format 'YYYY-MM-DD "X');;
+Missing closing quotation mark.
+!error
+
+# Format containing text token only.
+select cast("1985-11-29" as date format '" some text "');
+No datetime tokens provided.
+!error
+
+select cast(cast("1985-12-02" as date) as string format "\"free text\"");
+No datetime tokens provided.
+!error
+
+# FX modifier not at the begining of the format.
+select cast("2001-03-01 00:10:02" as timestamp format
+    "YYYY-MM-DD FXHH12:MI:SS");
+FX modifier should be at the beginning of the format string.
+!error
+
+select cast("2001-03-01 00:10:02" as timestamp format
+    "YYYY-MM-DD HH12:MI:SS FX");
+FX modifier should be at the beginning of the format string.
+!error
+
+select cast(date"2001-03-01" as string format "YYYYFX-MM-DD");
+FX modifier should be at the beginning of the format string.
+!error
+
+select cast(date"2001-03-02" as string format "FXFMFXYYYY-MM-DD");
+FX modifier should be at the beginning of the format string.
+!error
+
+select cast(date"2001-03-03" as string format "FXFXYYYY-MM-DD");
+FX modifier should be at the beginning of the format string.
+!error
+
+select cast(date"2001-03-04" as string format "FMFXYYYY-MM-DD");
+FX modifier should be at the beginning of the format string.
+!error
+
+select cast(date"2001-03-03" as string format "-FXYYYY-MM-DD");
+FX modifier should be at the beginning of the format string.
+!error
+
+select cast(date"2001-03-03" as string format '"text"FXYYYY-MM-DD');
+FX modifier should be at the beginning of the format string.
+!error
+
+!}
+
+# End cast-with-format.iq
diff --git a/core/src/test/resources/sql/conditions.iq b/core/src/test/resources/sql/conditions.iq
index 96a6bf4ebe1..1ef97e206aa 100644
--- a/core/src/test/resources/sql/conditions.iq
+++ b/core/src/test/resources/sql/conditions.iq
@@ -28,7 +28,6 @@ select *
   from tmp
  where a = 1 or b = 1
  order by 1, 2;
-
 +---+---+
 | A | B |
 +---+---+
@@ -50,7 +49,6 @@ select *
   from tmp
  where not (a = 1 or b = 1)
  order by 1, 2;
-
 +---+---+
 | A | B |
 +---+---+
@@ -70,7 +68,6 @@ select *
   from tmp
  where a = 1 AND b = 1
  order by 1, 2;
-
 +---+---+
 | A | B |
 +---+---+
@@ -88,7 +85,6 @@ select *
   from tmp
  where not (a = 1 AND b = 1)
  order by 1, 2;
-
 +---+---+
 | A | B |
 +---+---+
@@ -105,7 +101,6 @@ select *
 # Test cases for CALCITE-980
 
 select "value" from "nullables" a where "value" = 'A' or "value" = 'B' order by 1;
-
 +-------+
 | value |
 +-------+
@@ -117,7 +112,6 @@ select "value" from "nullables" a where "value" = 'A' or "value" = 'B' order by
 !ok
 
 select "value" from "nullables" a where not ("value" = 'A' or "value" = 'B') order by 1;
-
 +-------+
 | value |
 +-------+
@@ -128,7 +122,6 @@ select "value" from "nullables" a where not ("value" = 'A' or "value" = 'B') ord
 !ok
 
 select "value" from "nullables" a where not (not ("value" = 'A' or "value" = 'B')) order by 1;
-
 +-------+
 | value |
 +-------+
@@ -140,7 +133,6 @@ select "value" from "nullables" a where not (not ("value" = 'A' or "value" = 'B'
 !ok
 
 select "value" from "nullables" a where "value" = 'A' and "value" = 'B' order by 1;
-
 +-------+
 | value |
 +-------+
@@ -150,7 +142,6 @@ select "value" from "nullables" a where "value" = 'A' and "value" = 'B' order by
 !ok
 
 select "value" from "nullables" a where not ("value" = 'A' and "value" = 'B') order by 1;
-
 +-------+
 | value |
 +-------+
@@ -163,7 +154,6 @@ select "value" from "nullables" a where not ("value" = 'A' and "value" = 'B') or
 !ok
 
 select "value" from "nullables" a where not (not ("value" = 'A' and "value" = 'B')) order by 1;
-
 +-------+
 | value |
 +-------+
@@ -175,7 +165,6 @@ select "value" from "nullables" a where not (not ("value" = 'A' and "value" = 'B
 select "value" from "nullables" a
  where case when not ("value" = 'A' or "value" = 'B') then 1 else 0 end = 1
  order by 1;
-
 +-------+
 | value |
 +-------+
@@ -193,7 +182,6 @@ select "value" from "nullables" a
      else 0
    end = 2
  order by 1;
-
 +-------+
 | value |
 +-------+
@@ -211,7 +199,6 @@ select "value" from "nullables" a
      else 0
    end = 1 /* <- diff from above*/
  order by 1;
-
 +-------+
 | value |
 +-------+
@@ -229,7 +216,6 @@ select "value" from "nullables" a
      else 0
    end = 0 /* <- diff from above*/
  order by 1;
-
 +-------+
 | value |
 +-------+
@@ -249,7 +235,6 @@ select "value" from "nullables" a
      else 0
    end = 2 /* <- diff from above*/
  order by 1;
-
 +-------+
 | value |
 +-------+
@@ -273,7 +258,6 @@ from ax where ((s,t) in (('a','a'),(null, 'bb'))) is null;
 
 with ax(s) as (values (1),(0))
 select case when s=0 then false else 100/s > 0 end from ax;
-
 +--------+
 | EXPR$0 |
 +--------+
@@ -287,7 +271,6 @@ select case when s=0 then false else 100/s > 0 end from ax;
 # Test case for CALCITE-2783
 with ax(s) as (values (true),(false),(cast(null as boolean)))
 select s, (s or s is null), (s and s is not null) from ax;
-
 +-------+--------+--------+
 | S     | EXPR$1 | EXPR$2 |
 +-------+--------+--------+
@@ -422,7 +405,6 @@ EnumerableCalc(expr#0..2=[{inputs}], EMPNO=[$t0])
 select r.empno, s.deptno
 from emp as r
          left join dept as s on (select count(true) > 0 from emp) and s.deptno = r.deptno;
-
 +-------+--------+
 | EMPNO | DEPTNO |
 +-------+--------+
@@ -449,7 +431,6 @@ from emp as r
 select r.empno, s.deptno
 from emp as r
          left join dept as s on (select count(job) > 0 from bonus);
-
 +-------+--------+
 | EMPNO | DEPTNO |
 +-------+--------+
diff --git a/core/src/test/resources/sql/functions.iq b/core/src/test/resources/sql/functions.iq
index dbba1a895d0..9f5d6b02b19 100644
--- a/core/src/test/resources/sql/functions.iq
+++ b/core/src/test/resources/sql/functions.iq
@@ -56,7 +56,18 @@ SELECT ExtractValue('<a>c</a>', '//a');
 
 # STRING Functions
 
-#CONCAT
+# CHAR
+SELECT char(null), char(-1), char(65), char(233), char(256+66);
++--------+--------+--------+--------+--------+
+| EXPR$0 | EXPR$1 | EXPR$2 | EXPR$3 | EXPR$4 |
++--------+--------+--------+--------+--------+
+|        |        | A      | é      | B      |
++--------+--------+--------+--------+--------+
+(1 row)
+
+!ok
+
+# CONCAT
 SELECT CONCAT('c', 'h', 'a', 'r');
 +--------+
 | EXPR$0 |
@@ -115,7 +126,7 @@ select sinh(1);
 
 !ok
 
-#CONCAT
+# CONCAT
 select concat('a', 'b');
 +--------+
 | EXPR$0 |
@@ -196,7 +207,6 @@ select nvl("name", 'undefined') FROM "hr"."emps";
 EnumerableCalc(expr#0..4=[{inputs}], expr#5=[IS NOT NULL($t2)], expr#6=[CAST($t2):VARCHAR], expr#7=['undefined':VARCHAR], expr#8=[CASE($t5, $t6, $t7)], EXPR$0=[$t8])
   EnumerableTableScan(table=[[hr, emps]])
 !plan
-
 +-----------+
 | EXPR$0    |
 +-----------+
@@ -209,4 +219,88 @@ EnumerableCalc(expr#0..4=[{inputs}], expr#5=[IS NOT NULL($t2)], expr#6=[CAST($t2
 
 !ok
 
+# [CALCITE-5548] - Add support for MSSQL CONVERT function
+!use mssqlfunc
+select CONVERT(INTEGER, 45.4);
++--------+
+| EXPR$0 |
++--------+
+|     45 |
++--------+
+(1 row)
+
+!ok
+
+select CONVERT(INTEGER, 45.4, 121);
++--------+
+| EXPR$0 |
++--------+
+|     45 |
++--------+
+(1 row)
+
+!ok
+
+select CONVERT(FLOAT, '34.5');
++--------+
+| EXPR$0 |
++--------+
+|   34.5 |
++--------+
+(1 row)
+
+!ok
+
+select CONVERT(DATE, '2011-01-05');
++------------+
+| EXPR$0     |
++------------+
+| 2011-01-05 |
++------------+
+(1 row)
+
+!ok
+
+# style (3rd operand) ignored (for now)
+select CONVERT(DATE, '2011-01-05', 999);
++------------+
+| EXPR$0     |
++------------+
+| 2011-01-05 |
++------------+
+(1 row)
+
+!ok
+
+select CONVERT(INTEGER, 45.4, 121, 99999);
+parse failed: Encountered ","
+!error
+
+# since 'style' operand is ignored, usual behaviour of returning NULL with NULL style is not present
+select CONVERT(INTEGER, 5, NULL);
++--------+
+| EXPR$0 |
++--------+
+|      5 |
++--------+
+(1 row)
+
+!ok
+
+select CONVERT(INTEGER, NULL, NULL);
++--------+
+| EXPR$0 |
++--------+
+|        |
++--------+
+(1 row)
+
+!ok
+
+# below not executed due to huge stack trace quidem insists on generating
+# unsupported format test for documentation (dd/mm/yyyy) (need MSSQL "style" operand support in enumerable)
+# however CONVERT right now is simply a wrapper around CAST
+# select CONVERT(DATE, '05/01/2000', 103);
+
+
 # End functions.iq
diff --git a/core/src/test/resources/sql/join.iq b/core/src/test/resources/sql/join.iq
index cd8b36b9389..e68b26c30c5 100644
--- a/core/src/test/resources/sql/join.iq
+++ b/core/src/test/resources/sql/join.iq
@@ -18,6 +18,79 @@
 !use post
 !set outputformat mysql
 
+# Various combinations of comma and cross join
+with t (i) as (values (0), (1))
+select *
+from t as t1
+   cross join t as t2,
+ t as t3
+   cross join t as t4
+where t1.i + t2.i + t3.i + t4.i = 1;
++---+----+----+----+
+| I | I0 | I1 | I2 |
++---+----+----+----+
+| 0 |  0 |  0 |  1 |
+| 0 |  0 |  1 |  0 |
+| 0 |  1 |  0 |  0 |
+| 1 |  0 |  0 |  0 |
++---+----+----+----+
+(4 rows)
+
+!ok
+
+with t (i) as (values (0), (1))
+select *
+from t as t1
+   cross join t as t2,
+ t as t3
+where t1.i + t2.i + t3.i = 1;
++---+----+----+
+| I | I0 | I1 |
++---+----+----+
+| 0 |  0 |  1 |
+| 0 |  1 |  0 |
+| 1 |  0 |  0 |
++---+----+----+
+(3 rows)
+
+!ok
+
+with t (i) as (values (0), (1))
+select *
+from t as t1,
+ t as t2
+   cross join t as t3
+where t1.i + t2.i + t3.i = 1;
++---+----+----+
+| I | I0 | I1 |
++---+----+----+
+| 0 |  0 |  1 |
+| 0 |  1 |  0 |
+| 1 |  0 |  0 |
++---+----+----+
+(3 rows)
+
+!ok
+
+with t (i) as (values (0), (1))
+select *
+from t as t1
+ cross join t as t2
+ cross join t as t3
+ cross join t as t4
+where t1.i + t2.i + t3.i + t4.i = 1;
++---+----+----+----+
+| I | I0 | I1 | I2 |
++---+----+----+----+
+| 0 |  0 |  0 |  1 |
+| 0 |  0 |  1 |  0 |
+| 0 |  1 |  0 |  0 |
+| 1 |  0 |  0 |  0 |
++---+----+----+----+
+(4 rows)
+
+!ok
+
 # OR is a nestedLoop join
 select *
 from emp
@@ -69,8 +142,210 @@ EnumerableNestedLoopJoin(condition=[OR(=($1, $3), =(CAST($0):CHAR(11) NOT NULL,
   EnumerableValues(tuples=[[{ 10, 'Sales      ' }, { 20, 'Marketing  ' }, { 30, 'Engineering' }, { 40, 'Empty      ' }]])
 !plan
 
+!use foodmart
+# [CALCITE-35] Support parenthesized sub-clause in JOIN
+select
+   "product_class"."product_family" as "c0",
+   "product_class"."product_department" as "c1",
+   "customer"."country" as "c2",
+   "customer"."state_province" as "c3",
+   "customer"."city" as "c4"
+from
+   "sales_fact_1997" as "sales_fact_1997"
+join ("product" as "product"
+     join "product_class" as "product_class"
+     on "product"."product_class_id" = "product_class"."product_class_id")
+on  "sales_fact_1997"."product_id" = "product"."product_id"
+join "customer" as "customer"
+on  "sales_fact_1997"."customer_id" = "customer"."customer_id"
+join "promotion" as "promotion"
+on "sales_fact_1997"."promotion_id" = "promotion"."promotion_id"
+where ("promotion"."media_type" = 'Radio'
+ or "promotion"."media_type" = 'TV'
+ or "promotion"."media_type" = 'Sunday Paper'
+ or "promotion"."media_type" = 'Street Handout')
+ and ("product_class"."product_family" = 'Drink')
+ and ("customer"."country" = 'USA'
+   and "customer"."state_province" = 'WA'
+   and "customer"."city" = 'Bellingham')
+group by "product_class"."product_family",
+   "product_class"."product_department",
+   "customer"."country",
+   "customer"."state_province",
+   "customer"."city"
+order by "product_class"."product_family" asc nulls first,
+   "product_class"."product_department" asc nulls first,
+   "customer"."country" asc nulls first,
+   "customer"."state_province" asc nulls first,
+   "customer"."city" asc nulls first;
++-------+---------------------+-----+----+------------+
+| c0    | c1                  | c2  | c3 | c4         |
++-------+---------------------+-----+----+------------+
+| Drink | Alcoholic Beverages | USA | WA | Bellingham |
+| Drink | Dairy               | USA | WA | Bellingham |
++-------+---------------------+-----+----+------------+
+(2 rows)
+
+!ok
+
 !use scott
 
+# [CALCITE-35] Support parenthesized sub-clause in JOIN
+with clerk as (select * from emp where job = 'CLERK')
+select e.ename, d.dname, c.ename
+from dept as d
+ left join (emp as e
+   left join clerk as c using (empno))
+ on d.deptno = e.deptno;
++--------+------------+--------+
+| ENAME  | DNAME      | ENAME  |
++--------+------------+--------+
+| ADAMS  | RESEARCH   | ADAMS  |
+| ALLEN  | SALES      |        |
+| BLAKE  | SALES      |        |
+| CLARK  | ACCOUNTING |        |
+| FORD   | RESEARCH   |        |
+| JAMES  | SALES      | JAMES  |
+| JONES  | RESEARCH   |        |
+| KING   | ACCOUNTING |        |
+| MARTIN | SALES      |        |
+| MILLER | ACCOUNTING | MILLER |
+| SCOTT  | RESEARCH   |        |
+| SMITH  | RESEARCH   | SMITH  |
+| TURNER | SALES      |        |
+| WARD   | SALES      |        |
+|        | OPERATIONS |        |
++--------+------------+--------+
+(15 rows)
+
+!ok
+
+# Similar to previous; should be invalid because emp-join-clerk
+# returns duplicate "deptno" columns but Calcite currently allows it.
+with clerk as (select * from emp where job = 'CLERK')
+select e.ename, d.dname, c.ename
+from dept as d
+ natural left join (emp as e
+ left join clerk as c using (empno));
+Column name 'DEPTNO' in NATURAL join or USING clause is not unique on one side of join
+!error
+
+with clerk as (select * from emp where job = 'CLERK')
+select e.ename, d.dname, c.ename
+from dept as d
+ natural left join emp as e
+ left join clerk as c using (empno);
++--------+------------+--------+
+| ENAME  | DNAME      | ENAME  |
++--------+------------+--------+
+| ADAMS  | RESEARCH   | ADAMS  |
+| ALLEN  | SALES      |        |
+| BLAKE  | SALES      |        |
+| CLARK  | ACCOUNTING |        |
+| FORD   | RESEARCH   |        |
+| JAMES  | SALES      | JAMES  |
+| JONES  | RESEARCH   |        |
+| KING   | ACCOUNTING |        |
+| MARTIN | SALES      |        |
+| MILLER | ACCOUNTING | MILLER |
+| SCOTT  | RESEARCH   |        |
+| SMITH  | RESEARCH   | SMITH  |
+| TURNER | SALES      |        |
+| WARD   | SALES      |        |
+|        | OPERATIONS |        |
++--------+------------+--------+
+(15 rows)
+
+!ok
+
+# Without parentheses (i.e joining b to d, then (b-d) to e),
+# query would be invalid
+select d.dname, b.ename, b.job, e.job, e.ename
+from dept as d
+join (bonus as b
+  right join emp as e
+  on b.job = e.job)
+on d.deptno = e.deptno;
++------------+-------+-----+-----------+--------+
+| DNAME      | ENAME | JOB | JOB       | ENAME  |
++------------+-------+-----+-----------+--------+
+| ACCOUNTING |       |     | CLERK     | MILLER |
+| ACCOUNTING |       |     | MANAGER   | CLARK  |
+| ACCOUNTING |       |     | PRESIDENT | KING   |
+| RESEARCH   |       |     | ANALYST   | FORD   |
+| RESEARCH   |       |     | ANALYST   | SCOTT  |
+| RESEARCH   |       |     | CLERK     | ADAMS  |
+| RESEARCH   |       |     | CLERK     | SMITH  |
+| RESEARCH   |       |     | MANAGER   | JONES  |
+| SALES      |       |     | CLERK     | JAMES  |
+| SALES      |       |     | MANAGER   | BLAKE  |
+| SALES      |       |     | SALESMAN  | ALLEN  |
+| SALES      |       |     | SALESMAN  | MARTIN |
+| SALES      |       |     | SALESMAN  | TURNER |
+| SALES      |       |     | SALESMAN  | WARD   |
++------------+-------+-----+-----------+--------+
+(14 rows)
+
+!ok
+
+# As previous, but CROSS JOIN;
+# empty only because "bonus" is empty.
+select d.dname, b.ename, b.job, e.job, e.ename
+from dept as d
+cross join (bonus as b
+  cross join emp as e);
++-------+-------+-----+-----+-------+
+| DNAME | ENAME | JOB | JOB | ENAME |
++-------+-------+-----+-----+-------+
++-------+-------+-----+-----+-------+
+(0 rows)
+
+!ok
+
+# Join plus TABLE
+select e.ename, d.dname
+from emp as e
+natural join (table dept) as d;
++--------+------------+
+| ENAME  | DNAME      |
++--------+------------+
+| ADAMS  | RESEARCH   |
+| ALLEN  | SALES      |
+| BLAKE  | SALES      |
+| CLARK  | ACCOUNTING |
+| FORD   | RESEARCH   |
+| JAMES  | SALES      |
+| JONES  | RESEARCH   |
+| KING   | ACCOUNTING |
+| MARTIN | SALES      |
+| MILLER | ACCOUNTING |
+| SCOTT  | RESEARCH   |
+| SMITH  | RESEARCH   |
+| TURNER | SALES      |
+| WARD   | SALES      |
++--------+------------+
+(14 rows)
+
+!ok
+
+# Join plus INTERSECT and TABLE
+with clerk as (select * from emp where job = 'CLERK'),
+  ancient as (select * from emp where hiredate < '1982-01-01')
+select d.deptno, e.ename
+from (table dept) as d
+natural join (select * from clerk
+  intersect
+  select * from ancient) as e;
++--------+-------+
+| DEPTNO | ENAME |
++--------+-------+
+|     20 | SMITH |
+|     30 | JAMES |
++--------+-------+
+(2 rows)
+
+!ok
+
 # Full join with USING
 select *
 from (select * from emp where deptno <> 10) as e
diff --git a/core/src/test/resources/sql/match.iq b/core/src/test/resources/sql/match.iq
old mode 100755
new mode 100644
index 3df375310ea..887c781c15e
--- a/core/src/test/resources/sql/match.iq
+++ b/core/src/test/resources/sql/match.iq
@@ -102,7 +102,6 @@ from "hr"."emps" match_recognize (
     "empid" as empid
     pattern (s up)
     define up as up."commission" < prev(up."commission"));
-
 C    EMPID
 ---- -----
 1000   100
@@ -119,7 +118,6 @@ from "hr"."emps" match_recognize (
     CLASSIFIER() as cl
     pattern (s up)
     define up as up."commission" < prev(up."commission"));
-
 C    EMPID CL
 ---- ----- --
 1000   100 S
@@ -135,7 +133,6 @@ from "hr"."emps" match_recognize (
     LAST("empid") as empid
     pattern (s up)
     define up as up."commission" < prev(up."commission"));
-
 C    EMPID
 ---- -----
 1000   100
@@ -152,7 +149,6 @@ from "hr"."emps" match_recognize (
     LAST(S."empid") as empid
     pattern (s up)
     define up as up."commission" < prev(up."commission"));
-
 C    CL EMPID
 ---- -- -----
 1000 S    100
diff --git a/appveyor.yml b/core/src/test/resources/sql/measure.iq
similarity index 50%
rename from appveyor.yml
rename to core/src/test/resources/sql/measure.iq
index 206abeebc49..6ba46a76ca8 100644
--- a/appveyor.yml
+++ b/core/src/test/resources/sql/measure.iq
@@ -1,3 +1,4 @@
+# measure.iq - measure expressions
 #
 # Licensed to the Apache Software Foundation (ASF) under one or more
 # contributor license agreements.  See the NOTICE file distributed with
@@ -14,32 +15,30 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+!set outputformat mysql
+!use scott
 
-# Configuration file for Appveyor continuous integration.
-version: '{build}'
-image: Visual Studio 2019
-clone_depth: 100
-# Space and plus are here to catch unit tests that fail to support folders with spaces
-clone_folder: C:\projects\calcite +
-# branches to build
-init:
-# We expect that Windows would have CRLF for newlines, so autocrlf=true should be used
-# to automatically convert text files to CRLF on checkout
-  - git config --global core.autocrlf true
-branches:
-  # whitelist
-  only:
-    - main
-    - javadoc
-    - /^branch-.*$/
-    - /^[0-9]+-.*$/
-matrix:
-  fast_finish: true
-environment:
-  matrix:
-    - JAVA_HOME: C:\Program Files\Java\jdk1.8.0
-    - JAVA_HOME: C:\Program Files\Java\jdk16
-build_script:
-  - ./gradlew assemble javadoc
-test_script:
-  - ./gradlew check
+!if (false) {
+
+# Measure that references another measure
+select *
+from (
+  select deptno,
+    empno + 1 as measure e1,
+    e1 + deptno as measure e2
+  from "scott".emp
+  where deptno = 10);
++--------+------+------+
+| DEPTNO | E1   | E2   |
++--------+------+------+
+|     10 | 7783 | 7793 |
+|     10 | 7840 | 7850 |
+|     10 | 7935 | 7945 |
++--------+------+------+
+(3 rows)
+
+!ok
+
+!}
+
+# End measure.iq
diff --git a/core/src/test/resources/sql/misc.iq b/core/src/test/resources/sql/misc.iq
index 6800f6ea068..64554c05569 100644
--- a/core/src/test/resources/sql/misc.iq
+++ b/core/src/test/resources/sql/misc.iq
@@ -177,7 +177,6 @@ with data(c_row, c_timestamp) as (select * from (values
     (22, TIMESTAMP '1996-02-29 17:32:01'),
     (23, TIMESTAMP '1996-03-01 17:32:01')))
 select cast(c_timestamp as varchar(20)), cast(c_timestamp as date) from data where c_row <> 12;
-
 +---------------------+------------+
 | EXPR$0              | EXPR$1     |
 +---------------------+------------+
@@ -365,10 +364,9 @@ EnumerableCalc(expr#0..1=[{inputs}], deptno=[$t0])
   EnumerableNestedLoopJoin(condition=[true], joinType=[inner])
     EnumerableCalc(expr#0..3=[{inputs}], deptno=[$t0])
       EnumerableTableScan(table=[[hr, depts]])
-    EnumerableCalc(expr#0=[{inputs}], expr#1=[IS NOT NULL($t0)], $f0=[$t0], $condition=[$t1])
-      EnumerableAggregate(group=[{}], agg#0=[MIN($0)])
-        EnumerableCalc(expr#0..4=[{inputs}], expr#5=[true], $f0=[$t5])
-          EnumerableTableScan(table=[[hr, emps]])
+    EnumerableAggregate(group=[{0}])
+      EnumerableCalc(expr#0..4=[{inputs}], expr#5=[true], i=[$t5])
+        EnumerableTableScan(table=[[hr, emps]])
 !plan
 
 # Un-correlated NOT EXISTS
@@ -385,8 +383,8 @@ EnumerableCalc(expr#0..1=[{inputs}], expr#2=[IS NULL($t1)], deptno=[$t0], $condi
   EnumerableNestedLoopJoin(condition=[true], joinType=[left])
     EnumerableCalc(expr#0..3=[{inputs}], deptno=[$t0])
       EnumerableTableScan(table=[[hr, depts]])
-    EnumerableAggregate(group=[{}], agg#0=[MIN($0)])
-      EnumerableCalc(expr#0..4=[{inputs}], expr#5=[true], $f0=[$t5])
+    EnumerableAggregate(group=[{0}])
+      EnumerableCalc(expr#0..4=[{inputs}], expr#5=[true], i=[$t5])
         EnumerableTableScan(table=[[hr, emps]])
 !plan
 
@@ -404,10 +402,9 @@ EnumerableCalc(expr#0..1=[{inputs}], deptno=[$t0])
   EnumerableNestedLoopJoin(condition=[true], joinType=[inner])
     EnumerableCalc(expr#0..3=[{inputs}], deptno=[$t0])
       EnumerableTableScan(table=[[hr, depts]])
-    EnumerableCalc(expr#0=[{inputs}], expr#1=[IS NOT NULL($t0)], $f0=[$t0], $condition=[$t1])
-      EnumerableAggregate(group=[{}], agg#0=[MIN($0)])
-        EnumerableCalc(expr#0..4=[{inputs}], expr#5=[true], expr#6=[0], expr#7=[<($t0, $t6)], $f0=[$t5], $condition=[$t7])
-          EnumerableTableScan(table=[[hr, emps]])
+    EnumerableAggregate(group=[{0}])
+      EnumerableCalc(expr#0..4=[{inputs}], expr#5=[true], expr#6=[0], expr#7=[<($t0, $t6)], i=[$t5], $condition=[$t7])
+        EnumerableTableScan(table=[[hr, emps]])
 !plan
 
 # Un-correlated NOT EXISTS (table empty)
@@ -427,8 +424,8 @@ EnumerableCalc(expr#0..1=[{inputs}], expr#2=[IS NULL($t1)], deptno=[$t0], $condi
   EnumerableNestedLoopJoin(condition=[true], joinType=[left])
     EnumerableCalc(expr#0..3=[{inputs}], deptno=[$t0])
       EnumerableTableScan(table=[[hr, depts]])
-    EnumerableAggregate(group=[{}], agg#0=[MIN($0)])
-      EnumerableCalc(expr#0..4=[{inputs}], expr#5=[true], expr#6=[0], expr#7=[<($t0, $t6)], $f0=[$t5], $condition=[$t7])
+    EnumerableAggregate(group=[{0}])
+      EnumerableCalc(expr#0..4=[{inputs}], expr#5=[true], expr#6=[0], expr#7=[<($t0, $t6)], i=[$t5], $condition=[$t7])
         EnumerableTableScan(table=[[hr, emps]])
 !plan
 
@@ -469,8 +466,8 @@ EnumerableCalc(expr#0..6=[{inputs}], expr#7=[IS NULL($t6)], proj#0..4=[{exprs}],
     EnumerableSort(sort0=[$1], dir0=[ASC])
       EnumerableTableScan(table=[[hr, emps]])
     EnumerableSort(sort0=[$0], dir0=[ASC])
-      EnumerableAggregate(group=[{0}], agg#0=[MIN($1)])
-        EnumerableCalc(expr#0..3=[{inputs}], expr#4=[true], deptno=[$t0], $f0=[$t4])
+      EnumerableCalc(expr#0=[{inputs}], expr#1=[true], proj#0..1=[{exprs}])
+        EnumerableAggregate(group=[{0}])
           EnumerableTableScan(table=[[hr, depts]])
 !plan
 
@@ -481,7 +478,6 @@ where not exists (
   select 1 from "hr"."depts" where "depts"."deptno" = "emps"."deptno")
 or not exists (
   select 1 from "hr"."depts" where "depts"."deptno" + 90 = "emps"."empid");
-
 +-------+--------+-----------+---------+------------+
 | empid | deptno | name      | salary  | commission |
 +-------+--------+-----------+---------+------------+
@@ -495,18 +491,19 @@ or not exists (
 EnumerableCalc(expr#0..8=[{inputs}], expr#9=[IS NULL($t5)], expr#10=[IS NULL($t8)], expr#11=[OR($t9, $t10)], proj#0..4=[{exprs}], $condition=[$t11])
   EnumerableMergeJoin(condition=[=($6, $7)], joinType=[left])
     EnumerableSort(sort0=[$6], dir0=[ASC])
-      EnumerableCalc(expr#0..6=[{inputs}], expr#7=[CAST($t0):INTEGER NOT NULL], proj#0..4=[{exprs}], $f0=[$t6], empid0=[$t7])
+      EnumerableCalc(expr#0..6=[{inputs}], expr#7=[CAST($t0):INTEGER NOT NULL], proj#0..4=[{exprs}], i=[$t6], empid0=[$t7])
         EnumerableMergeJoin(condition=[=($1, $5)], joinType=[left])
           EnumerableSort(sort0=[$1], dir0=[ASC])
             EnumerableTableScan(table=[[hr, emps]])
           EnumerableSort(sort0=[$0], dir0=[ASC])
-            EnumerableAggregate(group=[{0}], agg#0=[MIN($1)])
-              EnumerableCalc(expr#0..3=[{inputs}], expr#4=[true], deptno=[$t0], $f0=[$t4])
+            EnumerableCalc(expr#0=[{inputs}], expr#1=[true], proj#0..1=[{exprs}])
+              EnumerableAggregate(group=[{0}])
                 EnumerableTableScan(table=[[hr, depts]])
     EnumerableSort(sort0=[$0], dir0=[ASC])
-      EnumerableAggregate(group=[{0}], agg#0=[MIN($1)])
-        EnumerableCalc(expr#0..3=[{inputs}], expr#4=[90], expr#5=[+($t0, $t4)], expr#6=[true], $f4=[$t5], $f0=[$t6])
-          EnumerableTableScan(table=[[hr, depts]])
+      EnumerableCalc(expr#0=[{inputs}], expr#1=[true], proj#0..1=[{exprs}])
+        EnumerableAggregate(group=[{0}])
+          EnumerableCalc(expr#0..3=[{inputs}], expr#4=[90], expr#5=[+($t0, $t4)], $f4=[$t5])
+            EnumerableTableScan(table=[[hr, depts]])
 !plan
 
 # Left join to a relation with one row is recognized as a trivial semi-join
@@ -1065,6 +1062,24 @@ Expression 'DEPTNO' is not being grouped
 
 !use scott
 
+# In Quidem's "scott" schema, we allow CREATE VIEW
+create view v as
+  select * from (values (1, 'a'), (2, 'b')) as t (x, y);
+(0 rows modified)
+
+!update
+
+select count(*) as c
+from v;
++---+
+| C |
++---+
+| 2 |
++---+
+(1 row)
+
+!ok
+
 # ORDER BY expression with SELECT DISTINCT
 select distinct deptno, job
 from "scott".emp
@@ -1246,7 +1261,6 @@ select * from "scott".emp where empno between '7500' and '07600';
 # BETWEEN follows the PostgreSQL style to coerce STRING operand to type of the other
 # NUMERIC operands, see TypeCoercionImpl#commonTypeForBinaryComparison.
 select * from "scott".emp where deptno between '7369' and '7876';
-
 Caused by: java.lang.NumberFormatException: Value out of range. Value:"7369" Radix:10
 !error
 
@@ -2100,6 +2114,17 @@ select
 
 !ok
 
+# TIMESTAMPDIFF with 'flag' literal as time unit argument
+SELECT TIMESTAMPDIFF(quarter, TIMESTAMP '2008-12-25', TIMESTAMP '2008-09-25');
++--------+
+| EXPR$0 |
++--------+
+|     -1 |
++--------+
+(1 row)
+
+! ok
+
 # ARRAY and MULTISET
 select array[1,2] as a from (values (1));
 +--------+
@@ -2280,7 +2305,6 @@ with data(c_date, c_timestamp) as (select * from (values
     (DATE'2019-06-28', TIMESTAMP '2019-06-28 17:32:01'),
     (DATE'2019-12-12', TIMESTAMP '2019-12-12 12:12:01')))
 select last_day(c_date), last_day(c_timestamp) from data;
-
 EXPR$0, EXPR$1
 1965-01-31, 1965-01-31
 2019-01-31, 2019-01-31
@@ -2343,4 +2367,18 @@ null
 14
 !ok
 
+# TIMESTAMP literals without a time part are OK.
+SELECT TIMESTAMP '1969-07-20' AS ts;
+TS
+1969-07-20 00:00:00
+!ok
+
+# Short TIMESTAMP literals are equivalent to long TIMESTAMP literals
+SELECT TIMESTAMP '1969-07-20' + i AS ts
+FROM (VALUES (INTERVAL '1' DAY)) AS t (i)
+GROUP BY TIMESTAMP '1969-07-20 00:00:00' + i;
+TS
+1969-07-21 00:00:00
+!ok
+
 # End misc.iq
diff --git a/core/src/test/resources/sql/operator.iq b/core/src/test/resources/sql/operator.iq
index c9b5fd8e1f4..9fe31a46329 100644
--- a/core/src/test/resources/sql/operator.iq
+++ b/core/src/test/resources/sql/operator.iq
@@ -66,6 +66,17 @@ select * from "scott".emp where not sal > 1300 and not sal < 1200;
 
 !ok
 
+# [CALCITE-5531] COALESCE throws ClassCastException
+SELECT COALESCE(DATE '2021-07-08', DATE '2020-01-01') as d;
++------------+
+| D          |
++------------+
+| 2021-07-08 |
++------------+
+(1 row)
+
+!ok
+
 # MULTISET EXCEPT
 values multiset ['a', 'c', 'a'] multiset except multiset ['a'];
 +--------+
diff --git a/core/src/test/resources/sql/pivot.iq b/core/src/test/resources/sql/pivot.iq
old mode 100755
new mode 100644
index 6d2b88e695c..ac576f88af7
--- a/core/src/test/resources/sql/pivot.iq
+++ b/core/src/test/resources/sql/pivot.iq
@@ -394,7 +394,6 @@ UNPIVOT (
   IN ((c10_ss, c10_c) AS ('CLERK', 10),
       (c20_ss, c20_c) AS ('CLERK', 20),
       (a20_ss, a20_c) AS ('ANALYST', 20)));
-
 +--------+---------+--------+---------+------------+
 | GENDER | JOB     | DEPTNO | SUM_SAL | COUNT_STAR |
 +--------+---------+--------+---------+------------+
@@ -501,7 +500,6 @@ UNPIVOT INCLUDE NULLS (
       (c20_ss) AS ('CLERK', 20),
       (c20_ss) AS ('CLERK', 20),
       (c10_ss) AS ('ANALYST', 20)));
-
 +--------+-------+-------+---------+-------+---------+--------+---------+
 | GENDER | C10_C | C20_C | A20_SS  | A20_C | JOB     | DEPTNO | SUM_SAL |
 +--------+-------+-------+---------+-------+---------+--------+---------+
@@ -538,7 +536,6 @@ UNPIVOT (
       (c20_ss) AS ('CLERK', 20),
       (c20_ss) AS ('CLERK', 20),
       (c10_ss) AS ('ANALYST', 20)));
-
 +--------+-------+-------+---------+-------+---------+--------+---------+
 | GENDER | C10_C | C20_C | A20_SS  | A20_C | JOB     | DEPTNO | SUM_SAL |
 +--------+-------+-------+---------+-------+---------+--------+---------+
@@ -709,7 +706,6 @@ UNPIVOT ((m0, m1, m2)
     FOR (a0, a1)
      IN ((c1, c2, c3) as ('col1','col2'),
          (c2, c3, c4)));
-
 +----+----------+----------+----+----+----+
 | C0 | A0       | A1       | M0 | M1 | M2 |
 +----+----------+----------+----+----+----+
diff --git a/core/src/test/resources/sql/qualify.iq b/core/src/test/resources/sql/qualify.iq
new file mode 100644
index 00000000000..47417a4a964
--- /dev/null
+++ b/core/src/test/resources/sql/qualify.iq
@@ -0,0 +1,99 @@
+# qualify.iq - QUALIFY clause
+#
+# 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.
+#
+!set outputformat oracle
+!use scott
+
+# Test QUALIFY without any references
+SELECT empno, ename, deptno
+FROM "scott".emp
+QUALIFY ROW_NUMBER() over (partition by ename order by deptno) = 1;
+EMPNO ENAME  DEPTNO
+----- ------ ------
+ 7369 SMITH      20
+ 7499 ALLEN      30
+ 7521 WARD       30
+ 7566 JONES      20
+ 7654 MARTIN     30
+ 7698 BLAKE      30
+ 7782 CLARK      10
+ 7788 SCOTT      20
+ 7839 KING       10
+ 7844 TURNER     30
+ 7876 ADAMS      20
+ 7900 JAMES      30
+ 7902 FORD       20
+ 7934 MILLER     10
+
+14 rows selected.
+
+!ok
+
+# Test QUALIFY without any references but with regular filter
+SELECT empno, ename, deptno
+FROM "scott".emp
+WHERE deptno > 20
+QUALIFY ROW_NUMBER() over (partition by ename order by deptno) = 1;
+EMPNO ENAME  DEPTNO
+----- ------ ------
+ 7499 ALLEN      30
+ 7521 WARD       30
+ 7654 MARTIN     30
+ 7698 BLAKE      30
+ 7844 TURNER     30
+ 7900 JAMES      30
+
+6 rows selected.
+
+!ok
+
+# Test QUALIFY with references
+SELECT empno, ename, deptno, ROW_NUMBER() over (partition by ename order by deptno) as row_num
+FROM "scott".emp
+QUALIFY row_num = 1;
+EMPNO ENAME  DEPTNO ROW_NUM
+----- ------ ------ -------
+ 7369 SMITH      20       1
+ 7499 ALLEN      30       1
+ 7521 WARD       30       1
+ 7566 JONES      20       1
+ 7654 MARTIN     30       1
+ 7698 BLAKE      30       1
+ 7782 CLARK      10       1
+ 7788 SCOTT      20       1
+ 7839 KING       10       1
+ 7844 TURNER     30       1
+ 7876 ADAMS      20       1
+ 7900 JAMES      30       1
+ 7902 FORD       20       1
+ 7934 MILLER     10       1
+
+14 rows selected.
+
+!ok
+
+# Test QUALIFY with WINDOW clause
+SELECT empno, ename, deptno, SUM(deptno) OVER myWindow as sumDeptNo
+FROM "scott".emp
+WINDOW myWindow AS (PARTITION BY ename ORDER BY empno)
+QUALIFY sumDeptNo = 1;
+
+no rows selected
+
+!ok
+
+# End qualify.iq
diff --git a/core/src/test/resources/sql/set-op.iq b/core/src/test/resources/sql/set-op.iq
index bdcabe2dd93..c5e277fe9d6 100644
--- a/core/src/test/resources/sql/set-op.iq
+++ b/core/src/test/resources/sql/set-op.iq
@@ -54,7 +54,6 @@ select * from
 intersect all
 (select x, y from (values (cast(NULL as int), cast(NULL as varchar(1))),
   (cast(NULL as int), cast(NULL as varchar(1)))) as t2(x, y));
-
 +---+---+
 | X | Y |
 +---+---+
@@ -72,7 +71,6 @@ select * from
 intersect
 (select x, y from (values (cast(NULL as int), cast(NULL as varchar(1))),
   (cast(NULL as int), cast(NULL as varchar(1)))) as t2(x, y));
-
 +---+---+
 | X | Y |
 +---+---+
@@ -195,7 +193,6 @@ select * from
 except all
 (select x, y from (values (cast(NULL as int), cast(NULL as varchar(1))),
   (cast(NULL as int), cast(NULL as varchar(1)))) as t2(x, y));
-
 +---+---+
 | X | Y |
 +---+---+
@@ -212,7 +209,6 @@ select * from
 except
 (select x, y from (values (cast(NULL as int), cast(NULL as varchar(1))),
   (cast(NULL as int), cast(NULL as varchar(1)))) as t2(x, y));
-
 +---+---+
 | X | Y |
 +---+---+
@@ -220,3 +216,33 @@ except
 (0 rows)
 
 !ok
+
+!use scott
+
+# Parentheses at top level
+(select * from emp where deptno = 10
+ union all
+ select * from emp where job = 'CLERK')
+intersect
+select * from emp where job = 'CLERK';
++-------+--------+-------+------+------------+---------+------+--------+
+| EMPNO | ENAME  | JOB   | MGR  | HIREDATE   | SAL     | COMM | DEPTNO |
++-------+--------+-------+------+------------+---------+------+--------+
+|  7369 | SMITH  | CLERK | 7902 | 1980-12-17 |  800.00 |      |     20 |
+|  7876 | ADAMS  | CLERK | 7788 | 1987-05-23 | 1100.00 |      |     20 |
+|  7900 | JAMES  | CLERK | 7698 | 1981-12-03 |  950.00 |      |     30 |
+|  7934 | MILLER | CLERK | 7782 | 1982-01-23 | 1300.00 |      |     10 |
++-------+--------+-------+------+------------+---------+------+--------+
+(4 rows)
+
+!ok
+
+# Join at top level is illegal
+# (Postgres doesn't allow it either)
+(emp natural join dept)
+intersect
+select * from emp natural join dept where job = 'CLERK';
+Non-query expression encountered in illegal context
+!error
+
+# End set-op.iq
diff --git a/core/src/test/resources/sql/some.iq b/core/src/test/resources/sql/some.iq
index e0f14bb43d7..3c1638b3741 100644
--- a/core/src/test/resources/sql/some.iq
+++ b/core/src/test/resources/sql/some.iq
@@ -16,7 +16,6 @@
 # limitations under the License.
 #
 !use scott
-!set expand false
 !set outputformat mysql
 
 # =ANY
@@ -47,7 +46,6 @@ where empno = any (select empno from "scott".emp);
 # Both sides NOT NULL
 select * from "scott".emp
 where empno > any (select deptno from "scott".dept);
-
 +-------+--------+-----------+------+------------+---------+---------+--------+
 | EMPNO | ENAME  | JOB       | MGR  | HIREDATE   | SAL     | COMM    | DEPTNO |
 +-------+--------+-----------+------+------------+---------+---------+--------+
@@ -73,7 +71,6 @@ where empno > any (select deptno from "scott".dept);
 # ANY; left side NOT NULL, right side nullable.
 select * from "scott".emp
 where sal > any (select comm from "scott".emp);
-
 +-------+--------+-----------+------+------------+---------+---------+--------+
 | EMPNO | ENAME  | JOB       | MGR  | HIREDATE   | SAL     | COMM    | DEPTNO |
 +-------+--------+-----------+------+------------+---------+---------+--------+
@@ -99,7 +96,6 @@ where sal > any (select comm from "scott".emp);
 # ALL; left side NOT NULL, right side nullable.
 select * from "scott".emp
 where sal > all (select comm from "scott".emp);
-
 +-------+-------+-----+-----+----------+-----+------+--------+
 | EMPNO | ENAME | JOB | MGR | HIREDATE | SAL | COMM | DEPTNO |
 +-------+-------+-----+-----+----------+-----+------+--------+
@@ -111,7 +107,6 @@ where sal > all (select comm from "scott".emp);
 # Previous, as scalar sub-query
 select *, sal > all (select comm from "scott".emp) as x
 from "scott".emp;
-
 +-------+--------+-----------+------+------------+---------+---------+--------+-------+
 | EMPNO | ENAME  | JOB       | MGR  | HIREDATE   | SAL     | COMM    | DEPTNO | X     |
 +-------+--------+-----------+------+------------+---------+---------+--------+-------+
@@ -143,7 +138,6 @@ EnumerableCalc(expr#0..10=[{inputs}], expr#11=[0], expr#12=[=($t9, $t11)], expr#
 # NOT SOME; left side NOT NULL, right side nullable; converse of previous query.
 select * from "scott".emp
 where not sal <= some (select comm from "scott".emp);
-
 +-------+-------+-----+-----+----------+-----+------+--------+
 | EMPNO | ENAME | JOB | MGR | HIREDATE | SAL | COMM | DEPTNO |
 +-------+-------+-----+-----+----------+-----+------+--------+
@@ -155,7 +149,6 @@ where not sal <= some (select comm from "scott".emp);
 # Similar, as scalar sub-query.
 select *, sal <= some (select comm from "scott".emp) as x
 from "scott".emp;
-
 +-------+--------+-----------+------+------------+---------+---------+--------+------+
 | EMPNO | ENAME  | JOB       | MGR  | HIREDATE   | SAL     | COMM    | DEPTNO | X    |
 +-------+--------+-----------+------+------------+---------+---------+--------+------+
@@ -183,7 +176,6 @@ from "scott".emp;
 select *
 from "scott".emp
 where empno <> some (values (100), (200));
-
 +-------+--------+-----------+------+------------+---------+---------+--------+
 | EMPNO | ENAME  | JOB       | MGR  | HIREDATE   | SAL     | COMM    | DEPTNO |
 +-------+--------+-----------+------+------------+---------+---------+--------+
@@ -209,7 +201,6 @@ where empno <> some (values (100), (200));
 # Previous, as scalar sub-query.
 select *, empno <> some (values (100), (200)) as x
 from "scott".emp;
-
 +-------+--------+-----------+------+------------+---------+---------+--------+------+
 | EMPNO | ENAME  | JOB       | MGR  | HIREDATE   | SAL     | COMM    | DEPTNO | X    |
 +-------+--------+-----------+------+------------+---------+---------+--------+------+
@@ -236,7 +227,6 @@ from "scott".emp;
 select *
 from "scott".emp
 where empno <> some (values (7499),(NULL));
-
 +-------+--------+-----------+------+------------+---------+---------+--------+
 | EMPNO | ENAME  | JOB       | MGR  | HIREDATE   | SAL     | COMM    | DEPTNO |
 +-------+--------+-----------+------+------------+---------+---------+--------+
@@ -261,7 +251,6 @@ where empno <> some (values (7499),(NULL));
 # Previous, as scalar sub-query.
 select *, empno <> some (values (7499), (NULL)) as x
 from "scott".emp;
-
 +-------+--------+-----------+------+------------+---------+---------+--------+------+
 | EMPNO | ENAME  | JOB       | MGR  | HIREDATE   | SAL     | COMM    | DEPTNO | X    |
 +-------+--------+-----------+------+------------+---------+---------+--------+------+
@@ -288,7 +277,6 @@ from "scott".emp;
 select *
 from "scott".emp
 where empno <> some (select empno from "scott".emp where empno = 8000);
-
 +-------+-------+-----+-----+----------+-----+------+--------+
 | EMPNO | ENAME | JOB | MGR | HIREDATE | SAL | COMM | DEPTNO |
 +-------+-------+-----+-----+----------+-----+------+--------+
@@ -300,7 +288,6 @@ where empno <> some (select empno from "scott".emp where empno = 8000);
 # Previous, as scalar sub-query.
 select *, empno <> some (select empno from "scott".emp where empno = 8000) as x
 from "scott".emp;
-
 +-------+--------+-----------+------+------------+---------+---------+--------+-------+
 | EMPNO | ENAME  | JOB       | MGR  | HIREDATE   | SAL     | COMM    | DEPTNO | X     |
 +-------+--------+-----------+------+------------+---------+---------+--------+-------+
@@ -327,7 +314,6 @@ from "scott".emp;
 select *
 from "scott".emp
 where emp.comm <> some (values (300), (500));
-
 +-------+--------+----------+------+------------+---------+---------+--------+
 | EMPNO | ENAME  | JOB      | MGR  | HIREDATE   | SAL     | COMM    | DEPTNO |
 +-------+--------+----------+------+------------+---------+---------+--------+
@@ -343,7 +329,6 @@ where emp.comm <> some (values (300), (500));
 # Previous, as scalar sub-query.
 select *, emp.comm <> some (values (300), (500)) as x
 from "scott".emp;
-
 +-------+--------+-----------+------+------------+---------+---------+--------+------+
 | EMPNO | ENAME  | JOB       | MGR  | HIREDATE   | SAL     | COMM    | DEPTNO | X    |
 +-------+--------+-----------+------+------------+---------+---------+--------+------+
@@ -370,7 +355,6 @@ from "scott".emp;
 select *
 from "scott".emp
 where emp.comm <> some (select comm from "scott".emp);
-
 +-------+--------+----------+------+------------+---------+---------+--------+
 | EMPNO | ENAME  | JOB      | MGR  | HIREDATE   | SAL     | COMM    | DEPTNO |
 +-------+--------+----------+------+------------+---------+---------+--------+
@@ -386,7 +370,6 @@ where emp.comm <> some (select comm from "scott".emp);
 # Previous, as scalar sub-query.
 select *, emp.comm <> some (select comm from "scott".emp) as x
 from "scott".emp;
-
 +-------+--------+-----------+------+------------+---------+---------+--------+------+
 | EMPNO | ENAME  | JOB       | MGR  | HIREDATE   | SAL     | COMM    | DEPTNO | X    |
 +-------+--------+-----------+------+------------+---------+---------+--------+------+
@@ -413,7 +396,6 @@ from "scott".emp;
 select *
 from "scott".emp
 where emp.comm <> some (select comm from "scott".emp where comm = 800);
-
 +-------+-------+-----+-----+----------+-----+------+--------+
 | EMPNO | ENAME | JOB | MGR | HIREDATE | SAL | COMM | DEPTNO |
 +-------+-------+-----+-----+----------+-----+------+--------+
@@ -425,7 +407,6 @@ where emp.comm <> some (select comm from "scott".emp where comm = 800);
 # Previous, as scalar sub-query.
 select *, emp.comm <> some (select comm from "scott".emp where comm = 800) as x
 from "scott".emp;
-
 +-------+--------+-----------+------+------------+---------+---------+--------+-------+
 | EMPNO | ENAME  | JOB       | MGR  | HIREDATE   | SAL     | COMM    | DEPTNO | X     |
 +-------+--------+-----------+------+------------+---------+---------+--------+-------+
@@ -452,7 +433,6 @@ from "scott".emp;
 select * from "scott".emp
 where comm < all (select comm from "scott".emp where 1 = 0)
 order by empno;
-
 +-------+--------+-----------+------+------------+---------+---------+--------+
 | EMPNO | ENAME  | JOB       | MGR  | HIREDATE   | SAL     | COMM    | DEPTNO |
 +-------+--------+-----------+------+------------+---------+---------+--------+
@@ -478,7 +458,6 @@ order by empno;
 # If sub-query is empty, "< some" is trivially false. Even for null comm.
 select * from "scott".emp
 where comm < some (select comm from "scott".emp where 1 = 0);
-
 +-------+-------+-----+-----+----------+-----+------+--------+
 | EMPNO | ENAME | JOB | MGR | HIREDATE | SAL | COMM | DEPTNO |
 +-------+-------+-----+-----+----------+-----+------+--------+
@@ -489,7 +468,6 @@ where comm < some (select comm from "scott".emp where 1 = 0);
 
 select * from "scott".emp
 where sal > all (select comm from "scott".emp where comm <> null);
-
 +-------+--------+-----------+------+------------+---------+---------+--------+
 | EMPNO | ENAME  | JOB       | MGR  | HIREDATE   | SAL     | COMM    | DEPTNO |
 +-------+--------+-----------+------+------------+---------+---------+--------+
@@ -514,7 +492,6 @@ where sal > all (select comm from "scott".emp where comm <> null);
 
 select * from "scott".emp
 where sal > all(500, 2000);
-
 +-------+-------+-----------+------+------------+---------+------+--------+
 | EMPNO | ENAME | JOB       | MGR  | HIREDATE   | SAL     | COMM | DEPTNO |
 +-------+-------+-----------+------+------------+---------+------+--------+
@@ -531,7 +508,6 @@ where sal > all(500, 2000);
 
 select * from "scott".emp
 where sal > all (4000, 2000);
-
 +-------+-------+-----------+-----+------------+---------+------+--------+
 | EMPNO | ENAME | JOB       | MGR | HIREDATE   | SAL     | COMM | DEPTNO |
 +-------+-------+-----------+-----+------------+---------+------+--------+
@@ -543,7 +519,6 @@ where sal > all (4000, 2000);
 
 select * from "scott".emp
 where sal > some (4000, 2000);
-
 +-------+-------+-----------+------+------------+---------+------+--------+
 | EMPNO | ENAME | JOB       | MGR  | HIREDATE   | SAL     | COMM | DEPTNO |
 +-------+-------+-----------+------+------------+---------+------+--------+
@@ -560,7 +535,6 @@ where sal > some (4000, 2000);
 
 select * from "scott".emp
 where sal > any (4000, 2000);
-
 +-------+-------+-----------+------+------------+---------+------+--------+
 | EMPNO | ENAME | JOB       | MGR  | HIREDATE   | SAL     | COMM | DEPTNO |
 +-------+-------+-----------+------+------------+---------+------+--------+
@@ -583,7 +557,6 @@ more than one value in agg SINGLE_VALUE
 select * from "scott".emp
 where sal > any (select sal * 2 from "scott".emp)
 order by sal desc;
-
 +-------+-------+-----------+------+------------+---------+------+--------+
 | EMPNO | ENAME | JOB       | MGR  | HIREDATE   | SAL     | COMM | DEPTNO |
 +-------+-------+-----------+------+------------+---------+------+--------+
@@ -601,7 +574,6 @@ order by sal desc;
 select * from "scott".emp
 where sal < all (select sal * 2 from "scott".emp)
 order by sal desc;
-
 +-------+--------+----------+------+------------+---------+---------+--------+
 | EMPNO | ENAME  | JOB      | MGR  | HIREDATE   | SAL     | COMM    | DEPTNO |
 +-------+--------+----------+------+------------+---------+---------+--------+
@@ -649,7 +621,6 @@ order by sal desc;
 
 select * from "scott".emp
 where sal < all (select comm * 2 from "scott".emp);
-
 +-------+-------+-----+-----+----------+-----+------+--------+
 | EMPNO | ENAME | JOB | MGR | HIREDATE | SAL | COMM | DEPTNO |
 +-------+-------+-----+-----+----------+-----+------+--------+
@@ -661,7 +632,6 @@ where sal < all (select comm * 2 from "scott".emp);
 select * from "scott".emp
 where sal < any (select comm * 2 from "scott".emp)
 order by empno;
-
 +-------+--------+----------+------+------------+---------+---------+--------+
 | EMPNO | ENAME  | JOB      | MGR  | HIREDATE   | SAL     | COMM    | DEPTNO |
 +-------+--------+----------+------+------------+---------+---------+--------+
@@ -683,7 +653,6 @@ order by empno;
 # It should return all rows.
 select * from "scott".emp
 where sal < any (select comm * 2 from "scott".emp) is unknown;
-
 +-------+-------+-----------+------+------------+---------+------+--------+
 | EMPNO | ENAME | JOB       | MGR  | HIREDATE   | SAL     | COMM | DEPTNO |
 +-------+-------+-----------+------+------------+---------+------+--------+
@@ -699,7 +668,6 @@ where sal < any (select comm * 2 from "scott".emp) is unknown;
 
 # Oracle gives error, but I believe the statement is valid and result is correct.
 select *, sal > all(select comm from "scott".emp) as x from "scott".emp;
-
 +-------+--------+-----------+------+------------+---------+---------+--------+-------+
 | EMPNO | ENAME  | JOB       | MGR  | HIREDATE   | SAL     | COMM    | DEPTNO | X     |
 +-------+--------+-----------+------+------------+---------+---------+--------+-------+
@@ -724,7 +692,6 @@ select *, sal > all(select comm from "scott".emp) as x from "scott".emp;
 
 select * from "scott".emp
 where sal > all (select comm from "scott".emp);
-
 +-------+-------+-----+-----+----------+-----+------+--------+
 | EMPNO | ENAME | JOB | MGR | HIREDATE | SAL | COMM | DEPTNO |
 +-------+-------+-----+-----+----------+-----+------+--------+
@@ -735,7 +702,6 @@ where sal > all (select comm from "scott".emp);
 
 select * from "scott".emp
 where sal > any (select comm from "scott".emp);
-
 +-------+--------+-----------+------+------------+---------+---------+--------+
 | EMPNO | ENAME  | JOB       | MGR  | HIREDATE   | SAL     | COMM    | DEPTNO |
 +-------+--------+-----------+------+------------+---------+---------+--------+
@@ -760,7 +726,6 @@ where sal > any (select comm from "scott".emp);
 
 select * from "scott".emp
 where sal > any (select comm from "scott".emp where comm < 1000);
-
 +-------+--------+-----------+------+------------+---------+---------+--------+
 | EMPNO | ENAME  | JOB       | MGR  | HIREDATE   | SAL     | COMM    | DEPTNO |
 +-------+--------+-----------+------+------------+---------+---------+--------+
@@ -785,7 +750,6 @@ where sal > any (select comm from "scott".emp where comm < 1000);
 
 select * from "scott".emp
 where sal > any (select comm from "scott".emp where comm < 2000);
-
 +-------+--------+-----------+------+------------+---------+---------+--------+
 | EMPNO | ENAME  | JOB       | MGR  | HIREDATE   | SAL     | COMM    | DEPTNO |
 +-------+--------+-----------+------+------------+---------+---------+--------+
@@ -810,7 +774,6 @@ where sal > any (select comm from "scott".emp where comm < 2000);
 
 select * from "scott".emp
 where sal > any (select comm * 2 from "scott".emp where comm < 2000);
-
 +-------+--------+-----------+------+------------+---------+---------+--------+
 | EMPNO | ENAME  | JOB       | MGR  | HIREDATE   | SAL     | COMM    | DEPTNO |
 +-------+--------+-----------+------+------------+---------+---------+--------+
@@ -835,7 +798,6 @@ where sal > any (select comm * 2 from "scott".emp where comm < 2000);
 
 select * from "scott".emp
 where sal > all (select comm * 2 from "scott".emp where comm < 2000);
-
 +-------+-------+-----------+------+------------+---------+------+--------+
 | EMPNO | ENAME | JOB       | MGR  | HIREDATE   | SAL     | COMM | DEPTNO |
 +-------+-------+-----------+------+------------+---------+------+--------+
@@ -851,7 +813,6 @@ where sal > all (select comm * 2 from "scott".emp where comm < 2000);
 
 select * from "scott".emp
 where sal > all (select comm from "scott".emp where comm is not null);
-
 +-------+--------+-----------+------+------------+---------+--------+--------+
 | EMPNO | ENAME  | JOB       | MGR  | HIREDATE   | SAL     | COMM   | DEPTNO |
 +-------+--------+-----------+------+------------+---------+--------+--------+
diff --git a/core/src/test/resources/sql/spatial.iq b/core/src/test/resources/sql/spatial.iq
index 1dfc45efe17..8f983e55575 100644
--- a/core/src/test/resources/sql/spatial.iq
+++ b/core/src/test/resources/sql/spatial.iq
@@ -36,25 +36,48 @@ C
 
 #### Geometry conversion functions (2D)
 
-# ST_AsBinary(geom) Geometry to Well Known Binary
-# Not implemented
+# ST_AsBinary(geom) Geometry to WKB
+SELECT ST_AsBinary('LINESTRING (1 2, 3 4)');
+EXPR$0
+0000000002000000023ff0000000000000400000000000000040080000000000004010000000000000
+!ok
+
+# ST_AsEWKT(geom) Geometry to EWKT
+SELECT ST_AsEWKT('LINESTRING (1 2, 3 4)');
+EXPR$0
+srid:0;LINESTRING (1 2, 3 4)
+!ok
+
+# ST_AsGeoJSON(geom) Geometry to GeoJSON
+SELECT ST_AsGeoJSON('LINESTRING (1 2, 3 4)');
+EXPR$0
+{"type":"LineString","coordinates":[[1,2],[3,4]],"crs":{"type":"name","properties":{"name":"EPSG:0"}}}
+!ok
 
 # ST_AsGML(geom) Geometry to GML
-# Not implemented
+SELECT ST_AsGML('LINESTRING (1 2, 3 4)');
+EXPR$0
+<gml:LineString><gml:coordinates>1.0,2.0 3.0,4.0 </gml:coordinates></gml:LineString>
+!ok
 
 # ST_AsText(geom) Alias for `ST_AsWKT`
-SELECT ST_AsText(ST_GeomFromText('POINT(-71.064544 42.28787)'));
+SELECT ST_AsText('POINT(-71.064544 42.28787)');
 EXPR$0
 POINT (-71.064544 42.28787)
 !ok
 
 # ST_AsWKT(geom) Converts *geom* → Well-Known Text
-
-SELECT ST_AsWKT(ST_GeomFromText('POINT(-71.064544 42.28787)'));
+SELECT ST_AsWKT('POINT(-71.064544 42.28787)');
 EXPR$0
 POINT (-71.064544 42.28787)
 !ok
 
+# ST_AsEWKB(geom) Geometry to WKB
+SELECT ST_AsWKB('LINESTRING (1 2, 3 4)');
+EXPR$0
+0000000002000000023ff0000000000000400000000000000040080000000000004010000000000000
+!ok
+
 # PostGIS can implicitly assign from CHAR to GEOMETRY; we can't
 !if (false) {
 # ST_AsWKT(geom) Geometry to Well Known Text
@@ -71,37 +94,72 @@ null
 !ok
 
 # ST_Force2D(geom) 3D Geometry to 2D Geometry
-# Not implemented
 
-# ST_GeomFromGML(gml [, srid ]) GML to Geometry
-# Not implemented
+SELECT ST_AsText(ST_Force2D('POINT(-10 10)'));
+EXPR$0
+POINT (-10 10)
+!ok
+
+SELECT ST_AsText(ST_Force2D('POINT(-10 10 6)'));
+EXPR$0
+POINT (-10 10)
+!ok
+
+SELECT ST_AsText(ST_Force2D('LINESTRING(-10 10 2, 10 10 3)'));
+EXPR$0
+LINESTRING (-10 10, 10 10)
+!ok
+
+# ST_GeomFromEWKT(ewkt) EWKT to Geometry
+SELECT ST_AsEWKT(ST_GeomFromEWKT('srid:4326;LINESTRING (1 2, 3 4)'));
+EXPR$0
+srid:4326;LINESTRING (1 2, 3 4)
+!ok
+
+# ST_GeomFromGeoJSON(geoJSON) GeoJSON to Geometry
+SELECT ST_GeomFromGeoJSON('{"type":"LineString","coordinates":[[1,2],[3,4]],"crs":{"type":"name","properties":{"name":"EPSG:0"}}}');
+EXPR$0
+LINESTRING (1 2, 3 4)
+!ok
+
+# ST_GeomFromGML(gml) GML to Geometry
+SELECT ST_GeomFromGML('<gml:LineString><gml:coordinates>1.0,2.0 3.0,4.0</gml:coordinates></gml:LineString>');
+EXPR$0
+LINESTRING (1 2, 3 4)
+!ok
+
+# ST_GeomFromGML(gml, srid) GML to Geometry
+SELECT ST_AsEWKT(ST_GeomFromGML('<gml:LineString><gml:coordinates>1.0,2.0 3.0,4.0</gml:coordinates></gml:LineString>', 4326));
+EXPR$0
+srid:4326;LINESTRING (1 2, 3 4)
+!ok
 
 # ST_GeomFromText(wkt [, srid ]) Returns a specified geometry value from Well-Known Text representation
 
 SELECT ST_GeomFromText('LINESTRING(-71.160281 42.258729,-71.160837 42.259113,-71.161144 42.25932)');
 EXPR$0
-{"paths":[[[-71.160281,42.258729],[-71.160837,42.259113],[-71.161144,42.25932]]]}
+LINESTRING (-71.160281 42.258729, -71.160837 42.259113, -71.161144 42.25932)
 !ok
 
 SELECT ST_GeomFromText('LINESTRING(-71.160281 42.258729,-71.160837 42.259113,-71.161144 42.25932)',4269);
 EXPR$0
-{"paths":[[[-71.160281,42.258729],[-71.160837,42.259113],[-71.161144,42.25932]]],"spatialReference":{"wkid":4269}}
+LINESTRING (-71.160281 42.258729, -71.160837 42.259113, -71.161144 42.25932)
 !ok
 
 SELECT ST_GeomFromText('MULTILINESTRING((-71.160281 42.258729,-71.160837 42.259113,-71.161144 42.25932))');
 EXPR$0
-{"paths":[[[-71.160281,42.258729],[-71.160837,42.259113],[-71.161144,42.25932]]]}
+MULTILINESTRING ((-71.160281 42.258729, -71.160837 42.259113, -71.161144 42.25932))
 !ok
 
 SELECT ST_GeomFromText('POINT(-71.064544 42.28787)');
 EXPR$0
-{"x":-71.064544,"y":42.28787}
+POINT (-71.064544 42.28787)
 !ok
 
 SELECT ST_GeomFromText('POLYGON((-71.1776585052917 42.3902909739571,-71.1776820268866 42.3903701743239,
 -71.1776063012595 42.3903825660754,-71.1775826583081 42.3903033653531,-71.1776585052917 42.3902909739571))');
 EXPR$0
-{"rings":[[[-71.1776585052917,42.3902909739571],[-71.1776820268866,42.3903701743239],[-71.1776063012595,42.3903825660754],[-71.1775826583081,42.3903033653531],[-71.1776585052917,42.3902909739571]]]}
+POLYGON ((-71.1776585052917 42.3902909739571, -71.1776820268866 42.3903701743239, -71.1776063012595 42.3903825660754, -71.1775826583081 42.3903033653531, -71.1776585052917 42.3902909739571))
 !ok
 
 SELECT ST_GeomFromText('MULTIPOLYGON(((-71.1031880899493 42.3152774590236,
@@ -128,7 +186,7 @@ SELECT ST_GeomFromText('MULTIPOLYGON(((-71.1031880899493 42.3152774590236,
 ((-71.1043632495873 42.315113108546,-71.1043583974082 42.3151211109857,
 -71.1043443253471 42.3150676015829,-71.1043850704575 42.3150793250568,-71.1043632495873 42.315113108546)))',4326);
 EXPR$0
-{"rings":[[[-71.1031880899493,42.3152774590236],[-71.1031627617667,42.3152960829043],[-71.102923838298,42.3149156848307],[-71.1023097974109,42.3151969047397],[-71.1019285062273,42.3147384934248],[-... (1697 characters)
+MULTIPOLYGON (((-71.1031880899493 42.3152774590236, -71.1031627617667 42.3152960829043, -71.102923838298 42.3149156848307, -71.1023097974109 42.3151969047397, -71.1019285062273 42.3147384934248, -71.102505233663 42.3144722937587, -71.10277487471 42.3141658254797, -71.103113945163 42.3142739188902, -71.10324876416 42.31402489987, -71.1033002961013 42.3140393340215, -71.1033488797549 42.3139495090772, -71.103396240451 42.3138632439557, -71.1041521907712 42.3141153348029, -71.1041411411543 42.3141545014533, -71.1041287795912 42.3142114839058, -71.1041188134329 42.3142693656241, -71.1041112482575 42.3143272556118, -71.1041072845732 42.3143851580048, -71.1041057218871 42.3144430686681, -71.1041065602059 42.3145009876017, -71.1041097995362 42.3145589148055, -71.1041166403905 42.3146168544148, -71.1041258822717 42.3146748022936, -71.1041375307579 42.3147318674446, -71.1041492906949 42.3147711126569, -71.1041598612795 42.314808571739, -71.1042515013869 42.3151287620809, -71.1041173835118 42.3150739481917, -71.1040809891419 42.3151344119048, -71.1040438678912 42.3151191367447, -71.1040194562988 42.3151832057859, -71.1038734225584 42.3151140942995, -71.1038446938243 42.3151006300338, -71.1038315271889 42.315094347535, -71.1037393329282 42.315054824985, -71.1035447555574 42.3152608696313, -71.1033436658644 42.3151648370544, -71.1032580383161 42.3152269126061, -71.103223066939 42.3152517403219, -71.1031880899493 42.3152774590236)), ((-71.1043632495873 42.315113108546, -71.1043583974082 42.3151211109857, -71.1043443253471 42.3150676015829, -71.1043850704575 42.3150793250568, -71.1043632495873 42.315113108546)))
 !ok
 
 # Disabled: Should not return null
@@ -152,11 +210,20 @@ SELECT ST_GeomFromText('CIRCULARSTRING(220268 150415,220227 150505,220227 150406
 # but ST_GeomFromText('GEOMETRYCOLLECTION EMPTY') is not preferred.
 SELECT ST_GeomFromText('GEOMETRYCOLLECTION EMPTY');
 EXPR$0
-null
+GEOMETRYCOLLECTION EMPTY
 !ok
 
-# ST_GeomFromWKB(wkb [, srid ]) Well Known Binary to Geometry
-# Not implemented
+# ST_GeomFromWKB(wkb) WKB to Geometry
+SELECT ST_GeomFromWKB(ST_AsWKB('LINESTRING (1 2, 3 4)'));
+EXPR$0
+LINESTRING (1 2, 3 4)
+!ok
+
+# ST_GeomFromWKB(wkb, srid) WKB to Geometry
+SELECT ST_AsEWKT(ST_GeomFromWKB(ST_AsWKB('LINESTRING (1 2, 3 4)'), 4326));
+EXPR$0
+srid:4326;LINESTRING (1 2, 3 4)
+!ok
 
 # ST_GoogleMapLink(geom [, layerType [, zoom ]]) Geometry to Google map link
 # Not implemented
@@ -165,39 +232,52 @@ null
 SELECT ST_LineFromText('LINESTRING(1 2, 3 4)') AS aline,
   ST_LineFromText('POINT(1 2)') AS null_return;
 ALINE, NULL_RETURN
-{"paths":[[[1,2],[3,4]]]}, {"x":1,"y":2}
+LINESTRING (1 2, 3 4), null
 !ok
 
 # ST_LineFromWKB(wkb [, srid ]) Well Known Binary to LINESTRING
-# Not implemented
+SELECT ST_LineFromWKB(ST_AsWKB('LINESTRING (4 3, 6 5, 8 12)'));
+EXPR$0
+LINESTRING (4 3, 6 5, 8 12)
+!ok
+
+SELECT ST_LineFromWKB(ST_AsWKB('LINESTRING (5 5, 1 2, 3 4, 99 3)'));
+EXPR$0
+LINESTRING (5 5, 1 2, 3 4, 99 3)
+!ok
+
+SELECT ST_LineFromWKB(ST_AsWKB('POINT(2 3)'));
+EXPR$0
+null
+!ok
 
 # ST_MLineFromText(wkt [, srid ]) Well Known Text to MULTILINESTRING
 SELECT ST_MLineFromText('MULTILINESTRING((1 2, 3 4), (4 5, 6 7))');
 EXPR$0
-{"paths":[[[1,2],[3,4]],[[4,5],[6,7]]]}
+MULTILINESTRING ((1 2, 3 4), (4 5, 6 7))
 !ok
 
 # ST_MPointFromText(wkt [, srid ]) Well Known Text to MULTIPOINT
 SELECT ST_MPointFromText('MULTIPOINT(1 2, 3 4)');
 EXPR$0
-{"points":[[1,2],[3,4]]}
+MULTIPOINT ((1 2), (3 4))
 !ok
 
-SELECT ST_MPointFromText('MULTIPOINT(-70.9590 42.1180, -70.9611 42.1223)', 4326);
+SELECT ST_AsEWKT(ST_MPointFromText('MULTIPOINT(-70.9590 42.1180, -70.9611 42.1223)', 4326));
 EXPR$0
-{"points":[[-70.959,42.118],[-70.9611,42.1223]],"spatialReference":{"wkid":4326}}
+srid:4326;MULTIPOINT ((-70.959 42.118), (-70.9611 42.1223))
 !ok
 
 # ST_MPolyFromText(wkt [, srid ]) Well Known Text to MULTIPOLYGON
-SELECT ST_MPolyFromText('MULTIPOLYGON Z(((0 0 1,20 0 1,20 20 1,0 20 1,0 0 1),(5 5 3,5 7 3,7 7 3,7 5 3,5 5 3)))');
+SELECT ST_AsWKT(ST_MPolyFromText('MULTIPOLYGON Z(((0 0 1,20 0 1,20 20 1,0 20 1,0 0 1),(5 5 3,5 7 3,7 7 3,7 5 3,5 5 3)))'));
 EXPR$0
-{"hasZ":true,"rings":[[[0,0,1],[0,20,1],[20,20,1],[20,0,1],[0,0,1]],[[5,5,3],[7,5,3],[7,7,3],[5,7,3],[5,5,3]]]}
+MULTIPOLYGON Z(((0 0 1, 20 0 1, 20 20 1, 0 20 1, 0 0 1), (5 5 3, 5 7 3, 7 7 3, 7 5 3, 5 5 3)))
 !ok
 
-SELECt ST_MPolyFromText('MULTIPOLYGON(((-70.916 42.1002,-70.9468 42.0946,-70.9765 42.0872,-70.9754 42.0875,-70.9749 42.0879,-70.9752 42.0881,-70.9754 42.0891,-70.9758 42.0894,-70.9759 42.0897,-70.9759 42.0899,-70.9754 42.0902,-70.9756 42.0906,-70.9753 42.0907,-70.9753 42.0917,-70.9757 42.0924,-70.9755 42.0928,-70.9755 42.0942,-70.9751 42.0948,-70.9755 42.0953,-70.9751 42.0958,-70.9751 42.0962,-70.9759 42.0983,-70.9767 42.0987,-70.9768 42.0991,-70.9771 42.0997,-70.9771 42.1003,-70.9768 42.1005,-70.977 42.1011,-70.9766 42.1019,-70.9768 42.1026,-70.9769 42.1033,-70.9775 42.1042,-70.9773 42.1043,-70.9776 42.1043,-70.9778 42.1048,-70.9773 42.1058,-70.9774 42.1061,-70.9779 42.1065,-70.9782 42.1078,-70.9788 42.1085,-70.9798 42.1087,-70.9806 42.109,-70.9807 42.1093,-70.9806 42.1099,-70.9809 42.1109,-70.9808 42.1112,-70.9798 42.1116,-70.9792 42.1127,-70.979 42.1129,-70.9787 42.1134,-70.979 42.1139,-70.9791 42.1141,-70.9987 42.1116,-71.0022 42.1273,
+SELECT ST_MPolyFromText('MULTIPOLYGON(((-70.916 42.1002,-70.9468 42.0946,-70.9765 42.0872,-70.9754 42.0875,-70.9749 42.0879,-70.9752 42.0881,-70.9754 42.0891,-70.9758 42.0894,-70.9759 42.0897,-70.9759 42.0899,-70.9754 42.0902,-70.9756 42.0906,-70.9753 42.0907,-70.9753 42.0917,-70.9757 42.0924,-70.9755 42.0928,-70.9755 42.0942,-70.9751 42.0948,-70.9755 42.0953,-70.9751 42.0958,-70.9751 42.0962,-70.9759 42.0983,-70.9767 42.0987,-70.9768 42.0991,-70.9771 42.0997,-70.9771 42.1003,-70.9768 42.1005,-70.977 42.1011,-70.9766 42.1019,-70.9768 42.1026,-70.9769 42.1033,-70.9775 42.1042,-70.9773 42.1043,-70.9776 42.1043,-70.9778 42.1048,-70.9773 42.1058,-70.9774 42.1061,-70.9779 42.1065,-70.9782 42.1078,-70.9788 42.1085,-70.9798 42.1087,-70.9806 42.109,-70.9807 42.1093,-70.9806 42.1099,-70.9809 42.1109,-70.9808 42.1112,-70.9798 42.1116,-70.9792 42.1127,-70.979 42.1129,-70.9787 42.1134,-70.979 42.1139,-70.9791 42.1141,-70.9987 42.1116,-71.0022 42.1273,
     -70.9408 42.1513,-70.9315 42.1165,-70.916 42.1002)))',4326);
 EXPR$0
-{"rings":[[[-70.916,42.1002],[-70.9468,42.0946],[-70.9765,42.0872],[-70.9754,42.0875],[-70.9749,42.0879],[-70.9752,42.0881],[-70.9754,42.0891],[-70.9758,42.0894],[-70.9759,42.0897],[-70.9759,42.089... (1123 characters)
+MULTIPOLYGON (((-70.916 42.1002, -70.9468 42.0946, -70.9765 42.0872, -70.9754 42.0875, -70.9749 42.0879, -70.9752 42.0881, -70.9754 42.0891, -70.9758 42.0894, -70.9759 42.0897, -70.9759 42.0899, -70.9754 42.0902, -70.9756 42.0906, -70.9753 42.0907, -70.9753 42.0917, -70.9757 42.0924, -70.9755 42.0928, -70.9755 42.0942, -70.9751 42.0948, -70.9755 42.0953, -70.9751 42.0958, -70.9751 42.0962, -70.9759 42.0983, -70.9767 42.0987, -70.9768 42.0991, -70.9771 42.0997, -70.9771 42.1003, -70.9768 42.1005, -70.977 42.1011, -70.9766 42.1019, -70.9768 42.1026, -70.9769 42.1033, -70.9775 42.1042, -70.9773 42.1043, -70.9776 42.1043, -70.9778 42.1048, -70.9773 42.1058, -70.9774 42.1061, -70.9779 42.1065, -70.9782 42.1078, -70.9788 42.1085, -70.9798 42.1087, -70.9806 42.109, -70.9807 42.1093, -70.9806 42.1099, -70.9809 42.1109, -70.9808 42.1112, -70.9798 42.1116, -70.9792 42.1127, -70.979 42.1129, -70.9787 42.1134, -70.979 42.1139, -70.9791 42.1141, -70.9987 42.1116, -71.0022 42.1273, -70.9408 42.1513, -70.9315 42.1165, -70.916 42.1002)))
 !ok
 
 # ST_OSMMapLink(geom [, marker ]) Geometry to OSM map link
@@ -206,21 +286,34 @@ EXPR$0
 # ST_PointFromText(wkt [, srid ]) Well Known Text to POINT
 SELECT ST_PointFromText('POINT(-71.064544 42.28787)');
 EXPR$0
-{"x":-71.064544,"y":42.28787}
+POINT (-71.064544 42.28787)
 !ok
 
-SELECT ST_PointFromText('POINT(-71.064544 42.28787)', 4326);
+SELECT ST_AsEWKT(ST_PointFromText('POINT(-71.064544 42.28787)', 4326));
 EXPR$0
-{"x":-71.064544,"y":42.28787,"spatialReference":{"wkid":4326}}
+srid:4326;POINT (-71.064544 42.28787)
 !ok
 
 # ST_PointFromWKB(wkb [, srid ]) Well Known Binary to POINT
-# Not implemented
+SELECT ST_PointFromWKB(ST_AsWKB('POINT (1 1)'));
+EXPR$0
+POINT (1 1)
+!ok
+
+SELECT ST_PointFromWKB(ST_AsWKB('POINT (5 5)'));
+EXPR$0
+POINT (5 5)
+!ok
+
+SELECT ST_PointFromWKB(ST_AsWKB('LINESTRING (4 3, 6 5, 8 12)'));
+EXPR$0
+null
+!ok
 
 # ST_PolyFromText(wkt [, srid ]) Well Known Text to POLYGON
-SELECT ST_PolyFromText('POLYGON Z((0 0 1,20 0 1,20 20 1,0 20 1,0 0 1))');
+SELECT ST_AsWKT(ST_PolyFromText('POLYGON Z((0 0 1,20 0 1,20 20 1,0 20 1,0 0 1))'));
 EXPR$0
-{"hasZ":true,"rings":[[[0,0,1],[0,20,1],[20,20,1],[20,0,1],[0,0,1]]]}
+POLYGON Z((0 0 1, 20 0 1, 20 20 1, 0 20 1, 0 0 1))
 !ok
 
 SELECT ST_PolyFromText(CAST(NULL AS VARCHAR));
@@ -228,65 +321,175 @@ EXPR$0
 null
 !ok
 
-SELECT ST_PolyFromText('POLYGON((0 0))');
+SELECT ST_PolyFromText('POLYGON((0 0, 0 1, 1 1, 0 0))');
 EXPR$0
-{"rings":[[[0,0],[0,0]]]}
+POLYGON ((0 0, 0 1, 1 1, 0 0))
 !ok
 
 # ST_PolyFromWKB(wkb [, srid ]) Well Known Binary to POLYGON
-# Not implemented
+SELECT ST_PolyFromWKB(ST_AsWKB('POLYGON ((49 30, 50 28, 53 28, 53 32, 50 32, 49 30))'));
+EXPR$0
+POLYGON ((49 30, 50 28, 53 28, 53 32, 50 32, 49 30))
+!ok
+
+SELECT ST_PolyFromWKB(ST_AsWKB('POLYGON((0 0, 0 1, 1 1, 1 0, 0 0))'));
+EXPR$0
+POLYGON ((0 0, 0 1, 1 1, 1 0, 0 0))
+!ok
+
+SELECT ST_PolyFromWKB(ST_AsWKB('POINT (1 1)'));
+EXPR$0
+null
+!ok
+
+# ST_ReducedPrecision(geom, gridSize) Reduces the precision of a geom to the provided gridSize
+SELECT ST_ReducePrecision('POINT(1.412 19.323)', 0.1);
+EXPR$0
+POINT (1.4 19.3)
+!ok
+
+SELECT ST_ReducePrecision('POINT(1.412 19.323)', 1.0);
+EXPR$0
+POINT (1 19)
+!ok
+
+SELECT ST_ReducePrecision('POINT(1.412 19.323)', 10);
+EXPR$0
+POINT (0 20)
+!ok
 
 # ST_ToMultiLine(geom) Converts the coordinates of *geom* (which may be a geometry-collection) into a multi-line-string
-# Not implemented
+
+SELECT ST_ToMultiLine('POLYGON((0 0, 10 0, 10 6, 0 6, 0 0), (1 1, 2 1, 2 5, 1 5, 1 1))');
+EXPR$0
+MULTILINESTRING ((0 0, 10 0, 10 6, 0 6, 0 0), (1 1, 2 1, 2 5, 1 5, 1 1))
+!ok
+
+SELECT ST_ToMultiLine('GEOMETRYCOLLECTION(LINESTRING(1 4 3, 10 7 9, 12 9 22), POLYGON((1 1 -1, 3 1 0, 3 2 1, 1 2 2, 1 1 -1)))');
+EXPR$0
+MULTILINESTRING ((1 4, 10 7, 12 9), (1 1, 3 1, 3 2, 1 2, 1 1))
+!ok
 
 # ST_ToMultiPoint(geom)) Converts the coordinates of *geom* (which may be a geometry-collection) into a multi-point
-# Not implemented
+
+SELECT ST_ToMultiPoint('POINT(5 5)');
+EXPR$0
+MULTIPOINT ((5 5))
+!ok
+
+SELECT ST_ToMultiPoint('MULTIPOINT(5 5, 1 2, 3 4, 99 3)');
+EXPR$0
+MULTIPOINT ((5 5), (1 2), (3 4), (99 3))
+!ok
+
+SELECT ST_ToMultiPoint('LINESTRING(5 5, 1 2, 3 4, 1 5)');
+EXPR$0
+MULTIPOINT ((5 5), (1 2), (3 4), (1 5))
+!ok
 
 # ST_ToMultiSegments(geom) Converts *geom* (which may be a geometry-collection) into a set of distinct segments stored in a multi-line-string
-# Not implemented
+
+SELECT ST_ToMultiSegments('LINESTRING(5 4, 1 1, 3 4, 4 5)');
+EXPR$0
+MULTILINESTRING ((5 4, 1 1), (1 1, 3 4), (3 4, 4 5))
+!ok
+
+SELECT ST_ToMultiSegments('MULTILINESTRING((1 4 3, 15 7 9, 16 17 22), (0 0 0, 1 0 0, 1 2 0, 0 2 1))');
+EXPR$0
+MULTILINESTRING ((1 4, 15 7), (15 7, 16 17), (0 0, 1 0), (1 0, 1 2), (1 2, 0 2))
+!ok
+
+SELECT ST_ToMultiSegments('POLYGON((0 0, 10 0, 10 6, 0 6, 0 0), (1 1, 2 1, 2 5, 1 5, 1 1))');
+EXPR$0
+MULTILINESTRING ((0 0, 10 0), (10 0, 10 6), (10 6, 0 6), (0 6, 0 0), (1 1, 2 1), (2 1, 2 5), (2 5, 1 5), (1 5, 1 1))
+!ok
 
 #### Geometry conversion functions (3D)
 
 # ST_Force3D(geom) 2D Geometry to 3D Geometry
-# Not implemented
+
+SELECT ST_AsText(ST_Force3D('POINT(-10 10 6)'));
+EXPR$0
+POINT Z(-10 10 6)
+!ok
+
+SELECT ST_AsText(ST_Force3D('POINT(-10 10)'));
+EXPR$0
+POINT Z(-10 10 0)
+!ok
+
+SELECT ST_AsText(ST_Force3D('LINESTRING(-10 10, 10 10)'));
+EXPR$0
+LINESTRING Z(-10 10 0, 10 10 0)
+!ok
 
 #### Geometry creation functions (2D)
 
 # ST_BoundingCircle(geom) Returns the minimum bounding circle of *geom*
-# Not implemented
+
+SELECT ST_ReducePrecision(ST_asText(ST_BoundingCircle('POLYGON((1 1, 1 4, 4 4, 4 1, 1 1))')), 0.01);
+EXPR$0
+POLYGON ((4.62 2.5, 4.58 2.09, 4.46 1.69, 4.26 1.32, 4 1, 3.68 0.74, 3.31 0.54, 2.91 0.42, 2.5 0.38, 2.09 0.42, 1.69 0.54, 1.32 0.74, 1 1, 0.74 1.32, 0.54 1.69, 0.42 2.09, 0.38 2.5, 0.42 2.91, 0.54 3.31, 0.74 3.68, 1 4, 1.32 4.26, 1.69 4.46, 2.09 4.58, 2.5 4.62, 2.91 4.58, 3.31 4.46, 3.68 4.26, 4 4, 4.26 3.68, 4.46 3.31, 4.58 2.91, 4.62 2.5))
+!ok
+
+SELECT ST_ReducePrecision(ST_asText(ST_BoundingCircle('MULTIPOINT((1 1), (4 2))')), 0.01);
+EXPR$0
+POLYGON ((4.08 1.5, 4.05 1.19, 3.96 0.89, 3.81 0.62, 3.62 0.38, 3.38 0.19, 3.11 0.04, 2.81 -0.05, 2.5 -0.08, 2.19 -0.05, 1.89 0.04, 1.62 0.19, 1.38 0.38, 1.19 0.62, 1.04 0.89, 0.95 1.19, 0.92 1.5, 0.95 1.81, 1.04 2.11, 1.19 2.38, 1.38 2.62, 1.62 2.81, 1.89 2.96, 2.19 3.05, 2.5 3.08, 2.81 3.05, 3.11 2.96, 3.38 2.81, 3.62 2.62, 3.81 2.38, 3.96 2.11, 4.05 1.81, 4.08 1.5))
+!ok
+
+SELECT ST_ReducePrecision(ST_asText(ST_BoundingCircle('LINESTRING(1 1, 4 5, 3 2)')), 0.01);
+EXPR$0
+POLYGON ((5 3, 4.95 2.51, 4.81 2.04, 4.58 1.61, 4.27 1.23, 3.89 0.92, 3.46 0.69, 2.99 0.55, 2.5 0.5, 2.01 0.55, 1.54 0.69, 1.11 0.92, 0.73 1.23, 0.42 1.61, 0.19 2.04, 0.05 2.51, 0 3, 0.05 3.49, 0.19 3.96, 0.42 4.39, 0.73 4.77, 1.11 5.08, 1.54 5.31, 2.01 5.45, 2.5 5.5, 2.99 5.45, 3.46 5.31, 3.89 5.08, 4.27 4.77, 4.58 4.39, 4.81 3.96, 4.95 3.49, 5 3))
+!ok
 
 # ST_Expand(geom, distance) Expands *geom*'s envelope
-# Not implemented
+
+SELECT ST_Expand('POINT(1 1)', 1);
+EXPR$0
+POLYGON ((0 0, 0 2, 2 2, 2 0, 0 0))
+!ok
 
 # ST_Expand(geom, deltaX, deltaY) Expands *geom*'s envelope
-# Not implemented
+
+SELECT ST_Expand('POINT(4 4)', 5, 2);
+EXPR$0
+POLYGON ((-1 2, -1 6, 9 6, 9 2, -1 2))
+!ok
+
+SELECT ST_Expand('LINESTRING(3 2, 7 5, 2 7)', 2, 1);
+EXPR$0
+POLYGON ((0 1, 0 8, 9 8, 9 1, 0 1))
+!ok
 
 # ST_MakeEllipse(point, width, height) Constructs an ellipse
-# Not implemented
+
+SELECT ST_ReducePrecision(ST_AsText(ST_MakeEllipse('POINT(5 5)', 2, 5)), 0.01);
+EXPR$0
+POLYGON ((6 5, 6 5.16, 5.99 5.31, 5.98 5.47, 5.97 5.62, 5.95 5.77, 5.93 5.92, 5.9 6.06, 5.88 6.2, 5.84 6.34, 5.81 6.47, 5.77 6.59, 5.73 6.71, 5.68 6.82, 5.64 6.93, 5.59 7.02, 5.54 7.11, 5.48 7.19, 5.43 7.26, 5.37 7.32, 5.31 7.38, 5.25 7.42, 5.19 7.46, 5.13 7.48, 5.06 7.5, 5 7.5, 4.94 7.5, 4.87 7.48, 4.81 7.46, 4.75 7.42, 4.69 7.38, 4.63 7.32, 4.57 7.26, 4.52 7.19, 4.46 7.11, 4.41 7.02, 4.36 6.93, 4.32 6.82, 4.27 6.71, 4.23 6.59, 4.19 6.47, 4.16 6.34, 4.12 6.2, 4.1 6.06, 4.07 5.92, 4.05 5.77, 4.03 5.62, 4.02 5.47, 4.01 5.31, 4 5.16, 4 5, 4 4.84, 4.01 4.69, 4.02 4.53, 4.03 4.38, 4.05 4.23, 4.07 4.08, 4.1 3.94, 4.12 3.8, 4.16 3.66, 4.19 3.53, 4.23 3.41, 4.27 3.29, 4.32 3.18, 4.36 3.07, 4.41 2.98, 4.46 2.89, 4.52 2.81, 4.57 2.74, 4.63 2.68, 4.69 2.62, 4.75 2.58, 4.81 2.54, 4.87 2.52, 4.94 2.5, 5 2.5, 5.06 2.5, 5.13 2.52, 5.19 2.54, 5.25 2.58, 5.31 2.62, 5.37 2.68, 5.43 2.74, 5.48 2.81, 5.54 2.89, 5.59 2.98, 5.64 3.07, 5.68 3.18, 5.73 3.29, 5.77 3.41, 5.81 3.53, 5.84 3.66, 5.88 3.8, 5.9 3.94, 5.93 4.08, 5.95 4.23, 5.97 4.38, 5.98 4.53, 5.99 4.69, 6 4.84, 6 5))
+!ok
 
 # ST_MakeEnvelope(xMin, yMin, xMax, yMax  [, srid ]) Creates a rectangular Polygon
-SELECT ST_AsText(ST_MakeEnvelope(10.0, 10.0, 11.0, 11.0, 4326));
 
+SELECT ST_AsText(ST_MakeEnvelope(10.0, 10.0, 11.0, 11.0, 4326));
 EXPR$0
-MULTIPOLYGON (((10 10, 11 10, 11 11, 10 11, 10 10)))
+POLYGON ((10 10, 10 11, 11 11, 11 10, 10 10))
 !ok
 
 SELECT ST_AsText(ST_MakeEnvelope(12.0, -1.0, 6.0, 4.0, 4326));
-
 EXPR$0
-MULTIPOLYGON (((12 -1, 12 4, 6 4, 6 -1, 12 -1)))
+POLYGON ((12 -1, 12 4, 6 4, 6 -1, 12 -1))
 !ok
 
 # ST_MakeGrid(geom, deltaX, deltaY) Calculates a regular grid of polygons based on *geom*
 SELECT * FROM TABLE(ST_MakeGrid(ST_Point(13.0,22.0), 10.0, 5.0));
 THE_GEOM, ID, ID_COL, ID_ROW, ABS_COL, ABS_ROW
-{"rings":[[[10,20],[20,20],[20,25],[10,25],[10,20]]]}, 0, 1, 1, 1, 4
+POLYGON ((10 20, 10 25, 20 25, 20 20, 10 20)), 0, 1, 1, 1, 4
 !ok
 
 # ST_MakeGridPoints(geom, deltaX, deltaY) Calculates a regular grid of points based on *geom*
 SELECT * FROM TABLE(ST_MakeGridPoints(ST_Point(13.0,22.0), 10.0, 5.0));
 THE_GEOM, ID, ID_COL, ID_ROW, ABS_COL, ABS_ROW
-{"x":15,"y":22.5}, 0, 1, 1, 1, 4
+POINT (15 22.5), 0, 1, 1, 1, 4
 !ok
 
 # Call ST_MakeGridPoints for each geometry in a set
@@ -296,21 +499,21 @@ from GEO."countries" AS c,
     ST_MakeGridPoints(ST_MakePoint("longitude", "latitude"), 10.0, 10.0)) as p
 ORDER BY "latitude" DESC LIMIT 3;
 name, latitude, longitude, THE_GEOM, ID, ID_COL, ID_ROW, ABS_COL, ABS_ROW
-Svalbard and Jan Mayen, 77.553604, 23.670272, {"x":25,"y":75}, 0, 1, 1, 2, 7
-Greenland, 71.706936, -42.604303, {"x":-45,"y":75}, 0, 1, 1, -5, 7
-Iceland, 64.963051, -19.020835, {"x":-15,"y":65}, 0, 1, 1, -2, 6
+Svalbard and Jan Mayen, 77.553604, 23.670272, POINT (25 75), 0, 1, 1, 2, 7
+Greenland, 71.706936, -42.604303, POINT (-45 75), 0, 1, 1, -5, 7
+Iceland, 64.963051, -19.020835, POINT (-15 65), 0, 1, 1, -2, 6
 !ok
 
 # ST_MakeLine(point1 [, point ]*) Creates a line-string from the given points (or multi-points)
 
 SELECT ST_MakeLine(ST_Point(1.0,1.0), ST_Point(-1.0,-1.0));
 EXPR$0
-{"paths":[[[1,1],[-1,-1]]]}
+LINESTRING (1 1, -1 -1)
 !ok
 
 SELECT ST_MakeLine(ST_Point(1.0,1.0), ST_Point(-1.0,-1.0), ST_Point(-3.0,0.0));
 EXPR$0
-{"paths":[[[1,1],[-1,-1],[-3,0]]]}
+LINESTRING (1 1, -1 -1, -3 0)
 !ok
 
 # ST_MakePoint(x, y [, z ]) Constructs a point from two or three coordinates
@@ -318,19 +521,19 @@ EXPR$0
 # Return point with unknown SRID
 SELECT ST_MakePoint(-71.1043443253471, 42.3150676015829);
 EXPR$0
-{"x":-71.1043443253471,"y":42.3150676015829}
+POINT (-71.1043443253471 42.3150676015829)
 !ok
 
 # Return point marked as WGS 84 long lat
 SELECT ST_SetSRID(ST_MakePoint(-71.1043443253471, 42.3150676015829),4326);
 EXPR$0
-{"x":-71.1043443253471,"y":42.3150676015829}
+POINT (-71.1043443253471 42.3150676015829)
 !ok
 
 # Return a 3D point (e.g. has altitude)
-SELECT ST_MakePoint(1.0, 2.0, 1.5);
+SELECT ST_AsWKT(ST_MakePoint(1.0, 2.0, 1.5));
 EXPR$0
-{"x":1,"y":2,"z":1.5}
+POINT Z(1 2 1.5)
 !ok
 
 # Get x of point
@@ -356,21 +559,56 @@ from GEO."countries" AS c
 ORDER BY "latitude" DESC LIMIT 3;
 name, P
 U.S.Minor Outlying Islands, null
-Svalbard and Jan Mayen, {"x":23.670272,"y":77.553604}
-Greenland, {"x":-42.604303,"y":71.706936}
+Svalbard and Jan Mayen, POINT (23.670272 77.553604)
+Greenland, POINT (-42.604303 71.706936)
 !ok
 
 # ST_MakePolygon(lineString [, hole ]*) Creates a polygon from *lineString* with the given holes (which are required to be closed line-strings)
-# Not implemented
+
+SELECT ST_MakePolygon('LINESTRING(100 250, 100 350, 200 350, 200 250, 100 250)');
+EXPR$0
+POLYGON ((100 250, 100 350, 200 350, 200 250, 100 250))
+!ok
+
+SELECT ST_MakePolygon('LINESTRING(0 5, 4 5, 4 0, 0 0, 0 5)', 'LINESTRING(1 1, 1 2, 2 2, 2 1, 1 1)');
+EXPR$0
+POLYGON ((0 5, 4 5, 4 0, 0 0, 0 5), (1 1, 1 2, 2 2, 2 1, 1 1))
+!ok
+
+SELECT ST_MakePolygon('POINT(1 1)');
+Only supports LINESTRINGs.
+!error
 
 # ST_MinimumDiameter(geom) Returns the minimum diameter of *geom*
-# Not implemented
+
+SELECT ST_MinimumDiameter('POINT(395 278)');
+EXPR$0
+LINESTRING (395 278, 395 278)
+!ok
+
+SELECT ST_MinimumDiameter('LINESTRING(0 0, 1 1, 3 9, 7 1)');
+EXPR$0
+LINESTRING (1 3, 7 1)
+!ok
 
 # ST_MinimumRectangle(geom) Returns the minimum rectangle enclosing *geom*
-# Not implemented
 
-# ST_OctogonalEnvelope(geom) Returns the octogonal envelope of *geom*
-# Not implemented
+SELECT ST_MinimumRectangle('MULTIPOINT((8 3), (4 6))');
+EXPR$0
+LINESTRING (4 6, 8 3)
+!ok
+
+SELECT ST_MinimumRectangle('POLYGON((1 2, 3 0, 5 2, 3 2, 2 3, 1 2))');
+EXPR$0
+POLYGON ((1.4 3.1999999999999993, 0.6 0.8, 4.2 -0.3999999999999996, 4.999999999999999 1.9999999999999993, 1.4 3.1999999999999993))
+!ok
+
+# ST_OctagonalEnvelope(geom) Returns the octogonal envelope of *geom*
+
+SELECT ST_OctagonalEnvelope('POLYGON((2 1, 1 2, 2 2, 2 4, 3 5, 3 3, 5 5, 7 2, 5 2, 6 1, 2 1))');
+EXPR$0
+POLYGON ((1 2, 1 3, 3 5, 5 5, 7 3, 7 2, 6 1, 2 1, 1 2))
+!ok
 
 # ST_RingBuffer(geom, bufferSize, bufferCount [, endCapStyle [, doDifference]]) Returns a multi-polygon of buffers centered at *geom* and of increasing buffer size
 # Not implemented
@@ -389,41 +627,100 @@ Greenland, {"x":-42.604303,"y":71.706936}
 #### Geometry properties (2D)
 
 # ST_Boundary(geom [, srid ]) Returns the boundary of *geom*
-SELECT ST_AsText(ST_Boundary(ST_GeomFromText('LINESTRING(1 1,0 0, -1 1)')));
+SELECT ST_AsText(ST_Boundary('LINESTRING(1 1,0 0, -1 1)'));
 EXPR$0
 MULTIPOINT ((1 1), (-1 1))
 !ok
 
-SELECT ST_AsText(ST_Boundary(ST_GeomFromText('POLYGON((1 1,0 0, -1 1, 1 1))')));
+SELECT ST_AsText(ST_Boundary('POLYGON((1 1,0 0, -1 1, 1 1))'));
 EXPR$0
-MULTILINESTRING ((1 1, 0 0, -1 1, 1 1))
+LINEARRING (1 1, 0 0, -1 1, 1 1)
 !ok
 
 # Using a 3d polygon
-SELECT ST_AsText(ST_Boundary(ST_GeomFromText('POLYGON Z((1 1 1,0 0 1, -1 1 1, 1 1 1))')));
-
+SELECT ST_AsText(ST_Boundary('POLYGON Z((1 1 1,0 0 1, -1 1 1, 1 1 1))'));
 EXPR$0
-MULTILINESTRING Z ((1 1 1, 0 0 1, -1 1 1, 1 1 1))
+LINEARRING Z(1 1 1, 0 0 1, -1 1 1, 1 1 1)
 !ok
 
 # Using a 3d multilinestring
-SELECT ST_AsText(ST_Boundary(ST_GeomFromText('MULTILINESTRING Z((1 1 1,0 0 0.5, -1 1 1),(1 1 0.5,0 0 0.5, -1 1 0.5, 1 1 0.5) )')));
-
+SELECT ST_AsText(ST_Boundary('MULTILINESTRING Z((1 1 1,0 0 0.5, -1 1 1),(1 1 0.5,0 0 0.5, -1 1 0.5, 1 1 0.5) )'));
 EXPR$0
-MULTIPOINT Z ((1 1 1), (-1 1 1))
+MULTIPOINT Z((-1 1 1), (1 1 1))
 !ok
 
 # ST_Centroid(geom) Returns the centroid of *geom* (which may be a geometry-collection)
-# Not implemented
+
+SELECT ST_Centroid('MULTIPOINT((4 4), (1 1), (1 0), (0 3))');
+EXPR$0
+POINT (1.5 2)
+!ok
+
+SELECT ST_Centroid('LINESTRING(2 1, 1 3, 5 2)');
+EXPR$0
+POINT (2.472556942838389 2.3241856476127962)
+!ok
+
+SELECT ST_Centroid('MULTILINESTRING((1 5, 6 5), (5 1, 5 4))');
+EXPR$0
+POINT (4.0625 4.0625)
+!ok
+
+SELECT ST_Centroid('POLYGON((1 5, 1 2, 6 2, 3 3, 3 4, 5 6, 1 5))');
+EXPR$0
+POINT (2.5964912280701755 3.666666666666667)
+!ok
+
+SELECT ST_Centroid('MULTIPOLYGON(((0 2, 3 2, 3 6, 0 6, 0 2)), ((5 0, 7 0, 7 1, 5 1, 5 0)))');
+EXPR$0
+POINT (2.142857142857143 3.5)
+!ok
+
+SELECT ST_Centroid('GEOMETRYCOLLECTION(
+                      POLYGON((1 2, 4 2, 4 6, 1 6, 1 2)),
+                      LINESTRING(2 6, 6 2),
+                      MULTIPOINT((4 4), (1 1), (1 0), (0 3)))');
+EXPR$0
+POINT (2.5 4)
+!ok
+
 
 # ST_CompactnessRatio(polygon) Returns the square root of *polygon*'s area divided by the area of the circle with circumference equal to its perimeter
 # Not implemented
 
 # ST_CoordDim(geom) Returns the dimension of the coordinates of *geom*
-# Not implemented
+
+SELECT ST_CoordDim('Point(1 2 3)');
+EXPR$0
+3
+!ok
+
+SELECT ST_CoordDim('Point(1 2)');
+EXPR$0
+2
+!ok
+
+SELECT ST_CoordDim('Point Empty');
+EXPR$0
+2
+!ok
 
 # ST_Dimension(geom) Returns the dimension of *geom*
-# Not implemented
+
+SELECT ST_Dimension('MULTIPOINT((4 4), (1 1), (1 0), (0 3))');
+EXPR$0
+0
+!ok
+
+SELECT ST_Dimension('LINESTRING(2 1, 1 3, 5 2)');
+EXPR$0
+1
+!ok
+
+SELECT ST_Dimension('MULTIPOLYGON(((0 2, 3 2, 3 6, 0 6, 0 2)), ((5 0, 7 0, 7 1, 5 1, 5 0)))');
+EXPR$0
+2
+!ok
 
 # ST_Distance(geom1, geom2) Returns the distance between *geom1* and *geom2*
 
@@ -435,35 +732,34 @@ EXPR$0
 !ok
 
 SELECT ST_Distance(
-    ST_GeomFromText('POINT(10 10)',4326),
+    ST_GeomFromText('POINT(10 10)', 4326),
     ST_GeomFromText('POINT(40 50)', 4326));
 EXPR$0
 50.0
 !ok
 
 # Geometry example - units in planar degrees 4326 is WGS 84 long lat unit=degrees
-SELECT ST_Distance(
-    ST_GeomFromText('POINT(-72.1235 42.3521)',4326),
-    ST_GeomFromText('LINESTRING(-72.1260 42.45, -72.123 42.1546)', 4326));
+SELECT round(ST_Distance(
+    ST_GeomFromText('POINT(-72.1235 42.3521)', 4326),
+    ST_GeomFromText('LINESTRING(-72.1260 42.45, -72.123 42.1546)', 4326)), 10);
 EXPR$0
-0.0015056772638282166
+0.0015056773
 !ok
 
 # Geometry example - units in meters (SRID: 26986 Massachusetts state plane meters) (most accurate for Massachusetts)
-SELECT ST_Distance(
+SELECT round(ST_Distance(
     ST_Transform(ST_GeomFromText('POINT(-72.1235 42.3521)',4326),26986),
-    ST_Transform(ST_GeomFromText('LINESTRING(-72.1260 42.45, -72.123 42.1546)', 4326),26986));
+    ST_Transform(ST_GeomFromText('LINESTRING(-72.1260 42.45, -72.123 42.1546)', 4326),26986)), 10);
 EXPR$0
-0.0015056772638282166
+123.7979378784
 !ok
 
 # Geometry example - units in meters (SRID: 2163 US National Atlas Equal area) (least accurate)
-SELECT ST_Distance(
-    ST_Transform(ST_GeomFromText('POINT(-72.1235 42.3521)',4326),2163),
-    ST_Transform(ST_GeomFromText('LINESTRING(-72.1260 42.45, -72.123 42.1546)', 4326),2163));
-
+SELECT round(ST_Distance(
+    ST_Transform(ST_GeomFromText('POINT(-72.1235 42.3521)', 4326), 2163),
+    ST_Transform(ST_GeomFromText('LINESTRING(-72.1260 42.45, -72.123 42.1546)', 4326), 2163)), 10);
 EXPR$0
-0.0015056772638282166
+126.6642560574
 !ok
 
 # Disabled: PostgreSQL does geography, Calcite does not
@@ -480,48 +776,100 @@ FROM (SELECT
 !ok
 !}
 
-# ST_EndPoint(lineString) Returns the last coordinate of *lineString*
-# Not implemented
+# ST_EndPoint(geom) Returns the last coordinate of *geom*
+
+SELECT ST_EndPoint('MULTILINESTRING((1 1, 1 6, 2 2, -1 2))');
+EXPR$0
+POINT (-1 2)
+!ok
 
 # ST_Envelope(geom [, srid ]) Returns the envelope of *geom* (which may be a geometry-collection) as a geometry
 
-SELECT ST_AsText(ST_Envelope(ST_GeomFromText('POINT(1 3)')));
+SELECT ST_AsText(ST_Envelope('POINT(1 3)'));
 EXPR$0
-POLYGON ((1 3, 1 3, 1 3, 1 3, 1 3))
+POINT (1 3)
 !ok
 
-SELECT ST_AsText(ST_Envelope(ST_GeomFromText('LINESTRING(0 0, 1 3)')));
+SELECT ST_AsText(ST_Envelope('LINESTRING(0 0, 1 3)'));
 EXPR$0
-POLYGON ((0 0, 1 0, 1 3, 0 3, 0 0))
+POLYGON ((0 0, 0 3, 1 3, 1 0, 0 0))
 !ok
 
-SELECT ST_AsText(ST_Envelope(ST_GeomFromText('POLYGON((0 0, 0 1, 1.0000001 1, 1.0000001 0, 0 0))')));
+SELECT ST_AsText(ST_Envelope('POLYGON((0 0, 0 1, 1.0000001 1, 1.0000001 0, 0 0))'));
 EXPR$0
-POLYGON ((0 0, 1.0000001 0, 1.0000001 1, 0 1, 0 0))
+POLYGON ((0 0, 0 1, 1.0000001 1, 1.0000001 0, 0 0))
 !ok
 
-SELECT ST_AsText(ST_Envelope(ST_GeomFromText('POLYGON((0 0, 0 1, 1.0000000001 1, 1.0000000001 0, 0 0))')));
+SELECT ST_AsText(ST_Envelope('POLYGON((0 0, 0 1, 1.0000000001 1, 1.0000000001 0, 0 0))'));
 EXPR$0
-POLYGON ((0 0, 1.0000000001 0, 1.0000000001 1, 0 1, 0 0))
+POLYGON ((0 0, 0 1, 1.0000000001 1, 1.0000000001 0, 0 0))
 !ok
 
 # ST_Explode(query [, fieldName]) Explodes the geometry-collections in the *fieldName* column of a query into multiple geometries
-# Not implemented
+
+SELECT t.geom, t.index FROM table(ST_Explode(ST_GeomFromText('MULTIPOINT((1 1), (2 2), (3 3), (4 4))'))) as t(geom, index);
+GEOM, INDEX
+POINT (1 1), 0
+POINT (2 2), 1
+POINT (3 3), 2
+POINT (4 4), 3
+!ok
+
+SELECT t1.id, t2.geom, t2.index
+FROM (SELECT 1 as id, 'MULTIPOINT((1 1), (2 2))' as points UNION ALL SELECT 2 as id, 'MULTIPOINT((3 3), (4 4))' as points) as t1,
+LATERAL table(ST_Explode(t1.points)) as t2(geom, index);
+ID, GEOM, INDEX
+1, POINT (1 1), 0
+1, POINT (2 2), 1
+2, POINT (3 3), 0
+2, POINT (4 4), 1
+!ok
 
 # ST_Extent(geom) Returns the minimum bounding box of *geom* (which may be a geometry-collection)
-# Not implemented
+
+SELECT ST_Extent('MULTIPOINT((5 6), (1 2), (3 4), (10 3))');
+EXPR$0
+POLYGON ((1 2, 1 6, 10 6, 10 2, 1 2))
+!ok
+
+SELECT ST_Extent('POINT(5 6)');
+EXPR$0
+POINT (5 6)
+!ok
+
+SELECT ST_Extent('GEOMETRYCOLLECTION(
+  POLYGON((0 0, 3 -1, 1.5 2, 0 0)),
+  POLYGON((2 0, 3 3, 4 2, 2 0)),
+  POINT(5 6),
+  LINESTRING(1 1, 1 6))');
+EXPR$0
+POLYGON ((0 -1, 0 6, 5 6, 5 -1, 0 -1))
+!ok
 
 # ST_ExteriorRing(polygon) Returns the exterior ring of *polygon* as a linear-ring
-# Not implemented
+
+SELECT ST_ExteriorRing('POLYGON((0 -1, 0 2, 3 2, 3 -1, 0 -1))');
+EXPR$0
+LINEARRING (0 -1, 0 2, 3 2, 3 -1, 0 -1)
+!ok
+
+SELECT ST_ExteriorRing('POINT(1 2)');
+EXPR$0
+null
+!ok
 
 # ST_GeometryN(geomCollection, n) Returns the *n*th geometry of *geomCollection*
-# Not implemented
+
+SELECT ST_ExteriorRing('POINT(1 2)');
+EXPR$0
+null
+!ok
 
 # ST_GeometryType(geom) Returns the type of *geom*
 
-SELECT ST_GeometryType(ST_Point(0.0, 0.0));
+SELECT ST_GeometryN('MULTIPOLYGON(((0 0, 3 -1, 1.5 2, 0 0)), ((1 2, 4 2, 4 6, 1 6, 1 2)))', 1);
 EXPR$0
-POINT
+POLYGON ((0 0, 3 -1, 1.5 2, 0 0))
 !ok
 
 # ST_GeometryTypeCode(geom) Returns the type code of *geom*
@@ -530,35 +878,135 @@ SELECT id, ST_GeometryType(g), ST_GeometryTypeCode(g) FROM (VALUES
  ('ls', ST_GeomFromText('LINESTRING(77.29 29.07,77.42 29.26,77.27 29.31,77.29 29.07)')),
  ('p', ST_Point(0.0, 0.0)),
  ('np', ST_Point(0.0, CAST(NULL AS DECIMAL))),
- ('mp', ST_GeomFromText('MULTIPOLYGON(((1 1, 2 2, 5 3, 1 1)),
-                                       ((0 0, 2 2, 5 3, 0 0)))'))) AS t(id, g);
+ ('mp', ST_GeomFromText('MULTIPOLYGON(((1 1, 2 2, 5 3, 1 1)), ((0 0, 2 2, 5 3, 0 0)))'))
+) AS t(id, g);
 ID, EXPR$1, EXPR$2
 ls, LINESTRING, 2
-mp, POLYGON, 3
+mp, MULTIPOLYGON, 6
 np, null, null
 p , POINT, 1
 !ok
 
 # ST_InteriorRingN(polygon, n) Returns the *n*th interior ring of *polygon*
-# Not implemented
+
+SELECT ST_InteriorRing('POLYGON((0 0, 10 0, 10 6, 0 6, 0 0), (1 1, 2 1, 2 5, 1 5, 1 1), (8 5, 8 4, 9 4, 9 5, 8 5))', 0);
+EXPR$0
+LINEARRING (1 1, 2 1, 2 5, 1 5, 1 1)
+!ok
+
+SELECT ST_InteriorRing('POLYGON((0 0, 10 0, 10 6, 0 6, 0 0), (1 1, 2 1, 2 5, 1 5, 1 1), (8 5, 8 4, 9 4, 9 5, 8 5))', 1);
+EXPR$0
+LINEARRING (8 5, 8 4, 9 4, 9 5, 8 5)
+!ok
 
 # ST_IsClosed(geom) Returns whether *geom* is a closed line-string or multi-line-string
-# Not implemented
+
+SELECT ST_IsClosed('LINESTRING(2 1, 1 3, 5 2)');
+EXPR$0
+false
+!ok
+
+SELECT ST_IsClosed('LINESTRING(2 1, 1 3, 5 2, 2 1)');
+EXPR$0
+true
+!ok
 
 # ST_IsEmpty(geom) Returns whether *geom* is empty
-# Not implemented
+
+SELECT ST_IsEmpty('MULTIPOINT((4 4), (1 1), (1 0), (0 3))');
+EXPR$0
+false
+!ok
+
+SELECT ST_IsEmpty('GEOMETRYCOLLECTION(
+  MULTIPOINT((4 4), (1 1), (1 0), (0 3)),
+  LINESTRING(2 6, 6 2),
+  POLYGON((1 2, 4 2, 4 6, 1 6, 1 2)))');
+EXPR$0
+false
+!ok
+
+SELECT ST_IsEmpty('POLYGON EMPTY');
+EXPR$0
+true
+!ok
 
 # ST_IsRectangle(geom) Returns whether *geom* is a rectangle
-# Not implemented
+
+SELECT ST_IsRectangle('POLYGON((0 0, 10 0, 10 5, 0 5, 0 0))');
+EXPR$0
+true
+!ok
+
+SELECT ST_IsRectangle('POLYGON((0 0, 10 0, 10 7, 0 5, 0 0))');
+EXPR$0
+false
+!ok
 
 # ST_IsRing(geom) Returns whether *geom* is a closed and simple line-string or multi-line-string
-# Not implemented
+
+SELECT ST_IsRing('LINESTRING(2 1, 1 3, 6 6, 2 1)');
+EXPR$0
+true
+!ok
+
+SELECT ST_IsRing('LINESTRING(2 1, 1 3, 6 6)');
+EXPR$0
+false
+!ok
+
+SELECT ST_IsRing('LINESTRING(2 1, 1 3, 6 6, 5 7, 5 2, 2 1)');
+EXPR$0
+false
+!ok
+
+SELECT ST_IsRing('LINESTRING(2 1, 1 3, 6 6, 5 7, 5 2)');
+EXPR$0
+false
+!ok
 
 # ST_IsSimple(geom) Returns whether *geom* is simple
-# Not implemented
+
+SELECT ST_IsSimple('POLYGON((0 0, 10 0, 10 6, 0 6, 0 0), (1 1, 2 1, 2 5, 1 5, 1 1), (8 5, 8 4, 9 4, 9 5, 8 5))');
+EXPR$0
+true
+!ok
+
+SELECT ST_IsSimple('MULTILINESTRING((0 2, 3 2, 3 6, 0 6, 0 2), (5 0, 7 0, 7 1, 5 1, 5 0))');
+EXPR$0
+true
+!ok
+
+SELECT ST_IsSimple(
+ 'GEOMETRYCOLLECTION(
+   MULTIPOINT((4 4), (1 1), (1 0), (0 3)),
+   LINESTRING(2 6, 6 2),
+   POLYGON((1 2, 4 2, 4 6, 1 6, 1 2)))');
+EXPR$0
+true
+!ok
+
+SELECT ST_IsSimple('LINESTRING(2 1, 1 3, 6 6, 5 7, 5 6)');
+EXPR$0
+true
+!ok
+
+SELECT ST_IsSimple('LINESTRING(2 1, 1 3, 6 6, 5 7, 5 2)');
+EXPR$0
+false
+!ok
 
 # ST_IsValid(geom) Returns whether *geom* is valid
-# Not implemented
+
+SELECT ST_IsValid('POLYGON((0 0, 10 0, 10 5, 0 5, 0 0))');
+EXPR$0
+true
+!ok
+
+SELECT ST_IsValid('POLYGON((0 0, 10 0, 10 5, 6 -2, 0 0))');
+EXPR$0
+false
+!ok
 
 # ST_IsValidDetail(geom [, selfTouchValid ]) Returns a valid detail as an array of objects
 # Not implemented
@@ -567,101 +1015,276 @@ p , POINT, 1
 # Not implemented
 
 # ST_NPoints(geom) Returns the number of points in *geom*
-# Not implemented
+# Alias: ST_NumPoints
 
 # ST_NumGeometries(geom) Returns the number of geometries in *geom* (1 if it is not a geometry-collection)
-# Not implemented
 
-# ST_NumInteriorRing(geom) Alias for `ST_NumInteriorRings`
-# Not implemented
+SELECT ST_NumGeometries('LINESTRING(2 1, 1 3, 5 2)');
+EXPR$0
+1
+!ok
+
+SELECT ST_NumGeometries('MULTILINESTRING(
+  (0 2, 3 2, 3 6, 0 6, 0 1),
+  (5 0, 7 0, 7 1, 5 1, 5 0))');
+EXPR$0
+2
+!ok
+
+SELECT ST_NumGeometries('POLYGON(
+  (0 0, 10 0, 10 6, 0 6, 0 0),
+  (1 1, 2 1, 2 5, 1 5, 1 1),
+  (8 5, 8 4, 9 4, 9 5, 8 5))');
+EXPR$0
+1
+!ok
+
+SELECT ST_NumGeometries('MULTIPOLYGON(
+  ((0 0, 10 0, 10 6, 0 6, 0 0)),
+  ((1 1, 2 1, 2 5, 1 5, 1 1)),
+  ((8 5, 8 4, 9 4, 9 5, 8 5)))');
+EXPR$0
+3
+!ok
+
+SELECT ST_NumGeometries('GEOMETRYCOLLECTION(
+  MULTIPOINT((4 4), (1 1), (1 0), (0 3)),
+  LINESTRING(2 6, 6 2),
+  POLYGON((1 2, 4 2, 4 6, 1 6, 1 2)))');
+EXPR$0
+3
+!ok
+
+SELECT ST_NumGeometries('MULTIPOINT(
+  (0 2), (3 2), (3 6), (0 6),
+  (0 1), (5 0), (7 0))');
+EXPR$0
+7
+!ok
 
 # ST_NumInteriorRings(geom) Returns the number of interior rings of *geom*
-# Not implemented
 
-# ST_NumPoints(lineString) Returns the number of points in *lineString*
-# Not implemented
+SELECT ST_NumInteriorRings('POLYGON(
+  (0 0, 10 0, 10 6, 0 6, 0 0),
+  (1 1, 2 1, 2 5, 1 5, 1 1),
+  (8 5, 8 4, 9 4, 9 5, 8 5))');
+EXPR$0
+2
+!ok
 
-# ST_PointN(geom, n) Returns the *n*th point of a *lineString*
-# Not implemented
+SELECT ST_NumInteriorRings('MULTIPOLYGON(
+  ((0 0, 10 0, 10 6, 0 6, 0 0), (1 1, 2 1, 2 5, 1 5, 1 1)),
+  ((1 1, 2 1, 2 5, 1 5, 1 1)),
+  ((8 5, 8 4, 9 4, 9 5, 8 5)))');
+EXPR$0
+1
+!ok
+
+SELECT ST_NumInteriorRings('GEOMETRYCOLLECTION(
+  MULTIPOINT((4 4), (1 1), (1 0), (0 3)),
+  LINESTRING(2 6, 6 2),
+  POLYGON((1 2, 4 2, 4 6, 1 6, 1 2)))');
+EXPR$0
+0
+!ok
+
+SELECT ST_NumInteriorRings(
+  'GEOMETRYCOLLECTION(
+    MULTIPOINT((4 4), (1 1), (1 0), (0 3)),
+    LINESTRING(2 6, 6 2),
+    POLYGON((1 2, 4 2, 4 6, 1 6, 1 2), (2 4, 3 4, 3 5, 2 5, 2 4)))');
+EXPR$0
+1
+!ok
+
+
+# ST_NumPoints(geom) Returns the number of points in *geom*
+
+SELECT ST_NumPoints('POINT(2 2)');
+EXPR$0
+1
+!ok
+
+SELECT ST_NumPoints('MULTIPOINT(2 2, 4 4)');
+EXPR$0
+2
+!ok
+
+SELECT ST_NumPoints('MULTIPOINT(2 2, 4 4, 4 4)');
+EXPR$0
+3
+!ok
+
+SELECT ST_NumPoints('MULTILINESTRING((2 2, 4 4), (3 1, 6 3))');
+EXPR$0
+4
+!ok
+
+SELECT ST_NumPoints('POLYGON((0 0, 10 0, 10 6, 0 6, 0 0), (1 1, 2 1, 2 5, 1 5, 1 1), (8 5, 8 4, 9 4, 9 5, 8 5))');
+EXPR$0
+15
+!ok
+
+# ST_PointN(geom, n) Returns the *n*th point of a *geom*
+
+SELECT ST_PointN('LINESTRING(1 1, 1 6, 2 2, -1 2))', 2);
+EXPR$0
+POINT (2 2)
+!ok
+
+SELECT ST_PointN('MULTILINESTRING((1 1, 1 6, 2 2, -1 2))', 3);
+EXPR$0
+POINT (-1 2)
+!ok
+
+SELECT ST_PointN('MULTIPOINT(1 1, 1 6, 2 2, -1 2)', -1);
+EXPR$0
+POINT (-1 2)
+!ok
+
+SELECT ST_PointN('MULTILINESTRING((1 1, 1 6, 2 2, -1 2), (0 1, 2 4))', 4);
+EXPR$0
+POINT (0 1)
+!ok
 
 # ST_PointOnSurface(geom) Returns an interior or boundary point of *geom*
-# Not implemented
+
+SELECT ST_PointOnSurface('POINT(1 5)');
+EXPR$0
+POINT (1 5)
+!ok
+
+SELECT ST_PointOnSurface('MULTIPOINT((4 4), (1 1), (1 0), (0 3)))');
+EXPR$0
+POINT (1 1)
+!ok
+
+SELECT ST_PointOnSurface('LINESTRING(-1 5, 0 10)');
+EXPR$0
+POINT (0 10)
+!ok
+
+SELECT ST_PointOnSurface('POLYGON((0 0, 0 5, 5 5, 5 0, 0 0))');
+EXPR$0
+POINT (2.5 2.5)
+!ok
 
 # ST_SRID(geom) Returns SRID value of *geom* or 0 if it does not have one
-# Not implemented
 
-# ST_StartPoint(lineString) Returns the first coordinate of *lineString*
-# Not implemented
+SELECT ST_SRID(ST_GeomFromText('POINT(15 25)', 2154));
+EXPR$0
+2154
+!ok
+
+SELECT ST_SRID(ST_GeomFromText('LINESTRING(2 1, 1 3, 5 2, 2 1)', 4326));
+EXPR$0
+4326
+!ok
+
+# ST_StartPoint(geom) Returns the first coordinate of *geom*
+
+SELECT ST_StartPoint('MULTILINESTRING((1 1, 1 6, 2 2, -1 2))');
+EXPR$0
+POINT (1 1)
+!ok
 
 # ST_X(geom) Returns the x-value of the first coordinate of *geom*
 
-SELECT ST_X(ST_GeomFromText('POINT Z(1 2 3)'));
+SELECT ST_X('POINT Z(1 2 3)');
 EXPR$0
 1.0
 !ok
 
-SELECT ST_X(ST_GeomFromText('POINT (1 2)'));
+SELECT ST_X('POINT (1 2)');
 EXPR$0
 1.0
 !ok
 
 # ST_XMax(geom) Returns the maximum x-value of *geom*
-# Not implemented
+SELECT ST_XMax('LINESTRING(1 3 4, 5 6 7)');
+EXPR$0
+5.0
+!ok
 
 # ST_XMin(geom) Returns the minimum x-value of *geom*
-# Not implemented
+SELECT ST_XMin('LINESTRING(1 3 4, 5 6 7)');
+EXPR$0
+1.0
+!ok
 
 # ST_Y(geom) Returns the y-value of the first coordinate of *geom*
 
-SELECT ST_Y(ST_GeomFromText('POINT Z(1 2 3)'));
+SELECT ST_Y('POINT Z(1 2 3)');
 EXPR$0
 2.0
 !ok
 
-SELECT ST_Y(ST_GeomFromText('POINT (1 2)'));
+SELECT ST_Y('POINT (1 2)');
 EXPR$0
 2.0
 !ok
 
 # ST_YMax(geom) Returns the maximum y-value of *geom*
-# Not implemented
+SELECT ST_YMax('LINESTRING(1 3 4, 5 6 7)');
+EXPR$0
+6.0
+!ok
 
 # ST_YMin(geom) Returns the minimum y-value of *geom*
-# Not implemented
+SELECT ST_YMin('LINESTRING(1 3 4, 5 6 7)');
+EXPR$0
+3.0
+!ok
 
 #### Geometry properties (3D)
 
 # ST_Is3D(s) Returns whether *geom* has at least one z-coordinate
 
-SELECT ST_Is3D(ST_GeomFromText('POINT Z(1 2 0)'));
+SELECT ST_Is3D('POINT Z(1 2 0)');
 EXPR$0
 true
 !ok
 
-SELECT ST_Is3D(ST_GeomFromText('POINT (1 2)'));
+SELECT ST_Is3D('POINT (1 2)');
 EXPR$0
 false
 !ok
 
 # ST_Z(geom) Returns the z-value of the first coordinate of *geom*
 
-SELECT ST_Z(ST_GeomFromText('POINT Z(1 2 3)'));
+SELECT ST_Z('POINT Z(1 2 3)');
 EXPR$0
 3.0
 !ok
 
-SELECT ST_Z(ST_GeomFromText('POINT (1 2)'));
+SELECT ST_Z('POINT (1 2)');
 EXPR$0
-null
+NaN
 !ok
 
-# Not implemented
-
 # ST_ZMax(geom) Returns the maximum z-value of *geom*
-# Not implemented
+
+SELECT ST_ZMax('LINESTRING(1 2 3, 4 5 6)');
+EXPR$0
+6.0
+!ok
+
+SELECT ST_ZMax('LINESTRING(1 2, 4 5)');
+EXPR$0
+NaN
+!ok
 
 # ST_ZMin(geom) Returns the minimum z-value of *geom*
-# Not implemented
+
+SELECT ST_ZMin('LINESTRING(1 2 3, 4 5 6)');
+EXPR$0
+3.0
+!ok
+
+SELECT ST_ZMin('LINESTRING(1 2, 4 5)');
+EXPR$0
+NaN
+!ok
 
 ### Geometry predicates
 
@@ -685,20 +1308,39 @@ SELECT ST_GeometryType(geomA) As geomtype, ST_Contains(geomA,geomA) AS acontains
 FROM (VALUES ( ST_Buffer(ST_Point(1.0,1.0), 5/*,1*/) ),
              ( ST_MakeLine(ST_Point(1.0,1.0), ST_Point(-1.0,-1.0) ) ),
              ( ST_Point(1.0,1.0))) As foo(geomA);
-
 GEOMTYPE, ACONTAINSA, ACONTAINSPROPA, ACONTAINSBA, ACONTAINSPROPBA
 LINESTRING, true, true, false, false
 POINT, true, true, false, false
 POLYGON, true, true, false, false
 !ok
 
+# ST_CoveredBy(geom1, geom2) Returns whether no point in *geom1* is outside *geom2*
+
+SELECT ST_CoveredBy('POINT(0 0)', ST_Buffer('POINT(0 0)', 1));
+EXPR$0
+true
+!ok
+
+SELECT ST_CoveredBy('POINT(1 1)', ST_Buffer('POINT(0 0)', 1));
+EXPR$0
+false
+!ok
+
 # ST_Covers(geom1, geom2) Returns whether no point in *geom2* is outside *geom1*
-# Not implemented
+
+SELECT ST_Covers(ST_Buffer('POINT(0 0)', 1), 'POINT(0 0)');
+EXPR$0
+true
+!ok
+
+SELECT ST_Covers(ST_Buffer('POINT(0 0)', 1), 'POINT(1 1)');
+EXPR$0
+false
+!ok
 
 # ST_Crosses(geom1, geom2) Returns whether *geom1* crosses *geom2*
 
-SELECT ST_Crosses(ST_GeomFromText('LINESTRING(1 3, 5 3)'),
-                  ST_GeomFromText('LINESTRING(1 1, 5 2, 2 5)'));
+SELECT ST_Crosses('LINESTRING(1 3, 5 3)', 'LINESTRING(1 1, 5 2, 2 5)');
 EXPR$0
 true
 !ok
@@ -741,8 +1383,7 @@ United Kingdom
 
 # ST_Disjoint(geom1, geom2) Returns whether *geom1* and *geom2* are disjoint
 
-SELECT ST_Disjoint(ST_GeomFromText('LINESTRING(1 3, 5 3)'),
-                   ST_GeomFromText('LINESTRING(1 1, 5 2, 2 5)'));
+SELECT ST_Disjoint('LINESTRING(1 3, 5 3)', 'LINESTRING(1 1, 5 2, 2 5)');
 EXPR$0
 false
 !ok
@@ -750,57 +1391,87 @@ false
 
 # ST_EnvelopesIntersect(geom1, geom2) Returns whether the envelope of *geom1* intersects the envelope of *geom2*
 
-SELECT ST_EnvelopesIntersect(ST_GeomFromText('LINESTRING(1 3, 5 3)'),
-                             ST_GeomFromText('LINESTRING(1 1, 5 2, 2 5)'));
+SELECT ST_EnvelopesIntersect('LINESTRING(1 3, 5 3)', 'LINESTRING(1 1, 5 2, 2 5)');
 EXPR$0
 true
 !ok
 
 # ST_Equals(geom1, geom2) Returns whether *geom1* equals *geom2*
 
-SELECT ST_Equals(ST_GeomFromText('LINESTRING(1 3, 5 3)'),
-                 ST_GeomFromText('LINESTRING(1 1, 5 2, 2 5)'));
+SELECT ST_Equals('LINESTRING(1 3, 5 3)', 'LINESTRING(1 1, 5 2, 2 5)');
 EXPR$0
 false
 !ok
 
 # ST_Intersects(geom1, geom2) Returns whether *geom1* intersects *geom2*
 
-SELECT ST_Intersects(ST_GeomFromText('LINESTRING(1 3, 5 3)'),
-                     ST_GeomFromText('LINESTRING(1 1, 5 2, 2 5)'));
+SELECT ST_Intersects('LINESTRING(1 3, 5 3)', 'LINESTRING(1 1, 5 2, 2 5)');
 EXPR$0
 true
 !ok
 
 # ST_OrderingEquals(geom1, geom2) Returns whether *geom1* equals *geom2* and their coordinates and component Geometries are listed in the same order
-# Not implemented
+SELECT ST_OrderingEquals('LINESTRING(0 0 1, 0 0, 10 10 3)', 'LINESTRING(0 0 1, 0 0, 10 10 3)');
+EXPR$0
+true
+!ok
+
+SELECT ST_OrderingEquals('LINESTRING(0 0, 10 10)', 'LINESTRING(0 0, 5 5, 10 10)');
+EXPR$0
+false
+!ok
+
+SELECT ST_OrderingEquals('POLYGON ((0 0, 10 10, 10 5, 0 0))', 'POLYGON ((0 0, 10 5, 10 10, 0 0))');
+EXPR$0
+false
+!ok
 
 # ST_Overlaps(geom1, geom2) Returns whether *geom1* overlaps *geom2*
 
-SELECT ST_Overlaps(ST_GeomFromText('LINESTRING(1 3, 5 3)'),
-                   ST_GeomFromText('LINESTRING(1 1, 5 2, 2 5)'));
+SELECT ST_Overlaps('LINESTRING(1 3, 5 3)', 'LINESTRING(1 1, 5 2, 2 5)');
 EXPR$0
 false
 !ok
 
 # ST_Relate(geom1, geom2) Returns the DE-9IM intersection matrix of *geom1* and *geom2*
-# Not implemented
+
+SELECT ST_Relate('LINESTRING(1 2, 3 4)', 'LINESTRING(5 6, 7 3)');
+EXPR$0
+FF1FF0102
+!ok
+
+SELECT ST_Relate('POLYGON((1 1, 4 1, 4 5, 1 5, 1 1))', 'POLYGON((3 2, 6 2, 6 6, 3 6, 3 2))');
+EXPR$0
+212101212
+!ok
 
 # ST_Relate(geom1, geom2, iMatrix) Returns whether *geom1* and *geom2* are related by the given intersection matrix *iMatrix*
-# Not implemented
 
-# ST_Touches(geom1, geom2) Returns whether *geom1* touches *geom2*
+SELECT ST_Relate('POLYGON((1 1, 4 1, 4 5, 1 5, 1 1))', 'POLYGON((3 2, 6 2, 6 6, 3 6, 3 2))', '212101212');
+EXPR$0
+true
+!ok
 
-SELECT ST_Touches(ST_GeomFromText('LINESTRING(1 3, 5 3)'),
-                  ST_GeomFromText('LINESTRING(1 1, 5 2, 2 5)'));
+SELECT ST_Relate('POLYGON((1 1, 4 1, 4 5, 1 5, 1 1))', 'POLYGON((3 2, 6 2, 6 6, 3 6, 3 2))', '112101212');
 EXPR$0
 false
 !ok
 
-# ST_Within(geom1, geom2) Returns whether *geom1* is within *geom2*
+SELECT ST_Relate('POINT(1 2)', ST_Buffer('POINT(1 2)', 2), '0F*FFF212');
+EXPR$0
+true
+!ok
+
+# ST_Touches(geom1, geom2) Returns whether *geom1* touches *geom2*
 
-SELECT ST_Within(ST_GeomFromText('LINESTRING(1 3, 5 3)'),
-                 ST_GeomFromText('LINESTRING(1 1, 5 2, 2 5)'));
+SELECT ST_Touches('LINESTRING(1 3, 5 3)', 'LINESTRING(1 1, 5 2, 2 5)');
+EXPR$0
+false
+!ok
+
+# ST_Within(geom1, geom2) Returns whether *geom1* is within *geom2*
+
+SELECT ST_Within('LINESTRING(1 3, 5 3)', 'LINESTRING(1 1, 5 2, 2 5)');
 EXPR$0
 false
 !ok
@@ -809,280 +1480,915 @@ false
 
 # ST_Buffer(geom, bufferSize [, quadSegs | style ]) Computes a buffer around *geom*
 
-SELECT ST_Buffer(
- ST_GeomFromText('POINT(100 90)'),
- 50);
+SELECT ST_ReducePrecision(ST_AsWKT(ST_Buffer('POINT(100 90)', 50)), 0.01);
+EXPR$0
+POLYGON ((150 90, 149.04 80.25, 146.19 70.87, 141.57 62.22, 135.36 54.64, 127.78 48.43, 119.13 43.81, 109.75 40.96, 100 40, 90.25 40.96, 80.87 43.81, 72.22 48.43, 64.64 54.64, 58.43 62.22, 53.81 70.87, 50.96 80.25, 50 90, 50.96 99.75, 53.81 109.13, 58.43 117.78, 64.64 125.36, 72.22 131.57, 80.87 136.19, 90.25 139.04, 100 140, 109.75 139.04, 119.13 136.19, 127.78 131.57, 135.36 125.36, 141.57 117.78, 146.19 109.13, 149.04 99.75, 150 90))
+!ok
+
+SELECT ST_ReducePrecision(ST_AsWKT(ST_Buffer('LINESTRING(10 10,30 10)', 5)), 0.01);
+EXPR$0
+POLYGON ((30 15, 30.98 14.9, 31.91 14.62, 32.78 14.16, 33.54 13.54, 34.16 12.78, 34.62 11.91, 34.9 10.98, 35 10, 34.9 9.02, 34.62 8.09, 34.16 7.22, 33.54 6.46, 32.78 5.84, 31.91 5.38, 30.98 5.1, 30 5, 10 5, 9.02 5.1, 8.09 5.38, 7.22 5.84, 6.46 6.46, 5.84 7.22, 5.38 8.09, 5.1 9.02, 5 10, 5.1 10.98, 5.38 11.91, 5.84 12.78, 6.46 13.54, 7.22 14.16, 8.09 14.62, 9.02 14.9, 10 15, 30 15))
+!ok
+
+SELECT ST_ReducePrecision(ST_AsWKT(ST_Buffer(
+  'POLYGON((-71.1776585052917 42.3902909739571,-71.1776820268866 42.3903701743239,
+    -71.1776063012595 42.3903825660754,-71.1775826583081 42.3903033653531,-71.1776585052917 42.3902909739571))',
+ 50)), 0.01);
+EXPR$0
+POLYGON ((-63.12 -6.96, -73.39 -7.56, -83.58 -6.05, -93.24 -2.48, -101.96 2.99, -109.38 10.13, -115.18 18.64, -119.11 28.16, -119.11 28.16, -120.93 37.39, -120.98 46.81, -119.27 56.07, -115.85 64.84, -110.85 72.82, -104.45 79.72, -96.86 85.29, -88.36 89.35, -79.25 91.73, -79.25 91.73, -68.98 92.34, -58.8 90.84, -49.15 87.28, -40.43 81.82, -33.01 74.69, -27.21 66.2, -23.27 56.69, -23.27 56.69, -21.43 47.45, -21.37 38.02, -23.07 28.75, -26.49 19.97, -31.49 11.98, -37.9 5.07, -45.49 -0.51, -54 -4.57, -63.12 -6.96, -63.12 -6.96))
+!ok
+
+# Negative buffer size makes the polgyon smaller
+SELECT ST_Buffer('POLYGON((10 10,10 20,20 20,20 10, 10 10))', -1);
+EXPR$0
+POLYGON ((11 11, 11 19, 19 19, 19 11, 11 11))
+!ok
+
+SELECT ST_PrecisionReducer(ST_Buffer('POINT(100 90)', 50, 'quad_segs=8'), 3);
+EXPR$0
+POLYGON ((149.039 80.245, 146.194 70.866, 141.573 62.221, 135.355 54.645, 127.779 48.427, 119.134 43.806, 109.755 40.961, 100 40, 90.245 40.961, 80.866 43.806, 72.221 48.427, 64.645 54.645, 58.427 62.221, 53.806 70.866, 50.961 80.245, 50 90, 50.961 99.755, 53.806 109.134, 58.427 117.779, 64.645 125.355, 72.221 131.573, 80.866 136.194, 90.245 139.039, 100 140, 109.755 139.039, 119.134 136.194, 127.779 131.573, 135.355 125.355, 141.573 117.779, 146.194 109.134, 149.039 99.755, 150 90, 149.039 80.245))
+!ok
+
+SELECT ST_PrecisionReducer(ST_Buffer('POINT(100 90)', 50, 'quad_segs=2'), 3);
+EXPR$0
+POLYGON ((135.355 54.645, 100 40, 64.645 54.645, 50 90, 64.645 125.355, 100 140, 135.355 125.355, 150 90, 135.355 54.645))
+!ok
+
+SELECT ST_PrecisionReducer(ST_Buffer('LINESTRING(50 50,150 150,150 50)', 10, 'endcap=round join=round'), 3);
+EXPR$0
+POLYGON ((144.444 158.315, 146.173 159.239, 148.049 159.808, 150 160, 151.951 159.808, 153.827 159.239, 155.556 158.315, 157.071 157.071, 158.315 155.556, 159.239 153.827, 159.808 151.951, 160 150, 160 50, 159.808 48.049, 159.239 46.173, 158.315 44.444, 157.071 42.929, 155.556 41.685, 153.827 40.761, 151.951 40.192, 150 40, 148.049 40.192, 146.173 40.761, 144.444 41.685, 142.929 42.929, 141.685 44.444, 140.761 46.173, 140.192 48.049, 140 50, 140 125.858, 57.071 42.929, 55.556 41.685, 53.827 40.761, 51.951 40.192, 50 40, 48.049 40.192, 46.173 40.761, 44.444 41.685, 42.929 42.929, 41.685 44.444, 40.761 46.173, 40.192 48.049, 40 50, 40.192 51.951, 40.761 53.827, 41.685 55.556, 42.929 57.071, 142.929 157.071, 144.444 158.315))
+!ok
+
+SELECT ST_PrecisionReducer(ST_Buffer('LINESTRING(50 50,150 150,150 50)', 10, 'endcap=square join=round'), 3);
+EXPR$0
+POLYGON ((144.444 158.315, 146.173 159.239, 148.049 159.808, 150 160, 151.951 159.808, 153.827 159.239, 155.556 158.315, 157.071 157.071, 158.315 155.556, 159.239 153.827, 159.808 151.951, 160 150, 160 50, 160 40, 140 40, 140 125.858, 57.071 42.929, 50 35.858, 35.858 50, 142.929 157.071, 144.444 158.315))
+!ok
+
+SELECT ST_PrecisionReducer(ST_Buffer('LINESTRING(50 50,150 150,150 50)', 10, 'endcap=flat join=round'), 3);
+EXPR$0
+POLYGON ((144.444 158.315, 146.173 159.239, 148.049 159.808, 150 160, 151.951 159.808, 153.827 159.239, 155.556 158.315, 157.071 157.071, 158.315 155.556, 159.239 153.827, 159.808 151.951, 160 150, 160 50, 140 50, 140 125.858, 57.071 42.929, 42.929 57.071, 142.929 157.071, 144.444 158.315))
+!ok
+
+SELECT ST_PrecisionReducer(ST_Buffer('LINESTRING(50 50,150 150,150 50)', 10, 'join=bevel'), 3);
+EXPR$0
+POLYGON ((160 150, 160 50, 159.808 48.049, 159.239 46.173, 158.315 44.444, 157.071 42.929, 155.556 41.685, 153.827 40.761, 151.951 40.192, 150 40, 148.049 40.192, 146.173 40.761, 144.444 41.685, 142.929 42.929, 141.685 44.444, 140.761 46.173, 140.192 48.049, 140 50, 140 125.858, 57.071 42.929, 55.556 41.685, 53.827 40.761, 51.951 40.192, 50 40, 48.049 40.192, 46.173 40.761, 44.444 41.685, 42.929 42.929, 41.685 44.444, 40.761 46.173, 40.192 48.049, 40 50, 40.192 51.951, 40.761 53.827, 41.685 55.556, 42.929 57.071, 142.929 157.071, 160 150))
+!ok
+
+SELECT ST_PrecisionReducer(ST_Buffer('LINESTRING(50 50,150 150,150 50)', 10, 'join=mitre mitre_limit=5.0'), 3);
+EXPR$0
+POLYGON ((160 50, 159.808 48.049, 159.239 46.173, 158.315 44.444, 157.071 42.929, 155.556 41.685, 153.827 40.761, 151.951 40.192, 150 40, 148.049 40.192, 146.173 40.761, 144.444 41.685, 142.929 42.929, 141.685 44.444, 140.761 46.173, 140.192 48.049, 140 50, 140 125.858, 57.071 42.929, 55.556 41.685, 53.827 40.761, 51.951 40.192, 50 40, 48.049 40.192, 46.173 40.761, 44.444 41.685, 42.929 42.929, 41.685 44.444, 40.761 46.173, 40.192 48.049, 40 50, 40.192 51.951, 40.761 53.827, 41.685 55.556, 42.929 57.071, 160 174.142, 160 50))
+!ok
+
+SELECT ST_PrecisionReducer(ST_Buffer('LINESTRING(50 50,150 150,150 50)', 10, 'join=mitre mitre_limit=1.0'), 3);
+EXPR$0
+POLYGON ((160 50, 159.808 48.049, 159.239 46.173, 158.315 44.444, 157.071 42.929, 155.556 41.685, 153.827 40.761, 151.951 40.192, 150 40, 148.049 40.192, 146.173 40.761, 144.444 41.685, 142.929 42.929, 141.685 44.444, 140.761 46.173, 140.192 48.049, 140 50, 140 125.858, 57.071 42.929, 55.556 41.685, 53.827 40.761, 51.951 40.192, 50 40, 48.049 40.192, 46.173 40.761, 44.444 41.685, 42.929 42.929, 41.685 44.444, 40.761 46.173, 40.192 48.049, 40 50, 40.192 51.951, 40.761 53.827, 41.685 55.556, 42.929 57.071, 160 174.142, 160 50))
+!ok
+
+SELECT ST_PrecisionReducer(ST_Buffer('LINESTRING(50 50,150 150,150 50)', 10, 'side=left'), 3);
+EXPR$0
+POLYGON ((150 150, 50 50, 42.929 57.071, 142.929 157.071, 144.444 158.315, 146.173 159.239, 148.049 159.808, 150 160, 151.951 159.808, 153.827 159.239, 155.556 158.315, 157.071 157.071, 158.315 155.556, 159.239 153.827, 159.808 151.951, 160 150, 160 50, 150 50, 150 150))
+!ok
+
+SELECT ST_PrecisionReducer(ST_Buffer('LINESTRING(50 50,150 150,150 50)', 10, 'side=right'), 3);
+EXPR$0
+POLYGON ((150 150, 150 50, 140 50, 140 125.858, 57.071 42.929, 50 50, 150 150))
+!ok
+
+SELECT ST_PrecisionReducer(ST_Buffer('LINESTRING(50 50,150 150,150 50)', 10, 'side=left join=mitre'), 3);
+EXPR$0
+POLYGON ((150 150, 50 50, 42.929 57.071, 160 174.142, 160 50, 150 50, 150 150))
+!ok
+
+!if (fixed.calcite2539) {
+# ST_BUFFER(geom, bufferSize, style) variant - not implemented
+SELECT ST_Buffer('POINT(100 90)', 50, 'quad_segs=8');
+at org.apache.calcite.runtime.Geometries.todo
+!error GeoFunctions
+
+# ST_BUFFER(geom, bufferSize, quadSegs) variant - not implemented
+# When implemented, remove comment from ST_Contains test case
+SELECT ST_Buffer('POINT(100 90)', 50, 2);
+at org.apache.calcite.runtime.Geometries.todo
+!error GeoFunctions
+!}
+
+# ST_ConvexHull(geom) Computes the smallest convex polygon that contains all the points in the Geometry
+
+SELECT ST_ConvexHull('GEOMETRYCOLLECTION(
+                        POINT(1 2),
+                        LINESTRING(1 4, 4 7),
+                        POLYGON((3 1, 7 1, 7 6, 3 1)))');
+EXPR$0
+POLYGON ((3 1, 1 2, 1 4, 4 7, 7 6, 7 1, 3 1))
+!ok
+
+# ST_Difference(geom1, geom2) Computes the difference between two geometries
+
+SELECT ST_Difference('POLYGON((1 1, 7 1, 7 6, 1 6, 1 1))', 'POLYGON((3 2, 8 2, 8 8, 3 8, 3 2))');
+EXPR$0
+POLYGON ((7 2, 7 1, 1 1, 1 6, 3 6, 3 2, 7 2))
+!ok
+
+SELECT ST_Difference('POLYGON((3 2, 8 2, 8 8, 3 8, 3 2))', 'POLYGON((1 1, 7 1, 7 6, 1 6, 1 1))');
+EXPR$0
+POLYGON ((3 6, 3 8, 8 8, 8 2, 7 2, 7 6, 3 6))
+!ok
+
+# ST_Intersection(geom1, geom2) Computes the intersection of two geometries
+
+SELECT ST_Intersection('POLYGON((1 1, 7 1, 7 6, 1 6, 1 1))', 'POLYGON((3 2, 8 2, 8 8, 3 8, 3 2))');
+EXPR$0
+POLYGON ((3 6, 7 6, 7 2, 3 2, 3 6))
+!ok
+
+SELECT ST_Intersection('POLYGON((1 1, 4 1, 4 6, 1 6, 1 1))', 'POLYGON((4 2, 8 2, 8 8, 4 8, 4 2))');
+EXPR$0
+LINESTRING (4 2, 4 6)
+!ok
+
+SELECT ST_Intersection('POLYGON((1 1, 4 1, 4 6, 1 6, 1 1))', 'POLYGON((4 6, 8 6, 8 8, 4 8, 4 6))');
+EXPR$0
+POINT (4 6)
+!ok
+
+SELECT ST_Intersection('LINESTRING(2 2, 6 6)', 'LINESTRING(2 8, 8 2)');
+EXPR$0
+POINT (5 5)
+!ok
+
+SELECT ST_Intersection('POLYGON((1 1, 7 1, 7 6, 1 6, 1 1))', 'POINT(3 5)');
+EXPR$0
+POINT (3 5)
+!ok
+
+# ST_OffsetCurve(geom, distance, bufferStyle) Computes an offset line for *linestring*.
+SELECT ST_ReducePrecision(ST_OffsetCurve('LINESTRING(0 0, 10 0, 10 10)', 2, ''), 0.01);
+EXPR$0
+LINESTRING (0 2, 8 2, 8 10)
+!ok
+
+SELECT ST_ReducePrecision(ST_OffsetCurve('LINESTRING(0 0, 10 0, 10 10)', -2, ''), 0.01);
+EXPR$0
+LINESTRING (0 -2, 10 -2, 10.39 -1.96, 10.77 -1.85, 11.11 -1.66, 11.41 -1.41, 11.66 -1.11, 11.85 -0.77, 11.96 -0.39, 12 0, 12 10)
+!ok
+
+# ST_SymDifference(geom1, geom2) Computes the symmetric difference between two geometries
+
+SELECT ST_SymDifference('POLYGON((1 1, 7 1, 7 6, 1 6, 1 1))', 'POLYGON((3 2, 8 2, 8 8, 3 8, 3 2))');
+EXPR$0
+MULTIPOLYGON (((7 2, 7 1, 1 1, 1 6, 3 6, 3 2, 7 2)), ((7 2, 7 6, 3 6, 3 8, 8 8, 8 2, 7 2)))
+!ok
+
+# ST_UnaryUnion(geom1, geom2) Computes the union of two or more geometries
+
+SELECT ST_AsText(ST_UnaryUnion('POINT(1 2)', 'POINT(-2 3)'));
+EXPR$0
+MULTIPOINT ((-2 3), (1 2))
+!ok
+
+SELECT ST_AsText(ST_UnaryUnion('POINT(1 2)', 'POINT(1 2)'));
+EXPR$0
+POINT (1 2)
+!ok
+
+SELECT ST_AsText(ST_UnaryUnion('GEOMETRYCOLLECTION(
+  POLYGON((-7 4.2,-7.1 4.2,-7.1 4.3,-7 4.2)),
+  POINT(5 5),
+  POINT(-2 3),
+  LINESTRING(5 5, 10 10))'));
+EXPR$0
+GEOMETRYCOLLECTION (POINT (-2 3), LINESTRING (5 5, 10 10), POLYGON ((-7 4.2, -7.1 4.2, -7.1 4.3, -7 4.2)))
+!ok
+
+# ST_UNION(ARRAY[GEOMETRY]) is a PostGIS extension
+# We don't support it
+!if (false) {
+
+SELECT ST_Union(ARRAY(SELECT the_geom FROM sometable));
+!ok
+
+SELECT ST_AsText(ST_Union(ARRAY[
+    ST_GeomFromText('LINESTRING(1 2, 3 4)'),
+    ST_GeomFromText('LINESTRING(3 4, 4 5)')])) As wktunion;
+
+--wktunion---
+MULTILINESTRING((3 4,4 5),(1 2,3 4))
+!ok
+!}
+
+#### Affine transformation functions (3D and 2D)
+
+# ST_Rotate(geom, angle [, origin | x, y]) Rotates a *geom* counter-clockwise by *angle* (in radians) about *origin* (or the point (*x*, *y*))
+
+SELECT ST_Rotate('LINESTRING(1 3, 1 1, 2 1)', pi());
+EXPR$0
+LINESTRING (-1.0000000000000004 -3, -1.0000000000000002 -0.9999999999999999, -2 -0.9999999999999998)
+!ok
+
+SELECT ST_Rotate('LINESTRING(1 3, 1 1, 2 1)', pi() / 3);
+EXPR$0
+LINESTRING (-2.098076211353316 2.3660254037844393, -0.3660254037844385 1.3660254037844388, 0.1339745962155616 2.232050807568877)
+!ok
+
+SELECT ST_Rotate('LINESTRING(1 3, 1 1, 2 1)', -pi() / 2, ST_PointFromText('POINT(2 1)'));
+EXPR$0
+LINESTRING (4 2, 1.9999999999999998 2, 2 1)
+!ok
+
+SELECT ST_Rotate('LINESTRING(1 3, 1 1, 2 1)', pi() / 2, 1.0, 1.0);
+EXPR$0
+LINESTRING (-1 1.0000000000000002, 1 0.9999999999999999, 1 2)
+!ok
+
+# ST_Scale(geom, xFactor, yFactor) Scales *geom* by multiplying the ordinates by the indicated scale factors
+
+SELECT ST_Scale('LINESTRING(1 2, 4 5)', 0.5, 0.75);
+EXPR$0
+LINESTRING (0.5 1.5, 2 3.75)
+!ok
+
+# ST_Translate(geom, x, y, [, z]) Translates *geom*
+
+SELECT ST_Translate('POINT(1 2)', 10, 20);
+EXPR$0
+POINT (11 22)
+!ok
+
+SELECT ST_Translate('LINESTRING(0 0, 1 0)', 1, 2);
+EXPR$0
+LINESTRING (1 2, 2 2)
+!ok
+
+SELECT ST_Translate('LINESTRING(-71.01 42.37, -71.11 42.38)', 1, 0.5);
+EXPR$0
+LINESTRING (-70.01 42.87, -70.11 42.88)
+!ok
+
+SELECT ST_Translate('MULTIPOINT((0 1), (2 2), (1 3))', 1, 0);
+EXPR$0
+MULTIPOINT ((1 1), (3 2), (2 3))
+!ok
+
+SELECT ST_Translate('GEOMETRYCOLLECTION(
+  POLYGON((0 0, 3 5, 6  6, 0 7, 0 0)),
+  MULTIPOINT((0 1), (2 2), (1 3)))', -1, 1);
+EXPR$0
+GEOMETRYCOLLECTION (POLYGON ((-1 1, 2 6, 5 7, -1 8, -1 1)), MULTIPOINT ((-1 2), (1 3), (0 4)))
+!ok
+
+SELECT ST_AsText(ST_Translate('POINT Z(1 2 3)', 10, 20));
+EXPR$0
+POINT Z(11 22 3)
+!ok
+
+SELECT ST_AsText(ST_Translate('LINESTRING Z(0 0 0, 1 0 1)', 1, 2));
+EXPR$0
+LINESTRING Z(1 2 0, 2 2 1)
+!ok
+
+#### Geometry editing functions (2D)
+
+# ST_AddPoint(linestring, point [, index ]) Adds *point* to *linestring* at a given *index* (or at the end if *index* is not specified)
+SELECT ST_AddPoint('LINESTRING(0 0, 1 1)', 'POINT(2 2)');
+EXPR$0
+LINESTRING (0 0, 1 1, 2 2)
+!ok
+
+SELECT ST_AddPoint('LINESTRING(0 0, 1 1, 3 3)', 'POINT(2 2)', 2);
+EXPR$0
+LINESTRING (0 0, 1 1, 2 2, 3 3)
+!ok
+
+# ST_CollectionExtract(geom, dimension) Filters *geom*, returning a multi-geometry of those members with a given *dimension* (1 = point, 2 = line-string, 3 = polygon)
+# Not implemented
+
+# ST_Densify(geom, tolerance) Densifies a *geom* by inserting extra vertices along the line segments.
+SELECT ST_Densify('POINT(14 2)', 10);
+EXPR$0
+POINT (14 2)
+!ok
+
+SELECT ST_ReducePrecision(ST_Densify('LINESTRING(1 11, 8 1)', 2), 0.01);
+EXPR$0
+LINESTRING (1 11, 2 9.57, 3 8.14, 4 6.71, 5 5.29, 6 3.86, 7 2.43, 8 1)
+!ok
+
+SELECT ST_Densify('LINESTRING(1 11, 8 1)', 10);
+EXPR$0
+LINESTRING (1 11, 4.5 6, 8 1)
+!ok
+
+SELECT ST_Densify('POLYGON((2 0, 2 8, 4 8, 4 0, 2 0))', 4.5);
+EXPR$0
+POLYGON ((2 0, 2 4, 2 8, 4 8, 4 4, 4 0, 2 0))
+!ok
+
+# ST_FlipCoordinates(geom) Flips the X and Y coordinates of *geom*
+SELECT ST_FlipCoordinates('POINT(1 2)');
+EXPR$0
+POINT (2 1)
+!ok
+
+SELECT ST_FlipCoordinates('LINESTRING(1 2, 3 3, 5 9)');
+EXPR$0
+LINESTRING (2 1, 3 3, 9 5)
+!ok
+
+SELECT ST_FlipCoordinates('POLYGON ((0 1, 2 3, 3 2, 2 1, 0 1))');
+EXPR$0
+POLYGON ((1 0, 3 2, 2 3, 1 2, 1 0))
+!ok
+
+# ST_Holes(geom) Returns the holes in *geom* (which may be a geometry-collection)
+SELECT ST_Holes('POLYGON((0 0, 10 0, 10 5, 0 5, 0 0))');
+EXPR$0
+GEOMETRYCOLLECTION EMPTY
+!ok
+
+SELECT ST_Holes('POLYGON((0 0, 10 0, 10 5, 0 5, 0 0), (1 1, 2 1, 2 4, 1 4, 1 1))');
+EXPR$0
+GEOMETRYCOLLECTION (LINEARRING (1 1, 2 1, 2 4, 1 4, 1 1))
+!ok
+
+SELECT ST_Holes('GEOMETRYCOLLECTION(POLYGON((0 0, 10 0, 10 5, 0 5, 0 0), (1 1, 2 1, 2 4, 1 4, 1 1)), POLYGON((11 6, 14 6, 14 9, 11 9, 11 6), (12 7, 14 7, 14 8, 12 8, 12 7)))');
+EXPR$0
+GEOMETRYCOLLECTION (LINEARRING (1 1, 2 1, 2 4, 1 4, 1 1), LINEARRING (12 7, 14 7, 14 8, 12 8, 12 7))
+!ok
+
+SELECT ST_Holes('LINESTRING(5 5, 1 2, 3 4, 9 3)');
+EXPR$0
+GEOMETRYCOLLECTION EMPTY
+!ok
+
+# ST_Normalize(geom) Converts *geom* to normal form
+SELECT ST_Normalize('POLYGON((2 4, 1 3, 2 1, 6 1, 6 3, 4 4, 2 4))');
+EXPR$0
+POLYGON ((1 3, 2 4, 4 4, 6 3, 6 1, 2 1, 1 3))
+!ok
+
+SELECT ST_Normalize('MULTIPOINT((2 2), (2 5), (10 3), (7 1), (5 1), (5 3))');
+EXPR$0
+MULTIPOINT ((2 2), (2 5), (5 1), (5 3), (7 1), (10 3))
+!ok
+
+SELECT ST_Normalize('LINESTRING(3 1, 6 1, 6 3, 3 3, 1 1)');
+EXPR$0
+LINESTRING (1 1, 3 3, 6 3, 6 1, 3 1)
+!ok
+
+# ST_RemoveRepeatedPoints(geom) Removes duplicated coordinates from *geom*
+SELECT ST_RemoveRepeatedPoints( 'LINESTRING (0 0, 0 0, 1 1, 5 5, 1 1, 2 2)', 2);
+EXPR$0
+LINESTRING (0 0, 5 5, 2 2)
+!ok
+
+SELECT ST_RemoveRepeatedPoints('LINESTRING(0 0, 0 0, 1 1, 0 0, 1 1, 2 2)');
+EXPR$0
+LINESTRING (0 0, 1 1, 0 0, 1 1, 2 2)
+!ok
+
+SELECT ST_RemoveRepeatedPoints('LINESTRING(1 1, 2 2, 2 2, 1 3, 1 3, 3 3, 3 3, 5 2, 5 2, 5 1)');
+EXPR$0
+LINESTRING (1 1, 2 2, 1 3, 3 3, 5 2, 5 1)
+!ok
+
+SELECT ST_RemoveRepeatedPoints('LINESTRING(1 1, 1 3, 2 3, 2 6, 3 8)', 2);
+EXPR$0
+LINESTRING (1 1, 2 3, 2 6, 3 8)
+!ok
+
+SELECT ST_RemoveRepeatedPoints('POLYGON((2 4, 1 3, 2 1, 2 1, 6 1, 6 3, 4 4, 4 4, 2 4))');
+EXPR$0
+POLYGON ((2 4, 1 3, 2 1, 6 1, 6 3, 4 4, 2 4))
+!ok
+
+SELECT ST_RemoveRepeatedPoints('GEOMETRYCOLLECTION(POLYGON((1 2, 4 2, 4 6, 1 6, 1 6, 1 2)), MULTIPOINT((4 4), (1 1), (1 0), (0 3)))');
+EXPR$0
+GEOMETRYCOLLECTION (POLYGON ((1 2, 4 2, 4 6, 1 6, 1 2)), MULTIPOINT ((4 4), (1 1), (1 0), (0 3)))
+!ok
+
+SELECT ST_RemoveRepeatedPoints('MULTIPOINT((4 4), (1 1), (1 0), (0 3), (4 4))');
+EXPR$0
+MULTIPOINT ((4 4), (1 1), (1 0), (0 3), (4 4))
+!ok
+
+# ST_RemoveHoles(geom) Removes a *geom*'s holes
+SELECT ST_RemoveHoles('POLYGON((1 5, 0 4, 0 1, 1 0, 4 0, 4 2, 5 4, 5 4, 1 5), (1 3, 1 4, 2 4, 2 3, 1 3), (2 2, 1 1, 2 1, 2 2))');
+EXPR$0
+POLYGON ((1 5, 0 4, 0 1, 1 0, 4 0, 4 2, 5 4, 5 4, 1 5))
+!ok
+
+SELECT ST_RemoveHoles('POLYGON((1 5, 0 4, 0 1, 1 0, 4 0, 4 2, 5 4, 5 4, 1 5))');
+EXPR$0
+POLYGON ((1 5, 0 4, 0 1, 1 0, 4 0, 4 2, 5 4, 5 4, 1 5))
+!ok
+
+SELECT ST_RemoveHoles('POINT(1 5)');
+EXPR$0
+POINT (1 5)
+!ok
+
+# ST_RemovePoint(linestring, index) Remove *point* at given *index* in *linestring*
+SELECT ST_RemovePoint('LINESTRING(0 0, 1 1, 2 2, 3 3)', 2);
+EXPR$0
+LINESTRING (0 0, 1 1, 3 3)
+!ok
+
+SELECT ST_RemovePoint('LINESTRING(0 0, 1 1, 2 2, 3 3)', 0);
+EXPR$0
+LINESTRING (1 1, 2 2, 3 3)
+!ok
+
+SELECT ST_RemovePoint('LINESTRING(0 0, 1 1, 2 2, 3 3)', 3);
+EXPR$0
+LINESTRING (0 0, 1 1, 2 2)
+!ok
+
+# ST_RemoveRepeatedPoints(geom, tolerance) Removes from *geom* all repeated points (or points within *tolerance* of another point)
+# Not implemented
+
+# ST_Reverse(geom) Reverses the vertex order of *geom*
+SELECT ST_Reverse('LINESTRING(1 1, 2 2, 1 3, 3 3, 5 2, 5 1)');
+EXPR$0
+LINESTRING (5 1, 5 2, 3 3, 1 3, 2 2, 1 1)
+!ok
+
+SELECT ST_Reverse('MULTILINESTRING((10 260, 150 290, 186 406, 286 286), (120 120, 130 125, 142 129, 360 160, 357 170, 380 340), (1 1, 5 5))');
+EXPR$0
+MULTILINESTRING ((286 286, 186 406, 150 290, 10 260), (380 340, 357 170, 360 160, 142 129, 130 125, 120 120), (5 5, 1 1))
+!ok
+
+SELECT ST_Reverse('POLYGON((2 4, 1 3, 2 1, 6 1, 6 3, 4 4, 2 4))');
+EXPR$0
+POLYGON ((2 4, 4 4, 6 3, 6 1, 2 1, 1 3, 2 4))
+!ok
+
+SELECT ST_Reverse('MULTIPOLYGON(((2 4, 1 3, 2 1, 6 1, 6 3, 4 4, 2 4)), ((1 6, 6 6, 6 5, 1 5, 1 6)), ((0 1, 1 1, 1 0, 0 0, 0 1)))');
+EXPR$0
+MULTIPOLYGON (((2 4, 4 4, 6 3, 6 1, 2 1, 1 3, 2 4)), ((1 6, 1 5, 6 5, 6 6, 1 6)), ((0 1, 0 0, 1 0, 1 1, 0 1)))
+!ok
+
+SELECT ST_Reverse('GEOMETRYCOLLECTION(POLYGON((1 2, 4 2, 4 6, 1 6, 1 2)), LINESTRING(2 6, 6 2))');
+EXPR$0
+GEOMETRYCOLLECTION (POLYGON ((1 2, 1 6, 4 6, 4 2, 1 2)), LINESTRING (6 2, 2 6))
+!ok
+
+#### Geometry editing functions (3D)
+
+# ST_AddZ(geom, zToAdd) Adds *zToAdd* to the z-coordinate of *geom*
+SELECT ST_AsText(ST_AddZ('MULTIPOINT((190 300 1), (10 11 0))', 10));
+EXPR$0
+MULTIPOINT Z((190 300 11), (10 11 10))
+!ok
+
+SELECT ST_Z(ST_GeometryN(ST_AddZ('MULTIPOINT((190 300 1), (10 11))', 10), 1));
+EXPR$0
+NaN
+!ok
+
+SELECT ST_AsText(ST_AddZ('MULTIPOINT Z((190 300 10), (10 11 5))', -10));
+EXPR$0
+MULTIPOINT Z((190 300 0), (10 11 -5))
+!ok
+
+SELECT ST_AsText(ST_AddZ('POLYGON((1 1 5, 1 7 10, 7 7 -1, 7 1 -1, 1 1 5))', -10));
+EXPR$0
+POLYGON Z((1 1 -5, 1 7 0, 7 7 -11, 7 1 -11, 1 1 -5))
+!ok
+
+# ST_Interpolate3DLine(geom) Returns *geom* with a interpolation of z values, or null if it is not a line-string or multi-line-string
+# Not implemented
+
+# ST_MultiplyZ(geom, zFactor) Returns *geom* with its z-values multiplied by *zFactor*
+# Not implemented
+
+# ST_Reverse3DLine(geom [, sortOrder ]) Potentially reverses *geom* according to the z-values of its first and last coordinates
+# Not implemented
+
+# ST_UpdateZ(geom, newZ [, updateCondition ]) Updates the z-values of *geom*
+# Not implemented
+
+# ST_ZUpdateLineExtremities(geom, startZ, endZ [, interpolate ]) Updates the start and end z-values of *geom*
+# Not implemented
+
+#### Geometry measurement functions (2D)
+
+# ST_Area(geom) Returns the area of *geom* (which may be a geometry collection)
+
+SELECT ST_Area('POINT(0 12)');
+EXPR$0
+0.0
+!ok
+
+SELECT ST_Area('LINESTRING(5 4, 1 1, 3 4, 4 5)');
+EXPR$0
+0.0
+!ok
+
+SELECT ST_Area('POLYGON((0 0, 10 0, 10 10, 0 10, 0 0))');
+EXPR$0
+100.0
+!ok
+
+SELECT ST_Area('MULTIPOLYGON(((0 0, 10 0, 10 10, 0 10, 0 0), (5 4, 1 1, 3 4, 4 5, 5 4)))');
+EXPR$0
+96.0
+!ok
+
+SELECT ST_Area('GEOMETRYCOLLECTION(LINESTRING(5 4, 1 1, 3 4, 4 5), POINT(0 12), POLYGON((0 0, 10 0, 10 10, 0 10, 0 0)), POLYGON((5 4, 1 1, 3 4, 4 5, 5 4)))');
+EXPR$0
+104.0
+!ok
+
+# ST_ClosestCoordinate(geom, point) Returns the coordinate(s) of *geom* closest to *point*
+
+SELECT ST_ClosestCoordinate('POINT(0 0)', 'POLYGON((2 2, 10 0, 10 5, 0 5, 2 2))');
+EXPR$0
+POINT (2 2)
+!ok
+
+SELECT ST_ClosestCoordinate('POINT(4 2.5)', 'POLYGON((0 0, 10 0, 10 5, 0 5, 0 0))');
+EXPR$0
+MULTIPOINT ((0 0), (0 5))
+!ok
+
+SELECT ST_ClosestCoordinate('POINT(4 2)', 'LINESTRING(10 0, 10 5, 0 5)');
+EXPR$0
+POINT (0 5)
+!ok
+
+# ST_ClosestPoint(geom1, geom2) Returns the point of *geom1* closest to *geom2*
+
+SELECT  ST_ClosestPoint('POLYGON((0 0, 10 0, 10 5, 0 5, 0 0))', 'POINT(4 2)');
+EXPR$0
+POINT (4 2)
+!ok
+
+SELECT  ST_ClosestPoint('POLYGON((0 0, 10 0, 10 5, 0 5, 0 0))', 'POINT(5 7)');
+EXPR$0
+POINT (5 5)
+!ok
+
+SELECT ST_ClosestPoint('LINESTRING(1 1, 1 5))', 'LINESTRING(2 1, 2 5))') A,
+       ST_ClosestPoint('LINESTRING(1 1, 1 5))', 'LINESTRING(2 5, 2 1))') B;
+A, B
+POINT (1 1), POINT (1 5)
+!ok
+
+SELECT ST_ClosestPoint('POLYGON((0 0, 10 0, 10 5, 0 5, 0 0))',
+                       'POLYGON((13 2, 15 0, 13 4, 13 2))') A,
+       ST_ClosestPoint('POLYGON((0 0, 10 0, 10 5, 0 5, 0 0))',
+                       'POLYGON((13 4, 13 2, 15 0, 13 4))') B;
+A, B
+POINT (10 2), POINT (10 4)
+!ok
+
+# ST_FurthestCoordinate(geom, point) Returns the coordinate(s) of *geom* that are furthest from *point*
+
+SELECT ST_FurthestCoordinate('POINT(0 0)', 'POLYGON((2 2, 10 0, 10 5, 0 5, 2 2))');
+EXPR$0
+POINT (10 5)
+!ok
+
+SELECT ST_FurthestCoordinate('POINT(5 2.5)', 'LINESTRING(3 1, 2 2, 2 4, 4 5)');
+EXPR$0
+POINT (2 4)
+!ok
+
+SELECT ST_FurthestCoordinate('POINT(5 2.5)', 'POLYGON((0 0, 10 0, 10 5, 0 5, 0 0))');
+EXPR$0
+MULTIPOINT ((0 0), (10 0), (10 5), (0 5))
+!ok
+
+# ST_Length(lineString) Returns the length of *lineString*
+
+SELECT ST_Length('MULTIPOINT((4 4), (1 1), (1 0), (0 3)))');
 EXPR$0
-{"rings":[[[150,90],[149.89294616193018,86.72984353849284],[149.5722430686905,83.47369038899743],[149.0392640201615,80.24548389919359],[148.2962913144534,77.05904774487396],[147.34650647475527,73.9... (3574 characters)
+0.0
 !ok
 
-SELECT ST_Buffer(
- ST_GeomFromText('LINESTRING(10 10,30 10)'),
- 5);
+SELECT ST_Length('LINESTRING(2 1, 1 3, 5 2)');
 EXPR$0
-{"rings":[[[10,5],[9.672984353849284,5.010705383806982],[9.347369038899743,5.042775693130948],[9.02454838991936,5.096073597983848],[8.705904774487397,5.1703708685546585],[8.39280267348419,5.2653493... (3532 characters)
+6.35917360311745
 !ok
 
-SELECT ST_Buffer(
-  ST_GeomFromText('POLYGON((-71.1776585052917 42.3902909739571,-71.1776820268866 42.3903701743239,
-    -71.1776063012595 42.3903825660754,-71.1775826583081 42.3903033653531,-71.1776585052917 42.3902909739571))'),
- 50);
+SELECT ST_Length('POLYGON((1 2, 4 2, 4 6, 1 6, 1 2))');
 EXPR$0
-{"rings":[[[-21.17763234259735,42.39033677001625],[-21.284686180667173,39.12018030850909],[-21.60538927390683,35.864027159013666],[-22.138368322435824,32.635820669209835],[-22.881341028143936,29.44... (3872 characters)
+14.0
 !ok
 
-# Negative buffer size makes the polgyon smaller
-SELECT ST_Buffer(
-  ST_GeomFromText('POLYGON((10 10,10 20,20 20,20 10))'),
- -1);
+SELECT ST_Length('MULTIPOLYGON(((0 2, 3 2, 3 6, 0 6, 0 2)), ((5 0, 7 0, 7 1, 5 1, 5 0)))');
 EXPR$0
-{"rings":[[[11,11],[11,19],[19,19],[19,11],[11,11]]]}
+20.0
 !ok
 
-!if (fixed.calcite2539) {
-# ST_BUFFER(geom, bufferSize, style) variant - not implemented
-SELECT ST_Buffer(
- ST_GeomFromText('POINT(100 90)'),
- 50, 'quad_segs=8');
-at org.apache.calcite.runtime.Geometries.todo
-!error GeoFunctions
+SELECT ST_Length('GEOMETRYCOLLECTION(
+    MULTIPOINT((4 4), (1 1), (1 0), (0 3)),
+    LINESTRING(2 1, 1 3, 5 2),
+    POLYGON((1 2, 4 2, 4 6, 1 6, 1 2)))');
+EXPR$0
+20.35917360311745
+!ok
 
-# ST_BUFFER(geom, bufferSize, quadSegs) variant - not implemented
-# When implemented, remove comment from ST_Contains test case
-SELECT ST_Buffer(
- ST_GeomFromText('POINT(100 90)'),
- 50, 2);
-at org.apache.calcite.runtime.Geometries.todo
-!error GeoFunctions
-!}
+# ST_LocateAlong(geom, segmentLengthFraction, offsetDistance) Returns a multi-point containing points along the line segments of *geom* at *segmentLengthFraction* and *offsetDistance*
 
-# ST_ConvexHull(geom) Computes the smallest convex polygon that contains all the points in the Geometry
-# Not implemented
+SELECT ST_LocateAlong('LINESTRING(1 1, 5 4)', 0.5, 2.0);
+EXPR$0
+MULTIPOINT ((1.8 4.1))
+!ok
 
-# ST_Difference(geom1, geom2) Computes the difference between two geometries
-# Not implemented
+SELECT ST_LocateAlong('LINESTRING(1 1, 5 1, 5 3)', 0.5, 1.0);
+EXPR$0
+MULTIPOINT ((3 2), (4 2))
+!ok
 
-# ST_Intersection(geom1, geom2) Computes the intersection of two geometries
-# Not implemented
+SELECT ST_LocateAlong('POLYGON((1 1, 4 1, 4 3, 1 3, 1 1))', 0.5, -1.0);
+EXPR$0
+MULTIPOINT ((2.5 0), (5 2), (2.5 4), (0 2))
+!ok
 
-# ST_SymDifference(geom1, geom2) Computes the symmetric difference between two geometries
-# Not implemented
+SELECT ST_LocateAlong('GEOMETRYCOLLECTION(
+    LINESTRING(1 4, 5 4, 5 2),
+    POLYGON((1 1, 4 1, 4 3, 1 3, 1 1)))', 2.0, 1.0);
+EXPR$0
+MULTIPOINT ((9 5), (6 0), (7 2), (3 5), (-2 2), (2 -1))
+!ok
 
-# ST_Union(geom1, geom2) Computes the union of two or more geometries
+# ST_LongestLine(geom1, geom2) Returns the 2-dimensional longest line-string between the points of *geom1* and *geom2*
 
-# NOTE: PostGIS altered the order: it returned MULTIPOINT(-2 3,1 2)
-SELECT ST_AsText(ST_Union(ST_GeomFromText('POINT(1 2)'),
-    ST_GeomFromText('POINT(-2 3)')));
+SELECT ST_LongestLine('POLYGON ((0 1, 1 1, 1 0, 0 0, 0 1))', 'POLYGON ((2 3, 2 2, 3 2, 4 3, 2 3))');
+EXPR$0
+LINESTRING (0 0, 4 3)
+!ok
 
+SELECT ST_LongestLine('POLYGON ((0 1, 1 1, 1 0, 0 0, 0 1))', 'LINESTRING (1 3, 4 3)');
 EXPR$0
-MULTIPOINT ((1 2), (-2 3))
+LINESTRING (0 0, 4 3)
 !ok
 
-# NOTE: PostGIS returned a point not a multipoint: POINT(1 2). ESRI bug?
-SELECT ST_AsText(ST_Union(ST_GeomFromText('POINT(1 2)'),
-    ST_GeomFromText('POINT(1 2)')));
+SELECT ST_LongestLine('POLYGON ((0 1, 1 1, 1 0, 0 0, 0 1))', 'POINT (3 2)');
 EXPR$0
-MULTIPOINT ((1 2))
+LINESTRING (0 0, 3 2)
 !ok
 
-# ST_Union(geomCollection) Computes the union of two or more geometries
+SELECT ST_LongestLine('MULTIPOLYGON (((0 1, 1 1, 1 0, 0 0, 0 1)), ((2 3, 2 2, 3 3, 2 3)))', 'POINT (3 2)');
+EXPR$0
+LINESTRING (0 0, 3 2)
+!ok
 
-# Disabled: ST_GeomFromText cannot handle GEOMETRYCOLLECTION
-!if (false) {
-SELECT ST_AsText(st_union(ST_GeomFromText('GEOMETRYCOLLECTION(
-  POLYGON((-7 4.2,-7.1 4.2,-7.1 4.3,-7 4.2))
-  POINT(5 5)
-  POINT(-2 3)
-  LINESTRING(5 5, 10 10)')));
+SELECT ST_LongestLine('POLYGON ((1 3, 0 0, 3 2, 1 3))', 'POLYGON ((1 3, 0 0, 3 2, 1 3))');
 EXPR$0
-null
+LINESTRING (0 0, 3 2)
 !ok
-!}
 
-# ST_UNION(ARRAY[GEOMETRY]) is a PostGIS extension
-# We don't support it
-!if (false) {
+# ST_MaxDistance(geom1, geom2) Computes the maximum distance between *geom1* and *geom2*
 
-SELECT ST_Union(ARRAY(SELECT the_geom FROM sometable));
+SELECT ST_MaxDistance('POLYGON ((0 1, 1 1, 1 0, 0 0, 0 1))', 'POLYGON ((2 3, 2 2, 3 2, 4 3, 2 3))');
+EXPR$0
+5.0
 !ok
 
-SELECT ST_AsText(ST_Union(ARRAY[ST_GeomFromText('LINESTRING(1 2, 3 4)'),
-    ST_GeomFromText('LINESTRING(3 4, 4 5)')])) As wktunion;
+SELECT ST_MaxDistance('POLYGON ((0 1, 1 1, 1 0, 0 0, 0 1))', 'LINESTRING (1 3, 4 3)');
+EXPR$0
+5.0
+!ok
 
---wktunion---
-MULTILINESTRING((3 4,4 5),(1 2,3 4))
+SELECT ST_MaxDistance('POLYGON ((0 1, 1 1, 1 0, 0 0, 0 1))', 'POINT (3 2)');
+EXPR$0
+3.605551275463989
 !ok
-!}
 
-#### Affine transformation functions (3D and 2D)
+SELECT ST_MaxDistance('POLYGON ((1 3, 0 0, 3 2, 1 3))', 'POLYGON ((1 3, 0 0, 3 2, 1 3))');
+EXPR$0
+3.605551275463989
+!ok
 
-# ST_Rotate(geom, angle [, origin | x, y]) Rotates a *geom* counter-clockwise by *angle* (in radians) about *origin* (or the point (*x*, *y*))
-# Not implemented
+# ST_Perimeter(polygon) Returns the length of the perimeter of *polygon* (which may be a multi-polygon)
 
-# ST_Scale(geom, xFactor, yFactor [, zFactor ]) Scales *geom* by multiplying the ordinates by the indicated scale factors
-# Not implemented
+SELECT ST_Perimeter('POLYGON((1 2, 4 2, 4 6, 1 6, 1 2))');
+EXPR$0
+14.0
+!ok
 
-# ST_Translate(geom, x, y, [, z]) Translates *geom*
-# Not implemented
+SELECT ST_Perimeter('MULTIPOLYGON(((0 2, 3 2, 3 6, 0 6, 0 2)), ((5 0, 7 0, 7 1, 5 1, 5 0)))');
+EXPR$0
+20.0
+!ok
 
-#### Geometry editing functions (2D)
+SELECT ST_Perimeter('GEOMETRYCOLLECTION(
+                    MULTIPOINT((4 4), (1 1), (1 0), (0 3)),
+                    LINESTRING(2 1, 1 3, 5 2),
+                    POLYGON((1 2, 4 2, 4 6, 1 6, 1 2)))');
+EXPR$0
+14.0
+!ok
 
-# ST_AddPoint(geom, point [, tolerance ]) Adds *point* to *geom* with a given *tolerance* (default 0)
-# Not implemented
+SELECT ST_Perimeter('LINESTRING(2 1, 1 3, 5 2)');
+EXPR$0
+0.0
+!ok
 
-# ST_CollectionExtract(geom, dimension) Filters *geom*, returning a multi-geometry of those members with a given *dimension* (1 = point, 2 = line-string, 3 = polygon)
-# Not implemented
+# ST_ProjectPoint(point, lineString) Projects *point* onto a *lineString* (which may be a multi-line-string)
 
-# ST_Densify(geom, tolerance) Inserts extra vertices every *tolerance* along the line segments of *geom*
-# Not implemented
+SELECT ST_PROJECTPOINT('POINT(0 4)', 'LINESTRING(0 0, 4 4)');
+EXPR$0
+POINT (2 2)
+!ok
 
-# ST_FlipCoordinates(geom) Flips the X and Y coordinates of *geom*
-# Not implemented
+SELECT ST_PROJECTPOINT('POINT(2 4)', 'MULTILINESTRING ((0 0, 4 0), (0 2, 4 2))');
+EXPR$0
+POINT (2 2)
+!ok
 
-# ST_Holes(geom) Returns the holes in *geom* (which may be a geometry-collection)
-# Not implemented
+SELECT ST_PROJECTPOINT('POINT(0 4)', 'LINESTRING (0 0, 4 4)');
+EXPR$0
+POINT (2 2)
+!ok
 
-# ST_Normalize(geom) Converts *geom* to normal form
-# Not implemented
+SELECT ST_PROJECTPOINT('POINT(0 4)', 'POLYGON ((2 4, 0 2, 3 0, 2 4))');
+EXPR$0
+null
+!ok
 
-# ST_RemoveDuplicatedCoordinates(geom) Removes duplicated coordinates from *geom*
-# Not implemented
+#### Geometry measurement functions (3D)
 
-# ST_RemoveHoles(geom) Removes a *geom*'s holes
+# ST_3DArea(geom) Return a polygon's 3D area
 # Not implemented
 
-# ST_RemovePoints(geom, poly) Removes all coordinates of *geom* located within *poly*; null if all coordinates are removed
+# ST_3DLength(geom) Returns the 3D length of a line-string
 # Not implemented
 
-# ST_RemoveRepeatedPoints(geom, tolerance) Removes from *geom* all repeated points (or points within *tolerance* of another point)
+# ST_3DPerimeter(geom) Returns the 3D perimeter of a polygon or multi-polygon
 # Not implemented
 
-# ST_Reverse(geom) Reverses the vertex order of *geom*
+# ST_SunPosition(point [, timestamp ]) Computes the sun position at *point* and *timestamp* (now by default)
 # Not implemented
 
-#### Geometry editing functions (3D)
+#### Geometry processing functions (2D)
 
-# ST_AddZ(geom, zToAdd) Adds *zToAdd* to the z-coordinate of *geom*
+# ST_LineIntersector(geom1, geom2) Splits *geom1* (a line-string) with *geom2*
 # Not implemented
 
-# ST_Interpolate3DLine(geom) Returns *geom* with a interpolation of z values, or null if it is not a line-string or multi-line-string
-# Not implemented
+# ST_LineMerge(geom) Merges a collection of linear components to form a line-string of maximal length
 
-# ST_MultiplyZ(geom, zFactor) Returns *geom* with its z-values multiplied by *zFactor*
-# Not implemented
+SELECT ST_LineMerge('LINESTRING (1 1, 1 4)');
+EXPR$0
+MULTILINESTRING ((1 1, 1 4))
+!ok
 
-# ST_Reverse3DLine(geom [, sortOrder ]) Potentially reverses *geom* according to the z-values of its first and last coordinates
-# Not implemented
+SELECT ST_LineMerge('MULTILINESTRING ((1 1, 1 4), (1 4, 5 4), (5 4, 5 1), (3 3, 3 4))');
+EXPR$0
+MULTILINESTRING ((1 1, 1 4, 5 4, 5 1), (3 3, 3 4))
+!ok
 
-# ST_UpdateZ(geom, newZ [, updateCondition ]) Updates the z-values of *geom*
-# Not implemented
+# ST_MakeValid(geom [, preserveGeomDim [, preserveDuplicateCoord [, preserveCoordDim]]]) Makes *geom* valid
 
-# ST_ZUpdateLineExtremities(geom, startZ, endZ [, interpolate ]) Updates the start and end z-values of *geom*
-# Not implemented
+SELECT ST_MakeValid('LINESTRING(0 0, 0 0)');
+EXPR$0
+LINESTRING EMPTY
+!ok
 
-#### Geometry measurement functions (2D)
+# ST_Polygonize(geom) Creates a multi-polygon from edges of *geom*
 
-# ST_Area(geom) Returns the area of *geom* (which may be a geometry collection)
-# Not implemented
+SELECT ST_Polygonize('LINESTRING(1 2, 2 4, 4 4, 5 2, 1 2)');
+EXPR$0
+POLYGON ((1 2, 2 4, 4 4, 5 2, 1 2))
+!ok
 
-# ST_ClosestCoordinate(geom, point) Returns the coordinate(s) of *geom* closest to *point*
-# Not implemented
+# ST_PrecisionReducer(geom, n) Reduces *geom*'s precision to *n* decimal places
+SELECT ST_PrecisionReducer('MULTIPOINT((190.1239999997 300), (10 11.1233))', 3);
+EXPR$0
+MULTIPOINT ((190.124 300), (10 11.123))
+!ok
 
-# ST_ClosestPoint(geom1, geom2) Returns the point of *geom1* closest to *geom2*
+# ST_RingSideBuffer(geom, bufferSize, bufferCount [, endCapStyle [, doDifference]]) Computes a ring buffer on one side
 # Not implemented
 
-# ST_FurthestCoordinate(geom, point) Returns the coordinate(s) of *geom* that are furthest from *point*
+# ST_SideBuffer(geom, bufferSize [, bufferStyle ]) Compute a single buffer on one side
 # Not implemented
 
-# ST_Length(lineString) Returns the length of *lineString*
-# Not implemented
+# ST_Simplify(geom, distance) Simplifies *geom* using the Douglas-Peuker algorithm with a *distance* tolerance
 
-# ST_LocateAlong(geom, segmentLengthFraction, offsetDistance) Returns a multi-point containing points along the line segments of *geom* at *segmentLengthFraction* and *offsetDistance*
-# Not implemented
+SELECT ST_Simplify('POLYGON((2 1, 1 2, 2 2, 2 3, 3 3, 3 2, 4 2, 4 1, 3 0, 2 0, 2 1))', 0.5);
+EXPR$0
+POLYGON ((2 1, 1 2, 3 3, 4 1, 3 0, 2 0, 2 1))
+!ok
 
-# ST_LongestLine(geom1, geom2) Returns the 2-dimensional longest line-string between the points of *geom1* and *geom2*
-# Not implemented
+SELECT ST_Simplify('POLYGON((2 1, 1 2, 2 2, 2 3, 3 3, 3 2, 4 2, 4 1, 3 0, 2 0, 2 1))', 1);
+EXPR$0
+POLYGON ((2 1, 1 2, 3 3, 4 1, 2 1))
+!ok
 
-# ST_MaxDistance(geom1, geom2) Computes the maximum distance between *geom1* and *geom2*
-# Not implemented
+SELECT ST_Simplify('POLYGON((2 1, 1 2, 2 2, 2 3, 3 3, 3 2, 4 2, 4 1, 3 0, 2 0, 2 1))', 2);
+EXPR$0
+POLYGON EMPTY
+!ok
 
-# ST_Perimeter(polygon) Returns the length of the perimeter of *polygon* (which may be a multi-polygon)
-# Not implemented
+SELECT ST_Simplify('MULTIPOINT((190 300), (10 11))', 4);
+EXPR$0
+MULTIPOINT ((190 300), (10 11))
+!ok
 
-# ST_ProjectPoint(point, lineString) Projects *point* onto a *lineString* (which may be a multi-line-string)
-# Not implemented
+SELECT ST_Simplify('LINESTRING(250 250, 280 290, 300 230, 340 300, 360 260, 440 310, 470 360, 604 286)', 40);
+EXPR$0
+LINESTRING (250 250, 280 290, 300 230, 470 360, 604 286)
+!ok
 
-#### Geometry measurement functions (3D)
+# ST_SimplifyPreserveTopology(geom, distance) Simplifies *geom*, preserving its topology
 
-# ST_3DArea(geom) Return a polygon's 3D area
-# Not implemented
+SELECT ST_SimplifyPreserveTopology('POLYGON((8 25, 28 22, 28 20, 15 11, 33 3, 56 30, 46 33,  46 34, 47 44, 35 36, 45 33, 43 19, 29 21, 29 22, 35 26, 24 39, 8 25))', 10);
+EXPR$0
+POLYGON ((8 25, 28 22, 15 11, 33 3, 56 30, 47 44, 35 36, 43 19, 24 39, 8 25))
+!ok
 
-# ST_3DLength(geom) Returns the 3D length of a line-string
-# Not implemented
+SELECT ST_SimplifyPreserveTopology('POLYGON((8 25, 28 22, 28 20, 15 11, 33 3, 56 30, 46 33,  46 34, 47 44, 35 36, 45 33, 43 19, 29 21, 29 22, 35 26, 24 39, 8 25))', 20);
+EXPR$0
+POLYGON ((8 25, 33 3, 56 30, 47 44, 43 19, 8 25))
+!ok
 
-# ST_3DPerimeter(geom) Returns the 3D perimeter of a polygon or multi-polygon
-# Not implemented
+SELECT ST_SimplifyPreserveTopology('POLYGON((8 25, 28 22, 28 20, 15 11, 33 3, 56 30, 46 33,  46 34, 47 44, 35 36, 45 33, 43 19, 29 21, 29 22, 35 26, 24 39, 8 25))', 30);
+EXPR$0
+POLYGON ((8 25, 33 3, 56 30, 47 44, 8 25))
+!ok
 
-# ST_SunPosition(point [, timestamp ]) Computes the sun position at *point* and *timestamp* (now by default)
-# Not implemented
+# ST_Snap(geom1, geom2, tolerance) Snaps *geom1* and *geom2* together
 
-#### Geometry processing functions (2D)
+SELECT ST_Snap('LINESTRING(1 2, 2 4, 4 4, 5 2)', 'LINESTRING(5 2, 2 1, 1 2)', 1);
+EXPR$0
+LINESTRING (1 2, 2 4, 4 4, 5 2)
+!ok
 
-# ST_LineIntersector(geom1, geom2) Splits *geom1* (a line-string) with *geom2*
-# Not implemented
+SELECT ST_Snap('LINESTRING(1 2, 2 4, 4 4, 5 2)', 'LINESTRING(5 2, 2 1, 1 2)', 2);
+EXPR$0
+LINESTRING (1 2, 2 1, 2 4, 4 4, 5 2)
+!ok
 
-# ST_LineMerge(geom) Merges a collection of linear components to form a line-string of maximal length
-# Not implemented
+SELECT ST_Snap('LINESTRING(1 2, 2 4, 4 4, 5 2)', 'LINESTRING(5 2, 2 1, 1 2)', 3);
+EXPR$0
+LINESTRING (1 2, 1 2, 2 1, 5 2, 5 2)
+!ok
 
-# ST_MakeValid(geom [, preserveGeomDim [, preserveDuplicateCoord [, preserveCoordDim]]]) Makes *geom* valid
-# Not implemented
+SELECT ST_Snap('POLYGON((1 1, 1 7, 7 7, 7 1, 1 1))', 'POLYGON((3 3, 1 2, 0 2, 0 1, -2 1, -1 7, 3 6, 4 8, 7 8, 6 6, 9 6, 8 1, 8 1, 3 3))', 2);
+EXPR$0
+POLYGON ((0 1, 1 2, 0 2, -1 7, 1 7, 3 6, 6 6, 8 1, 0 1))
+!ok
 
-# ST_Polygonize(geom) Creates a multi-polygon from edges of *geom*
-# Not implemented
+SELECT ST_Snap('POLYGON((3 3, 1 2, 0 2, 0 1, -2 1, -1 7, 3 6, 4 8, 7 8, 6 6, 9 6, 8 1, 8 1, 3 3))', 'POLYGON((1 1, 1 7, 7 7, 7 1, 1 1))', 2);
+EXPR$0
+POLYGON ((3 3, 1 1, 1 1, 1 1, -2 1, -1 7, 1 7, 3 6, 4 8, 7 7, 7 7, 9 6, 7 1, 7 1, 3 3))
+!ok
 
-# ST_PrecisionReducer(geom, n) Reduces *geom*'s precision to *n* decimal places
-# Not implemented
+# ST_Split(geom, blade) Splits *geom* by *blade*
 
-# ST_RingSideBuffer(geom, bufferSize, bufferCount [, endCapStyle [, doDifference]]) Computes a ring buffer on one side
-# Not implemented
+SELECT ST_Split('LINESTRING(0 0, 10 0)', 'POINT(5 0)');
+EXPR$0
+MULTILINESTRING ((0 0, 5 0), (5 0, 10 0))
+!ok
 
-# ST_SideBuffer(geom, bufferSize [, bufferStyle ]) Compute a single buffer on one side
-# Not implemented
+SELECT ST_Split('MULTILINESTRING ((5 0, 5 10), (0 5, 10 5))', 'POINT(5 5)');
+EXPR$0
+MULTILINESTRING ((5 0, 5 5), (5 5, 5 10), (0 5, 5 5), (5 5, 10 5))
+!ok
 
-# ST_Simplify(geom, distance) Simplifies *geom* using the Douglas-Peuker algorithm with a *distance* tolerance
-# Not implemented
+SELECT ST_Split('LINESTRING(0 0, 10 0)', 'LINESTRING(5 -1, 5 1)');
+EXPR$0
+MULTILINESTRING ((0 0, 5 0), (5 0, 10 0))
+!ok
 
-# ST_SimplifyPreserveTopology(geom) Simplifies *geom*, preserving its topology
-# Not implemented
+SELECT ST_Split('MULTILINESTRING ((1 0, 1 10), (2 0, 2 10))', 'LINESTRING(0 5, 4 5))');
+EXPR$0
+MULTILINESTRING ((1 0, 1 5), (1 5, 1 10), (2 0, 2 5), (2 5, 2 10))
+!ok
 
-# ST_Snap(geom1, geom2, tolerance) Snaps *geom1* and *geom2* together
-# Not implemented
+SELECT ST_Split('POLYGON((0 0, 5 0, 5 5, 0 5, 0 0))', 'LINESTRING(2 0, 2 5)');
+EXPR$0
+MULTIPOLYGON (((0 0, 0 5, 2 5, 2 0, 0 0)), ((2 0, 2 5, 5 5, 5 0, 2 0)))
+!ok
 
-# ST_Split(geom1, geom2 [, tolerance]) Splits *geom1* by *geom2* using *tolerance* (default 1E-6) to determine where the point splits the line
-# Not implemented
+SELECT ST_Split('MULTIPOLYGON (((0 0, 0 5, 2 5, 2 0, 0 0)), ((2 0, 2 5, 5 5, 5 0, 2 0)))', 'LINESTRING(0 2, 5 2)');
+EXPR$0
+MULTIPOLYGON (((0 0, 0 2, 2 2, 2 0, 0 0)), ((0 2, 0 5, 2 5, 2 2, 0 2)), ((2 0, 2 2, 5 2, 5 0, 2 0)), ((2 2, 2 5, 5 5, 5 2, 2 2)))
+!ok
 
 #### Geometry projection functions
 
 # ST_SetSRID(geom, srid) Returns a copy of *geom* with a new SRID
-
-SELECT ST_SetSRID(ST_MakePoint(-123.365556, 48.428611),4326) As wgs84long_lat;
+SELECT ST_AsEWKT(ST_SetSRID(ST_MakePoint(-123.365556, 48.428611),4326)) As wgs84long_lat;
 WGS84LONG_LAT
-{"x":-123.365556,"y":48.428611}
+srid:4326;POINT (-123.365556 48.428611)
 !ok
 
 # Mark a point as WGS 84 long lat and then transform to web mercator (Spherical Mercator)
-SELECT ST_Transform(ST_SetSRID(ST_MakePoint(-123.365556, 48.428611),4326),3785) As sphere_merc;
+SELECT ST_AsEWKT(ST_Transform(ST_SetSRID(ST_MakePoint(-123.365556, 48.428611),4326),3785)) As sphere_merc;
 SPHERE_MERC
-{"x":-123.365556,"y":48.428611,"spatialReference":{"wkid":102113,"latestWkid":3785}}
+srid:9804;POINT (-13732990.875349075 6178458.964254234)
 !ok
 
 # ST_Transform(geom, srid) Transforms *geom* from one coordinate reference system (CRS) to the CRS specified by *srid*
-
-SELECT ST_AsText(ST_Transform(ST_GeomFromText('POLYGON((743238 2967416,743238 2967450,
-  743265 2967450,743265.625 2967416,743238 2967416))',2249),4326)) As wgs_geom;
-
+SELECT ST_ReducePrecision(ST_AsText(ST_Transform(ST_GeomFromText('POLYGON((743238 2967416,743238 2967450,
+  743265 2967450,743265.625 2967416,743238 2967416))',2249),4326)), 0.01) As wgs_geom;
 WGS_GEOM
-MULTIPOLYGON (((743238 2967416, 743265.625 2967416, 743265 2967450, 743238 2967450, 743238 2967416)))
+POLYGON ((-71.18 42.39, -71.18 42.39, -71.18 42.39, -71.18 42.39, -71.18 42.39))
 !ok
 
 #### Trigonometry functions
@@ -1110,41 +2416,77 @@ MULTIPOLYGON (((743238 2967416, 743265.625 2967416, 743265 2967450, 743238 29674
 #### Triangulation functions
 
 # ST_ConstrainedDelaunay(geom [, flag [, quality ]]) Computes a constrained Delaunay triangulation based on *geom*
-# Not implemented
+SELECT ST_ConstrainedDelaunay('POLYGON((0 0, 0 10, 10 10, 10 0, 0 0))');
+EXPR$0
+MULTIPOLYGON (((0 0, 0 10, 10 10, 0 0)), ((10 10, 10 0, 0 0, 10 10)))
+!ok
+
+SELECT ST_ConstrainedDelaunay('POLYGON((0 0, 0 10, 10 10, 10 0, 0 0))', 1);
+EXPR$0
+MULTILINESTRING ((0 0, 0 10), (0 0, 10 0), (0 0, 10 10), (0 10, 10 10), (10 0, 10 10))
+!ok
 
 # ST_Delaunay(geom [, flag [, quality ]]) Computes a Delaunay triangulation based on points
-# Not implemented
+SELECT ST_Delaunay('MULTIPOINT((1 1), (0 4), (3 2), (3 7), (4 5), (5 2), (7 1), (7 6), (8 4), (5 8), (1 8), (4 0))');
+EXPR$0
+MULTIPOLYGON (((1 8, 0 4, 3 7, 1 8)), ((1 8, 3 7, 5 8, 1 8)), ((5 8, 3 7, 4 5, 5 8)), ((5 8, 4 5, 7 6, 5 8)), ((7 6, 4 5, 8 4, 7 6)), ((8 4, 4 5, 5 2, 8 4)), ((8 4, 5 2, 7 1, 8 4)), ((4 0, 7 1, 5 2, 4 0)), ((4 0, 5 2, 3 2, 4 0)), ((4 0, 3 2, 1 1, 4 0)), ((1 1, 3 2, 0 4, 1 1)), ((0 4, 3 2, 4 5, 0 4)), ((0 4, 4 5, 3 7, 0 4)), ((4 5, 3 2, 5 2, 4 5)))
+!ok
+
+SELECT ST_Delaunay('MULTIPOINT((1 1), (0 4), (3 2), (3 7), (4 5), (5 2), (7 1), (7 6), (8 4), (5 8), (1 8), (4 0))', 1);
+EXPR$0
+MULTILINESTRING ((0 4, 1 1), (0 4, 1 8), (0 4, 3 2), (0 4, 3 7), (0 4, 4 5), (1 1, 3 2), (1 1, 4 0), (1 8, 3 7), (1 8, 5 8), (3 2, 4 0), (3 2, 4 5), (3 2, 5 2), (3 7, 4 5), (3 7, 5 8), (4 0, 5 2), (4 0, 7 1), (4 5, 5 2), (4 5, 5 8), (4 5, 7 6), (4 5, 8 4), (5 2, 7 1), (5 2, 8 4), (5 8, 7 6), (7 1, 8 4), (7 6, 8 4))
+!ok
 
 # ST_Tessellate(polygon) Tessellates *polygon* (may be multi-polygon) with adaptive triangles
 # Not implemented
 
 #### Geometry aggregate functions
 
-# ST_Accum(geom) Accumulates *geom* into a geometry-collection (or multi-point, multi-line-string or multi-polygon if possible)
-# Not implemented
+# ST_Accum(geom) Accumulates *geom* into an array
+SELECT ST_Accum(tmp.geom)
+FROM (
+  SELECT ST_GeomFromText('POINT(1 1)') as geom
+  UNION ALL
+  SELECT ST_GeomFromText('POINT(2 2)') as geom
+) AS tmp;
+EXPR$0
+[POINT (1 1), POINT (2 2)]
+!ok
 
-# ST_Collect(geom) Alias for `ST_Accum`
-# Not implemented
+# ST_Collect(geom) Collects *geom* into a GeometryCollection
+SELECT ST_Collect(tmp.geom)
+FROM (
+  SELECT ST_GeomFromText('POINT(1 1)') as geom
+  UNION ALL
+  SELECT ST_GeomFromText('POINT(2 2)') as geom
+) AS tmp;
+EXPR$0
+GEOMETRYCOLLECTION (POINT (1 1), POINT (2 2))
+!ok
 
 # ST_Union(geom) Computes the union of geometries
-# Not implemented
+SELECT ST_Union(tmp.geom)
+FROM (
+  SELECT ST_GeomFromText('POINT(1 1)') as geom
+  UNION ALL
+  SELECT ST_GeomFromText('POINT(2 2)') as geom
+) AS tmp;
+EXPR$0
+MULTIPOINT ((1 1), (2 2))
+!ok
 
-# Disabled - ST_Union agg function is not implemented
-!if (false) {
+# ST_Union agg function is not implemented
 SELECT ST_AsText(st_union(the_geom))
-FROM (VALUES ST_GeomFromText('POLYGON((-7 4.2,-7.1 4.2,-7.1 4.3,-7 4.2))'),
+FROM (VALUES
+  ST_GeomFromText('POLYGON((-7 4.2,-7.1 4.2,-7.1 4.3,-7 4.2))'),
   ST_GeomFromText('POINT(5 5)'),
   ST_GeomFromText('POINT(-2 3)'),
   ST_GeomFromText('LINESTRING(5 5, 10 10)')) as foo(the_geom);
-
-st_asewkt
----------
-GEOMETRYCOLLECTION(POINT(-2 3 1),LINESTRING(5 5 5,10 10 10),POLYGON((-7 4.2 5,-7.1 4.2 5,-7.1 4.3 5,-7 4.2 5)))
+EXPR$0
+GEOMETRYCOLLECTION (POINT (-2 3), LINESTRING (5 5, 10 10), POLYGON ((-7 4.2, -7.1 4.2, -7.1 4.3, -7 4.2)))
 !ok
-!}
 
 # 3d example - sort of supports 3d (and with mixed dimensions!)
-# WRONG: Currently returns 4 rows, should return 1 row when ST_Union is aggregate function
 SELECT ST_AsText(st_union(the_geom))
 FROM (
   SELECT ST_GeomFromText('POLYGON((-7 4.2,-7.1 4.2,-7.1 4.3,-7 4.2))') as the_geom
@@ -1154,16 +2496,11 @@ FROM (
   SELECT ST_GeomFromText('POINT Z(-2 3 1)') as the_geom
   UNION ALL
   SELECT ST_GeomFromText('LINESTRING Z(5 5 5, 10 10 10)') as the_geom ) as foo;
-
 EXPR$0
-MULTILINESTRING Z ((5 5 5, 10 10 10))
-MULTIPOLYGON (((-7 4.2, -7.1 4.3, -7.1 4.2, -7 4.2)))
-POINT Z (-2 3 1)
-POINT Z (5 5 5)
+GEOMETRYCOLLECTION (POINT (-2 3), LINESTRING (5 5, 10 10), POLYGON ((-7 4.2, -7.1 4.2, -7.1 4.3, -7 4.2)))
 !ok
 
 # 3d example not mixing dimensions
-# WRONG: Currently returns 4 rows, should return 1 row when ST_Union is aggregate function
 SELECT ST_AsText(st_union(the_geom))
 FROM (
   SELECT ST_GeomFromText('POLYGON Z((-7 4.2 2,-7.1 4.2 3,-7.1 4.3 2,-7 4.2 2))') as the_geom
@@ -1173,12 +2510,8 @@ FROM (
   SELECT ST_GeomFromText('POINT Z(-2 3 1)') as the_geom
   UNION ALL
   SELECT ST_GeomFromText('LINESTRING Z(5 5 5, 10 10 10)') as the_geom ) as foo;
-
 EXPR$0
-MULTILINESTRING Z ((5 5 5, 10 10 10))
-MULTIPOLYGON Z (((-7 4.2 2, -7.1 4.3 2, -7.1 4.2 3, -7 4.2 2)))
-POINT Z (-2 3 1)
-POINT Z (5 5 5)
+GEOMETRYCOLLECTION Z(POINT Z(-2 3 1), LINESTRING Z(5 5 5, 10 10 10), POLYGON Z((-7 4.2 2, -7.1 4.2 3, -7.1 4.3 2, -7 4.2 2)))
 !ok
 
 # Polygon-to-polygon joins
@@ -1186,26 +2519,26 @@ select *
 from GEO."states" as s
 order by "name";
 name, geom
-AZ, {"rings":[[[-114,37],[-109.05,37],[-109.05,31.33],[-111.07,31.33],[-114.75,32.5],[-114.75,35.1],[-114,37]]]}
-CA, {"rings":[[[-124.25,42],[-120,42],[-120,39],[-114.75,35.1],[-114.75,32.5],[-117.15,32.5],[-118.3,33.75],[-120.5,34.5],[-122.4,37.2],[-124.25,42]]]}
-CO, {"rings":[[[-109.05,41],[-102,41],[-102,37],[-109.05,37],[-109.05,41]]]}
-ID, {"rings":[[[-117,49],[-116.05,49],[-116.05,48],[-114.4,46.6],[-112.9,44.45],[-111.05,44.45],[-111.05,42],[-117.03,42],[-117.03,44.2],[-116.5,45.5],[-117,46],[-117,49]]]}
-MT, {"rings":[[[-116.05,49],[-104.05,49],[-104.05,45],[-111.05,45],[-111.05,44.45],[-112.9,44.45],[-114.4,46.6],[-116.05,48],[-116.05,49]]]}
-NM, {"rings":[[[-109.05,37],[-103,37],[-103,32],[-106.65,32],[-106.5,31.8],[-108.2,31.8],[-108.2,31.33],[-109.05,31.33],[-109.05,37]]]}
-NV, {"rings":[[[-120,42],[-114,42],[-114,37],[-114.75,35.1],[-120,39],[-120,42]]]}
-OR, {"rings":[[[-123.9,46.2],[-122.7,45.7],[-119,46],[-117,46],[-116.5,45.5],[-117.03,44.2],[-117.03,42],[-124.25,42],[-124.6,42.8],[-123.9,46.2]]]}
-UT, {"rings":[[[-114,42],[-111.05,42],[-111.05,41],[-109.05,41],[-109.05,37],[-114,37],[-114,42]]]}
-WA, {"rings":[[[-124.8,48.4],[-123.2,48.2],[-123.2,49],[-117,49],[-117,46],[-119,46],[-122.7,45.7],[-123.9,46.2],[-124.8,48.4]]]}
-WY, {"rings":[[[-111.05,45],[-104.05,45],[-104.05,41],[-111.05,41],[-111.05,45]]]}
+AZ, POLYGON ((-114 37, -109.05 37, -109.05 31.33, -111.07 31.33, -114.75 32.5, -114.75 35.1, -114 37))
+CA, POLYGON ((-124.25 42, -120 42, -120 39, -114.75 35.1, -114.75 32.5, -117.15 32.5, -118.3 33.75, -120.5 34.5, -122.4 37.2, -124.25 42))
+CO, POLYGON ((-109.05 41, -102 41, -102 37, -109.05 37, -109.05 41))
+ID, POLYGON ((-117 49, -116.05 49, -116.05 48, -114.4 46.6, -112.9 44.45, -111.05 44.45, -111.05 42, -117.03 42, -117.03 44.2, -116.5 45.5, -117 46, -117 49))
+MT, POLYGON ((-116.05 49, -104.05 49, -104.05 45, -111.05 45, -111.05 44.45, -112.9 44.45, -114.4 46.6, -116.05 48, -116.05 49))
+NM, POLYGON ((-109.05 37, -103 37, -103 32, -106.65 32, -106.5 31.8, -108.2 31.8, -108.2 31.33, -109.05 31.33, -109.05 37))
+NV, POLYGON ((-120 42, -114 42, -114 37, -114.75 35.1, -120 39, -120 42))
+OR, POLYGON ((-123.9 46.2, -122.7 45.7, -119 46, -117 46, -116.5 45.5, -117.03 44.2, -117.03 42, -124.25 42, -124.6 42.8, -123.9 46.2))
+UT, POLYGON ((-114 42, -111.05 42, -111.05 41, -109.05 41, -109.05 37, -114 37, -114 42))
+WA, POLYGON ((-124.8 48.4, -123.2 48.2, -123.2 49, -117 49, -117 46, -119 46, -122.7 45.7, -123.9 46.2, -124.8 48.4))
+WY, POLYGON ((-111.05 45, -104.05 45, -104.05 41, -111.05 41, -111.05 45))
 !ok
 
 select *
 from GEO."parks" as p
 order by "name";
 name, geom
-Death Valley NP, {"rings":[[[-118.2,37.3],[-117,37],[-116.3,35.7],[-117,35.7],[-117.2,36.2],[-117.8,36.4],[-118.2,37.3]]]}
-Yellowstone NP, {"rings":[[[-111.2,45.1],[-109.3,45.1],[-109.3,44.1],[-109,43.8],[-110,43],[-111.2,43.4],[-111.2,45.1]]]}
-Yosemite NP, {"rings":[[[-120.2,38],[-119.3,38.2],[-119,37.7],[-119.9,37.6],[-120.2,38]]]}
+Death Valley NP, POLYGON ((-118.2 37.3, -117 37, -116.3 35.7, -117 35.7, -117.2 36.2, -117.8 36.4, -118.2 37.3))
+Yellowstone NP, POLYGON ((-111.2 45.1, -109.3 45.1, -109.3 44.1, -109 43.8, -110 43, -111.2 43.4, -111.2 45.1))
+Yosemite NP, POLYGON ((-120.2 38, -119.3 38.2, -119 37.7, -119.9 37.6, -120.2 38))
 !ok
 
 # Parks that may intersect states
@@ -1268,4 +2601,5 @@ EXPR$0
 33204
 !ok
 
+
 # End spatial.iq
diff --git a/core/src/test/resources/sql/sub-query.iq b/core/src/test/resources/sql/sub-query.iq
index 2d4936b696f..89b28976e23 100644
--- a/core/src/test/resources/sql/sub-query.iq
+++ b/core/src/test/resources/sql/sub-query.iq
@@ -50,7 +50,6 @@ t2(x) as (select * from  (values (1),(case when 1 = 1 then null else 3 end)) as
 select *
 from t1
 where t1.x not in (select t2.x from t2);
-
  X
 ---
 (0 rows)
@@ -310,50 +309,97 @@ group by (select deptno from "scott".emp where empno = 10);
 
 !ok
 
-!if (fixed.calcite1045) {
 # Correlated IN sub-query in WHERE clause of JOIN
 select empno from "scott".emp as e
 join "scott".dept as d using (deptno)
 where e.job in (
   select e2.job from "scott".emp as e2 where e2.deptno > e.deptno);
- EMPNO
--------
-  7369
-  7566
-  7782
-  7876
-  7934
++-------+
+| EMPNO |
++-------+
+|  7369 |
+|  7566 |
+|  7782 |
+|  7876 |
+|  7934 |
++-------+
 (5 rows)
 
 !ok
-EnumerableCalc(expr#0..5=[{inputs}], EMPNO=[$t0])
-  EnumerableHashJoin(condition=[=($2, $5)], joinType=[inner])
+EnumerableCalc(expr#0..4=[{inputs}], EMPNO=[$t0])
+  EnumerableHashJoin(condition=[=($2, $5)], joinType=[semi])
     EnumerableCalc(expr#0..4=[{inputs}], EMPNO=[$t2], JOB=[$t3], DEPTNO=[$t4], JOB0=[$t0], DEPTNO0=[$t1])
       EnumerableHashJoin(condition=[AND(=($1, $4), =($0, $3))], joinType=[inner])
-        EnumerableCalc(expr#0..1=[{inputs}], JOB=[$t1], DEPTNO=[$t0])
-          EnumerableAggregate(group=[{0, 2}])
-            EnumerableCalc(expr#0..3=[{inputs}], expr#4=[>($t3, $t0)], proj#0..3=[{exprs}], $condition=[$t4])
-              EnumerableNestedLoopJoin(condition=[true], joinType=[inner])
-                EnumerableAggregate(group=[{7}])
-                  EnumerableTableScan(table=[[scott, EMP]])
-                EnumerableCalc(expr#0..7=[{inputs}], EMPNO=[$t0], JOB=[$t2], DEPTNO=[$t7])
+        EnumerableAggregate(group=[{1, 3}])
+          EnumerableNestedLoopJoin(condition=[>($2, $3)], joinType=[inner])
+            EnumerableCalc(expr#0..7=[{inputs}], EMPNO=[$t0], JOB=[$t2], DEPTNO=[$t7])
+              EnumerableTableScan(table=[[scott, EMP]])
+            EnumerableAggregate(group=[{1}])
+              EnumerableHashJoin(condition=[=($1, $2)], joinType=[semi])
+                EnumerableCalc(expr#0..7=[{inputs}], EMPNO=[$t0], DEPTNO=[$t7])
                   EnumerableTableScan(table=[[scott, EMP]])
+                EnumerableCalc(expr#0..2=[{inputs}], DEPTNO=[$t0])
+                  EnumerableTableScan(table=[[scott, DEPT]])
         EnumerableCalc(expr#0..7=[{inputs}], EMPNO=[$t0], JOB=[$t2], DEPTNO=[$t7])
           EnumerableTableScan(table=[[scott, EMP]])
     EnumerableCalc(expr#0..2=[{inputs}], DEPTNO=[$t0])
       EnumerableTableScan(table=[[scott, DEPT]])
 !plan
-!}
 
-!if (fixed.calcite1045) {
 # Correlated NOT IN sub-query in WHERE clause of JOIN
 select empno from "scott".emp as e
 join "scott".dept as d using (deptno)
 where e.job not in (
   select e2.job from "scott".emp as e2 where e2.deptno > e.deptno);
++-------+
+| EMPNO |
++-------+
+|  7499 |
+|  7521 |
+|  7654 |
+|  7698 |
+|  7788 |
+|  7839 |
+|  7844 |
+|  7900 |
+|  7902 |
++-------+
+(9 rows)
+
 !ok
+EnumerableCalc(expr#0..9=[{inputs}], expr#10=[0], expr#11=[=($t5, $t10)], expr#12=[IS NULL($t1)], expr#13=[IS NOT NULL($t9)], expr#14=[<($t6, $t5)], expr#15=[OR($t12, $t13, $t14)], expr#16=[IS NOT TRUE($t15)], expr#17=[OR($t11, $t16)], EMPNO=[$t0], $condition=[$t17])
+  EnumerableMergeJoin(condition=[AND(=($1, $7), =($2, $8))], joinType=[left])
+    EnumerableSort(sort0=[$1], sort1=[$2], dir0=[ASC], dir1=[ASC])
+      EnumerableHashJoin(condition=[=($2, $4)], joinType=[left])
+        EnumerableCalc(expr#0..3=[{inputs}], EMPNO=[$t1], JOB=[$t2], DEPTNO=[$t3], DEPTNO0=[$t0])
+          EnumerableHashJoin(condition=[=($0, $3)], joinType=[inner])
+            EnumerableCalc(expr#0..2=[{inputs}], DEPTNO=[$t0])
+              EnumerableTableScan(table=[[scott, DEPT]])
+            EnumerableCalc(expr#0..7=[{inputs}], EMPNO=[$t0], JOB=[$t2], DEPTNO=[$t7])
+              EnumerableTableScan(table=[[scott, EMP]])
+        EnumerableAggregate(group=[{3}], c=[COUNT()], ck=[COUNT($1)])
+          EnumerableNestedLoopJoin(condition=[>($2, $3)], joinType=[inner])
+            EnumerableCalc(expr#0..7=[{inputs}], EMPNO=[$t0], JOB=[$t2], DEPTNO=[$t7])
+              EnumerableTableScan(table=[[scott, EMP]])
+            EnumerableAggregate(group=[{1}])
+              EnumerableHashJoin(condition=[=($1, $2)], joinType=[semi])
+                EnumerableCalc(expr#0..7=[{inputs}], EMPNO=[$t0], DEPTNO=[$t7])
+                  EnumerableTableScan(table=[[scott, EMP]])
+                EnumerableCalc(expr#0..2=[{inputs}], DEPTNO=[$t0])
+                  EnumerableTableScan(table=[[scott, DEPT]])
+    EnumerableSort(sort0=[$0], sort1=[$1], dir0=[ASC], dir1=[ASC])
+      EnumerableCalc(expr#0..1=[{inputs}], expr#2=[true], expr#3=[IS NOT NULL($t0)], proj#0..2=[{exprs}], $condition=[$t3])
+        EnumerableAggregate(group=[{1, 3}])
+          EnumerableNestedLoopJoin(condition=[>($2, $3)], joinType=[inner])
+            EnumerableCalc(expr#0..7=[{inputs}], EMPNO=[$t0], JOB=[$t2], DEPTNO=[$t7])
+              EnumerableTableScan(table=[[scott, EMP]])
+            EnumerableAggregate(group=[{1}])
+              EnumerableHashJoin(condition=[=($1, $2)], joinType=[semi])
+                EnumerableCalc(expr#0..7=[{inputs}], EMPNO=[$t0], DEPTNO=[$t7])
+                  EnumerableTableScan(table=[[scott, EMP]])
+                EnumerableCalc(expr#0..2=[{inputs}], DEPTNO=[$t0])
+                  EnumerableTableScan(table=[[scott, DEPT]])
 !plan
-!}
 
 # Condition that returns a NULL key.
 # Tested on Oracle.
@@ -448,11 +494,10 @@ EnumerableCalc(expr#0..2=[{inputs}], proj#0..1=[{exprs}])
 # Uncorrelated
 with t (a, b) as (select * from (values (60, 'b')))
 select * from t where a in (select deptno from "scott".dept);
-EnumerableCalc(expr#0..2=[{inputs}], proj#0..1=[{exprs}])
-  EnumerableHashJoin(condition=[=($0, $2)], joinType=[inner])
-    EnumerableValues(tuples=[[{ 60, 'b' }]])
-    EnumerableCalc(expr#0..2=[{inputs}], DEPTNO=[$t0])
-      EnumerableTableScan(table=[[scott, DEPT]])
+EnumerableHashJoin(condition=[=($0, $2)], joinType=[semi])
+  EnumerableValues(tuples=[[{ 60, 'b' }]])
+  EnumerableCalc(expr#0..2=[{inputs}], DEPTNO=[$t0])
+    EnumerableTableScan(table=[[scott, DEPT]])
 !plan
 +---+---+
 | A | B |
@@ -550,23 +595,68 @@ and exists (select 0 from "scott".emp where deptno = d.deptno and ename = 'SMITH
 !ok
 
 # Two scalar sub-queries
-!if (fixed.calcite1045) {
 select deptno,
   (select min(1) from "scott".emp where empno > d.deptno) as i0,
   (select min(0) from "scott".emp where deptno = d.deptno and ename = 'SMITH') as i1
 from "scott".dept as d;
-+--------+----+---+
-| DEPTNO | I0 | I1|
-+--------+----+---+
-|     10 |  1 |   |
-|     20 |  1 | 0 |
-|     30 |  1 |   |
-|     40 |  1 |   |
-+--------+----+---+
++--------+----+----+
+| DEPTNO | I0 | I1 |
++--------+----+----+
+|     10 |  1 |    |
+|     20 |  1 |  0 |
+|     30 |  1 |    |
+|     40 |  1 |    |
++--------+----+----+
 (4 rows)
 
 !ok
-!}
+
+# Correlated scalar sub-query
+SELECT d.dname,
+    (WITH clerks AS
+      (SELECT *
+       FROM "scott".emp
+       WHERE deptno = d.deptno)
+     SELECT min(sal)
+     FROM clerks) AS min_clerk_sal
+FROM "scott".dept AS d;
++------------+---------------+
+| DNAME      | MIN_CLERK_SAL |
++------------+---------------+
+| ACCOUNTING |       1300.00 |
+| OPERATIONS |               |
+| RESEARCH   |        800.00 |
+| SALES      |        950.00 |
++------------+---------------+
+(4 rows)
+
+!ok
+
+# As previous, minimal
+SELECT (WITH t2 AS (SELECT t.a)
+        SELECT a FROM t2) AS c
+FROM (SELECT 1 AS a) AS t;
++---+
+| C |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
+
+# As above, converting CTE to inline view
+SELECT (SELECT a
+        FROM (SELECT t.a) AS t2) AS c
+FROM (SELECT 1 AS a) AS t;
++---+
+| C |
++---+
+| 1 |
++---+
+(1 row)
+
+!ok
 
 # [CALCITE-1494] Inefficient plan for correlated sub-queries
 # Plan must have only one scan each of emp and dept.
@@ -583,12 +673,12 @@ where empno IN (
 (0 rows)
 
 !ok
-EnumerableCalc(expr#0..4=[{inputs}], SAL=[$t3])
-  EnumerableHashJoin(condition=[AND(=($1, $4), =($0, $2))], joinType=[inner])
-    EnumerableCalc(expr#0..2=[{inputs}], expr#3=[IS NOT NULL($t1)], proj#0..1=[{exprs}], $condition=[$t3])
-      EnumerableTableScan(table=[[scott, DEPT]])
+EnumerableCalc(expr#0..2=[{inputs}], SAL=[$t1])
+  EnumerableHashJoin(condition=[AND(=($2, $4), =($0, $3))], joinType=[semi])
     EnumerableCalc(expr#0..7=[{inputs}], expr#8=[CAST($t2):VARCHAR(14)], EMPNO=[$t0], SAL=[$t5], JOB0=[$t8])
       EnumerableTableScan(table=[[scott, EMP]])
+    EnumerableCalc(expr#0..2=[{inputs}], expr#3=[IS NOT NULL($t1)], proj#0..1=[{exprs}], $condition=[$t3])
+      EnumerableTableScan(table=[[scott, DEPT]])
 !plan
 
 # As above, but for EXISTS
@@ -606,11 +696,10 @@ where exists (
 (1 row)
 
 !ok
-EnumerableCalc(expr#0..3=[{inputs}], DEPTNO=[$t1], DNAME=[$t2], LOC=[$t3])
-  EnumerableHashJoin(condition=[=($0, $1)], joinType=[inner])
-    EnumerableCalc(expr#0..7=[{inputs}], expr#8=['SMITH':VARCHAR(10)], expr#9=[=($t1, $t8)], expr#10=[IS NOT NULL($t7)], expr#11=[AND($t9, $t10)], DEPTNO=[$t7], $condition=[$t11])
-      EnumerableTableScan(table=[[scott, EMP]])
-    EnumerableTableScan(table=[[scott, DEPT]])
+EnumerableHashJoin(condition=[=($0, $3)], joinType=[semi])
+  EnumerableTableScan(table=[[scott, DEPT]])
+  EnumerableCalc(expr#0..7=[{inputs}], expr#8=['SMITH':VARCHAR(10)], expr#9=[=($t1, $t8)], expr#10=[IS NOT NULL($t7)], expr#11=[AND($t9, $t10)], DEPTNO=[$t7], $condition=[$t11])
+    EnumerableTableScan(table=[[scott, EMP]])
 !plan
 
 # [DRILL-5644]
@@ -745,8 +834,6 @@ and empno in (7876, 7698, 7900);
 
 !set outputformat psql
 
-!set expand false
-
 # [CALCITE-2329] Enhance SubQueryRemoveRule to rewrite IN operator with the constant from the left side more optimally
 # Test project null IN null
 select sal,
@@ -1696,12 +1783,12 @@ select sal from "scott".emp e
 (3 rows)
 
 !ok
-EnumerableCalc(expr#0..3=[{inputs}], SAL=[$t2])
-  EnumerableHashJoin(condition=[=($0, $3)], joinType=[inner])
-    EnumerableCalc(expr#0..2=[{inputs}], expr#3=[10], expr#4=[=($t3, $t0)], DEPTNO=[$t0], $condition=[$t4])
-      EnumerableTableScan(table=[[scott, DEPT]])
+EnumerableCalc(expr#0..2=[{inputs}], SAL=[$t1])
+  EnumerableHashJoin(condition=[=($2, $3)], joinType=[semi])
     EnumerableCalc(expr#0..7=[{inputs}], EMPNO=[$t0], SAL=[$t5], DEPTNO=[$t7])
       EnumerableTableScan(table=[[scott, EMP]])
+    EnumerableCalc(expr#0..2=[{inputs}], expr#3=[10], expr#4=[=($t3, $t0)], DEPTNO=[$t0], $condition=[$t4])
+      EnumerableTableScan(table=[[scott, DEPT]])
 !plan
 
 # Test filter literal IN nullable correlated
@@ -1717,12 +1804,12 @@ select sal from "scott".emp e
 (3 rows)
 
 !ok
-EnumerableCalc(expr#0..3=[{inputs}], SAL=[$t2])
-  EnumerableHashJoin(condition=[=($0, $3)], joinType=[inner])
-    EnumerableCalc(expr#0..2=[{inputs}], expr#3=[10], expr#4=[=($t3, $t0)], DEPTNO=[$t0], $condition=[$t4])
-      EnumerableTableScan(table=[[scott, DEPT]])
+EnumerableCalc(expr#0..2=[{inputs}], SAL=[$t1])
+  EnumerableHashJoin(condition=[=($2, $3)], joinType=[semi])
     EnumerableCalc(expr#0..7=[{inputs}], EMPNO=[$t0], SAL=[$t5], DEPTNO=[$t7])
       EnumerableTableScan(table=[[scott, EMP]])
+    EnumerableCalc(expr#0..2=[{inputs}], expr#3=[10], expr#4=[=($t3, $t0)], DEPTNO=[$t0], $condition=[$t4])
+      EnumerableTableScan(table=[[scott, DEPT]])
 !plan
 
 # Test filter null NOT IN null correlated
@@ -1880,13 +1967,8 @@ select sal from "scott".emp e
 (14 rows)
 
 !ok
-EnumerableCalc(expr#0..3=[{inputs}], SAL=[$t1])
-  EnumerableMergeJoin(condition=[=($2, $3)], joinType=[left])
-    EnumerableSort(sort0=[$2], dir0=[ASC])
-      EnumerableCalc(expr#0..7=[{inputs}], EMPNO=[$t0], SAL=[$t5], DEPTNO=[$t7])
-        EnumerableTableScan(table=[[scott, EMP]])
-    EnumerableCalc(expr#0..2=[{inputs}], DEPTNO=[$t0])
-      EnumerableTableScan(table=[[scott, DEPT]])
+EnumerableCalc(expr#0..7=[{inputs}], SAL=[$t5])
+  EnumerableTableScan(table=[[scott, EMP]])
 !plan
 
 
@@ -2060,11 +2142,10 @@ EnumerableAggregate(group=[{}], C=[COUNT()])
 select empno from "scott".emp as e
 where e.empno > ANY(
   select 2 from "scott".dept e2 where e2.deptno = e.deptno) ;
-EnumerableCalc(expr#0..6=[{inputs}], expr#7=[>($t0, $t2)], expr#8=[IS NULL($t5)], expr#9=[0], expr#10=[=($t3, $t9)], expr#11=[OR($t8, $t10)], expr#12=[IS NOT TRUE($t11)], expr#13=[AND($t7, $t12)], expr#14=[IS NOT TRUE($t7)], expr#15=[>($t3, $t4)], expr#16=[IS NOT TRUE($t15)], expr#17=[AND($t7, $t12, $t14, $t16)], expr#18=[OR($t13, $t17)], EMPNO=[$t0], $condition=[$t18])
-  EnumerableMergeJoin(condition=[=($1, $6)], joinType=[left])
-    EnumerableSort(sort0=[$1], dir0=[ASC])
-      EnumerableCalc(expr#0..7=[{inputs}], EMPNO=[$t0], DEPTNO=[$t7])
-        EnumerableTableScan(table=[[scott, EMP]])
+EnumerableCalc(expr#0..1=[{inputs}], EMPNO=[$t0])
+  EnumerableHashJoin(condition=[AND(=($1, $6), OR(AND(>($0, $2), <>($3, 0)), AND(>($0, $2), <>($3, 0), IS NOT TRUE(>($0, $2)), IS NOT TRUE(>($3, $4)))))], joinType=[semi])
+    EnumerableCalc(expr#0..7=[{inputs}], EMPNO=[$t0], DEPTNO=[$t7])
+      EnumerableTableScan(table=[[scott, EMP]])
     EnumerableCalc(expr#0..2=[{inputs}], expr#3=[2], expr#4=[1:BIGINT], expr#5=[true], m=[$t3], c=[$t4], d=[$t4], trueLiteral=[$t5], DEPTNO=[$t0])
       EnumerableTableScan(table=[[scott, DEPT]])
 !plan
@@ -2140,7 +2221,6 @@ EnumerableCalc(expr#0..2=[{inputs}], ENAME=[$t1])
     EnumerableCalc(expr#0..7=[{inputs}], expr#8=[IS NOT NULL($t3)], expr#9=[CAST($t3):INTEGER NOT NULL], expr#10=[0], expr#11=[CASE($t8, $t9, $t10)], $f8=[$t11])
       EnumerableTableScan(table=[[scott, EMP]])
 !plan
-
  ENAME
 --------
  ADAMS
@@ -2186,7 +2266,6 @@ EnumerableCalc(expr#0..5=[{inputs}], expr#6=[<>($t2, $t1)], expr#7=[1], expr#8=[
 # Previous, as scalar sub-query.
 select empno, empno <> some (select emp2.empno from "scott".emp emp2 where emp2.empno = emp1.empno) as x
 from "scott".emp emp1;
-
 +-------+-------+
 | EMPNO | X     |
 +-------+-------+
@@ -2242,7 +2321,6 @@ EnumerableCalc(expr#0..12=[{inputs}], expr#13=[<>($t9, $t8)], expr#14=[1], expr#
 # Previous, as scalar sub-query.
 select *, empno <> some (select comm from "scott".emp where deptno = emp1.deptno) as x
 from "scott".emp as emp1;
-
 +-------+--------+-----------+------+------------+---------+---------+--------+------+
 | EMPNO | ENAME  | JOB       | MGR  | HIREDATE   | SAL     | COMM    | DEPTNO | X    |
 +-------+--------+-----------+------+------------+---------+---------+--------+------+
@@ -2291,7 +2369,6 @@ EnumerableCalc(expr#0..12=[{inputs}], expr#13=[<>($t9, $t8)], expr#14=[1], expr#
 # Previous, as scalar sub-query.
 select *, empno <> some (select 2 from "scott".dept dept1 where dept1.deptno = emp1.empno) as x
 from "scott".emp as emp1;
-
 +-------+--------+-----------+------+------------+---------+---------+--------+-------+
 | EMPNO | ENAME  | JOB       | MGR  | HIREDATE   | SAL     | COMM    | DEPTNO | X     |
 +-------+--------+-----------+------+------------+---------+---------+--------+-------+
@@ -2340,7 +2417,6 @@ EnumerableCalc(expr#0..12=[{inputs}], expr#13=[<>($t9, $t8)], expr#14=[1], expr#
 # Previous, as scalar sub-query.
 select *, comm <> some (select 2 from "scott".dept dept1 where dept1.deptno = emp1.empno) as x
 from "scott".emp as emp1;
-
 +-------+--------+-----------+------+------------+---------+---------+--------+-------+
 | EMPNO | ENAME  | JOB       | MGR  | HIREDATE   | SAL     | COMM    | DEPTNO | X     |
 +-------+--------+-----------+------+------------+---------+---------+--------+-------+
@@ -2392,7 +2468,6 @@ EnumerableCalc(expr#0..12=[{inputs}], expr#13=[<>($t9, $t8)], expr#14=[1], expr#
 # Previous, as scalar sub-query.
 select *, emp1.comm <> some (select comm from "scott".emp where sal = emp1.sal) as x
 from "scott".emp emp1;
-
 +-------+--------+-----------+------+------------+---------+---------+--------+-------+
 | EMPNO | ENAME  | JOB       | MGR  | HIREDATE   | SAL     | COMM    | DEPTNO | X     |
 +-------+--------+-----------+------+------------+---------+---------+--------+-------+
@@ -2417,14 +2492,12 @@ from "scott".emp emp1;
 
 # [CALCITE-4486] UNIQUE predicate
 !use scott
-!set expand false
 !set outputformat mysql
 
 # singleton keys have unique value which excludes fully or partially null rows.
 select deptno
 from "scott".dept
 where unique (select comm from "scott".emp where comm is not null);
-
 +--------+
 | DEPTNO |
 +--------+
@@ -2451,7 +2524,6 @@ EnumerableCalc(expr#0..1=[{inputs}], expr#2=[IS NULL($t1)], DEPTNO=[$t0], $condi
 # Previous, as scalar sub-query.
 select deptno, unique (select comm from "scott".emp where comm is not null) as u
 from "scott".dept;
-
 +--------+------+
 | DEPTNO | U    |
 +--------+------+
@@ -2478,7 +2550,6 @@ EnumerableCalc(expr#0..1=[{inputs}], expr#2=[IS NULL($t1)], DEPTNO=[$t0], U=[$t2
 # Previous, but NOT UNIQUE.
 select deptno, not unique (select comm from "scott".emp where comm is not null) as u
 from "scott".dept;
-
 +--------+-------+
 | DEPTNO | U     |
 +--------+-------+
@@ -2506,7 +2577,6 @@ EnumerableCalc(expr#0..1=[{inputs}], expr#2=[IS NOT NULL($t1)], DEPTNO=[$t0], U=
 select deptno
 from "scott".dept
 where unique (select comm from "scott".emp);
-
 +--------+
 | DEPTNO |
 +--------+
@@ -2533,7 +2603,6 @@ EnumerableCalc(expr#0..1=[{inputs}], expr#2=[IS NULL($t1)], DEPTNO=[$t0], $condi
 # Previous, as scalar sub-query.
 select deptno, unique (select comm from "scott".emp) as u
 from "scott".dept;
-
 +--------+------+
 | DEPTNO | U    |
 +--------+------+
@@ -2561,7 +2630,6 @@ EnumerableCalc(expr#0..1=[{inputs}], expr#2=[IS NULL($t1)], DEPTNO=[$t0], U=[$t2
 select deptno
 from "scott".dept
 where unique (select comm from "scott".emp where comm is null);
-
 +--------+
 | DEPTNO |
 +--------+
@@ -2574,17 +2642,13 @@ where unique (select comm from "scott".emp where comm is null);
 
 !ok
 
-EnumerableCalc(expr#0..1=[{inputs}], expr#2=[IS NULL($t1)], DEPTNO=[$t0], $condition=[$t2])
-  EnumerableNestedLoopJoin(condition=[true], joinType=[left])
-    EnumerableCalc(expr#0..2=[{inputs}], DEPTNO=[$t0])
-      EnumerableTableScan(table=[[scott, DEPT]])
-    EnumerableValues(tuples=[[]])
+EnumerableCalc(expr#0..2=[{inputs}], DEPTNO=[$t0])
+  EnumerableTableScan(table=[[scott, DEPT]])
 !plan
 
 # Previous, as scalar sub-query.
 select deptno, unique (select comm from "scott".emp where comm is null) as u
 from "scott".dept;
-
 +--------+------+
 | DEPTNO | U    |
 +--------+------+
@@ -2597,18 +2661,14 @@ from "scott".dept;
 
 !ok
 
-EnumerableCalc(expr#0..1=[{inputs}], expr#2=[IS NULL($t1)], DEPTNO=[$t0], U=[$t2])
-  EnumerableNestedLoopJoin(condition=[true], joinType=[left])
-    EnumerableCalc(expr#0..2=[{inputs}], DEPTNO=[$t0])
-      EnumerableTableScan(table=[[scott, DEPT]])
-    EnumerableValues(tuples=[[]])
+EnumerableCalc(expr#0..2=[{inputs}], expr#3=[true], DEPTNO=[$t0], U=[$t3])
+  EnumerableTableScan(table=[[scott, DEPT]])
 !plan
 
 # composite keys have unique value which excludes fully or partially null rows.
 select deptno
 from "scott".dept
 where unique (select comm, sal from "scott".emp where comm is not null);
-
 +--------+
 | DEPTNO |
 +--------+
@@ -2635,7 +2695,6 @@ EnumerableCalc(expr#0..1=[{inputs}], expr#2=[IS NULL($t1)], DEPTNO=[$t0], $condi
 # Previous, as scalar sub-query.
 select deptno, unique (select comm, sal from "scott".emp where comm is not null) as u
 from "scott".dept;
-
 +--------+------+
 | DEPTNO | U    |
 +--------+------+
@@ -2665,7 +2724,6 @@ EnumerableCalc(expr#0..1=[{inputs}], expr#2=[IS NULL($t1)], DEPTNO=[$t0], U=[$t2
 select deptno
 from "scott".dept
 where unique (select comm, sal from "scott".emp);
-
 +--------+
 | DEPTNO |
 +--------+
@@ -2692,7 +2750,6 @@ EnumerableCalc(expr#0..1=[{inputs}], expr#2=[IS NULL($t1)], DEPTNO=[$t0], $condi
 # Previous, as scalar sub-query.
 select deptno, unique (select comm, sal from "scott".emp) as u
 from "scott".dept;
-
 +--------+------+
 | DEPTNO | U    |
 +--------+------+
@@ -2742,7 +2799,6 @@ EnumerableCalc(expr#0..1=[{inputs}], expr#2=[IS NULL($t1)], DEPTNO=[$t0], $condi
 # Previous, as scalar sub-query.
 select deptno, unique (select deptno from "scott".emp) as u
 from "scott".dept;
-
 +--------+-------+
 | DEPTNO | U     |
 +--------+-------+
@@ -2792,7 +2848,6 @@ EnumerableCalc(expr#0..1=[{inputs}], expr#2=[IS NULL($t1)], DEPTNO=[$t0], $condi
 # Previous, as scalar sub-query.
 select deptno, unique (select deptno, sal from "scott".emp where sal = 3000) as u
 from "scott".dept;
-
 +--------+-------+
 | DEPTNO | U     |
 +--------+-------+
@@ -2819,7 +2874,6 @@ EnumerableCalc(expr#0..1=[{inputs}], expr#2=[IS NULL($t1)], DEPTNO=[$t0], U=[$t2
 # Previous, but NOT UNIQUE.
 select deptno, not unique (select deptno, sal from "scott".emp where sal = 3000) as u
 from "scott".dept;
-
 +--------+------+
 | DEPTNO | U    |
 +--------+------+
@@ -2847,7 +2901,6 @@ EnumerableCalc(expr#0..1=[{inputs}], expr#2=[IS NOT NULL($t1)], DEPTNO=[$t0], U=
 select deptno
 from "scott".dept
 where unique (select deptno from "scott".emp where deptno = 35);
-
 +--------+
 | DEPTNO |
 +--------+
@@ -2874,7 +2927,6 @@ EnumerableCalc(expr#0..1=[{inputs}], expr#2=[IS NULL($t1)], DEPTNO=[$t0], $condi
 # Previous, as scalar sub-query.
 select deptno, unique (select deptno from "scott".emp where deptno = 35) as u
 from "scott".dept;
-
 +--------+------+
 | DEPTNO | U    |
 +--------+------+
@@ -2902,7 +2954,6 @@ EnumerableCalc(expr#0..1=[{inputs}], expr#2=[IS NULL($t1)], DEPTNO=[$t0], U=[$t2
 select *
 from "scott".dept
 where unique (select deptno from "scott".dept);
-
 +--------+------------+----------+
 | DEPTNO | DNAME      | LOC      |
 +--------+------------+----------+
@@ -2922,7 +2973,6 @@ EnumerableTableScan(table=[[scott, DEPT]])
 select *
 from "scott".dept
 where unique (select deptno from "scott".emp limit 1);
-
 +--------+------------+----------+
 | DEPTNO | DNAME      | LOC      |
 +--------+------------+----------+
@@ -2942,7 +2992,6 @@ EnumerableTableScan(table=[[scott, DEPT]])
 select deptno
 from "scott".dept
 where unique (select distinct deptno, sal from "scott".emp where sal = 3000);
-
 +--------+
 | DEPTNO |
 +--------+
@@ -2963,7 +3012,6 @@ EnumerableCalc(expr#0..2=[{inputs}], DEPTNO=[$t0])
 select deptno
 from "scott".dept
 where unique (select job from "scott".emp group by job);
-
 +--------+
 | DEPTNO |
 +--------+
@@ -2985,7 +3033,6 @@ select *
 from "scott".dept
 where unique (
     select 1 from "scott".emp where dept.deptno = emp.deptno);
-
 +--------+------------+--------+
 | DEPTNO | DNAME      | LOC    |
 +--------+------------+--------+
@@ -3008,7 +3055,6 @@ EnumerableCalc(expr#0..4=[{inputs}], expr#5=[IS NULL($t3)], proj#0..2=[{exprs}],
 # Previous, as scalar sub-query.
 select *, unique (select 1 from "scott".emp where dept.deptno = emp.deptno) as u
 from "scott".dept;
-
 +--------+------------+----------+-------+
 | DEPTNO | DNAME      | LOC      | U     |
 +--------+------------+----------+-------+
@@ -3036,7 +3082,6 @@ select *
 from "scott".dept
 where not unique (
     select 1 from "scott".emp where dept.deptno = emp.deptno);
-
 +--------+------------+----------+
 | DEPTNO | DNAME      | LOC      |
 +--------+------------+----------+
@@ -3048,19 +3093,17 @@ where not unique (
 
 !ok
 
-EnumerableCalc(expr#0..3=[{inputs}], DEPTNO=[$t1], DNAME=[$t2], LOC=[$t3])
-  EnumerableHashJoin(condition=[=($0, $1)], joinType=[inner])
-    EnumerableCalc(expr#0..1=[{inputs}], expr#2=[1], expr#3=[>($t1, $t2)], DEPTNO=[$t0], $condition=[$t3])
-      EnumerableAggregate(group=[{7}], c=[COUNT()])
-        EnumerableCalc(expr#0..7=[{inputs}], expr#8=[IS NOT NULL($t7)], proj#0..7=[{exprs}], $condition=[$t8])
-          EnumerableTableScan(table=[[scott, EMP]])
-    EnumerableTableScan(table=[[scott, DEPT]])
+EnumerableHashJoin(condition=[=($0, $3)], joinType=[semi])
+  EnumerableTableScan(table=[[scott, DEPT]])
+  EnumerableCalc(expr#0..1=[{inputs}], expr#2=[1], expr#3=[>($t1, $t2)], DEPTNO=[$t0], $condition=[$t3])
+    EnumerableAggregate(group=[{7}], c=[COUNT()])
+      EnumerableCalc(expr#0..7=[{inputs}], expr#8=[IS NOT NULL($t7)], proj#0..7=[{exprs}], $condition=[$t8])
+        EnumerableTableScan(table=[[scott, EMP]])
 !plan
 
 # Previous, as scalar sub-query.
 select *, not unique (select 1 from "scott".emp where dept.deptno = emp.deptno) as u
 from "scott".dept;
-
 +--------+------------+----------+-------+
 | DEPTNO | DNAME      | LOC      | U     |
 +--------+------------+----------+-------+
@@ -3088,7 +3131,6 @@ EnumerableCalc(expr#0..4=[{inputs}], expr#5=[IS NOT NULL($t3)], proj#0..2=[{expr
 
 # The IN-list contains partial null value.
 select * from "scott".emp where comm in (300, 500, null);
-
 +-------+-------+----------+------+------------+---------+--------+--------+
 | EMPNO | ENAME | JOB      | MGR  | HIREDATE   | SAL     | COMM   | DEPTNO |
 +-------+-------+----------+------+------------+---------+--------+--------+
@@ -3105,7 +3147,6 @@ EnumerableCalc(expr#0..7=[{inputs}], expr#8=[Sarg[300:DECIMAL(7, 2), 500:DECIMAL
 
 # Previous, as scalar sub-query.
 select *, comm in (300, 500, null) as i from "scott".emp;
-
 +-------+--------+-----------+------+------------+---------+---------+--------+------+
 | EMPNO | ENAME  | JOB       | MGR  | HIREDATE   | SAL     | COMM    | DEPTNO | I    |
 +-------+--------+-----------+------+------------+---------+---------+--------+------+
@@ -3134,7 +3175,6 @@ EnumerableCalc(expr#0..7=[{inputs}], expr#8=[Sarg[300:DECIMAL(7, 2), 500:DECIMAL
 
 # As above, but NOT IN.
 select * from "scott".emp where comm not in (300, 500, null);
-
 +-------+-------+-----+-----+----------+-----+------+--------+
 | EMPNO | ENAME | JOB | MGR | HIREDATE | SAL | COMM | DEPTNO |
 +-------+-------+-----+-----+----------+-----+------+--------+
@@ -3148,7 +3188,6 @@ EnumerableValues(tuples=[[]])
 
 # Previous, as scalar sub-query.
 select *, comm not in (300, 500, null) as i from "scott".emp;
-
 +-------+--------+-----------+------+------------+---------+---------+--------+-------+
 | EMPNO | ENAME  | JOB       | MGR  | HIREDATE   | SAL     | COMM    | DEPTNO | I     |
 +-------+--------+-----------+------+------------+---------+---------+--------+-------+
@@ -3462,4 +3501,47 @@ where NOT EXISTS (select count(*) from emp e having false);
 EnumerableTableScan(table=[[scott, DEPT]])
 !plan
 
+# Test case about nested row
+select (select (1, 2));
++--------+
+| EXPR$0 |
++--------+
+| {1, 2} |
++--------+
+(1 row)
+
+!ok
+
+EnumerableCalc(expr#0..1=[{inputs}], EXPR$0=[$t1])
+  EnumerableNestedLoopJoin(condition=[true], joinType=[left])
+    EnumerableValues(tuples=[[{ 0 }]])
+    EnumerableAggregate(group=[{}], agg#0=[SINGLE_VALUE($0)])
+      EnumerableCalc(expr#0=[{inputs}], expr#1=[1], expr#2=[2], expr#3=[ROW($t1, $t2)], EXPR$0=[$t3])
+        EnumerableValues(tuples=[[{ 0 }]])
+!plan
+
+# Test case for correlated sub-query
+SELECT ARRAY(SELECT s.x) FROM (SELECT 1 as x) s;
++--------+
+| EXPR$0 |
++--------+
+| [1]    |
++--------+
+(1 row)
+
+!ok
+
+# Test case for [CALCITE-5310] JSON_OBJECT in scalar sub-query throws AssertionError
+SELECT (SELECT json_object('1': (a.attidentity = 'a'), '2': v) FROM UNNEST(ARRAY[1]) as v) as options
+FROM UNNEST(ARRAY['a', 'b']) AS a(attidentity);
++-------------------+
+| OPTIONS           |
++-------------------+
+| {"1":false,"2":1} |
+| {"1":true,"2":1}  |
++-------------------+
+(2 rows)
+
+!ok
+
 # End sub-query.iq
diff --git a/core/src/test/resources/sql/unnest.iq b/core/src/test/resources/sql/unnest.iq
index 8056742279a..bf990ad4634 100644
--- a/core/src/test/resources/sql/unnest.iq
+++ b/core/src/test/resources/sql/unnest.iq
@@ -105,6 +105,31 @@ from UNNEST(array ['apple', 'banana']) as "fruit";
 
 !ok
 
+select fruit
+from UNNEST(array(select 'banana')) as fruit;
++--------+
+| FRUIT  |
++--------+
+| banana |
++--------+
+(1 row)
+
+!ok
+
+#TODO: Remove if when [CALCITE-5127] will be fixed.
+!if (false) {
+SELECT ARRAY(SELECT y + 1 FROM UNNEST(s.x) y)
+FROM (SELECT ARRAY[1,2,3] as x) s;
++--------+
+| FRUIT  |
++--------+
+| banana |
++--------+
+(1 row)
+
+!ok
+!}
+
 # If UNNEST is not the direct child of the AS, aliasing doesn't happen.
 SELECT fruit.*
 FROM (
@@ -120,21 +145,19 @@ FROM (
 
 !ok
 
-# If UNNEST applies to a value that is not an array constructor,
-# aliasing doesn't happen. Thus the last column is 'EXPR$0', not 'z'.
 SELECT *
 FROM (
     SELECT x, collect(y) as ys
     FROM (VALUES (1, 1), (2, 2), (1, 3)) AS t (x, y)
     GROUP BY x) AS u,
   UNNEST(u.ys) AS z;
-+---+--------+--------+
-| X | YS     | EXPR$0 |
-+---+--------+--------+
-| 1 | [1, 3] |      1 |
-| 1 | [1, 3] |      3 |
-| 2 | [2]    |      2 |
-+---+--------+--------+
++---+--------+---+
+| X | YS     | Z |
++---+--------+---+
+| 1 | [1, 3] | 1 |
+| 1 | [1, 3] | 3 |
+| 2 | [2]    | 2 |
++---+--------+---+
 (3 rows)
 
 !ok
diff --git a/core/src/test/resources/sql/winagg.iq b/core/src/test/resources/sql/winagg.iq
index ce4264c0539..e6228a3966f 100644
--- a/core/src/test/resources/sql/winagg.iq
+++ b/core/src/test/resources/sql/winagg.iq
@@ -78,12 +78,31 @@ from emp;
 
 !ok
 
+# STDDEV applied to nullable column
+select empno,
+  stddev(comm) over (order by empno rows unbounded preceding) as stdev
+from emp
+where deptno = 30
+order by 1;
++-------+-------------------------------------------------+
+| EMPNO | STDEV                                           |
++-------+-------------------------------------------------+
+|  7499 |                                                 |
+|  7521 |  141.421356237309510106570087373256683349609375 |
+|  7654 | 585.9465277082316561063635163009166717529296875 |
+|  7698 | 585.9465277082316561063635163009166717529296875 |
+|  7844 | 602.7713773341707792496890760958194732666015625 |
+|  7900 | 602.7713773341707792496890760958194732666015625 |
++-------+-------------------------------------------------+
+(6 rows)
+
+!ok
+
 !use post
 # [CALCITE-1540] Support multiple columns in PARTITION BY clause of window function
 select gender,deptno,
   count(*) over (partition by gender,deptno) as count1
 from emp;
-
 +--------+--------+--------+
 | GENDER | DEPTNO | COUNT1 |
 +--------+--------+--------+
@@ -106,7 +125,6 @@ from emp;
 select gender,deptno,
   count(*) over (partition by gender,gender) as count1
 from emp;
-
 +--------+--------+--------+
 | GENDER | DEPTNO | COUNT1 |
 +--------+--------+--------+
@@ -400,7 +418,6 @@ select min(deptno) as x, rank() over (order by ename) as y,
   max(ename) over (partition by deptno) as z
 from emp
 group by deptno, ename;
-
 +----+---+-------+
 | X  | Y | Z     |
 +----+---+-------+
@@ -447,7 +464,6 @@ select * from (
   select "empid", count(*) over () c
     from "hr"."emps"
 ) where "empid"=100;
-
 +-------+---+
 | empid | C |
 +-------+---+
@@ -469,7 +485,6 @@ join (
   window w as (partition by "deptno" order by "commission")) b
 on a."deptno" = b."deptno"
 order by "deptno", ar, br limit 5;
-
 +--------+-----+-----+
 | deptno | AR  | BR  |
 +--------+-----+-----+
@@ -494,7 +509,6 @@ join (
   window w as (partition by "deptno" order by "commission")) b
 on a."empid" = b."empid"
 limit 5;
-
 +-------+--------+------------+-----+-----+
 | empid | deptno | commission | AR  | BR  |
 +-------+--------+------------+-----+-----+
@@ -526,7 +540,6 @@ from
   from
    unnest(map[2,2]) k
  ) t2 on (t1.l = t2.l and t1.key + 1 = t2.key);
-
 +---+------+------+
 | L | KEY1 | KEY2 |
 +---+------+------+
@@ -740,5 +753,29 @@ from emp;
 +--------+-------+---+
 (9 rows)
 
+!ok
+
+# [CALCITE-5283] Add ARG_MIN, ARG_MAX aggregate function
+
+# ARG_MIN, ARG_MAX function without ORDER BY.
+select gender,
+  arg_min(ename, deptno) over (partition by gender order by ename) as mi,
+  arg_max(ename, deptno) over (partition by gender order by ename) as ma
+from emp;
++--------+-------+-------+
+| GENDER | MI    | MA    |
++--------+-------+-------+
+| F      | Alice | Alice |
+| F      | Alice | Eve   |
+| F      | Alice | Grace |
+| F      | Jane  | Grace |
+| F      | Jane  | Grace |
+| F      | Jane  | Grace |
+| M      | Adam  | Adam  |
+| M      | Bob   | Adam  |
+| M      | Bob   | Adam  |
++--------+-------+-------+
+(9 rows)
+
 !ok
 # End winagg.iq
diff --git a/druid/src/main/java/org/apache/calcite/adapter/druid/BinaryOperatorConversion.java b/druid/src/main/java/org/apache/calcite/adapter/druid/BinaryOperatorConversion.java
index 64a0d1ba2f3..952f83d8888 100644
--- a/druid/src/main/java/org/apache/calcite/adapter/druid/BinaryOperatorConversion.java
+++ b/druid/src/main/java/org/apache/calcite/adapter/druid/BinaryOperatorConversion.java
@@ -45,9 +45,9 @@ public BinaryOperatorConversion(final SqlOperator operator, final String druidOp
 
     final RexCall call = (RexCall) rexNode;
 
-    final List<String> druidExpressions = DruidExpressions.toDruidExpressions(
-        druidQuery, rowType,
-        call.getOperands());
+    final List<String> druidExpressions =
+        DruidExpressions.toDruidExpressions(druidQuery, rowType,
+            call.getOperands());
     if (druidExpressions == null) {
       return null;
     }
diff --git a/druid/src/main/java/org/apache/calcite/adapter/druid/CeilOperatorConversion.java b/druid/src/main/java/org/apache/calcite/adapter/druid/CeilOperatorConversion.java
index b714bad14e5..8845f4092f5 100644
--- a/druid/src/main/java/org/apache/calcite/adapter/druid/CeilOperatorConversion.java
+++ b/druid/src/main/java/org/apache/calcite/adapter/druid/CeilOperatorConversion.java
@@ -43,10 +43,8 @@ public class CeilOperatorConversion implements DruidSqlOperatorConverter {
       DruidQuery query) {
     final RexCall call = (RexCall) rexNode;
     final RexNode arg = call.getOperands().get(0);
-    final String druidExpression = DruidExpressions.toDruidExpression(
-        arg,
-        rowType,
-        query);
+    final String druidExpression =
+        DruidExpressions.toDruidExpression(arg, rowType, query);
     if (druidExpression == null) {
       return null;
     } else if (call.getOperands().size() == 1) {
diff --git a/druid/src/main/java/org/apache/calcite/adapter/druid/DirectOperatorConversion.java b/druid/src/main/java/org/apache/calcite/adapter/druid/DirectOperatorConversion.java
index eba9ce52356..da5aea0edb8 100644
--- a/druid/src/main/java/org/apache/calcite/adapter/druid/DirectOperatorConversion.java
+++ b/druid/src/main/java/org/apache/calcite/adapter/druid/DirectOperatorConversion.java
@@ -42,9 +42,9 @@ public DirectOperatorConversion(final SqlOperator operator, final String druidFu
   @Override public String toDruidExpression(RexNode rexNode, RelDataType rowType,
       DruidQuery druidQuery) {
     final RexCall call = (RexCall) rexNode;
-    final List<String> druidExpressions = DruidExpressions.toDruidExpressions(
-        druidQuery, rowType,
-        call.getOperands());
+    final List<String> druidExpressions =
+        DruidExpressions.toDruidExpressions(druidQuery, rowType,
+            call.getOperands());
     if (druidExpressions == null) {
       return null;
     }
diff --git a/druid/src/main/java/org/apache/calcite/adapter/druid/DruidExpressions.java b/druid/src/main/java/org/apache/calcite/adapter/druid/DruidExpressions.java
index 147a9189ee9..cf0eea0187d 100644
--- a/druid/src/main/java/org/apache/calcite/adapter/druid/DruidExpressions.java
+++ b/druid/src/main/java/org/apache/calcite/adapter/druid/DruidExpressions.java
@@ -37,9 +37,10 @@
 import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
-import java.util.Objects;
 import java.util.TimeZone;
 
+import static java.util.Objects.requireNonNull;
+
 /**
  * Expression utility class to transform Calcite expressions to Druid expressions when possible.
  */
@@ -190,15 +191,14 @@ private static String escape(final String s) {
   }
 
   public static String functionCall(final String functionName, final List<String> args) {
-    Objects.requireNonNull(functionName, "druid functionName");
-    Objects.requireNonNull(args, "args");
+    requireNonNull(functionName, "druid functionName");
+    requireNonNull(args, "args");
 
     final StringBuilder builder = new StringBuilder(functionName);
     builder.append("(");
     for (int i = 0; i < args.size(); i++) {
       int finalI = i;
-      final String arg = Objects.requireNonNull(args.get(i),
-          () -> "arg #" + finalI);
+      final String arg = requireNonNull(args.get(i), () -> "arg #" + finalI);
       builder.append(arg);
       if (i < args.size() - 1) {
         builder.append(",");
@@ -209,14 +209,13 @@ public static String functionCall(final String functionName, final List<String>
   }
 
   public static String nAryOperatorCall(final String druidOperator, final List<String> args) {
-    Objects.requireNonNull(druidOperator, "druid operator missing");
-    Objects.requireNonNull(args, "args");
+    requireNonNull(druidOperator, "druid operator missing");
+    requireNonNull(args, "args");
     final StringBuilder builder = new StringBuilder();
     builder.append("(");
     for (int i = 0; i < args.size(); i++) {
       int finalI = i;
-      final String arg = Objects.requireNonNull(args.get(i),
-          () -> "arg #" + finalI);
+      final String arg = requireNonNull(args.get(i), () -> "arg #" + finalI);
       builder.append(arg);
       if (i < args.size() - 1) {
         builder.append(druidOperator);
@@ -254,8 +253,8 @@ public static String applyTimestampFloor(
       final String granularity,
       final String origin,
       final TimeZone timeZone) {
-    Objects.requireNonNull(input, "input");
-    Objects.requireNonNull(granularity, "granularity");
+    requireNonNull(input, "input");
+    requireNonNull(granularity, "granularity");
     return DruidExpressions.functionCall(
         "timestamp_floor",
         ImmutableList.of(input,
@@ -269,8 +268,8 @@ public static String applyTimestampCeil(
       final String granularity,
       final String origin,
       final TimeZone timeZone) {
-    Objects.requireNonNull(input, "input");
-    Objects.requireNonNull(granularity, "granularity");
+    requireNonNull(input, "input");
+    requireNonNull(granularity, "granularity");
     return DruidExpressions.functionCall(
         "timestamp_ceil",
         ImmutableList.of(input,
diff --git a/druid/src/main/java/org/apache/calcite/adapter/druid/DruidJsonFilter.java b/druid/src/main/java/org/apache/calcite/adapter/druid/DruidJsonFilter.java
index 43ec4072a2d..81cb0ad49c4 100644
--- a/druid/src/main/java/org/apache/calcite/adapter/druid/DruidJsonFilter.java
+++ b/druid/src/main/java/org/apache/calcite/adapter/druid/DruidJsonFilter.java
@@ -98,8 +98,8 @@ abstract class DruidJsonFilter implements DruidJson {
     }
     final boolean isNumeric = refNode.getType().getFamily() == SqlTypeFamily.NUMERIC
         || rexLiteral.getType().getFamily() == SqlTypeFamily.NUMERIC;
-    final Pair<String, ExtractionFunction> druidColumn = DruidQuery.toDruidColumn(refNode, rowType,
-        druidQuery);
+    final Pair<String, ExtractionFunction> druidColumn =
+        DruidQuery.toDruidColumn(refNode, rowType, druidQuery);
     final String columnName = druidColumn.left;
     final ExtractionFunction extractionFunction = druidColumn.right;
     if (columnName == null) {
@@ -109,8 +109,9 @@ abstract class DruidJsonFilter implements DruidJson {
     final DruidJsonFilter partialFilter;
     if (isNumeric) {
       //need bound filter since it one of operands is numeric
-      partialFilter = new JsonBound(columnName, literalValue, false, literalValue, false, true,
-          extractionFunction);
+      partialFilter =
+          new JsonBound(columnName, literalValue, false, literalValue,
+              false, true, extractionFunction);
     } else {
       partialFilter = new JsonSelector(columnName, literalValue, extractionFunction);
     }
diff --git a/druid/src/main/java/org/apache/calcite/adapter/druid/DruidQuery.java b/druid/src/main/java/org/apache/calcite/adapter/druid/DruidQuery.java
index b4d13a50ce5..5628e935a06 100644
--- a/druid/src/main/java/org/apache/calcite/adapter/druid/DruidQuery.java
+++ b/druid/src/main/java/org/apache/calcite/adapter/druid/DruidQuery.java
@@ -88,6 +88,8 @@
 import java.util.TimeZone;
 import java.util.regex.Pattern;
 
+import static java.util.Objects.requireNonNull;
+
 /**
  * Relational expression representing a scan of a Druid data set.
  */
@@ -183,8 +185,8 @@ protected DruidQuery(RelOptCluster cluster, RelTraitSet traitSet,
     this.druidTable = druidTable;
     this.intervals = ImmutableList.copyOf(intervals);
     this.rels = ImmutableList.copyOf(rels);
-    this.converterOperatorMap = Objects.requireNonNull(converterOperatorMap,
-        "Operator map cannot be null");
+    this.converterOperatorMap =
+        requireNonNull(converterOperatorMap, "Operator map cannot be null");
     assert isValid(Litmus.THROW, null);
   }
 
@@ -267,8 +269,8 @@ protected static Pair<String, ExtractionFunction> toDruidColumn(RexNode rexNode,
     case INPUT_REF:
       columnName = extractColumnName(rexNode, rowType, druidQuery);
       if (needUtcTimeExtract(rexNode)) {
-        extractionFunction = TimeExtractionFunction.createDefault(
-            DateTimeUtils.UTC_ZONE.getID());
+        extractionFunction =
+            TimeExtractionFunction.createDefault(DateTimeUtils.UTC_ZONE.getID());
       } else {
         extractionFunction = null;
       }
@@ -334,8 +336,9 @@ protected static Pair<String, ExtractionFunction> toDruidColumn(RexNode rexNode,
           extractColumnName(operand0, rowType, druidQuery);
       if (needUtcTimeExtract(rexNode)) {
         // CASE CAST to TIME/DATE need to make sure that we have valid extraction fn
-        extractionFunction = TimeExtractionFunction.translateCastToTimeExtract(rexNode,
-            TimeZone.getTimeZone(druidQuery.getConnectionConfig().timeZone()));
+        extractionFunction =
+            TimeExtractionFunction.translateCastToTimeExtract(rexNode,
+                TimeZone.getTimeZone(druidQuery.getConnectionConfig().timeZone()));
         if (extractionFunction == null) {
           // no extraction Function means cast is not valid thus bail out
           return Pair.of(null, null);
@@ -664,8 +667,9 @@ protected QuerySpec deriveQuerySpec() {
       final Aggregate aggregate = (Aggregate) rels.get(i++);
       groupSet = aggregate.getGroupSet();
       aggCalls = aggregate.getAggCallList();
-      aggNames = Util.skip(aggregate.getRowType().getFieldNames(),
-          groupSet.cardinality());
+      aggNames =
+          Util.skip(aggregate.getRowType().getFieldNames(),
+              groupSet.cardinality());
     }
 
     Filter havingFilter = null;
@@ -775,8 +779,9 @@ protected CalciteConnectionConfig getConnectionConfig() {
         if (expression == null) {
           return null;
         }
-        final String virColName = SqlValidatorUtil.uniquify("vc",
-            usedFieldNames, SqlValidatorUtil.EXPR_SUGGESTER);
+        final String virColName =
+            SqlValidatorUtil.uniquify("vc", usedFieldNames,
+                SqlValidatorUtil.EXPR_SUGGESTER);
         virtualColumnsBuilder.add(VirtualColumn.builder()
             .withName(virColName)
             .withExpression(expression).withType(
@@ -787,8 +792,9 @@ protected CalciteConnectionConfig getConnectionConfig() {
       } else {
         // simple inputRef or extractable function
         if (usedFieldNames.contains(druidColumn.left)) {
-          final String virColName = SqlValidatorUtil.uniquify("vc",
-              usedFieldNames, SqlValidatorUtil.EXPR_SUGGESTER);
+          final String virColName =
+              SqlValidatorUtil.uniquify("vc", usedFieldNames,
+                  SqlValidatorUtil.EXPR_SUGGESTER);
           virtualColumnsBuilder.add(VirtualColumn.builder()
               .withName(virColName)
               .withExpression(DruidExpressions.fromColumn(druidColumn.left)).withType(
@@ -838,8 +844,9 @@ protected CalciteConnectionConfig getConnectionConfig() {
           toDruidColumn(project, inputRowType, druidQuery);
       if (druidColumn.left != null && druidColumn.right == null) {
         // SIMPLE INPUT REF
-        dimensionSpec = new DefaultDimensionSpec(druidColumn.left, druidColumn.left,
-            DruidExpressions.EXPRESSION_TYPES.get(project.getType().getSqlTypeName()));
+        dimensionSpec =
+            new DefaultDimensionSpec(druidColumn.left, druidColumn.left,
+                DruidExpressions.EXPRESSION_TYPES.get(project.getType().getSqlTypeName()));
         usedFieldNames.add(druidColumn.left);
       } else if (druidColumn.left != null && druidColumn.right != null) {
        // CASE it is an extraction Dimension
@@ -847,14 +854,12 @@ protected CalciteConnectionConfig getConnectionConfig() {
         //@TODO Remove it! if else statement is not really needed it is here to make tests pass.
         if (project.getKind() == SqlKind.EXTRACT) {
           columnPrefix =
-              EXTRACT_COLUMN_NAME_PREFIX + "_" + Objects
-                  .requireNonNull(DruidDateTimeUtils
+              EXTRACT_COLUMN_NAME_PREFIX + "_" + requireNonNull(DruidDateTimeUtils
                       .extractGranularity(project, druidQuery.getConnectionConfig().timeZone())
                       .getType().lowerName);
         } else if (project.getKind() == SqlKind.FLOOR) {
           columnPrefix =
-              FLOOR_COLUMN_NAME_PREFIX + "_" + Objects
-                  .requireNonNull(DruidDateTimeUtils
+              FLOOR_COLUMN_NAME_PREFIX + "_" + requireNonNull(DruidDateTimeUtils
                       .extractGranularity(project, druidQuery.getConnectionConfig().timeZone())
                       .getType().lowerName);
         } else {
@@ -863,8 +868,9 @@ protected CalciteConnectionConfig getConnectionConfig() {
         final String uniqueExtractColumnName = SqlValidatorUtil
             .uniquify(columnPrefix, usedFieldNames,
                 SqlValidatorUtil.EXPR_SUGGESTER);
-        dimensionSpec = new ExtractionDimensionSpec(druidColumn.left,
-            druidColumn.right, uniqueExtractColumnName);
+        dimensionSpec =
+            new ExtractionDimensionSpec(druidColumn.left, druidColumn.right,
+                uniqueExtractColumnName);
         usedFieldNames.add(uniqueExtractColumnName);
       } else {
         // CASE it is Expression
@@ -876,11 +882,13 @@ protected CalciteConnectionConfig getConnectionConfig() {
         final String name = SqlValidatorUtil
             .uniquify("vc", usedFieldNames,
                 SqlValidatorUtil.EXPR_SUGGESTER);
-        VirtualColumn vc = new VirtualColumn(name, expression,
-            DruidExpressions.EXPRESSION_TYPES.get(project.getType().getSqlTypeName()));
+        VirtualColumn vc =
+            new VirtualColumn(name, expression,
+                DruidExpressions.EXPRESSION_TYPES.get(project.getType().getSqlTypeName()));
         virtualColumnList.add(vc);
-        dimensionSpec = new DefaultDimensionSpec(name, name,
-            DruidExpressions.EXPRESSION_TYPES.get(project.getType().getSqlTypeName()));
+        dimensionSpec =
+            new DefaultDimensionSpec(name, name,
+                DruidExpressions.EXPRESSION_TYPES.get(project.getType().getSqlTypeName()));
         usedFieldNames.add(name);
 
       }
@@ -993,16 +1001,17 @@ protected QuerySpec getQuery(RelDataType rowType, Filter filter, Project project
       final List<VirtualColumn> virtualColumnList = new ArrayList<>();
       if (project != null) {
         // project some fields only
-        Pair<List<String>, List<VirtualColumn>> projectResult = computeProjectAsScan(
-            project, project.getInput().getRowType(), this);
+        Pair<List<String>, List<VirtualColumn>> projectResult =
+            computeProjectAsScan(project, project.getInput().getRowType(), this);
         scanColumnNames = projectResult.left;
         virtualColumnList.addAll(projectResult.right);
       } else {
         // Scan all the fields
         scanColumnNames = rowType.getFieldNames();
       }
-      final ScanQuery scanQuery = new ScanQuery(druidTable.dataSource, intervals, jsonFilter,
-          virtualColumnList, scanColumnNames, fetch);
+      final ScanQuery scanQuery =
+          new ScanQuery(druidTable.dataSource, intervals, jsonFilter,
+              virtualColumnList, scanColumnNames, fetch);
       return new QuerySpec(QueryType.SCAN, scanQuery.toQuery(), scanColumnNames);
     }
 
@@ -1019,16 +1028,16 @@ protected QuerySpec getQuery(RelDataType rowType, Filter filter, Project project
     final RelDataType aggInputRowType = table.getRowType();
     final List<String> aggregateStageFieldNames = new ArrayList<>();
 
-    Pair<List<DimensionSpec>, List<VirtualColumn>> projectGroupSet = computeProjectGroupSet(
-        project, groupSet, aggInputRowType, this);
+    Pair<List<DimensionSpec>, List<VirtualColumn>> projectGroupSet =
+        computeProjectGroupSet(project, groupSet, aggInputRowType, this);
 
     final List<DimensionSpec> groupByKeyDims = projectGroupSet.left;
     final List<VirtualColumn> virtualColumnList = projectGroupSet.right;
     for (DimensionSpec dim : groupByKeyDims) {
       aggregateStageFieldNames.add(dim.getOutputName());
     }
-    final List<JsonAggregation> aggregations = computeDruidJsonAgg(aggCalls, aggNames, project,
-        this);
+    final List<JsonAggregation> aggregations =
+        computeDruidJsonAgg(aggCalls, aggNames, project, this);
     for (JsonAggregation jsonAgg : aggregations) {
       aggregateStageFieldNames.add(jsonAgg.name);
     }
@@ -1065,8 +1074,9 @@ protected QuerySpec getQuery(RelDataType rowType, Filter filter, Project project
           // simple input ref or Druid runtime identity cast will skip it, since it is here already
           postProjectDimListBuilder.add(existingFieldName);
         } else {
-          final String uniquelyProjectFieldName = SqlValidatorUtil.uniquify(pair.right,
-              existingAggFieldsNames, SqlValidatorUtil.EXPR_SUGGESTER);
+          final String uniquelyProjectFieldName =
+              SqlValidatorUtil.uniquify(pair.right,
+                  existingAggFieldsNames, SqlValidatorUtil.EXPR_SUGGESTER);
           postAggs.add(new JsonExpressionPostAgg(uniquelyProjectFieldName, expression, null));
           postProjectDimListBuilder.add(uniquelyProjectFieldName);
           existingAggFieldsNames.add(uniquelyProjectFieldName);
@@ -1083,11 +1093,13 @@ protected QuerySpec getQuery(RelDataType rowType, Filter filter, Project project
         : postAggregateStageFieldNames;
 
     // handle sort all together
-    limit = computeSort(fetch, collationIndexes, collationDirections, numericCollationIndexes,
-        queryOutputFieldNames);
+    limit =
+        computeSort(fetch, collationIndexes, collationDirections,
+            numericCollationIndexes, queryOutputFieldNames);
 
-    final String timeSeriesQueryString = planAsTimeSeries(groupByKeyDims, jsonFilter,
-        virtualColumnList, aggregations, postAggs, limit, havingJsonFilter);
+    final String timeSeriesQueryString =
+        planAsTimeSeries(groupByKeyDims, jsonFilter,
+            virtualColumnList, aggregations, postAggs, limit, havingJsonFilter);
     if (timeSeriesQueryString != null) {
       final String timeExtractColumn = groupByKeyDims.isEmpty()
           ? null
@@ -1106,14 +1118,16 @@ protected QuerySpec getQuery(RelDataType rowType, Filter filter, Project project
       }
       return new QuerySpec(QueryType.TIMESERIES, timeSeriesQueryString, queryOutputFieldNames);
     }
-    final String topNQuery = planAsTopN(groupByKeyDims, jsonFilter,
-        virtualColumnList, aggregations, postAggs, limit, havingJsonFilter);
+    final String topNQuery =
+        planAsTopN(groupByKeyDims, jsonFilter,
+            virtualColumnList, aggregations, postAggs, limit, havingJsonFilter);
     if (topNQuery != null) {
       return new QuerySpec(QueryType.TOP_N, topNQuery, queryOutputFieldNames);
     }
 
-    final String groupByQuery = planAsGroupBy(groupByKeyDims, jsonFilter,
-        virtualColumnList, aggregations, postAggs, limit, havingJsonFilter);
+    final String groupByQuery =
+        planAsGroupBy(groupByKeyDims, jsonFilter,
+            virtualColumnList, aggregations, postAggs, limit, havingJsonFilter);
 
     if (groupByQuery == null) {
       throw new IllegalStateException("Cannot plan Druid Query");
@@ -1406,10 +1420,12 @@ public String toQuery() {
       if (aggCall.isDistinct()) {
         if (aggCall.isApproximate() || config.approximateDistinctCount()) {
           if (complexMetric == null) {
-            aggregation = new JsonCardinalityAggregation("cardinality", name,
-                ImmutableList.of(fieldName));
+            aggregation =
+                new JsonCardinalityAggregation("cardinality", name,
+                    ImmutableList.of(fieldName));
           } else {
-            aggregation = new JsonAggregation(complexMetric.getMetricType(), name,
+            aggregation =
+                new JsonAggregation(complexMetric.getMetricType(), name,
                     complexMetric.getMetricName(), null);
           }
           break;
@@ -1426,8 +1442,9 @@ public String toQuery() {
         } else {
           matchNulls = DruidJsonFilter.getSelectorFilter(fieldName, null, null);
         }
-        aggregation = new JsonFilteredAggregation(DruidJsonFilter.toNotDruidFilter(matchNulls),
-            new JsonAggregation("count", name, fieldName, aggExpression));
+        aggregation =
+            new JsonFilteredAggregation(DruidJsonFilter.toNotDruidFilter(matchNulls),
+                new JsonAggregation("count", name, fieldName, aggExpression));
       } else if (!aggCall.isDistinct()) {
         aggregation = new JsonAggregation("count", name, fieldName, aggExpression);
       } else {
@@ -1437,16 +1454,19 @@ public String toQuery() {
       break;
     case SUM:
     case SUM0:
-      aggregation = new JsonAggregation(fractional ? "doubleSum" : "longSum", name, fieldName,
-          aggExpression);
+      aggregation =
+          new JsonAggregation(fractional ? "doubleSum" : "longSum",
+              name, fieldName, aggExpression);
       break;
     case MIN:
-      aggregation = new JsonAggregation(fractional ? "doubleMin" : "longMin", name, fieldName,
-          aggExpression);
+      aggregation =
+          new JsonAggregation(fractional ? "doubleMin" : "longMin",
+              name, fieldName, aggExpression);
       break;
     case MAX:
-      aggregation = new JsonAggregation(fractional ? "doubleMax" : "longMax", name, fieldName,
-          aggExpression);
+      aggregation =
+          new JsonAggregation(fractional ? "doubleMax" : "longMax",
+              name, fieldName, aggExpression);
       break;
     default:
       return null;
@@ -1544,8 +1564,8 @@ public static class QuerySpec {
 
     QuerySpec(QueryType queryType, String queryString,
         List<String> fieldNames) {
-      this.queryType = Objects.requireNonNull(queryType, "queryType");
-      this.queryString = Objects.requireNonNull(queryString, "queryString");
+      this.queryType = requireNonNull(queryType, "queryType");
+      this.queryString = requireNonNull(queryString, "queryString");
       this.fieldNames = ImmutableList.copyOf(fieldNames);
     }
 
diff --git a/druid/src/main/java/org/apache/calcite/adapter/druid/DruidRules.java b/druid/src/main/java/org/apache/calcite/adapter/druid/DruidRules.java
index 3c7800f3804..b8786f1be35 100644
--- a/druid/src/main/java/org/apache/calcite/adapter/druid/DruidRules.java
+++ b/druid/src/main/java/org/apache/calcite/adapter/druid/DruidRules.java
@@ -229,8 +229,9 @@ protected DruidFilterRule(DruidFilterRuleConfig config) {
         final String timeZone = cluster.getPlanner().getContext()
             .unwrap(CalciteConnectionConfig.class).timeZone();
         assert timeZone != null;
-        intervals = DruidDateTimeUtils.createInterval(
-            RexUtil.composeConjunction(rexBuilder, triple.getLeft()));
+        intervals =
+            DruidDateTimeUtils.createInterval(
+                RexUtil.composeConjunction(rexBuilder, triple.getLeft()));
         if (intervals == null || intervals.isEmpty()) {
           // Case we have a filter with extract that can not be written as interval push down
           triple.getMiddle().addAll(triple.getLeft());
@@ -238,8 +239,9 @@ protected DruidFilterRule(DruidFilterRuleConfig config) {
       }
 
       if (!triple.getMiddle().isEmpty()) {
-        final RelNode newFilter = filter.copy(filter.getTraitSet(), Util.last(query.rels),
-            RexUtil.composeConjunction(rexBuilder, triple.getMiddle()));
+        final RelNode newFilter =
+            filter.copy(filter.getTraitSet(), Util.last(query.rels),
+                RexUtil.composeConjunction(rexBuilder, triple.getMiddle()));
         newDruidQuery = DruidQuery.extendQuery(query, newFilter);
       }
       if (intervals != null && !intervals.isEmpty()) {
@@ -356,6 +358,11 @@ protected DruidProjectRule(DruidProjectRuleConfig config) {
       super(config);
     }
 
+    @Override public boolean matches(RelOptRuleCall call) {
+      final Project project = call.rel(0);
+      return project.getVariablesSet().isEmpty();
+    }
+
     @Override public void onMatch(RelOptRuleCall call) {
       final Project project = call.rel(0);
       final DruidQuery query = call.rel(1);
@@ -368,8 +375,9 @@ protected DruidProjectRule(DruidProjectRuleConfig config) {
       if (DruidQuery.computeProjectAsScan(project, query.getTable().getRowType(), query)
           != null) {
         // All expressions can be pushed to Druid in their entirety.
-        final RelNode newProject = project.copy(project.getTraitSet(),
-            ImmutableList.of(Util.last(query.rels)));
+        final RelNode newProject =
+            project.copy(project.getTraitSet(),
+                ImmutableList.of(Util.last(query.rels)));
         RelNode newNode = DruidQuery.extendQuery(query, newProject);
         call.transformTo(newNode);
         return;
@@ -395,10 +403,12 @@ protected DruidProjectRule(DruidProjectRuleConfig config) {
         }
         builder.add(name, e.getType());
       }
-      final RelNode newProject = project.copy(project.getTraitSet(), input, below, builder.build());
+      final RelNode newProject =
+          project.copy(project.getTraitSet(), input, below, builder.build());
       final DruidQuery newQuery = DruidQuery.extendQuery(query, newProject);
-      final RelNode newProject2 = project.copy(project.getTraitSet(), newQuery, above,
-              project.getRowType());
+      final RelNode newProject2 =
+              project.copy(project.getTraitSet(), newQuery, above,
+                  project.getRowType());
       call.transformTo(newProject2);
     }
 
@@ -595,15 +605,18 @@ protected DruidAggregateProjectRule(DruidAggregateProjectRuleConfig config) {
           == null) {
         return;
       }
-      final RelNode newProject = project.copy(project.getTraitSet(),
+      final RelNode newProject =
+          project.copy(project.getTraitSet(),
               ImmutableList.of(Util.last(query.rels)));
-      final RelNode newAggregate = aggregate.copy(aggregate.getTraitSet(),
+      final RelNode newAggregate =
+          aggregate.copy(aggregate.getTraitSet(),
               ImmutableList.of(newProject));
       List<Integer> filterRefs = getFilterRefs(aggregate.getAggCallList());
       final DruidQuery query2;
       if (filterRefs.size() > 0) {
-        query2 = optimizeFilteredAggregations(call, query, (Project) newProject,
-            (Aggregate) newAggregate);
+        query2 =
+            optimizeFilteredAggregations(call, query, (Project) newProject,
+                (Aggregate) newAggregate);
       } else {
         final DruidQuery query1 = DruidQuery.extendQuery(query, newProject);
         query2 = DruidQuery.extendQuery(query1, newAggregate);
@@ -689,8 +702,9 @@ private static DruidQuery optimizeFilteredAggregations(RelOptRuleCall call,
         }
         newCalls.add(aggCall);
       }
-      aggregate = aggregate.copy(aggregate.getTraitSet(), aggregate.getInput(),
-          aggregate.getGroupSet(), aggregate.getGroupSets(), newCalls);
+      aggregate =
+          aggregate.copy(aggregate.getTraitSet(), aggregate.getInput(),
+              aggregate.getGroupSet(), aggregate.getGroupSets(), newCalls);
 
       if (containsFilter) {
         // AND the current filterNode with the filter node inside filter
@@ -720,7 +734,8 @@ private static DruidQuery optimizeFilteredAggregations(RelOptRuleCall call,
       // TableScan nodes (which are always present)
       int startIndex = containsFilter && addNewFilter ? 2 : 1;
 
-      List<RelNode> newNodes = constructNewNodes(query.rels, addNewFilter, startIndex,
+      List<RelNode> newNodes =
+          constructNewNodes(query.rels, addNewFilter, startIndex,
               filter, project, aggregate);
 
       return DruidQuery.create(query.getCluster(),
diff --git a/druid/src/main/java/org/apache/calcite/adapter/druid/DruidSchema.java b/druid/src/main/java/org/apache/calcite/adapter/druid/DruidSchema.java
index cad188fa66c..397500e344d 100644
--- a/druid/src/main/java/org/apache/calcite/adapter/druid/DruidSchema.java
+++ b/druid/src/main/java/org/apache/calcite/adapter/druid/DruidSchema.java
@@ -65,13 +65,14 @@ public DruidSchema(String url, String coordinatorUrl,
     }
 
     if (tableMap == null) {
-      final DruidConnectionImpl connection = new DruidConnectionImpl(url, coordinatorUrl);
+      final DruidConnectionImpl connection =
+          new DruidConnectionImpl(url, coordinatorUrl);
       Set<String> tableNames = connection.tableNames();
 
-      tableMap = Maps.asMap(
-          ImmutableSet.copyOf(tableNames),
-          CacheBuilder.newBuilder()
-              .build(CacheLoader.from(name -> table(name, connection))));
+      tableMap =
+          Maps.asMap(ImmutableSet.copyOf(tableNames),
+              CacheBuilder.newBuilder()
+                  .build(CacheLoader.from(name -> table(name, connection))));
     }
 
     return tableMap;
diff --git a/druid/src/main/java/org/apache/calcite/adapter/druid/DruidSqlCastConverter.java b/druid/src/main/java/org/apache/calcite/adapter/druid/DruidSqlCastConverter.java
index b38ead52a2c..e615e44b054 100644
--- a/druid/src/main/java/org/apache/calcite/adapter/druid/DruidSqlCastConverter.java
+++ b/druid/src/main/java/org/apache/calcite/adapter/druid/DruidSqlCastConverter.java
@@ -44,8 +44,8 @@ public class DruidSqlCastConverter implements DruidSqlOperatorConverter {
       DruidQuery druidQuery) {
 
     final RexNode operand = ((RexCall) rexNode).getOperands().get(0);
-    final String operandExpression = DruidExpressions.toDruidExpression(operand,
-        topRel, druidQuery);
+    final String operandExpression =
+        DruidExpressions.toDruidExpression(operand, topRel, druidQuery);
 
     if (operandExpression == null) {
       return null;
@@ -110,9 +110,9 @@ public class DruidSqlCastConverter implements DruidSqlOperatorConverter {
       }
       final String typeCastExpression;
       if (fromExprType != toExprType) {
-        typeCastExpression = DruidQuery.format("CAST(%s, '%s')", operandExpression,
-            toExprType
-            .toString());
+        typeCastExpression =
+            DruidQuery.format("CAST(%s, '%s')", operandExpression,
+                toExprType.toString());
       } else {
         // case it is the same type it is ok to skip CAST
         typeCastExpression = operandExpression;
@@ -137,12 +137,11 @@ private static String castCharToDateTime(
       String operand,
       final SqlTypeName toType, String format) {
     // Cast strings to date times by parsing them from SQL format.
-    final String timestampExpression = DruidExpressions.functionCall(
-        "timestamp_parse",
-        ImmutableList.of(
-            operand,
-            DruidExpressions.stringLiteral(format),
-            DruidExpressions.stringLiteral(timeZone.getID())));
+    final String timestampExpression =
+        DruidExpressions.functionCall("timestamp_parse",
+            ImmutableList.of(operand,
+                DruidExpressions.stringLiteral(format),
+                DruidExpressions.stringLiteral(timeZone.getID())));
 
     if (toType == SqlTypeName.DATE) {
       // case to date we need to floor to day first
diff --git a/druid/src/main/java/org/apache/calcite/adapter/druid/DruidTableFactory.java b/druid/src/main/java/org/apache/calcite/adapter/druid/DruidTableFactory.java
index 77b4d2d6729..20f972f5248 100644
--- a/druid/src/main/java/org/apache/calcite/adapter/druid/DruidTableFactory.java
+++ b/druid/src/main/java/org/apache/calcite/adapter/druid/DruidTableFactory.java
@@ -148,8 +148,9 @@ private DruidTableFactory() {}
     final Object interval = operand.get("interval");
     final List<Interval> intervals;
     if (interval instanceof String) {
-      intervals = ImmutableList.of(
-          new Interval((String) interval, ISOChronology.getInstanceUTC()));
+      intervals =
+          ImmutableList.of(
+              new Interval(interval, ISOChronology.getInstanceUTC()));
     } else {
       intervals = null;
     }
@@ -157,13 +158,15 @@ private DruidTableFactory() {}
     final String dataSourceName = Util.first(dataSource, name);
 
     if (dimensionsRaw == null || metricsRaw == null) {
-      DruidConnectionImpl connection = new DruidConnectionImpl(druidSchema.url,
+      DruidConnectionImpl connection =
+          new DruidConnectionImpl(druidSchema.url,
               druidSchema.url.replace(":8082", ":8081"));
-      return DruidTable.create(druidSchema, dataSourceName, intervals, fieldBuilder,
-              metricNameBuilder, timestampColumnName, connection, complexMetrics);
+      return DruidTable.create(druidSchema, dataSourceName, intervals,
+          fieldBuilder, metricNameBuilder, timestampColumnName, connection,
+          complexMetrics);
     } else {
-      return DruidTable.create(druidSchema, dataSourceName, intervals, fieldBuilder,
-              metricNameBuilder, timestampColumnName, complexMetrics);
+      return DruidTable.create(druidSchema, dataSourceName, intervals,
+          fieldBuilder, metricNameBuilder, timestampColumnName, complexMetrics);
     }
   }
 }
diff --git a/druid/src/main/java/org/apache/calcite/adapter/druid/FloorOperatorConversion.java b/druid/src/main/java/org/apache/calcite/adapter/druid/FloorOperatorConversion.java
index 5d2298f7765..89240d61a64 100644
--- a/druid/src/main/java/org/apache/calcite/adapter/druid/FloorOperatorConversion.java
+++ b/druid/src/main/java/org/apache/calcite/adapter/druid/FloorOperatorConversion.java
@@ -41,10 +41,8 @@ public class FloorOperatorConversion implements DruidSqlOperatorConverter {
       DruidQuery druidQuery) {
     final RexCall call = (RexCall) rexNode;
     final RexNode arg = call.getOperands().get(0);
-    final String druidExpression = DruidExpressions.toDruidExpression(
-        arg,
-        rowType,
-        druidQuery);
+    final String druidExpression =
+        DruidExpressions.toDruidExpression(arg, rowType, druidQuery);
     if (druidExpression == null) {
       return null;
     } else if (call.getOperands().size() == 1) {
diff --git a/druid/src/main/java/org/apache/calcite/adapter/druid/NaryOperatorConverter.java b/druid/src/main/java/org/apache/calcite/adapter/druid/NaryOperatorConverter.java
index c3002ab9900..b897e517f0c 100644
--- a/druid/src/main/java/org/apache/calcite/adapter/druid/NaryOperatorConverter.java
+++ b/druid/src/main/java/org/apache/calcite/adapter/druid/NaryOperatorConverter.java
@@ -43,12 +43,12 @@ public NaryOperatorConverter(SqlOperator operator, String druidOperatorName) {
     return operator;
   }
 
-  @Override public @Nullable String toDruidExpression(RexNode rexNode, RelDataType rowType,
-      DruidQuery druidQuery) {
+  @Override public @Nullable String toDruidExpression(RexNode rexNode,
+      RelDataType rowType, DruidQuery druidQuery) {
     final RexCall call = (RexCall) rexNode;
-    final List<String> druidExpressions = DruidExpressions.toDruidExpressions(
-        druidQuery, rowType,
-        call.getOperands());
+    final List<String> druidExpressions =
+        DruidExpressions.toDruidExpressions(druidQuery, rowType,
+            call.getOperands());
     if (druidExpressions == null) {
       return null;
     }
diff --git a/druid/src/main/java/org/apache/calcite/adapter/druid/SubstringOperatorConversion.java b/druid/src/main/java/org/apache/calcite/adapter/druid/SubstringOperatorConversion.java
index bb5321aefd1..868ec2b782f 100644
--- a/druid/src/main/java/org/apache/calcite/adapter/druid/SubstringOperatorConversion.java
+++ b/druid/src/main/java/org/apache/calcite/adapter/druid/SubstringOperatorConversion.java
@@ -34,11 +34,12 @@ public class SubstringOperatorConversion implements DruidSqlOperatorConverter {
     return SqlStdOperatorTable.SUBSTRING;
   }
 
-  @Override public @Nullable String toDruidExpression(RexNode rexNode, RelDataType rowType,
-      DruidQuery query) {
+  @Override public @Nullable String toDruidExpression(RexNode rexNode,
+      RelDataType rowType, DruidQuery query) {
     final RexCall call = (RexCall) rexNode;
-    final String arg = DruidExpressions.toDruidExpression(
-        call.getOperands().get(0), rowType, query);
+    final String arg =
+        DruidExpressions.toDruidExpression(call.getOperands().get(0), rowType,
+            query);
     if (arg == null) {
       return null;
     }
@@ -47,30 +48,35 @@ public class SubstringOperatorConversion implements DruidSqlOperatorConverter {
     final String length;
     // SQL is 1-indexed, Druid is 0-indexed.
     if (!call.getOperands().get(1).isA(SqlKind.LITERAL)) {
-      final String arg1 = DruidExpressions.toDruidExpression(
-          call.getOperands().get(1), rowType, query);
+      final String arg1 =
+          DruidExpressions.toDruidExpression(call.getOperands().get(1), rowType,
+              query);
       if (arg1 == null) {
         // can not infer start index expression bailout.
         return null;
       }
       startIndex = DruidQuery.format("(%s - 1)", arg1);
     } else {
-      startIndex = DruidExpressions.numberLiteral(
-          RexLiteral.intValue(call.getOperands().get(1)) - 1);
+      startIndex =
+          DruidExpressions.numberLiteral(
+              RexLiteral.intValue(call.getOperands().get(1)) - 1);
     }
 
     if (call.getOperands().size() > 2) {
       //case substring from start index with length
       if (!call.getOperands().get(2).isA(SqlKind.LITERAL)) {
         // case it is an expression try to parse it
-        length = DruidExpressions.toDruidExpression(
-            call.getOperands().get(2), rowType, query);
+        length =
+            DruidExpressions.toDruidExpression(call.getOperands().get(2),
+                rowType, query);
         if (length == null) {
           return null;
         }
       } else {
         // case length is a constant
-        length = DruidExpressions.numberLiteral(RexLiteral.intValue(call.getOperands().get(2)));
+        length =
+            DruidExpressions.numberLiteral(
+                RexLiteral.intValue(call.getOperands().get(2)));
       }
 
     } else {
diff --git a/druid/src/main/java/org/apache/calcite/adapter/druid/TimeExtractionFunction.java b/druid/src/main/java/org/apache/calcite/adapter/druid/TimeExtractionFunction.java
index b509e8c9656..5bb86194803 100644
--- a/druid/src/main/java/org/apache/calcite/adapter/druid/TimeExtractionFunction.java
+++ b/druid/src/main/java/org/apache/calcite/adapter/druid/TimeExtractionFunction.java
@@ -48,24 +48,24 @@
  */
 public class TimeExtractionFunction implements ExtractionFunction {
 
-  private static final ImmutableSet<TimeUnitRange> VALID_TIME_EXTRACT = Sets.immutableEnumSet(
-      TimeUnitRange.YEAR,
-      TimeUnitRange.MONTH,
-      TimeUnitRange.DAY,
-      TimeUnitRange.WEEK,
-      TimeUnitRange.HOUR,
-      TimeUnitRange.MINUTE,
-      TimeUnitRange.SECOND);
-
-  private static final ImmutableSet<TimeUnitRange> VALID_TIME_FLOOR = Sets.immutableEnumSet(
-      TimeUnitRange.YEAR,
-      TimeUnitRange.QUARTER,
-      TimeUnitRange.MONTH,
-      TimeUnitRange.DAY,
-      TimeUnitRange.WEEK,
-      TimeUnitRange.HOUR,
-      TimeUnitRange.MINUTE,
-      TimeUnitRange.SECOND);
+  private static final ImmutableSet<TimeUnitRange> VALID_TIME_EXTRACT =
+      Sets.immutableEnumSet(TimeUnitRange.YEAR,
+          TimeUnitRange.MONTH,
+          TimeUnitRange.DAY,
+          TimeUnitRange.WEEK,
+          TimeUnitRange.HOUR,
+          TimeUnitRange.MINUTE,
+          TimeUnitRange.SECOND);
+
+  private static final ImmutableSet<TimeUnitRange> VALID_TIME_FLOOR =
+      Sets.immutableEnumSet(TimeUnitRange.YEAR,
+          TimeUnitRange.QUARTER,
+          TimeUnitRange.MONTH,
+          TimeUnitRange.DAY,
+          TimeUnitRange.WEEK,
+          TimeUnitRange.HOUR,
+          TimeUnitRange.MINUTE,
+          TimeUnitRange.SECOND);
 
   private final String format;
   private final Granularity granularity;
diff --git a/druid/src/main/java/org/apache/calcite/adapter/druid/UnaryPrefixOperatorConversion.java b/druid/src/main/java/org/apache/calcite/adapter/druid/UnaryPrefixOperatorConversion.java
index df33083e2b4..1fb6d462e33 100644
--- a/druid/src/main/java/org/apache/calcite/adapter/druid/UnaryPrefixOperatorConversion.java
+++ b/druid/src/main/java/org/apache/calcite/adapter/druid/UnaryPrefixOperatorConversion.java
@@ -48,9 +48,9 @@ public UnaryPrefixOperatorConversion(final SqlOperator operator, final String dr
 
     final RexCall call = (RexCall) rexNode;
 
-    final List<String> druidExpressions = DruidExpressions.toDruidExpressions(
-        druidQuery, rowType,
-        call.getOperands());
+    final List<String> druidExpressions =
+        DruidExpressions.toDruidExpressions(druidQuery, rowType,
+            call.getOperands());
 
     if (druidExpressions == null) {
       return null;
diff --git a/druid/src/main/java/org/apache/calcite/adapter/druid/UnarySuffixOperatorConversion.java b/druid/src/main/java/org/apache/calcite/adapter/druid/UnarySuffixOperatorConversion.java
index c56ef0b26d6..1aa59dbca67 100644
--- a/druid/src/main/java/org/apache/calcite/adapter/druid/UnarySuffixOperatorConversion.java
+++ b/druid/src/main/java/org/apache/calcite/adapter/druid/UnarySuffixOperatorConversion.java
@@ -46,16 +46,15 @@ public UnarySuffixOperatorConversion(SqlOperator operator, String druidOperator)
       DruidQuery druidQuery) {
     final RexCall call = (RexCall) rexNode;
 
-    final List<String> druidExpressions = DruidExpressions.toDruidExpressions(
-        druidQuery, rowType,
-        call.getOperands());
+    final List<String> druidExpressions =
+        DruidExpressions.toDruidExpressions(druidQuery, rowType,
+            call.getOperands());
 
     if (druidExpressions == null) {
       return null;
     }
 
-    return DruidQuery.format(
-            "(%s %s)",
-            Iterables.getOnlyElement(druidExpressions), druidOperator);
+    return DruidQuery.format("(%s %s)",
+        Iterables.getOnlyElement(druidExpressions), druidOperator);
   }
 }
diff --git a/druid/src/test/java/org/apache/calcite/adapter/druid/DruidQueryFilterTest.java b/druid/src/test/java/org/apache/calcite/adapter/druid/DruidQueryFilterTest.java
index ff3fa81815c..8e7d4fc1c2f 100644
--- a/druid/src/test/java/org/apache/calcite/adapter/druid/DruidQueryFilterTest.java
+++ b/druid/src/test/java/org/apache/calcite/adapter/druid/DruidQueryFilterTest.java
@@ -95,8 +95,9 @@ class DruidQueryFilterTest {
             f.rexBuilder.makeLiteral("lower-bound"),
             f.rexBuilder.makeLiteral("upper-bound"));
     RelDataType relDataType = f.typeFactory.createSqlType(SqlTypeName.BOOLEAN);
-    RexNode betweenRexNode = f.rexBuilder.makeCall(relDataType,
-        SqlInternalOperators.DRUID_BETWEEN, listRexNodes);
+    RexNode betweenRexNode =
+        f.rexBuilder.makeCall(relDataType,
+            SqlInternalOperators.DRUID_BETWEEN, listRexNodes);
 
     DruidJsonFilter returnValue = DruidJsonFilter
         .toDruidFilters(betweenRexNode, f.varcharRowType, druidQuery, f.rexBuilder);
diff --git a/druid/src/test/java/org/apache/calcite/test/DruidAdapter2IT.java b/druid/src/test/java/org/apache/calcite/test/DruidAdapter2IT.java
index 0f5eec2caf1..a98ba3998d5 100644
--- a/druid/src/test/java/org/apache/calcite/test/DruidAdapter2IT.java
+++ b/druid/src/test/java/org/apache/calcite/test/DruidAdapter2IT.java
@@ -2612,8 +2612,8 @@ private void testCountWithApproxDistinct(boolean approx, String sql,
    * {@link org.apache.calcite.adapter.druid.DruidSchema} is always the same Java object.
    * */
   @Test void testTableMapReused() {
-    AbstractSchema schema = new DruidSchema(
-        "http://localhost:8082", "http://localhost:8081", true);
+    AbstractSchema schema =
+        new DruidSchema("http://localhost:8082", "http://localhost:8081", true);
     assertSame(schema.getTable("wikiticker"), schema.getTable("wikiticker"));
   }
 
diff --git a/druid/src/test/java/org/apache/calcite/test/DruidDateRangeRulesTest.java b/druid/src/test/java/org/apache/calcite/test/DruidDateRangeRulesTest.java
index 33931549dd0..bdf3c01f5eb 100644
--- a/druid/src/test/java/org/apache/calcite/test/DruidDateRangeRulesTest.java
+++ b/druid/src/test/java/org/apache/calcite/test/DruidDateRangeRulesTest.java
@@ -175,14 +175,15 @@ private static class Fixture2 extends Fixture {
     private final RexNode exDay;
 
     Fixture2() {
-      exYear = rexBuilder.makeCall(SqlStdOperatorTable.EXTRACT,
-          ImmutableList.of(rexBuilder.makeFlag(TimeUnitRange.YEAR), ts));
-      exMonth = rexBuilder.makeCall(intRelDataType,
-          SqlStdOperatorTable.EXTRACT,
-          ImmutableList.of(rexBuilder.makeFlag(TimeUnitRange.MONTH), ts));
-      exDay = rexBuilder.makeCall(intRelDataType,
-          SqlStdOperatorTable.EXTRACT,
-          ImmutableList.of(rexBuilder.makeFlag(TimeUnitRange.DAY), ts));
+      exYear =
+          rexBuilder.makeCall(SqlStdOperatorTable.EXTRACT,
+              ImmutableList.of(rexBuilder.makeFlag(TimeUnitRange.YEAR), ts));
+      exMonth =
+          rexBuilder.makeCall(intRelDataType, SqlStdOperatorTable.EXTRACT,
+              ImmutableList.of(rexBuilder.makeFlag(TimeUnitRange.MONTH), ts));
+      exDay =
+          rexBuilder.makeCall(intRelDataType, SqlStdOperatorTable.EXTRACT,
+              ImmutableList.of(rexBuilder.makeFlag(TimeUnitRange.DAY), ts));
     }
 
     public RexNode timestampLiteral(int year, int month, int day) {
diff --git a/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchAggregate.java b/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchAggregate.java
index e3751f91e80..01fa68171b2 100644
--- a/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchAggregate.java
+++ b/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchAggregate.java
@@ -64,8 +64,9 @@ public class ElasticsearchAggregate extends Aggregate implements ElasticsearchRe
     super(cluster, traitSet, ImmutableList.of(), input, groupSet, groupSets, aggCalls);
 
     if (getConvention() != input.getConvention()) {
-      String message = String.format(Locale.ROOT, "%s != %s", getConvention(),
-          input.getConvention());
+      String message =
+          String.format(Locale.ROOT, "%s != %s", getConvention(),
+              input.getConvention());
       throw new AssertionError(message);
     }
 
@@ -83,8 +84,10 @@ public class ElasticsearchAggregate extends Aggregate implements ElasticsearchRe
 
       final SqlKind kind = aggCall.getAggregation().getKind();
       if (!SUPPORTED_AGGREGATIONS.contains(kind)) {
-        final String message = String.format(Locale.ROOT,
-            "Aggregation %s not supported (use one of %s)", kind, SUPPORTED_AGGREGATIONS);
+        final String message =
+            String.format(Locale.ROOT,
+                "Aggregation %s not supported (use one of %s)", kind,
+                SUPPORTED_AGGREGATIONS);
         throw new InvalidRelException(message);
       }
     }
@@ -141,7 +144,7 @@ public class ElasticsearchAggregate extends Aggregate implements ElasticsearchRe
       }
 
       final ObjectNode aggregation = mapper.createObjectNode();
-      final ObjectNode field = aggregation.with(toElasticAggregate(aggCall));
+      final ObjectNode field = aggregation.withObject("/" + toElasticAggregate(aggCall));
 
       final String name = names.isEmpty() ? ElasticsearchConstants.ID : names.get(0);
       field.put("field", implementor.expressionItemMap.getOrDefault(name, name));
diff --git a/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchJson.java b/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchJson.java
index 0d2185c1f77..d316eb86303 100644
--- a/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchJson.java
+++ b/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchJson.java
@@ -346,15 +346,17 @@ static class SearchHit {
 
       // both can't be null
       if (source == null && fields == null) {
-        final String message = String.format(Locale.ROOT,
-            "Both '_source' and 'fields' are missing for %s", id);
+        final String message =
+            String.format(Locale.ROOT,
+                "Both '_source' and 'fields' are missing for %s", id);
         throw new IllegalArgumentException(message);
       }
 
       // both can't be non-null
       if (source != null && fields != null) {
-        final String message = String.format(Locale.ROOT,
-            "Both '_source' and 'fields' are populated (non-null) for %s", id);
+        final String message =
+            String.format(Locale.ROOT,
+                "Both '_source' and 'fields' are populated (non-null) for %s", id);
         throw new IllegalArgumentException(message);
       }
 
diff --git a/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchMapping.java b/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchMapping.java
index 0749f69ef11..d2c688245f1 100644
--- a/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchMapping.java
+++ b/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchMapping.java
@@ -80,8 +80,9 @@ Map<String, Datatype> mapping() {
    */
   Optional<JsonNode> missingValueFor(String fieldName) {
     if (!mapping().containsKey(fieldName)) {
-      final String message = String.format(Locale.ROOT,
-          "Field %s not defined for %s", fieldName, index);
+      final String message =
+          String.format(Locale.ROOT,
+              "Field %s not defined for %s", fieldName, index);
       throw new IllegalArgumentException(message);
     }
 
diff --git a/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchProject.java b/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchProject.java
index 0a341c683c3..5aadcbceca1 100644
--- a/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchProject.java
+++ b/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchProject.java
@@ -29,6 +29,7 @@
 import org.apache.calcite.util.Pair;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 
@@ -43,7 +44,7 @@
 public class ElasticsearchProject extends Project implements ElasticsearchRel {
   ElasticsearchProject(RelOptCluster cluster, RelTraitSet traitSet, RelNode input,
       List<? extends RexNode> projects, RelDataType rowType) {
-    super(cluster, traitSet, ImmutableList.of(), input, projects, rowType);
+    super(cluster, traitSet, ImmutableList.of(), input, projects, rowType, ImmutableSet.of());
     assert getConvention() == ElasticsearchRel.CONVENTION;
     assert getConvention() == input.getConvention();
   }
diff --git a/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchRules.java b/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchRules.java
index 78261b9ae59..00685af824b 100644
--- a/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchRules.java
+++ b/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchRules.java
@@ -21,6 +21,7 @@
 import org.apache.calcite.adapter.java.JavaTypeFactory;
 import org.apache.calcite.plan.Convention;
 import org.apache.calcite.plan.RelOptRule;
+import org.apache.calcite.plan.RelOptRuleCall;
 import org.apache.calcite.plan.RelTraitSet;
 import org.apache.calcite.rel.InvalidRelException;
 import org.apache.calcite.rel.RelCollations;
@@ -293,6 +294,11 @@ protected ElasticsearchProjectRule(Config config) {
       super(config);
     }
 
+    @Override public boolean matches(RelOptRuleCall call) {
+      final LogicalProject project = call.rel(0);
+      return project.getVariablesSet().isEmpty();
+    }
+
     @Override public RelNode convert(RelNode relNode) {
       final LogicalProject project = (LogicalProject) relNode;
       final RelTraitSet traitSet = project.getTraitSet().replace(out);
diff --git a/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchSchema.java b/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchSchema.java
index 9deb1d3b177..02a6bf20fb3 100644
--- a/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchSchema.java
+++ b/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchSchema.java
@@ -38,6 +38,10 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.Set;
+import java.util.Spliterator;
+import java.util.Spliterators;
+import java.util.stream.Collectors;
+import java.util.stream.StreamSupport;
 
 /**
  * Each table in the schema is an ELASTICSEARCH index.
@@ -94,8 +98,8 @@ public ElasticsearchSchema(RestClient client, ObjectMapper mapper, String index)
   private Map<String, Table> createTables(Iterable<String> indices) {
     final ImmutableMap.Builder<String, Table> builder = ImmutableMap.builder();
     for (String index : indices) {
-      final ElasticsearchTransport transport = new ElasticsearchTransport(client, mapper,
-          index, fetchSize);
+      final ElasticsearchTransport transport =
+          new ElasticsearchTransport(client, mapper, index, fetchSize);
       builder.put(index, new ElasticsearchTable(transport));
     }
     return builder.build();
@@ -121,6 +125,13 @@ private Set<String> indicesFromElastic() throws IOException {
       }
 
       Set<String> indices = Sets.newHashSet(root.fieldNames());
+      Set<String> aliases = root.findValues("aliases").stream()
+          .map(JsonNode::fieldNames)
+          .flatMap(
+              it -> StreamSupport.stream(
+                  Spliterators.spliteratorUnknownSize(it, Spliterator.ORDERED), false))
+          .collect(Collectors.toSet());
+      indices.addAll(aliases);
       return indices;
     }
   }
diff --git a/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchSchemaFactory.java b/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchSchemaFactory.java
index afb49fa5d51..4f580309e41 100644
--- a/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchSchemaFactory.java
+++ b/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchSchemaFactory.java
@@ -78,8 +78,7 @@ public class ElasticsearchSchemaFactory implements SchemaFactory {
               + "broken! Do not try to access more than {} distinct ES REST APIs through this "
               + "adapter.",
               REST_CLIENT_CACHE_SIZE,
-              REST_CLIENT_CACHE_SIZE
-          );
+              REST_CLIENT_CACHE_SIZE);
 
           try {
             // Free resources allocated by this RestClient
@@ -107,19 +106,21 @@ public ElasticsearchSchemaFactory() {
       List<HttpHost> hosts;
 
       if (map.containsKey("hosts")) {
-        final List<String> configHosts = mapper.readValue((String) map.get("hosts"),
+        final List<String> configHosts =
+            mapper.readValue((String) map.get("hosts"),
                 new TypeReference<List<String>>() { });
 
-        hosts = configHosts
-                .stream()
+        hosts =
+            configHosts.stream()
                 .map(host -> HttpHost.create(host))
                 .collect(Collectors.toList());
       } else if (map.containsKey("coordinates")) {
-        final Map<String, Integer> coordinates = mapper.readValue((String) map.get("coordinates"),
-                new TypeReference<Map<String, Integer>>() { });
+        final Map<String, Integer> coordinates =
+                mapper.readValue((String) map.get("coordinates"),
+                    new TypeReference<Map<String, Integer>>() { });
 
-        hosts =  coordinates
-                .entrySet()
+        hosts =
+            coordinates.entrySet()
                 .stream()
                 .map(entry -> new HttpHost(entry.getKey(), entry.getValue()))
                 .collect(Collectors.toList());
diff --git a/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchSearchResult.java b/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchSearchResult.java
index 80a4fbbd75a..8784be3375b 100644
--- a/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchSearchResult.java
+++ b/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchSearchResult.java
@@ -100,15 +100,17 @@ private SearchHit(@JsonProperty("_id") final String id,
 
       // both can't be null
       if (source == null && fields == null) {
-        final String message = String.format(Locale.ROOT,
-            "Both '_source' and 'fields' are missing for %s", id);
+        final String message =
+            String.format(Locale.ROOT,
+                "Both '_source' and 'fields' are missing for %s", id);
         throw new IllegalArgumentException(message);
       }
 
       // both can't be non-null
       if (source != null && fields != null) {
-        final String message = String.format(Locale.ROOT,
-            "Both '_source' and 'fields' are populated (non-null) for %s", id);
+        final String message =
+            String.format(Locale.ROOT,
+                "Both '_source' and 'fields' are populated (non-null) for %s", id);
         throw new IllegalArgumentException(message);
       }
 
@@ -135,8 +137,9 @@ Object value(String name) {
       Objects.requireNonNull(name, "name");
 
       if (!sourceOrFields().containsKey(name)) {
-        final String message = String.format(Locale.ROOT,
-            "Attribute %s not found in search result %s", name, id);
+        final String message =
+            String.format(Locale.ROOT,
+                "Attribute %s not found in search result %s", name, id);
         throw new IllegalArgumentException(message);
       }
 
diff --git a/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchTable.java b/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchTable.java
index ce0cb24d43a..419cc430319 100644
--- a/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchTable.java
+++ b/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchTable.java
@@ -205,13 +205,13 @@ private Enumerable<Object> aggregate(List<String> ops,
     orderedGroupBy.addAll(groupBy);
 
     // construct nested aggregations node(s)
-    ObjectNode parent = query.with(AGGREGATIONS);
+    ObjectNode parent = query.withObject("/" + AGGREGATIONS);
     for (String name: orderedGroupBy) {
       final String aggName = "g_" + name;
       fieldMap.put(aggName, name);
 
-      final ObjectNode section = parent.with(aggName);
-      final ObjectNode terms = section.with("terms");
+      final ObjectNode section = parent.withObject("/" + aggName);
+      final ObjectNode terms = section.withObject("/terms");
       terms.put("field", name);
 
       transport.mapping.missingValueFor(name).ifPresent(m -> {
@@ -225,10 +225,10 @@ private Enumerable<Object> aggregate(List<String> ops,
 
       sort.stream().filter(e -> e.getKey().equals(name)).findAny()
           .ifPresent(s ->
-              terms.with("order")
+              terms.withObject("/order")
                   .put("_key", s.getValue().isDescending() ? "desc" : "asc"));
 
-      parent = section.with(AGGREGATIONS);
+      parent = section.withObject("/" + AGGREGATIONS);
     }
 
     // simple version for queries like "select count(*), max(col1) from table" (no GROUP BY cols)
@@ -305,11 +305,12 @@ private Enumerable<Object> aggregate(List<String> ops,
   }
 
   @Override public RelDataType getRowType(RelDataTypeFactory relDataTypeFactory) {
-    final RelDataType mapType = relDataTypeFactory.createMapType(
-        relDataTypeFactory.createSqlType(SqlTypeName.VARCHAR),
-        relDataTypeFactory.createTypeWithNullability(
-            relDataTypeFactory.createSqlType(SqlTypeName.ANY),
-            true));
+    final RelDataType mapType =
+        relDataTypeFactory.createMapType(
+            relDataTypeFactory.createSqlType(SqlTypeName.VARCHAR),
+            relDataTypeFactory.createTypeWithNullability(
+                relDataTypeFactory.createSqlType(SqlTypeName.ANY),
+                true));
     return relDataTypeFactory.builder().add("_MAP", mapType).build();
   }
 
diff --git a/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchToEnumerableConverter.java b/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchToEnumerableConverter.java
index 497e95d5bd7..99d6b5f289c 100644
--- a/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchToEnumerableConverter.java
+++ b/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchToEnumerableConverter.java
@@ -67,39 +67,46 @@ public class ElasticsearchToEnumerableConverter extends ConverterImpl implements
     implementor.visitChild(0, getInput());
 
     final RelDataType rowType = getRowType();
-    final PhysType physType = PhysTypeImpl.of(relImplementor.getTypeFactory(), rowType,
-        prefer.prefer(JavaRowFormat.ARRAY));
-    final Expression fields = block.append("fields",
-        constantArrayList(
-            Pair.zip(ElasticsearchRules.elasticsearchFieldNames(rowType),
-                new AbstractList<Class>() {
-                  @Override public Class get(int index) {
-                    return physType.fieldClass(index);
-                  }
+    final PhysType physType =
+        PhysTypeImpl.of(relImplementor.getTypeFactory(),
+            rowType, prefer.prefer(JavaRowFormat.ARRAY));
+    final Expression fields =
+        block.append("fields",
+            constantArrayList(
+                Pair.zip(ElasticsearchRules.elasticsearchFieldNames(rowType),
+                    new AbstractList<Class>() {
+                      @Override public Class get(int index) {
+                        return physType.fieldClass(index);
+                      }
 
-                  @Override public int size() {
-                    return rowType.getFieldCount();
-                  }
-                }),
-            Pair.class));
-    final Expression table = block.append("table",
-        implementor.table
-            .getExpression(ElasticsearchTable.ElasticsearchQueryable.class));
+                      @Override public int size() {
+                        return rowType.getFieldCount();
+                      }
+                    }),
+                Pair.class));
+    final Expression table =
+        block.append("table",
+            implementor.table.getExpression(
+                ElasticsearchTable.ElasticsearchQueryable.class));
     final Expression ops = block.append("ops", Expressions.constant(implementor.list));
     final Expression sort = block.append("sort", constantArrayList(implementor.sort, Pair.class));
     final Expression groupBy = block.append("groupBy", Expressions.constant(implementor.groupBy));
-    final Expression aggregations = block.append("aggregations",
-        constantArrayList(implementor.aggregations, Pair.class));
+    final Expression aggregations =
+        block.append("aggregations",
+            constantArrayList(implementor.aggregations, Pair.class));
 
-    final Expression mappings = block.append("mappings",
-        Expressions.constant(implementor.expressionItemMap));
+    final Expression mappings =
+        block.append("mappings",
+            Expressions.constant(implementor.expressionItemMap));
 
     final Expression offset = block.append("offset", Expressions.constant(implementor.offset));
     final Expression fetch = block.append("fetch", Expressions.constant(implementor.fetch));
 
-    Expression enumerable = block.append("enumerable",
-        Expressions.call(table, ElasticsearchMethod.ELASTICSEARCH_QUERYABLE_FIND.method, ops,
-            fields, sort, groupBy, aggregations, mappings, offset, fetch));
+    Expression enumerable =
+        block.append("enumerable",
+            Expressions.call(table,
+                ElasticsearchMethod.ELASTICSEARCH_QUERYABLE_FIND.method, ops,
+                fields, sort, groupBy, aggregations, mappings, offset, fetch));
     block.add(Expressions.return_(null, enumerable));
     return relImplementor.result(physType, block.toBlock());
   }
diff --git a/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchTransport.java b/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchTransport.java
index e5023a89c56..ef10225617d 100644
--- a/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchTransport.java
+++ b/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/ElasticsearchTransport.java
@@ -108,8 +108,9 @@ RestClient restClient() {
   private ElasticsearchVersion version() {
     final HttpRequest request = new HttpGet("/");
     // version extract function
-    final Function<ObjectNode, ElasticsearchVersion> fn = node -> ElasticsearchVersion.fromString(
-        node.get("version").get("number").asText());
+    final Function<ObjectNode, ElasticsearchVersion> fn =
+        node -> ElasticsearchVersion.fromString(
+            node.get("version").get("number").asText());
     return rawHttp(ObjectNode.class)
         .andThen(fn)
         .apply(request);
@@ -242,8 +243,9 @@ private static class JsonParserFn<T> implements Function<Response, T> {
       try (InputStream is = response.getEntity().getContent()) {
         return mapper.readValue(is, klass);
       } catch (IOException e) {
-        final String message = String.format(Locale.ROOT,
-            "Couldn't parse HTTP response %s into %s", response, klass);
+        final String message =
+            String.format(Locale.ROOT,
+                "Couldn't parse HTTP response %s into %s", response, klass);
         throw new UncheckedIOException(message, e);
       }
     }
@@ -275,9 +277,9 @@ private Response applyInternal(final HttpRequest request)
       final HttpEntity entity = request instanceof HttpEntityEnclosingRequest
           ? ((HttpEntityEnclosingRequest) request).getEntity() : null;
 
-      final Request r = new Request(
-          request.getRequestLine().getMethod(),
-          request.getRequestLine().getUri());
+      final Request r =
+          new Request(request.getRequestLine().getMethod(),
+              request.getRequestLine().getUri());
       r.setEntity(entity);
       final Response response = restClient.performRequest(r);
 
@@ -287,10 +289,15 @@ private Response applyInternal(final HttpRequest request)
       if (response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
         final String error = EntityUtils.toString(response.getEntity());
 
-        final String message = String.format(Locale.ROOT,
-            "Error while querying Elastic (on %s/%s) status: %s\nPayload:\n%s\nError:\n%s\n",
-            response.getHost(), response.getRequestLine(),
-            response.getStatusLine(), payload, error);
+        final String message =
+            String.format(Locale.ROOT,
+                "Error while querying Elastic (on %s/%s) status: %s\n"
+                    + "Payload:\n"
+                    + "%s\n"
+                    + "Error:\n"
+                    + "%s\n",
+                response.getHost(), response.getRequestLine(),
+                response.getStatusLine(), payload, error);
         throw new RuntimeException(message);
       }
 
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 0f48de9eeb5..f2f65e33696 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
@@ -266,14 +266,16 @@ static boolean isSearchWithComplementedPoints(RexCall search) {
       case FUNCTION:
         if (call.getOperator().getName().equalsIgnoreCase("CONTAINS")) {
           List<Expression> operands = visitList(call.getOperands());
-          String query = convertQueryString(operands.subList(0, operands.size() - 1),
-              operands.get(operands.size() - 1));
+          String query =
+              convertQueryString(operands.subList(0, operands.size() - 1),
+                  operands.get(operands.size() - 1));
           return QueryExpression.create(new NamedFieldExpression()).queryString(query);
         }
         // fall through
       default:
-        String message = format(Locale.ROOT, "Unsupported syntax [%s] for call: [%s]",
-            syntax, call);
+        String message =
+            format(Locale.ROOT,
+                "Unsupported syntax [%s] for call: [%s]", syntax, call);
         throw new PredicateAnalyzerException(message);
       }
     }
@@ -501,8 +503,10 @@ private static SwapResult swap(Expression left, Expression right) {
       }
 
       if (literal == null || terminal == null) {
-        String message = String.format(Locale.ROOT,
-            "Unexpected combination of expressions [left: %s] [right: %s]", left, right);
+        String message =
+            String.format(Locale.ROOT,
+                "Unexpected combination of expressions [left: %s] [right: %s]",
+                left, right);
         throw new PredicateAnalyzerException(message);
       }
 
@@ -833,8 +837,9 @@ private SimpleQueryExpression(NamedFieldExpression rel) {
 
     @Override public QueryExpression gt(LiteralExpression literal) {
       Object value = literal.value();
-      builder = addFormatIfNecessary(literal,
-          rangeQuery(getFieldReference()).gt(value));
+      builder =
+          addFormatIfNecessary(literal,
+              rangeQuery(getFieldReference()).gt(value));
       return this;
     }
 
diff --git a/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/Scrolling.java b/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/Scrolling.java
index a62cf9d155f..573ddc2ca5d 100644
--- a/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/Scrolling.java
+++ b/elasticsearch/src/main/java/org/apache/calcite/adapter/elasticsearch/Scrolling.java
@@ -63,9 +63,9 @@ Iterator<ElasticsearchJson.SearchHit> query(ObjectNode query) {
     final ElasticsearchJson.Result first = transport
         .search(Collections.singletonMap("scroll", "1m")).apply(query);
 
-    AutoClosingIterator iterator = new AutoClosingIterator(
-        new SequentialIterator(first, transport, limit),
-        scrollId -> transport.closeScroll(Collections.singleton(scrollId)));
+    AutoClosingIterator iterator =
+        new AutoClosingIterator(new SequentialIterator(first, transport, limit),
+            scrollId -> transport.closeScroll(Collections.singleton(scrollId)));
 
     Iterator<ElasticsearchJson.SearchHit> result = flatten(iterator);
     // apply limit
@@ -82,8 +82,9 @@ Iterator<ElasticsearchJson.SearchHit> query(ObjectNode query) {
    */
   private static Iterator<ElasticsearchJson.SearchHit> flatten(
       Iterator<ElasticsearchJson.Result> results) {
-    final Iterator<Iterator<ElasticsearchJson.SearchHit>> inputs = Iterators.transform(results,
-        input -> input.searchHits().hits().iterator());
+    final Iterator<Iterator<ElasticsearchJson.SearchHit>> inputs =
+        Iterators.transform(results,
+            input -> input.searchHits().hits().iterator());
     return Iterators.concat(inputs);
   }
 
diff --git a/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/AggregationTest.java b/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/AggregationTest.java
index 22274dd8f35..35316b7c1f7 100644
--- a/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/AggregationTest.java
+++ b/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/AggregationTest.java
@@ -94,15 +94,17 @@ private static Connection createConnection() throws SQLException {
         new ElasticsearchSchema(NODE.restClient(), NODE.mapper(), NAME));
 
     // add calcite view programmatically
-    final String viewSql = String.format(Locale.ROOT,
-        "select _MAP['cat1'] AS \"cat1\", "
-            + " _MAP['cat2']  AS \"cat2\", "
-            + " _MAP['cat3'] AS \"cat3\", "
-            + " _MAP['cat4'] AS \"cat4\", "
-            + " _MAP['cat5'] AS \"cat5\", "
-            + " _MAP['val1'] AS \"val1\", "
-            + " _MAP['val2'] AS \"val2\" "
-            + " from \"elastic\".\"%s\"", NAME);
+    final String viewSql =
+        String.format(Locale.ROOT,
+            "select _MAP['cat1'] AS \"cat1\", "
+                + " _MAP['cat2']  AS \"cat2\", "
+                + " _MAP['cat3'] AS \"cat3\", "
+                + " _MAP['cat4'] AS \"cat4\", "
+                + " _MAP['cat5'] AS \"cat5\", "
+                + " _MAP['val1'] AS \"val1\", "
+                + " _MAP['val2'] AS \"val2\" "
+                + " from \"elastic\".\"%s\"",
+            NAME);
 
     root.add("view",
         ViewTable.viewMacro(root, viewSql,
diff --git a/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/BooleanLogicTest.java b/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/BooleanLogicTest.java
index e035eb6d37c..9afa28652b1 100644
--- a/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/BooleanLogicTest.java
+++ b/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/BooleanLogicTest.java
@@ -55,8 +55,9 @@ class BooleanLogicTest {
   @BeforeAll
   public static void setupInstance() throws Exception {
 
-    final Map<String, String> mapping = ImmutableMap.of("a", "keyword", "b", "keyword",
-        "c", "keyword", "int", "long");
+    final Map<String, String> mapping =
+        ImmutableMap.of("a", "keyword", "b", "keyword",
+            "c", "keyword", "int", "long");
 
     NODE.createIndex(NAME, mapping);
 
@@ -73,8 +74,8 @@ private static Connection createConnection() throws SQLException {
         new ElasticsearchSchema(NODE.restClient(), NODE.mapper(), NAME));
 
     // add calcite view programmatically
-    final String viewSql = String.format(Locale.ROOT,
-        "select cast(_MAP['a'] AS varchar(2)) AS a, "
+    final String viewSql =
+        String.format(Locale.ROOT, "select cast(_MAP['a'] AS varchar(2)) AS a, "
             + " cast(_MAP['b'] AS varchar(2)) AS b, "
             + " cast(_MAP['c'] AS varchar(2)) AS c, "
             + " cast(_MAP['int'] AS integer) AS num"
diff --git a/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/ElasticSearchAdapterTest.java b/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/ElasticSearchAdapterTest.java
index c33bab46cde..28ebcbb2eb7 100644
--- a/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/ElasticSearchAdapterTest.java
+++ b/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/ElasticSearchAdapterTest.java
@@ -63,6 +63,7 @@ class ElasticSearchAdapterTest {
 
   /** Default index/type name. */
   private static final String ZIPS = "zips";
+  private static final String ZIPS_ALIAS = "zips_alias";
   private static final int ZIPS_SIZE = 149;
 
   /**
@@ -71,10 +72,11 @@ class ElasticSearchAdapterTest {
    */
   @BeforeAll
   public static void setupInstance() throws Exception {
-    final Map<String, String> mapping = ImmutableMap.of("city", "keyword", "state",
-        "keyword", "pop", "long");
+    final Map<String, String> mapping =
+        ImmutableMap.of("city", "keyword", "state", "keyword", "pop", "long");
 
     NODE.createIndex(ZIPS, mapping);
+    NODE.createAlias(ZIPS, ZIPS_ALIAS);
 
     // load records from file
     final List<ObjectNode> bulk = new ArrayList<>();
@@ -105,7 +107,7 @@ private static Connection createConnection() throws SQLException {
         connection.unwrap(CalciteConnection.class).getRootSchema();
 
     root.add("elastic",
-        new ElasticsearchSchema(NODE.restClient(), NODE.mapper(), ZIPS));
+        new ElasticsearchSchema(NODE.restClient(), NODE.mapper(), null));
 
     // add calcite view programmatically
     final String viewSql = "select cast(_MAP['city'] AS varchar(20)) AS \"city\", "
@@ -189,6 +191,12 @@ private CalciteAssert.AssertThat calciteAssert() {
         .returnsCount(0);
   }
 
+  @Test void testAlias() {
+    calciteAssert()
+        .query("select * from elastic.zips_alias")
+        .returnsCount(ZIPS_SIZE);
+  }
+
   @Test void testSort() {
     final String explain = "PLAN=ElasticsearchToEnumerableConverter\n"
         + "  ElasticsearchSort(sort0=[$4], dir0=[ASC])\n"
@@ -251,11 +259,10 @@ private static Consumer<ResultSet> sortedResultSetChecker(String column,
           //noinspection unchecked
           final int cmp = current.compareTo(next);
           if (direction == RelFieldCollation.Direction.ASCENDING ? cmp > 0 : cmp < 0) {
-            final String message = String.format(Locale.ROOT,
-                "Column %s NOT sorted (%s): %s (index:%d) > %s (index:%d) count: %d",
-                column,
-                direction,
-                current, i, next, i + 1, states.size());
+            final String message =
+                String.format(Locale.ROOT,
+                    "Column %s NOT sorted (%s): %s (index:%d) > %s (index:%d) count: %d",
+                    column, direction, current, i, next, i + 1, states.size());
             throw new AssertionError(message);
           }
         }
diff --git a/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/EmbeddedElasticsearchPolicy.java b/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/EmbeddedElasticsearchPolicy.java
index e89af6c2e86..c1fca5a7dbe 100644
--- a/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/EmbeddedElasticsearchPolicy.java
+++ b/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/EmbeddedElasticsearchPolicy.java
@@ -114,19 +114,56 @@ void createIndex(String index, Map<String, String> mapping) throws IOException {
 
     ObjectNode mappings = mapper().createObjectNode();
 
-    ObjectNode properties = mappings.with("mappings").with("properties");
+    ObjectNode properties = mappings.withObject("/mappings")
+        .withObject("/properties");
     for (Map.Entry<String, String> entry: mapping.entrySet()) {
       applyMapping(properties, entry.getKey(), entry.getValue());
     }
 
     // create index and mapping
-    final HttpEntity entity = new StringEntity(mapper().writeValueAsString(mappings),
-        ContentType.APPLICATION_JSON);
+    final HttpEntity entity =
+        new StringEntity(mapper().writeValueAsString(mappings),
+            ContentType.APPLICATION_JSON);
     final Request r = new Request("PUT", "/" + index);
     r.setEntity(entity);
     restClient().performRequest(r);
   }
 
+  /**
+   * Creates alias in elastic search given an index.
+   * as dots({@code .}).
+   *
+   * <p>Example
+   * <pre>
+   *  {@code
+   *     b.a: long
+   *     b.b: keyword
+   *  }
+   * </pre>
+   *
+   * @param index index of the index
+   * @param alias alias of the index
+   * @throws IOException if there is an error
+   */
+  void createAlias(String index, String alias) throws IOException {
+    Objects.requireNonNull(index, "index");
+    Objects.requireNonNull(alias, "alias");
+
+    ObjectNode actions = mapper().createObjectNode();
+
+    ObjectNode properties = actions.withObject("/actions").withObject("/add");
+    properties.put("index", index);
+    properties.put("alias", alias);
+
+    // create alias
+    final HttpEntity entity =
+        new StringEntity(mapper().writeValueAsString(actions),
+            ContentType.APPLICATION_JSON);
+    final Request r = new Request("POST", "/_aliases");
+    r.setEntity(entity);
+    restClient().performRequest(r);
+  }
+
   /**
    * Creates nested mappings for an index. This function is called recursively for each level.
    *
@@ -139,19 +176,19 @@ private static void applyMapping(ObjectNode parent, String key, String type) {
     if (index > -1) {
       String prefix  = key.substring(0, index);
       String suffix = key.substring(index + 1, key.length());
-      applyMapping(parent.with(prefix).with("properties"), suffix, type);
+      applyMapping(parent.withObject("/" + prefix).withObject("/properties"), suffix, type);
     } else {
-      parent.with(key).put("type", type);
+      parent.withObject("/" + key).put("type", type);
     }
   }
 
   void insertDocument(String index, ObjectNode document) throws IOException {
     Objects.requireNonNull(index, "index");
     Objects.requireNonNull(document, "document");
-    String uri = String.format(Locale.ROOT,
-          "/%s/_doc?refresh", index);
-    StringEntity entity = new StringEntity(mapper().writeValueAsString(document),
-        ContentType.APPLICATION_JSON);
+    String uri = String.format(Locale.ROOT, "/%s/_doc?refresh", index);
+    StringEntity entity =
+        new StringEntity(mapper().writeValueAsString(document),
+            ContentType.APPLICATION_JSON);
     final Request r = new Request("POST", uri);
     r.setEntity(entity);
     restClient().performRequest(r);
@@ -172,8 +209,9 @@ void insertBulk(String index, List<ObjectNode> documents) throws IOException {
       bulk.add(mapper().writeValueAsString(doc));
     }
 
-    final StringEntity entity = new StringEntity(String.join("\n", bulk) + "\n",
-        ContentType.APPLICATION_JSON);
+    final StringEntity entity =
+        new StringEntity(String.join("\n", bulk) + "\n",
+            ContentType.APPLICATION_JSON);
 
     final Request r = new Request("POST", "/_bulk?refresh");
     r.setEntity(entity);
diff --git a/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/MatchTest.java b/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/MatchTest.java
index fd75af11bc2..a2417ab0163 100644
--- a/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/MatchTest.java
+++ b/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/MatchTest.java
@@ -83,8 +83,8 @@ class MatchTest {
    */
   @BeforeAll
   public static void setup() throws Exception {
-    final Map<String, String> mapping = ImmutableMap.of("city", "text", "state",
-        "keyword", "pop", "long");
+    final Map<String, String> mapping =
+        ImmutableMap.of("city", "text", "state", "keyword", "pop", "long");
 
     NODE.createIndex(ZIPS, mapping);
 
@@ -120,8 +120,8 @@ private static CalciteConnection createConnection() throws SQLException {
         new ElasticsearchSchema(NODE.restClient(), NODE.mapper(), ZIPS));
 
     // add calcite view programmatically
-    final String viewSql = String.format(Locale.ROOT,
-        "select cast(_MAP['city'] AS varchar(20)) AS \"city\", "
+    final String viewSql =
+        String.format(Locale.ROOT, "select cast(_MAP['city'] AS varchar(20)) AS \"city\", "
             + " cast(_MAP['loc'][0] AS float) AS \"longitude\",\n"
             + " cast(_MAP['loc'][1] AS float) AS \"latitude\",\n"
             + " cast(_MAP['pop'] AS integer) AS \"pop\", "
@@ -170,16 +170,17 @@ private static CalciteConnection createConnection() throws SQLException {
         new SqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT);
     final RexBuilder rexBuilder = new RexBuilder(typeFactory);
 
-    RexNode nameRexNode = rexBuilder.makeCall(SqlStdOperatorTable.ITEM,
-        rexBuilder.makeInputRef(typeFactory.createSqlType(SqlTypeName.ANY), 0),
-        rexBuilder.makeCharLiteral(
-            new NlsString("city", typeFactory.getDefaultCharset().name(),
-                SqlCollation.COERCIBLE)));
-
-    RelDataType mapType = typeFactory.createMapType(
-        typeFactory.createSqlType(SqlTypeName.VARCHAR),
-        typeFactory.createTypeWithNullability(
-            typeFactory.createSqlType(SqlTypeName.ANY), true));
+    RexNode nameRexNode =
+        rexBuilder.makeCall(SqlStdOperatorTable.ITEM,
+            rexBuilder.makeInputRef(typeFactory.createSqlType(SqlTypeName.ANY), 0),
+            rexBuilder.makeCharLiteral(
+                new NlsString("city", typeFactory.getDefaultCharset().name(),
+                    SqlCollation.COERCIBLE)));
+
+    RelDataType mapType =
+        typeFactory.createMapType(typeFactory.createSqlType(SqlTypeName.VARCHAR),
+            typeFactory.createTypeWithNullability(
+                typeFactory.createSqlType(SqlTypeName.ANY), true));
 
     List<RexNode> namedList =
         ImmutableList.of(rexBuilder.makeInputRef(mapType, 0),
diff --git a/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/Projection2Test.java b/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/Projection2Test.java
index 06fe6d8d4f3..0c53ff92011 100644
--- a/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/Projection2Test.java
+++ b/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/Projection2Test.java
@@ -58,9 +58,9 @@ class Projection2Test {
 
   @BeforeAll
   public static void setupInstance() throws Exception {
-
-    final Map<String, String> mappings = ImmutableMap.of("a", "long",
-        "b.a", "long", "b.b", "long", "b.c.a", "keyword");
+    final Map<String, String> mappings =
+        ImmutableMap.of("a", "long",
+            "b.a", "long", "b.b", "long", "b.c.a", "keyword");
 
     NODE.createIndex(NAME, mappings);
 
@@ -77,16 +77,17 @@ private static Connection createConnection() throws SQLException {
     root.add("elastic", new ElasticsearchSchema(NODE.restClient(), NODE.mapper(), NAME));
 
     // add calcite view programmatically
-    final String viewSql = String.format(Locale.ROOT,
-        "select _MAP['a'] AS \"a\", "
+    final String viewSql =
+        String.format(Locale.ROOT, "select _MAP['a'] AS \"a\", "
             + " _MAP['b.a']  AS \"b.a\", "
             + " _MAP['b.b'] AS \"b.b\", "
             + " _MAP['b.c.a'] AS \"b.c.a\", "
             + " _MAP['_id'] AS \"id\" " // _id field is implicit
             + " from \"elastic\".\"%s\"", NAME);
 
-    ViewTableMacro macro = ViewTable.viewMacro(root, viewSql,
-        Collections.singletonList("elastic"), Arrays.asList("elastic", "view"), false);
+    ViewTableMacro macro =
+        ViewTable.viewMacro(root, viewSql, Collections.singletonList("elastic"),
+            Arrays.asList("elastic", "view"), false);
     root.add("VIEW", macro);
     return connection;
   }
diff --git a/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/ProjectionTest.java b/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/ProjectionTest.java
index 0923151ca30..87dd22ecc9d 100644
--- a/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/ProjectionTest.java
+++ b/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/ProjectionTest.java
@@ -49,9 +49,9 @@ class ProjectionTest {
 
   @BeforeAll
   public static void setupInstance() throws Exception {
-
-    final Map<String, String> mappings = ImmutableMap.of("A", "keyword",
-        "b", "keyword", "cCC", "keyword", "DDd", "keyword");
+    final Map<String, String> mappings =
+        ImmutableMap.of("A", "keyword",
+            "b", "keyword", "cCC", "keyword", "DDd", "keyword");
 
     NODE.createIndex(NAME, mappings);
 
@@ -69,8 +69,8 @@ private static Connection createConnection() throws SQLException {
         new ElasticsearchSchema(NODE.restClient(), NODE.mapper(), NAME));
 
     // add calcite view programmatically
-    final String viewSql = String.format(Locale.ROOT,
-        "select cast(_MAP['A'] AS varchar(2)) AS a,"
+    final String viewSql =
+        String.format(Locale.ROOT, "select cast(_MAP['A'] AS varchar(2)) AS a,"
             + " cast(_MAP['b'] AS varchar(2)) AS b, "
             + " cast(_MAP['cCC'] AS varchar(2)) AS c, "
             + " cast(_MAP['DDd'] AS varchar(2)) AS d "
diff --git a/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/ScrollingTest.java b/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/ScrollingTest.java
index a280506b67d..63205551cc5 100644
--- a/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/ScrollingTest.java
+++ b/elasticsearch/src/test/java/org/apache/calcite/adapter/elasticsearch/ScrollingTest.java
@@ -108,7 +108,8 @@ private void assertNoActiveScrolls() throws IOException  {
     try (InputStream is = response.getEntity().getContent()) {
       final ObjectNode node = NODE.mapper().readValue(is, ObjectNode.class);
       final String path = "/indices/search/scroll_current";
-      final JsonNode scrollCurrent = node.with("nodes").elements().next().at(path);
+      final JsonNode scrollCurrent =
+          node.get("nodes").elements().next().at(path);
       if (scrollCurrent.isMissingNode()) {
         throw new IllegalStateException("Couldn't find node at " + path);
       }
diff --git a/elasticsearch/src/test/java/org/apache/calcite/test/ElasticsearchChecker.java b/elasticsearch/src/test/java/org/apache/calcite/test/ElasticsearchChecker.java
index 14174f33a78..7e67020e919 100644
--- a/elasticsearch/src/test/java/org/apache/calcite/test/ElasticsearchChecker.java
+++ b/elasticsearch/src/test/java/org/apache/calcite/test/ElasticsearchChecker.java
@@ -113,7 +113,7 @@ private static <T extends JsonNode> T expandDots(T parent) {
       final String[] names = property.split("\\.");
       ObjectNode copy2 = copy;
       for (int i = 0; i < names.length - 1; i++) {
-        copy2 = copy2.with(names[i]);
+        copy2 = copy2.withObject("/" + names[i]);
       }
       copy2.set(names[names.length - 1], expandDots(node));
     });
diff --git a/example/csv/src/main/java/org/apache/calcite/adapter/csv/CsvTable.java b/example/csv/src/main/java/org/apache/calcite/adapter/csv/CsvTable.java
index 17ad898dbad..a882e5c8247 100644
--- a/example/csv/src/main/java/org/apache/calcite/adapter/csv/CsvTable.java
+++ b/example/csv/src/main/java/org/apache/calcite/adapter/csv/CsvTable.java
@@ -49,8 +49,9 @@ public abstract class CsvTable extends AbstractTable {
       return protoRowType.apply(typeFactory);
     }
     if (rowType == null) {
-      rowType = CsvEnumerator.deduceRowType((JavaTypeFactory) typeFactory, source,
-          null, isStream());
+      rowType =
+          CsvEnumerator.deduceRowType((JavaTypeFactory) typeFactory, source,
+              null, isStream());
     }
     return rowType;
   }
diff --git a/example/csv/src/main/java/org/apache/calcite/adapter/csv/CsvTableScan.java b/example/csv/src/main/java/org/apache/calcite/adapter/csv/CsvTableScan.java
index fbf3b9fe6a3..6de7542834c 100644
--- a/example/csv/src/main/java/org/apache/calcite/adapter/csv/CsvTableScan.java
+++ b/example/csv/src/main/java/org/apache/calcite/adapter/csv/CsvTableScan.java
@@ -21,7 +21,6 @@
 import org.apache.calcite.adapter.enumerable.EnumerableRelImplementor;
 import org.apache.calcite.adapter.enumerable.PhysType;
 import org.apache.calcite.adapter.enumerable.PhysTypeImpl;
-import org.apache.calcite.adapter.file.JsonTable;
 import org.apache.calcite.linq4j.tree.Blocks;
 import org.apache.calcite.linq4j.tree.Expressions;
 import org.apache.calcite.linq4j.tree.Primitive;
@@ -107,13 +106,6 @@ protected CsvTableScan(RelOptCluster cluster, RelOptTable table,
             getRowType(),
             pref.preferArray());
 
-    if (table instanceof JsonTable) {
-      return implementor.result(
-          physType,
-          Blocks.toBlock(
-              Expressions.call(table.getExpression(JsonTable.class),
-                  "enumerable")));
-    }
     return implementor.result(
         physType,
         Blocks.toBlock(
diff --git a/example/csv/src/test/java/org/apache/calcite/test/CsvTest.java b/example/csv/src/test/java/org/apache/calcite/test/CsvTest.java
index 56f0992c761..9a091e8a9f0 100644
--- a/example/csv/src/test/java/org/apache/calcite/test/CsvTest.java
+++ b/example/csv/src/test/java/org/apache/calcite/test/CsvTest.java
@@ -616,24 +616,28 @@ private String range(int first, int count) {
 
     try (Connection connection =
         DriverManager.getConnection("jdbc:calcite:", info)) {
-      ResultSet res = connection.getMetaData().getColumns(null, null,
-          "DATE", "JOINEDAT");
+      ResultSet res =
+          connection.getMetaData().getColumns(null, null,
+              "DATE", "JOINEDAT");
       res.next();
       assertEquals(res.getInt("DATA_TYPE"), java.sql.Types.DATE);
 
-      res = connection.getMetaData().getColumns(null, null,
-          "DATE", "JOINTIME");
+      res =
+          connection.getMetaData().getColumns(null, null,
+              "DATE", "JOINTIME");
       res.next();
       assertEquals(res.getInt("DATA_TYPE"), java.sql.Types.TIME);
 
-      res = connection.getMetaData().getColumns(null, null,
-          "DATE", "JOINTIMES");
+      res =
+          connection.getMetaData().getColumns(null, null,
+              "DATE", "JOINTIMES");
       res.next();
       assertEquals(res.getInt("DATA_TYPE"), java.sql.Types.TIMESTAMP);
 
       Statement statement = connection.createStatement();
-      ResultSet resultSet = statement.executeQuery(
-          "select \"JOINEDAT\", \"JOINTIME\", \"JOINTIMES\" from \"DATE\" where EMPNO = 100");
+      final String sql = "select \"JOINEDAT\", \"JOINTIME\", \"JOINTIMES\" "
+          + "from \"DATE\" where EMPNO = 100";
+      ResultSet resultSet = statement.executeQuery(sql);
       resultSet.next();
 
       // date
@@ -762,8 +766,8 @@ private String range(int first, int count) {
     properties.setProperty("caseSensitive", "true");
     try (Connection connection =
         DriverManager.getConnection("jdbc:calcite:", properties)) {
-      final CalciteConnection calciteConnection = connection.unwrap(
-          CalciteConnection.class);
+      final CalciteConnection calciteConnection =
+          connection.unwrap(CalciteConnection.class);
 
       final Schema schema =
           CsvSchemaFactory.INSTANCE
diff --git a/file/src/main/java/org/apache/calcite/adapter/file/CsvEnumerator.java b/file/src/main/java/org/apache/calcite/adapter/file/CsvEnumerator.java
index 600ec89693a..73992525a85 100644
--- a/file/src/main/java/org/apache/calcite/adapter/file/CsvEnumerator.java
+++ b/file/src/main/java/org/apache/calcite/adapter/file/CsvEnumerator.java
@@ -59,9 +59,9 @@
  * @param <E> Row type
  */
 public class CsvEnumerator<E> implements Enumerator<E> {
+  private static final CalciteLogger LOGGER =
+      new CalciteLogger(LoggerFactory.getLogger(CsvEnumerator.class));
 
-  private static final CalciteLogger LOGGER = new CalciteLogger(
-      LoggerFactory.getLogger(CsvEnumerator.class));
   private final CSVReader reader;
   private final @Nullable List<@Nullable String> filterValues;
   private final AtomicBoolean cancelFlag;
diff --git a/file/src/main/java/org/apache/calcite/adapter/file/CsvStreamReader.java b/file/src/main/java/org/apache/calcite/adapter/file/CsvStreamReader.java
index fecdc3d6773..aa00472d24d 100644
--- a/file/src/main/java/org/apache/calcite/adapter/file/CsvStreamReader.java
+++ b/file/src/main/java/org/apache/calcite/adapter/file/CsvStreamReader.java
@@ -78,10 +78,12 @@ private CsvStreamReader(Source source, char separator, char quoteChar,
     super(new StringReader("")); // dummy call to base constructor
     contentQueue = new ArrayDeque<>();
     TailerListener listener = new CsvContentListener(contentQueue);
-    tailer = Tailer.create(source.file(), listener, DEFAULT_MONITOR_DELAY,
-        false, true, 4096);
-    this.parser = new CSVParser(separator, quoteChar, escape, strictQuotes,
-        ignoreLeadingWhiteSpace);
+    tailer =
+        Tailer.create(source.file(), listener, DEFAULT_MONITOR_DELAY,
+            false, true, 4096);
+    this.parser =
+        new CSVParser(separator, quoteChar, escape, strictQuotes,
+            ignoreLeadingWhiteSpace);
     this.skipLines = line;
     try {
       // wait for tailer to capture data
diff --git a/file/src/main/java/org/apache/calcite/adapter/file/CsvTable.java b/file/src/main/java/org/apache/calcite/adapter/file/CsvTable.java
index eb704ae3e2a..c4db8ecea70 100644
--- a/file/src/main/java/org/apache/calcite/adapter/file/CsvTable.java
+++ b/file/src/main/java/org/apache/calcite/adapter/file/CsvTable.java
@@ -49,8 +49,9 @@ public abstract class CsvTable extends AbstractTable {
       return protoRowType.apply(typeFactory);
     }
     if (rowType == null) {
-      rowType = CsvEnumerator.deduceRowType((JavaTypeFactory) typeFactory, source,
-          null, isStream());
+      rowType =
+          CsvEnumerator.deduceRowType((JavaTypeFactory) typeFactory, source,
+              null, isStream());
     }
     return rowType;
   }
diff --git a/file/src/main/java/org/apache/calcite/adapter/file/CsvTableScan.java b/file/src/main/java/org/apache/calcite/adapter/file/CsvTableScan.java
index d0157094add..c446b16c8a5 100644
--- a/file/src/main/java/org/apache/calcite/adapter/file/CsvTableScan.java
+++ b/file/src/main/java/org/apache/calcite/adapter/file/CsvTableScan.java
@@ -106,13 +106,6 @@ protected CsvTableScan(RelOptCluster cluster, RelOptTable table,
             getRowType(),
             pref.preferArray());
 
-    if (table instanceof JsonTable) {
-      return implementor.result(
-          physType,
-          Blocks.toBlock(
-              Expressions.call(table.getExpression(JsonTable.class),
-                  "enumerable")));
-    }
     return implementor.result(
         physType,
         Blocks.toBlock(
diff --git a/file/src/test/java/org/apache/calcite/adapter/file/FileAdapterTest.java b/file/src/test/java/org/apache/calcite/adapter/file/FileAdapterTest.java
index bb0a41fbaaa..b5989fa96e1 100644
--- a/file/src/test/java/org/apache/calcite/adapter/file/FileAdapterTest.java
+++ b/file/src/test/java/org/apache/calcite/adapter/file/FileAdapterTest.java
@@ -693,24 +693,28 @@ private String range(int first, int count) {
 
     try (Connection connection =
              DriverManager.getConnection("jdbc:calcite:", info)) {
-      ResultSet res = connection.getMetaData().getColumns(null, null,
-          "DATE", "JOINEDAT");
+      ResultSet res =
+          connection.getMetaData().getColumns(null, null,
+              "DATE", "JOINEDAT");
       res.next();
       assertEquals(res.getInt("DATA_TYPE"), Types.DATE);
 
-      res = connection.getMetaData().getColumns(null, null,
-          "DATE", "JOINTIME");
+      res =
+          connection.getMetaData().getColumns(null, null,
+              "DATE", "JOINTIME");
       res.next();
       assertEquals(res.getInt("DATA_TYPE"), Types.TIME);
 
-      res = connection.getMetaData().getColumns(null, null,
-          "DATE", "JOINTIMES");
+      res =
+          connection.getMetaData().getColumns(null, null,
+              "DATE", "JOINTIMES");
       res.next();
       assertEquals(res.getInt("DATA_TYPE"), Types.TIMESTAMP);
 
       Statement statement = connection.createStatement();
-      ResultSet resultSet = statement.executeQuery(
-          "select \"JOINEDAT\", \"JOINTIME\", \"JOINTIMES\" from \"DATE\" where EMPNO = 100");
+      final String sql = "select \"JOINEDAT\", \"JOINTIME\", \"JOINTIMES\" "
+          + "from \"DATE\" where EMPNO = 100";
+      ResultSet resultSet = statement.executeQuery(sql);
       resultSet.next();
 
       // date
@@ -835,8 +839,8 @@ private String range(int first, int count) {
     properties.setProperty("caseSensitive", "true");
     try (Connection connection =
              DriverManager.getConnection("jdbc:calcite:", properties)) {
-      final CalciteConnection calciteConnection = connection.unwrap(
-          CalciteConnection.class);
+      final CalciteConnection calciteConnection =
+          connection.unwrap(CalciteConnection.class);
 
       final Schema schema =
           FileSchemaFactory.INSTANCE
diff --git a/file/src/test/resources/wiki.json b/file/src/test/resources/wiki.json
index 712b3c4fa5b..1becc51a4a5 100644
--- a/file/src/test/resources/wiki.json
+++ b/file/src/test/resources/wiki.json
@@ -48,7 +48,7 @@
    * resulting database column.  Processing steps are applied in the
    * order described and replace and match patterns are based on Java
    * Pattern syntax see:
-   * (http://docs.oracle.com/javase/7/docs/api/java/util/regex/Pattern.html).
+   * (https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/regex/Pattern.html).
    *
    */
   "schemas": [ {
diff --git a/geode/src/main/java/org/apache/calcite/adapter/geode/rel/GeodeAggregate.java b/geode/src/main/java/org/apache/calcite/adapter/geode/rel/GeodeAggregate.java
index 39e988e23f6..f2fc79250a9 100644
--- a/geode/src/main/java/org/apache/calcite/adapter/geode/rel/GeodeAggregate.java
+++ b/geode/src/main/java/org/apache/calcite/adapter/geode/rel/GeodeAggregate.java
@@ -119,8 +119,8 @@ public GeodeAggregate(RelOptCluster cluster,
         aggCallFieldNames.add(inputFields.get(0));
       }
 
-      String oqlAggregateCall = Util.toString(aggCallFieldNames, functionName + "(", ", ",
-          ")");
+      String oqlAggregateCall =
+          Util.toString(aggCallFieldNames, functionName + "(", ", ", ")");
 
       aggregateFunctionMap.put(aggCall.getName(), oqlAggregateCall);
     }
diff --git a/geode/src/main/java/org/apache/calcite/adapter/geode/rel/GeodeProject.java b/geode/src/main/java/org/apache/calcite/adapter/geode/rel/GeodeProject.java
index da5cf40a739..fc7a0f33b98 100644
--- a/geode/src/main/java/org/apache/calcite/adapter/geode/rel/GeodeProject.java
+++ b/geode/src/main/java/org/apache/calcite/adapter/geode/rel/GeodeProject.java
@@ -29,6 +29,7 @@
 import org.apache.calcite.util.Pair;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 
@@ -45,7 +46,7 @@ public class GeodeProject extends Project implements GeodeRel {
 
   GeodeProject(RelOptCluster cluster, RelTraitSet traitSet,
       RelNode input, List<? extends RexNode> projects, RelDataType rowType) {
-    super(cluster, traitSet, ImmutableList.of(), input, projects, rowType);
+    super(cluster, traitSet, ImmutableList.of(), input, projects, rowType, ImmutableSet.of());
     assert getConvention() == GeodeRel.CONVENTION;
     assert getConvention() == input.getConvention();
   }
diff --git a/geode/src/main/java/org/apache/calcite/adapter/geode/rel/GeodeRules.java b/geode/src/main/java/org/apache/calcite/adapter/geode/rel/GeodeRules.java
index 5fd12fa3e67..6004f8b5bbf 100644
--- a/geode/src/main/java/org/apache/calcite/adapter/geode/rel/GeodeRules.java
+++ b/geode/src/main/java/org/apache/calcite/adapter/geode/rel/GeodeRules.java
@@ -40,6 +40,8 @@
 import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.sql.validate.SqlValidatorUtil;
 
+import com.google.common.base.Preconditions;
+
 import org.immutables.value.Value;
 
 import java.util.ArrayList;
@@ -145,12 +147,13 @@ protected GeodeProjectRule(Config config) {
           return false;
         }
       }
-
-      return true;
+      return project.getVariablesSet().isEmpty();
     }
 
     @Override public RelNode convert(RelNode rel) {
       final LogicalProject project = (LogicalProject) rel;
+      Preconditions.checkArgument(project.getVariablesSet().isEmpty(),
+          "GeodeProject does now allow variables");
       final RelTraitSet traitSet =
           project.getTraitSet().replace(getOutConvention());
       return new GeodeProject(
@@ -220,9 +223,10 @@ protected GeodeSortLimitRule(GeodeSortLimitRuleConfig config) {
           .replace(GeodeRel.CONVENTION)
           .replace(sort.getCollation());
 
-      GeodeSort geodeSort = new GeodeSort(sort.getCluster(), traitSet,
-          convert(sort.getInput(), traitSet.replace(RelCollations.EMPTY)),
-          sort.getCollation(), sort.fetch);
+      GeodeSort geodeSort =
+          new GeodeSort(sort.getCluster(), traitSet,
+              convert(sort.getInput(), traitSet.replace(RelCollations.EMPTY)),
+              sort.getCollation(), sort.fetch);
 
       call.transformTo(geodeSort);
     }
diff --git a/geode/src/main/java/org/apache/calcite/adapter/geode/rel/GeodeSchemaFactory.java b/geode/src/main/java/org/apache/calcite/adapter/geode/rel/GeodeSchemaFactory.java
index 1c3ad623d41..5c1f5a679bd 100644
--- a/geode/src/main/java/org/apache/calcite/adapter/geode/rel/GeodeSchemaFactory.java
+++ b/geode/src/main/java/org/apache/calcite/adapter/geode/rel/GeodeSchemaFactory.java
@@ -17,7 +17,7 @@
 package org.apache.calcite.adapter.geode.rel;
 
 import org.apache.calcite.model.ModelHandler;
-import org.apache.calcite.runtime.GeoFunctions;
+import org.apache.calcite.runtime.SpatialTypeFunctions;
 import org.apache.calcite.schema.Schema;
 import org.apache.calcite.schema.SchemaFactory;
 import org.apache.calcite.schema.SchemaPlus;
@@ -61,7 +61,7 @@ public GeodeSchemaFactory() {
 
     if (allowSpatialFunctions) {
       ModelHandler.addFunctions(parentSchema, null, ImmutableList.of(),
-          GeoFunctions.class.getName(), "*", true);
+          SpatialTypeFunctions.class.getName(), "*", true);
     }
 
     return new GeodeSchema(
diff --git a/geode/src/main/java/org/apache/calcite/adapter/geode/rel/GeodeTable.java b/geode/src/main/java/org/apache/calcite/adapter/geode/rel/GeodeTable.java
index 7de3aa28e93..13c94d67c0f 100644
--- a/geode/src/main/java/org/apache/calcite/adapter/geode/rel/GeodeTable.java
+++ b/geode/src/main/java/org/apache/calcite/adapter/geode/rel/GeodeTable.java
@@ -100,13 +100,13 @@ public Enumerable<Object> query(final GemFireCache clientCache,
       SqlTypeName typeName = typeFactory.createJavaType(field.getValue()).getSqlTypeName();
       RelDataType type;
       if (typeName == SqlTypeName.ARRAY) {
-        type = typeFactory.createArrayType(
-            typeFactory.createSqlType(SqlTypeName.ANY),
-            -1);
+        type =
+            typeFactory.createArrayType(
+                typeFactory.createSqlType(SqlTypeName.ANY), -1);
       } else if (typeName == SqlTypeName.MULTISET) {
-        type = typeFactory.createMultisetType(
-            typeFactory.createSqlType(SqlTypeName.ANY),
-            -1);
+        type =
+            typeFactory.createMultisetType(
+                typeFactory.createSqlType(SqlTypeName.ANY), -1);
       } else if (typeName == SqlTypeName.MAP) {
         RelDataType anyType = typeFactory.createSqlType(SqlTypeName.ANY);
         type = typeFactory.createMapType(anyType, anyType);
@@ -200,8 +200,9 @@ public Enumerable<Object> query(final GemFireCache clientCache,
           SelectResults results = (SelectResults) queryService.newQuery(oqlQuery).execute();
           return new GeodeEnumerator(results, resultRowType);
         } catch (Exception e) {
-          String message = String.format(Locale.ROOT, "Failed to execute query [%s] on %s",
-              oqlQuery, clientCache.getName());
+          String message =
+              String.format(Locale.ROOT, "Failed to execute query [%s] on %s",
+                  oqlQuery, clientCache.getName());
           throw new RuntimeException(message, e);
         }
       }
diff --git a/geode/src/main/java/org/apache/calcite/adapter/geode/rel/GeodeToEnumerableConverter.java b/geode/src/main/java/org/apache/calcite/adapter/geode/rel/GeodeToEnumerableConverter.java
index f55bbe69780..e870ace614d 100644
--- a/geode/src/main/java/org/apache/calcite/adapter/geode/rel/GeodeToEnumerableConverter.java
+++ b/geode/src/main/java/org/apache/calcite/adapter/geode/rel/GeodeToEnumerableConverter.java
@@ -94,10 +94,9 @@ protected GeodeToEnumerableConverter(RelOptCluster cluster,
 
     // PhysType is Enumerable Adapter class that maps SQL types (getRowType)
     // with physical Java types (getJavaTypes())
-    final PhysType physType = PhysTypeImpl.of(
-        implementor.getTypeFactory(),
-        rowType,
-        pref.prefer(JavaRowFormat.ARRAY));
+    final PhysType physType =
+        PhysTypeImpl.of(implementor.getTypeFactory(), rowType,
+            pref.prefer(JavaRowFormat.ARRAY));
 
     final List<Class> physFieldClasses = new AbstractList<Class>() {
       @Override public Class get(int index) {
@@ -111,7 +110,8 @@ protected GeodeToEnumerableConverter(RelOptCluster cluster,
 
     // Expression meta-program for calling the GeodeTable.GeodeQueryable#query
     // method form the generated code
-    final BlockBuilder blockBuilder = new BlockBuilder().append(
+    final BlockBuilder blockBuilder = new BlockBuilder();
+    blockBuilder.append(
         Expressions.call(
             geodeImplementContext.table.getExpression(GeodeTable.GeodeQueryable.class),
             GEODE_QUERY_METHOD,
diff --git a/geode/src/main/java/org/apache/calcite/adapter/geode/simple/GeodeSimpleSchema.java b/geode/src/main/java/org/apache/calcite/adapter/geode/simple/GeodeSimpleSchema.java
index a4823f15838..671ba1aee6d 100644
--- a/geode/src/main/java/org/apache/calcite/adapter/geode/simple/GeodeSimpleSchema.java
+++ b/geode/src/main/java/org/apache/calcite/adapter/geode/simple/GeodeSimpleSchema.java
@@ -55,11 +55,11 @@ public GeodeSimpleSchema(
     this.regionNames = regionNames;
     this.pdxAutoSerializerPackageExp = pdxAutoSerializerPackageExp;
 
-    this.clientCache = GeodeUtils.createClientCache(
-        locatorHost,
-        locatorPort,
-        pdxAutoSerializerPackageExp,
-        true);
+    this.clientCache =
+        GeodeUtils.createClientCache(locatorHost,
+            locatorPort,
+            pdxAutoSerializerPackageExp,
+            true);
   }
 
   @Override protected Map<String, Table> getTableMap() {
@@ -71,8 +71,9 @@ public GeodeSimpleSchema(
 
         Region region = GeodeUtils.createRegion(clientCache, regionName);
 
-        Table table = new GeodeSimpleScannableTable(regionName, autodetectRelTypeFromRegion(region),
-            clientCache);
+        Table table =
+            new GeodeSimpleScannableTable(regionName,
+                autodetectRelTypeFromRegion(region), clientCache);
 
         builder.put(regionName, table);
       }
diff --git a/geode/src/test/java/org/apache/calcite/adapter/geode/rel/RelationalJdbcExample.java b/geode/src/test/java/org/apache/calcite/adapter/geode/rel/RelationalJdbcExample.java
index 2799cd1ee63..cad50f5ae50 100644
--- a/geode/src/test/java/org/apache/calcite/adapter/geode/rel/RelationalJdbcExample.java
+++ b/geode/src/test/java/org/apache/calcite/adapter/geode/rel/RelationalJdbcExample.java
@@ -42,8 +42,8 @@
  */
 public class RelationalJdbcExample {
 
-  protected static final Logger LOGGER = LoggerFactory.getLogger(
-      RelationalJdbcExample.class.getName());
+  protected static final Logger LOGGER =
+      LoggerFactory.getLogger(RelationalJdbcExample.class.getName());
 
   private RelationalJdbcExample() {
   }
@@ -77,21 +77,23 @@ public static void main(String[] args) throws Exception {
     Connection connection = DriverManager.getConnection("jdbc:calcite:", info);
 
     Statement statement = connection.createStatement();
-    ResultSet resultSet = statement.executeQuery(
-        "SELECT \"b\".\"author\", \"b\".\"retailCost\", \"i\".\"quantityInStock\"\n"
-            + "FROM \"TEST\".\"BookMaster\" AS \"b\" "
-            + " INNER JOIN \"TEST\".\"BookInventory\" AS \"i\""
-            + "  ON \"b\".\"itemNumber\" = \"i\".\"itemNumber\"\n "
-            + "WHERE  \"b\".\"retailCost\" > 0");
+    String sql = "SELECT \"b\".\"author\", \"b\".\"retailCost\", \"i\".\"quantityInStock\"\n"
+        + "FROM \"TEST\".\"BookMaster\" AS \"b\" "
+        + " INNER JOIN \"TEST\".\"BookInventory\" AS \"i\""
+        + "  ON \"b\".\"itemNumber\" = \"i\".\"itemNumber\"\n "
+        + "WHERE  \"b\".\"retailCost\" > 0";
+    ResultSet resultSet = statement.executeQuery(sql);
 
     final StringBuilder buf = new StringBuilder();
     while (resultSet.next()) {
       ResultSetMetaData metaData = resultSet.getMetaData();
       for (int i = 1; i <= metaData.getColumnCount(); i++) {
         buf.append(i > 1 ? "; " : "")
-            .append(metaData.getColumnLabel(i)).append("=").append(resultSet.getObject(i));
+            .append(metaData.getColumnLabel(i))
+            .append("=")
+            .append(resultSet.getObject(i));
       }
-      LOGGER.info("Result entry: " + buf.toString());
+      LOGGER.info("Result entry: " + buf);
       buf.setLength(0);
     }
     resultSet.close();
diff --git a/gradle.properties b/gradle.properties
index 923d777b5eb..c0189e8d218 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -14,7 +14,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-org.gradle.jvmargs=-XX:+UseG1GC -Xmx512m -XX:MaxMetaspaceSize=512m
+org.gradle.jvmargs=-XX:+UseG1GC -Xmx1g -XX:MaxMetaspaceSize=512m
 org.gradle.parallel=true
 # Build cache can be disabled with --no-build-cache option
 org.gradle.caching=true
@@ -27,9 +27,9 @@ systemProp.org.gradle.internal.publish.checksums.insecure=true
 # This is version for Calcite itself
 # Note: it should not include "-SNAPSHOT" as it is automatically added by build.gradle.kts
 # Release version can be generated by using -Prelease or -Prc=<int> arguments
-calcite.version=1.31.0
+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.20.0
+calcite.avatica.version=1.23.0
 
 # 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>
@@ -48,15 +48,17 @@ com.github.autostyle.version=3.0
 com.github.burrunan.s3-build-cache.version=1.2
 com.github.johnrengelman.shadow.version=5.1.0
 com.github.spotbugs.version=2.0.0
-com.github.vlsi.vlsi-release-plugins.version=1.76
+com.github.vlsi.vlsi-release-plugins.version=1.84
 com.google.protobuf.version=0.8.10
-de.thetaphi.forbiddenapis.version=3.1
-kotlin.version=1.5.31
+de.thetaphi.forbiddenapis.version=3.4
+jacoco.version=0.8.8
+kotlin.version=1.7.10
 net.ltgt.errorprone.version=1.3.0
 me.champeau.gradle.jmh.version=0.5.3
 org.jetbrains.gradle.plugin.idea-ext.version=0.5
 org.nosphere.apache.rat.version=0.7.0
 org.owasp.dependencycheck.version=6.1.6
+org.sonarqube.version=3.5.0.2730
 
 # For now, we use Kotlin for tests only, so we don't want to include kotlin-stdlib dependency to the runtimeClasspath
 # See https://kotlinlang.org/docs/gradle.html#dependency-on-the-standard-library
@@ -74,10 +76,10 @@ errorprone.version=2.5.1
 # The property is used in https://github.com/wildfly/jandex regression testing, so avoid renaming
 jandex.version=2.2.3.Final
 
-# We support Guava versions as old as 19.0 but prefer more recent versions.
+# We support Guava versions as old as 16.0.1 but prefer more recent versions.
 # elasticsearch does not like asm:6.2.1+
 aggdesigner-algorithm.version=6.0
-apiguardian-api.version=1.1.0
+apiguardian-api.version=1.1.2
 asm.version=7.2
 bouncycastle.version=1.60
 byte-buddy.version=1.9.3
@@ -89,17 +91,20 @@ commons-codec.version=1.13
 commons-dbcp2.version=2.6.0
 commons-io.version=2.11.0
 commons-lang3.version=3.8
+commons-math3.version=3.6.1
 commons-pool2.version=2.6.2
 dropwizard-metrics.version=4.0.5
 
 # do not upgrade this, new versions are Category X license.
 elasticsearch.version=7.10.2
 embedded-redis.version=0.6
-esri-geometry-api.version=2.2.0
+jts-core.version=1.19.0
+jts-io-common.version=1.19.0
+proj4j.version=1.2.2
 foodmart-data-hsqldb.version=0.5
 foodmart-data-json.version=0.4
 foodmart-queries.version=0.4.1
-geode-core.version=1.10.0
+geode-core.version=1.15.1
 guava.version=31.1-jre
 h2.version=2.1.210
 hadoop.version=2.7.5
@@ -111,9 +116,9 @@ httpcore.version=4.4.11
 hydromatic.tpcds.version=0.4
 immutables.version=2.8.8
 innodb-java-reader.version=1.0.10
-jackson-databind.version=2.13.2.1
-jackson.version=2.13.2.1
-janino.version=3.1.6
+jackson-databind.version=2.14.1
+jackson.version=2.14.1
+janino.version=3.1.9
 java-diff.version=1.1.2
 jcip-annotations.version=1.0-1
 jcommander.version=1.72
@@ -125,8 +130,8 @@ joda-time.version=2.8.1
 json-path.version=2.7.0
 jsr305.version=3.0.2
 jsoup.version=1.11.3
-junit4.version=4.12
-junit5.version=5.8.1
+junit4.version=4.13.2
+junit5.version=5.9.1
 kafka-clients.version=2.1.1
 kerby.version=1.1.1
 log4j2.version=2.17.1
@@ -140,8 +145,8 @@ opencsv.version=2.3
 pig.version=0.16.0
 pigunit.version=0.16.0
 postgresql.version=9.3-1102-jdbc41
-protobuf.version=3.17.1
-quidem.version=0.10
+protobuf.version=3.21.5
+quidem.version=0.11
 scala-library.version=2.10.3
 scott-data-hsqldb.version=0.2
 servlet.version=4.0.1
@@ -155,3 +160,8 @@ tpch.version=1.0
 uzaygezen.version=0.2
 xalan.version=2.7.1
 xercesImpl.version=2.9.1
+
+# sonar properties
+systemProp.sonar.organization=apache
+systemProp.sonar.projectKey=apache_calcite
+systemProp.sonar.host.url=https://sonarcloud.io
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
index e708b1c023e..943f0cbfa75 100644
Binary files a/gradle/wrapper/gradle-wrapper.jar and b/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index a43615b1c45..49b350a3a55 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -16,7 +16,8 @@
 #
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionSha256Sum=de8f52ad49bdc759164f72439a3bf56ddb1589c4cde802d3cec7d6ad0e0ee410
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.3-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.6.1-bin.zip
+networkTimeout=10000
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
+distributionSha256Sum=6147605a23b4eff6c334927a86ff3508cb5d6722cd624c97ded4c2e8640f1f87
diff --git a/gradlew b/gradlew
index 4f906e0c811..65dcd68d65c 100755
--- a/gradlew
+++ b/gradlew
@@ -1,7 +1,7 @@
-#!/usr/bin/env sh
+#!/bin/sh
 
 #
-# Copyright 2015 the original author or authors.
+# Copyright © 2015-2021 the original authors.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -17,67 +17,101 @@
 #
 
 ##############################################################################
-##
-##  Gradle start up script for UN*X
-##
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
 ##############################################################################
 
 # Attempt to set APP_HOME
+
 # Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
 done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
 
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
 
 # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
+MAX_FD=maximum
 
 warn () {
     echo "$*"
-}
+} >&2
 
 die () {
     echo
     echo "$*"
     echo
     exit 1
-}
+} >&2
 
 # OS specific support (must be 'true' or 'false').
 cygwin=false
 msys=false
 darwin=false
 nonstop=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
 esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
@@ -87,9 +121,9 @@ CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
         # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
+        JAVACMD=$JAVA_HOME/jre/sh/java
     else
-        JAVACMD="$JAVA_HOME/bin/java"
+        JAVACMD=$JAVA_HOME/bin/java
     fi
     if [ ! -x "$JAVACMD" ] ; then
         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
@@ -98,7 +132,7 @@ Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
     fi
 else
-    JAVACMD="java"
+    JAVACMD=java
     which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
@@ -106,80 +140,105 @@ location of your Java installation."
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if [ $? -eq 0 ] ; then
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            MAX_FD="$MAX_FD_LIMIT"
-        fi
-        ulimit -n $MAX_FD
-        if [ $? -ne 0 ] ; then
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        fi
-    else
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC3045 
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC3045 
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
 fi
 
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
 
 # For Cygwin or MSYS, switch paths to Windows format before running java
-if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-
-    JAVACMD=`cygpath --unix "$JAVACMD"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
     # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
         fi
-        i=`expr $i + 1`
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
     done
-    case $i in
-        0) set -- ;;
-        1) set -- "$args0" ;;
-        2) set -- "$args0" "$args1" ;;
-        3) set -- "$args0" "$args1" "$args2" ;;
-        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
-    esac
 fi
 
-# Escape application args
-save () {
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
-    echo " "
-}
-APP_ARGS=`save "$@"`
+# Collect all arguments for the java command;
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#     shell script including quotes and variable substitutions, so put them in
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
 
-# Collect all arguments for the java command, following the shell quoting and substitution rules
-eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
 
 exec "$JAVACMD" "$@"
diff --git a/gradlew.bat b/gradlew.bat
index 107acd32c4e..93e3f59f135 100644
--- a/gradlew.bat
+++ b/gradlew.bat
@@ -14,7 +14,7 @@
 @rem limitations under the License.
 @rem
 
-@if "%DEBUG%" == "" @echo off
+@if "%DEBUG%"=="" @echo off
 @rem ##########################################################################
 @rem
 @rem  Gradle startup script for Windows
@@ -25,7 +25,8 @@
 if "%OS%"=="Windows_NT" setlocal
 
 set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
@@ -40,7 +41,7 @@ if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto execute
+if %ERRORLEVEL% equ 0 goto execute
 
 echo.
 echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
@@ -75,13 +76,15 @@ set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
 :end
 @rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
+if %ERRORLEVEL% equ 0 goto mainEnd
 
 :fail
 rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
 rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
 
 :mainEnd
 if "%OS%"=="Windows_NT" endlocal
diff --git a/innodb/src/main/java/org/apache/calcite/adapter/innodb/InnodbEnumerator.java b/innodb/src/main/java/org/apache/calcite/adapter/innodb/InnodbEnumerator.java
index ae5561cfadd..622fb9e8955 100644
--- a/innodb/src/main/java/org/apache/calcite/adapter/innodb/InnodbEnumerator.java
+++ b/innodb/src/main/java/org/apache/calcite/adapter/innodb/InnodbEnumerator.java
@@ -97,12 +97,13 @@ private static Object convertToEnumeratorObject(Object obj, RelDataType relDataT
     case VARBINARY:
       return new ByteString((byte[]) obj);
     case TIMESTAMP:
-      Timestamp timestamp = Utils.convertDateTime((String) obj,
-          relDataType.getPrecision());
+    case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
+      Timestamp timestamp =
+          Utils.convertDateTime((String) obj, relDataType.getPrecision());
       return shift(timestamp).getTime();
     case TIME:
-      Time time = Utils.convertTime((String) obj,
-          relDataType.getPrecision());
+      Time time =
+          Utils.convertTime((String) obj, relDataType.getPrecision());
       return shift(time).getTime();
     case DATE:
       Date date = Date.valueOf(LocalDate.parse((String) obj));
diff --git a/innodb/src/main/java/org/apache/calcite/adapter/innodb/InnodbFilterTranslator.java b/innodb/src/main/java/org/apache/calcite/adapter/innodb/InnodbFilterTranslator.java
index 7f81399a023..b26f1e9c9e8 100644
--- a/innodb/src/main/java/org/apache/calcite/adapter/innodb/InnodbFilterTranslator.java
+++ b/innodb/src/main/java/org/apache/calcite/adapter/innodb/InnodbFilterTranslator.java
@@ -166,17 +166,20 @@ private IndexCondition findPushDownCondition(List<RexNode> rexNodeList, KeyMeta
             pushDownRexNodeList, remainderRexNodeList);
 
     // handle point query if possible
-    condition = handlePointQuery(condition, keyMeta, leftMostKeyNodes,
-        keyOrdToNodesMap, pushDownRexNodeList, remainderRexNodeList);
+    condition =
+        handlePointQuery(condition, keyMeta, leftMostKeyNodes,
+            keyOrdToNodesMap, pushDownRexNodeList, remainderRexNodeList);
     if (condition.canPushDown()) {
       return condition;
     }
 
     // handle range query
-    condition = handleRangeQuery(condition, keyMeta, leftMostKeyNodes,
-        pushDownRexNodeList, remainderRexNodeList, ">=", ">");
-    condition = handleRangeQuery(condition, keyMeta, leftMostKeyNodes,
-        pushDownRexNodeList, remainderRexNodeList, "<=", "<");
+    condition =
+        handleRangeQuery(condition, keyMeta, leftMostKeyNodes,
+            pushDownRexNodeList, remainderRexNodeList, ">=", ">");
+    condition =
+        handleRangeQuery(condition, keyMeta, leftMostKeyNodes,
+            pushDownRexNodeList, remainderRexNodeList, "<=", "<");
 
     return condition;
   }
diff --git a/innodb/src/main/java/org/apache/calcite/adapter/innodb/InnodbProject.java b/innodb/src/main/java/org/apache/calcite/adapter/innodb/InnodbProject.java
index b7e657ac07d..202068aadb2 100644
--- a/innodb/src/main/java/org/apache/calcite/adapter/innodb/InnodbProject.java
+++ b/innodb/src/main/java/org/apache/calcite/adapter/innodb/InnodbProject.java
@@ -28,6 +28,7 @@
 import org.apache.calcite.util.Pair;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 
@@ -42,7 +43,7 @@
 public class InnodbProject extends Project implements InnodbRel {
   InnodbProject(RelOptCluster cluster, RelTraitSet traitSet,
       RelNode input, List<? extends RexNode> projects, RelDataType rowType) {
-    super(cluster, traitSet, ImmutableList.of(), input, projects, rowType);
+    super(cluster, traitSet, ImmutableList.of(), input, projects, rowType, ImmutableSet.of());
     assert getConvention() == InnodbRel.CONVENTION;
     assert getConvention() == input.getConvention();
   }
diff --git a/innodb/src/main/java/org/apache/calcite/adapter/innodb/InnodbRules.java b/innodb/src/main/java/org/apache/calcite/adapter/innodb/InnodbRules.java
index cf381de2471..5b8a67509ee 100644
--- a/innodb/src/main/java/org/apache/calcite/adapter/innodb/InnodbRules.java
+++ b/innodb/src/main/java/org/apache/calcite/adapter/innodb/InnodbRules.java
@@ -140,8 +140,7 @@ protected InnodbProjectRule(Config config) {
           return false;
         }
       }
-
-      return true;
+      return project.getVariablesSet().isEmpty();
     }
 
     @Override public RelNode convert(RelNode rel) {
diff --git a/innodb/src/main/java/org/apache/calcite/adapter/innodb/InnodbTable.java b/innodb/src/main/java/org/apache/calcite/adapter/innodb/InnodbTable.java
index 14c6188b0c8..0df30ca43cf 100644
--- a/innodb/src/main/java/org/apache/calcite/adapter/innodb/InnodbTable.java
+++ b/innodb/src/main/java/org/apache/calcite/adapter/innodb/InnodbTable.java
@@ -185,20 +185,23 @@ public Enumerable<Object> query(
                     .queryByPrimaryKey(pointQueryKey, selectedColumnNames));
             break;
           case PK_RANGE_QUERY:
-            resultIterator = tableReader.getRangeQueryIterator(
-                rangeQueryLowerKey, rangeQueryLowerOp, rangeQueryUpperKey, rangeQueryUpperOp,
-                selectedColumnNames, ascOrder);
+            resultIterator =
+                tableReader.getRangeQueryIterator(rangeQueryLowerKey,
+                    rangeQueryLowerOp, rangeQueryUpperKey, rangeQueryUpperOp,
+                    selectedColumnNames, ascOrder);
             break;
           case SK_POINT_QUERY:
-            resultIterator = tableReader.getRecordIteratorBySk(indexName,
-                pointQueryKey, ComparisonOperator.GTE, pointQueryKey, ComparisonOperator.LTE,
-                selectedColumnNames, ascOrder);
+            resultIterator =
+                tableReader.getRecordIteratorBySk(indexName, pointQueryKey,
+                    ComparisonOperator.GTE, pointQueryKey,
+                    ComparisonOperator.LTE, selectedColumnNames, ascOrder);
             break;
           case SK_RANGE_QUERY:
           case SK_FULL_SCAN:
-            resultIterator = tableReader.getRecordIteratorBySk(indexName,
-                rangeQueryLowerKey, rangeQueryLowerOp, rangeQueryUpperKey, rangeQueryUpperOp,
-                selectedColumnNames, ascOrder);
+            resultIterator =
+                tableReader.getRecordIteratorBySk(indexName, rangeQueryLowerKey,
+                    rangeQueryLowerOp, rangeQueryUpperKey, rangeQueryUpperOp,
+                    selectedColumnNames, ascOrder);
             break;
           case PK_FULL_SCAN:
             resultIterator =
diff --git a/innodb/src/main/java/org/apache/calcite/adapter/innodb/InnodbToEnumerableConverter.java b/innodb/src/main/java/org/apache/calcite/adapter/innodb/InnodbToEnumerableConverter.java
index 386c9741cb4..2c5c1874cc8 100644
--- a/innodb/src/main/java/org/apache/calcite/adapter/innodb/InnodbToEnumerableConverter.java
+++ b/innodb/src/main/java/org/apache/calcite/adapter/innodb/InnodbToEnumerableConverter.java
@@ -138,12 +138,12 @@ static List<String> innodbFieldNames(final RelDataType rowType) {
             constantArrayList(condition.getRangeQueryUpperKey(), Object.class));
     final Expression cond =
         list.append("condition",
-            Expressions.call(
-                IndexCondition.class,
+            Expressions.call(IndexCondition.class,
                 "create", indexName, queryType, pointQueryKey,
-                rangeQueryLowerOp, rangeQueryUpperOp, rangeQueryLowerKey, rangeQueryUpperKey));
-    final Expression ascOrder = Expressions.constant(
-        innodbImplementor.ascOrder);
+                rangeQueryLowerOp, rangeQueryUpperOp, rangeQueryLowerKey,
+                rangeQueryUpperKey));
+    final Expression ascOrder =
+        Expressions.constant(innodbImplementor.ascOrder);
     Expression enumerable =
         list.append("enumerable",
             Expressions.call(table,
diff --git a/innodb/src/test/java/org/apache/calcite/adapter/innodb/InnodbAdapterDataTypesTest.java b/innodb/src/test/java/org/apache/calcite/adapter/innodb/InnodbAdapterDataTypesTest.java
index bf48ab2c1f6..22384a86d5c 100644
--- a/innodb/src/test/java/org/apache/calcite/adapter/innodb/InnodbAdapterDataTypesTest.java
+++ b/innodb/src/test/java/org/apache/calcite/adapter/innodb/InnodbAdapterDataTypesTest.java
@@ -40,9 +40,10 @@
  */
 public class InnodbAdapterDataTypesTest {
 
-  private static final ImmutableMap<String, String> INNODB_MODEL = ImmutableMap.of("model",
-      Sources.of(InnodbAdapterTest.class.getResource("/model.json"))
-          .file().getAbsolutePath());
+  private static final ImmutableMap<String, String> INNODB_MODEL =
+      ImmutableMap.of("model",
+          Sources.of(InnodbAdapterTest.class.getResource("/model.json"))
+              .file().getAbsolutePath());
 
   @Test void testTypesRowType() {
     CalciteAssert.that()
diff --git a/innodb/src/test/java/org/apache/calcite/adapter/innodb/InnodbAdapterTest.java b/innodb/src/test/java/org/apache/calcite/adapter/innodb/InnodbAdapterTest.java
index f6da8dc69a2..d18e37f5892 100644
--- a/innodb/src/test/java/org/apache/calcite/adapter/innodb/InnodbAdapterTest.java
+++ b/innodb/src/test/java/org/apache/calcite/adapter/innodb/InnodbAdapterTest.java
@@ -57,9 +57,10 @@
  */
 public class InnodbAdapterTest {
 
-  private static final ImmutableMap<String, String> INNODB_MODEL = ImmutableMap.of("model",
-      Sources.of(InnodbAdapterTest.class.getResource("/model.json"))
-          .file().getAbsolutePath());
+  private static final ImmutableMap<String, String> INNODB_MODEL =
+      ImmutableMap.of("model",
+          Sources.of(InnodbAdapterTest.class.getResource("/model.json"))
+              .file().getAbsolutePath());
 
   @Test void testSelectCount() {
     sql("SELECT * FROM \"EMP\"")
@@ -1079,64 +1080,64 @@ public class InnodbAdapterTest {
         .failsAtValidation("Object 'NOT_EXIST' not found");
   }
 
-  static List<Pair<Integer, String>> rows = Lists.newArrayList(
-      Pair.of(7369, "EMPNO=7369; ENAME=SMITH; JOB=CLERK; AGE=30; MGR=7902; "
-          + "HIREDATE=1980-12-17; SAL=800.00; COMM=null; DEPTNO=20; EMAIL=smith@calcite; "
-          + "CREATE_DATETIME=2020-01-01 18:35:40; CREATE_TIME=18:35:40; UPSERT_TIME="
-          + expectedLocalTime("2020-01-01 18:35:40")),
-      Pair.of(7499, "EMPNO=7499; ENAME=ALLEN; JOB=SALESMAN; AGE=24; MGR=7698; "
-          + "HIREDATE=1981-02-20; SAL=1600.00; COMM=300.00; DEPTNO=30; EMAIL=allen@calcite; "
-          + "CREATE_DATETIME=2018-04-09 09:00:00; CREATE_TIME=09:00:00; UPSERT_TIME="
-          + expectedLocalTime("2018-04-09 09:00:00")),
-      Pair.of(7521, "EMPNO=7521; ENAME=WARD; JOB=SALESMAN; AGE=41; MGR=7698; "
-          + "HIREDATE=1981-02-22; SAL=1250.00; COMM=500.00; DEPTNO=30; EMAIL=ward@calcite; "
-          + "CREATE_DATETIME=2019-11-16 10:26:40; CREATE_TIME=10:26:40; UPSERT_TIME="
-          + expectedLocalTime("2019-11-16 10:26:40")),
-      Pair.of(7566, "EMPNO=7566; ENAME=JONES; JOB=MANAGER; AGE=28; MGR=7839; "
-          + "HIREDATE=1981-02-04; SAL=2975.00; COMM=null; DEPTNO=20; EMAIL=jones@calcite; "
-          + "CREATE_DATETIME=2015-03-09 22:16:30; CREATE_TIME=22:16:30; UPSERT_TIME="
-          + expectedLocalTime("2015-03-09 22:16:30")),
-      Pair.of(7654, "EMPNO=7654; ENAME=MARTIN; JOB=SALESMAN; AGE=27; MGR=7698; "
-          + "HIREDATE=1981-09-28; SAL=1250.00; COMM=1400.00; DEPTNO=30; EMAIL=martin@calcite; "
-          + "CREATE_DATETIME=2018-09-02 12:12:56; CREATE_TIME=12:12:56; UPSERT_TIME="
-          + expectedLocalTime("2018-09-02 12:12:56")),
-      Pair.of(7698, "EMPNO=7698; ENAME=BLAKE; JOB=MANAGER; AGE=38; MGR=7839; "
-          + "HIREDATE=1981-01-05; SAL=2850.00; COMM=null; DEPTNO=30; EMAIL=blake@calcite; "
-          + "CREATE_DATETIME=2018-06-01 14:45:00; CREATE_TIME=14:45:00; UPSERT_TIME="
-          + expectedLocalTime("2018-06-01 14:45:00")),
-      Pair.of(7782, "EMPNO=7782; ENAME=CLARK; JOB=MANAGER; AGE=32; MGR=7839; "
-          + "HIREDATE=1981-06-09; SAL=2450.00; COMM=null; DEPTNO=10; EMAIL=null; "
-          + "CREATE_DATETIME=2019-09-30 02:14:56; CREATE_TIME=02:14:56; UPSERT_TIME="
-          + expectedLocalTime("2019-09-30 02:14:56")),
-      Pair.of(7788, "EMPNO=7788; ENAME=SCOTT; JOB=ANALYST; AGE=45; MGR=7566; "
-          + "HIREDATE=1987-04-19; SAL=3000.00; COMM=null; DEPTNO=20; EMAIL=scott@calcite; "
-          + "CREATE_DATETIME=2019-07-28 12:12:12; CREATE_TIME=12:12:12; UPSERT_TIME="
-          + expectedLocalTime("2019-07-28 12:12:12")),
-      Pair.of(7839, "EMPNO=7839; ENAME=KING; JOB=PRESIDENT; AGE=22; MGR=null; "
-          + "HIREDATE=1981-11-17; SAL=5000.00; COMM=null; DEPTNO=10; EMAIL=king@calcite; "
-          + "CREATE_DATETIME=2019-06-08 15:15:15; CREATE_TIME=null; UPSERT_TIME="
-          + expectedLocalTime("2019-06-08 15:15:15")),
-      Pair.of(7844, "EMPNO=7844; ENAME=TURNER; JOB=SALESMAN; AGE=54; MGR=7698; "
-          + "HIREDATE=1981-09-08; SAL=1500.00; COMM=0.00; DEPTNO=30; EMAIL=turner@calcite; "
-          + "CREATE_DATETIME=2017-08-17 22:01:37; CREATE_TIME=22:01:37; UPSERT_TIME="
-          + expectedLocalTime("2017-08-17 22:01:37")),
-      Pair.of(7876, "EMPNO=7876; ENAME=ADAMS; JOB=CLERK; AGE=35; MGR=7788; "
-          + "HIREDATE=1987-05-23; SAL=1100.00; COMM=null; DEPTNO=20; EMAIL=adams@calcite; "
-          + "CREATE_DATETIME=null; CREATE_TIME=23:11:06; UPSERT_TIME="
-          + expectedLocalTime("2017-08-18 23:11:06")),
-      Pair.of(7900, "EMPNO=7900; ENAME=JAMES; JOB=CLERK; AGE=40; MGR=7698; "
-          + "HIREDATE=1981-12-03; SAL=950.00; COMM=null; DEPTNO=30; EMAIL=james@calcite; "
-          + "CREATE_DATETIME=2020-01-02 12:19:00; CREATE_TIME=12:19:00; UPSERT_TIME="
-          + expectedLocalTime("2020-01-02 12:19:00")),
-      Pair.of(7902, "EMPNO=7902; ENAME=FORD; JOB=ANALYST; AGE=28; MGR=7566; "
-          + "HIREDATE=1981-12-03; SAL=3000.00; COMM=null; DEPTNO=20; EMAIL=ford@calcite; "
-          + "CREATE_DATETIME=2019-05-29 00:00:00; CREATE_TIME=null; UPSERT_TIME="
-          + expectedLocalTime("2019-05-29 00:00:00")),
-      Pair.of(7934, "EMPNO=7934; ENAME=MILLER; JOB=CLERK; AGE=32; MGR=7782; "
-          + "HIREDATE=1982-01-23; SAL=1300.00; COMM=null; DEPTNO=10; EMAIL=null; "
-          + "CREATE_DATETIME=2016-09-02 23:15:01; CREATE_TIME=23:15:01; UPSERT_TIME="
-          + expectedLocalTime("2016-09-02 23:15:01"))
-  );
+  static List<Pair<Integer, String>> rows =
+      Lists.newArrayList(
+          Pair.of(7369, "EMPNO=7369; ENAME=SMITH; JOB=CLERK; AGE=30; MGR=7902; "
+              + "HIREDATE=1980-12-17; SAL=800.00; COMM=null; DEPTNO=20; EMAIL=smith@calcite; "
+              + "CREATE_DATETIME=2020-01-01 18:35:40; CREATE_TIME=18:35:40; UPSERT_TIME="
+              + expectedLocalTime("2020-01-01 18:35:40")),
+          Pair.of(7499, "EMPNO=7499; ENAME=ALLEN; JOB=SALESMAN; AGE=24; MGR=7698; "
+              + "HIREDATE=1981-02-20; SAL=1600.00; COMM=300.00; DEPTNO=30; EMAIL=allen@calcite; "
+              + "CREATE_DATETIME=2018-04-09 09:00:00; CREATE_TIME=09:00:00; UPSERT_TIME="
+              + expectedLocalTime("2018-04-09 09:00:00")),
+          Pair.of(7521, "EMPNO=7521; ENAME=WARD; JOB=SALESMAN; AGE=41; MGR=7698; "
+              + "HIREDATE=1981-02-22; SAL=1250.00; COMM=500.00; DEPTNO=30; EMAIL=ward@calcite; "
+              + "CREATE_DATETIME=2019-11-16 10:26:40; CREATE_TIME=10:26:40; UPSERT_TIME="
+              + expectedLocalTime("2019-11-16 10:26:40")),
+          Pair.of(7566, "EMPNO=7566; ENAME=JONES; JOB=MANAGER; AGE=28; MGR=7839; "
+              + "HIREDATE=1981-02-04; SAL=2975.00; COMM=null; DEPTNO=20; EMAIL=jones@calcite; "
+              + "CREATE_DATETIME=2015-03-09 22:16:30; CREATE_TIME=22:16:30; UPSERT_TIME="
+              + expectedLocalTime("2015-03-09 22:16:30")),
+          Pair.of(7654, "EMPNO=7654; ENAME=MARTIN; JOB=SALESMAN; AGE=27; MGR=7698; "
+              + "HIREDATE=1981-09-28; SAL=1250.00; COMM=1400.00; DEPTNO=30; EMAIL=martin@calcite; "
+              + "CREATE_DATETIME=2018-09-02 12:12:56; CREATE_TIME=12:12:56; UPSERT_TIME="
+              + expectedLocalTime("2018-09-02 12:12:56")),
+          Pair.of(7698, "EMPNO=7698; ENAME=BLAKE; JOB=MANAGER; AGE=38; MGR=7839; "
+              + "HIREDATE=1981-01-05; SAL=2850.00; COMM=null; DEPTNO=30; EMAIL=blake@calcite; "
+              + "CREATE_DATETIME=2018-06-01 14:45:00; CREATE_TIME=14:45:00; UPSERT_TIME="
+              + expectedLocalTime("2018-06-01 14:45:00")),
+          Pair.of(7782, "EMPNO=7782; ENAME=CLARK; JOB=MANAGER; AGE=32; MGR=7839; "
+              + "HIREDATE=1981-06-09; SAL=2450.00; COMM=null; DEPTNO=10; EMAIL=null; "
+              + "CREATE_DATETIME=2019-09-30 02:14:56; CREATE_TIME=02:14:56; UPSERT_TIME="
+              + expectedLocalTime("2019-09-30 02:14:56")),
+          Pair.of(7788, "EMPNO=7788; ENAME=SCOTT; JOB=ANALYST; AGE=45; MGR=7566; "
+              + "HIREDATE=1987-04-19; SAL=3000.00; COMM=null; DEPTNO=20; EMAIL=scott@calcite; "
+              + "CREATE_DATETIME=2019-07-28 12:12:12; CREATE_TIME=12:12:12; UPSERT_TIME="
+              + expectedLocalTime("2019-07-28 12:12:12")),
+          Pair.of(7839, "EMPNO=7839; ENAME=KING; JOB=PRESIDENT; AGE=22; MGR=null; "
+              + "HIREDATE=1981-11-17; SAL=5000.00; COMM=null; DEPTNO=10; EMAIL=king@calcite; "
+              + "CREATE_DATETIME=2019-06-08 15:15:15; CREATE_TIME=null; UPSERT_TIME="
+              + expectedLocalTime("2019-06-08 15:15:15")),
+          Pair.of(7844, "EMPNO=7844; ENAME=TURNER; JOB=SALESMAN; AGE=54; MGR=7698; "
+              + "HIREDATE=1981-09-08; SAL=1500.00; COMM=0.00; DEPTNO=30; EMAIL=turner@calcite; "
+              + "CREATE_DATETIME=2017-08-17 22:01:37; CREATE_TIME=22:01:37; UPSERT_TIME="
+              + expectedLocalTime("2017-08-17 22:01:37")),
+          Pair.of(7876, "EMPNO=7876; ENAME=ADAMS; JOB=CLERK; AGE=35; MGR=7788; "
+              + "HIREDATE=1987-05-23; SAL=1100.00; COMM=null; DEPTNO=20; EMAIL=adams@calcite; "
+              + "CREATE_DATETIME=null; CREATE_TIME=23:11:06; UPSERT_TIME="
+              + expectedLocalTime("2017-08-18 23:11:06")),
+          Pair.of(7900, "EMPNO=7900; ENAME=JAMES; JOB=CLERK; AGE=40; MGR=7698; "
+              + "HIREDATE=1981-12-03; SAL=950.00; COMM=null; DEPTNO=30; EMAIL=james@calcite; "
+              + "CREATE_DATETIME=2020-01-02 12:19:00; CREATE_TIME=12:19:00; UPSERT_TIME="
+              + expectedLocalTime("2020-01-02 12:19:00")),
+          Pair.of(7902, "EMPNO=7902; ENAME=FORD; JOB=ANALYST; AGE=28; MGR=7566; "
+              + "HIREDATE=1981-12-03; SAL=3000.00; COMM=null; DEPTNO=20; EMAIL=ford@calcite; "
+              + "CREATE_DATETIME=2019-05-29 00:00:00; CREATE_TIME=null; UPSERT_TIME="
+              + expectedLocalTime("2019-05-29 00:00:00")),
+          Pair.of(7934, "EMPNO=7934; ENAME=MILLER; JOB=CLERK; AGE=32; MGR=7782; "
+              + "HIREDATE=1982-01-23; SAL=1300.00; COMM=null; DEPTNO=10; EMAIL=null; "
+              + "CREATE_DATETIME=2016-09-02 23:15:01; CREATE_TIME=23:15:01; UPSERT_TIME="
+              + expectedLocalTime("2016-09-02 23:15:01")));
 
   static List<Pair<Integer, String>> reversedRows = rows.stream()
       .sorted(Comparator.reverseOrder()).collect(toList());
diff --git a/kafka/src/main/java/org/apache/calcite/adapter/kafka/KafkaTableFactory.java b/kafka/src/main/java/org/apache/calcite/adapter/kafka/KafkaTableFactory.java
index 51441bd17f2..f6cbce53539 100644
--- a/kafka/src/main/java/org/apache/calcite/adapter/kafka/KafkaTableFactory.java
+++ b/kafka/src/main/java/org/apache/calcite/adapter/kafka/KafkaTableFactory.java
@@ -57,11 +57,12 @@ public KafkaTableFactory() {
       } catch (InstantiationException | InvocationTargetException
           | IllegalAccessException | ClassNotFoundException
           | NoSuchMethodException e) {
-        final String details = String.format(Locale.ROOT,
-            "Failed to create table '%s' with configuration:\n"
-                + "'%s'\n"
-                + "KafkaRowConverter '%s' is invalid",
-            name, operand, rowConverterClass);
+        final String details =
+            String.format(Locale.ROOT,
+                "Failed to create table '%s' with configuration:\n"
+                    + "'%s'\n"
+                    + "KafkaRowConverter '%s' is invalid",
+                name, operand, rowConverterClass);
         throw new RuntimeException(details, e);
       }
     } else {
@@ -82,12 +83,12 @@ public KafkaTableFactory() {
                 .newInstance(OffsetResetStrategy.NONE));
       } catch (ClassNotFoundException | NoSuchMethodException | IllegalAccessException
           | InstantiationException | InvocationTargetException e) {
-        final String details = String.format(
-            Locale.ROOT,
-            "Fail to create table '%s' with configuration:\n"
-                + "'%s'\n"
-                + "KafkaCustConsumer '%s' is invalid",
-            name, operand, custConsumerClass);
+        final String details =
+            String.format(Locale.ROOT,
+                "Fail to create table '%s' with configuration:\n"
+                    + "'%s'\n"
+                    + "KafkaCustConsumer '%s' is invalid",
+                name, operand, custConsumerClass);
         throw new RuntimeException(details, e);
       }
     }
diff --git a/linq4j/src/main/java/org/apache/calcite/linq4j/EnumerableDefaults.java b/linq4j/src/main/java/org/apache/calcite/linq4j/EnumerableDefaults.java
index 7febd11ddf7..025487cf341 100644
--- a/linq4j/src/main/java/org/apache/calcite/linq4j/EnumerableDefaults.java
+++ b/linq4j/src/main/java/org/apache/calcite/linq4j/EnumerableDefaults.java
@@ -1915,8 +1915,8 @@ private static <TSource, TInner, TKey> Enumerable<TSource> semiJoinWithPredicate
         // moment when we are sure
         // that it will be really needed, i.e. when the first outer
         // enumerator item is processed
-        final Supplier<Lookup<TKey, TInner>> innerLookup = Suppliers.memoize(
-            () ->
+        final Supplier<Lookup<TKey, TInner>> innerLookup =
+            Suppliers.memoize(() ->
                 comparer == null
                     ? inner.toLookup(innerKeySelector)
                     : inner.toLookup(innerKeySelector, comparer));
@@ -2656,8 +2656,8 @@ public static <TSource, TKey> Enumerable<TSource> orderBy(
         // must supply a comparator if the key does not extend Comparable.
         // Otherwise there will be a ClassCastException while retrieving.
         final Map<TKey, List<TSource>> map = new TreeMap<>(comparator);
-        final LookupImpl<TKey, TSource> lookup = toLookup_(map, source, keySelector,
-            Functions.identitySelector());
+        final LookupImpl<TKey, TSource> lookup =
+            toLookup_(map, source, keySelector, Functions.identitySelector());
         return lookup.valuesEnumerable().enumerator();
       }
     };
@@ -3533,9 +3533,11 @@ public static <TSource, TKey, TElement> Map<TKey, TElement> toMap(
       EqualityComparer<TKey> comparer) {
     // Use LinkedHashMap because groupJoin requires order of keys to be
     // preserved.
-    final Map<TKey, TElement> map = new WrapMap<>(
-        // Java 8 cannot infer return type with LinkedHashMap::new is used
-        () -> new LinkedHashMap<Wrapped<TKey>, TElement>(), comparer);
+    // Java 8 cannot infer return type with LinkedHashMap::new is used
+    @SuppressWarnings("Convert2MethodRef")
+    final Map<TKey, TElement> map =
+        new WrapMap<>(() -> new LinkedHashMap<Wrapped<TKey>, TElement>(),
+            comparer);
     try (Enumerator<TSource> os = source.enumerator()) {
       while (os.moveNext()) {
         TSource o = os.current();
@@ -4293,8 +4295,10 @@ private boolean advance() {
               if (!advanceLeft(left, leftKey)) {
                 done = true;
               }
-              results = new CartesianProductJoinEnumerator<>(resultSelector,
-                  Linq4j.enumerator(lefts), Linq4j.enumerator(Collections.singletonList(null)));
+              results =
+                  new CartesianProductJoinEnumerator<>(resultSelector,
+                      Linq4j.enumerator(lefts),
+                      Linq4j.enumerator(Collections.singletonList(null)));
               return true;
             }
             if (!getLeftEnumerator().moveNext()) {
@@ -4350,8 +4354,10 @@ private boolean advance() {
                   Linq4j.enumerator(rights));
         } else {
           // we must verify the non equi-join predicate, use nested loop join for that
-          results = nestedLoopJoin(Linq4j.asEnumerable(lefts), Linq4j.asEnumerable(rights),
-              extraPredicate, resultSelector, joinType).enumerator();
+          results =
+              nestedLoopJoin(Linq4j.asEnumerable(lefts),
+                  Linq4j.asEnumerable(rights), extraPredicate, resultSelector,
+                  joinType).enumerator();
         }
         return true;
       }
diff --git a/linq4j/src/main/java/org/apache/calcite/linq4j/LookupImpl.java b/linq4j/src/main/java/org/apache/calcite/linq4j/LookupImpl.java
index 2e1d125e091..de7dff1156b 100644
--- a/linq4j/src/main/java/org/apache/calcite/linq4j/LookupImpl.java
+++ b/linq4j/src/main/java/org/apache/calcite/linq4j/LookupImpl.java
@@ -51,8 +51,8 @@ class LookupImpl<K, V> extends AbstractEnumerable<Grouping<K, V>>
 
   @Override public Enumerator<Grouping<K, V>> enumerator() {
     return new Enumerator<Grouping<K, V>>() {
-      Enumerator<Entry<K, List<V>>> enumerator = Linq4j.enumerator(
-          map.entrySet());
+      Enumerator<Entry<K, List<V>>> enumerator =
+          Linq4j.enumerator(map.entrySet());
 
       @Override public Grouping<K, V> current() {
         final Entry<K, List<V>> keyAndList = enumerator.current();
diff --git a/linq4j/src/main/java/org/apache/calcite/linq4j/MergeUnionEnumerator.java b/linq4j/src/main/java/org/apache/calcite/linq4j/MergeUnionEnumerator.java
index 841c34fc066..7039fd98156 100644
--- a/linq4j/src/main/java/org/apache/calcite/linq4j/MergeUnionEnumerator.java
+++ b/linq4j/src/main/java/org/apache/calcite/linq4j/MergeUnionEnumerator.java
@@ -165,9 +165,9 @@ private int compare(TSource e1, TSource e2) {
             continue;
           }
 
-          final int comp = compare(
-              currentInputsValues[candidateIndex],
-              currentInputsValues[i]);
+          final int comp =
+              compare(currentInputsValues[candidateIndex],
+                  currentInputsValues[i]);
           if (comp > 0) {
             candidateIndex = i;
           }
diff --git a/linq4j/src/main/java/org/apache/calcite/linq4j/Nullness.java b/linq4j/src/main/java/org/apache/calcite/linq4j/Nullness.java
index dd87f0cc8d4..4ae66f400f6 100644
--- a/linq4j/src/main/java/org/apache/calcite/linq4j/Nullness.java
+++ b/linq4j/src/main/java/org/apache/calcite/linq4j/Nullness.java
@@ -74,6 +74,21 @@ private Nullness() {
     return (@NonNull T) ref;
   }
 
+  /**
+   * Allows you to treat an array of nullable values as an array of non-nullable
+   * values.
+   *
+   * @param <T>     Type of the array elements
+   * @param ts      Array
+   * @return the argument, cast so that elements are @NonNull
+   */
+  @Pure
+  public static <T> @NonNull T[] castNonNullArray(
+      @Nullable T[] ts) {
+    //noinspection ConstantConditions,unchecked
+    return (@NonNull T []) (Object) ts;
+  }
+
   /**
    * Allows you to treat an uninitialized or under-initialization object as
    * initialized with no assertions.
diff --git a/linq4j/src/main/java/org/apache/calcite/linq4j/tree/BlockBuilder.java b/linq4j/src/main/java/org/apache/calcite/linq4j/tree/BlockBuilder.java
index ea8bd7ac9d3..750d513db56 100644
--- a/linq4j/src/main/java/org/apache/calcite/linq4j/tree/BlockBuilder.java
+++ b/linq4j/src/main/java/org/apache/calcite/linq4j/tree/BlockBuilder.java
@@ -143,10 +143,10 @@ public Expression append(String name, BlockStatement block,
           if (declaration.initializer != null && isSafeForReuse(declaration)) {
             x = append(newName, declaration.initializer);
           } else {
-            ParameterExpression pe = Expressions.parameter(
-                declaration.parameter.type, newName);
-            DeclarationStatement newDeclaration = Expressions.declare(
-                declaration.modifiers, pe, declaration.initializer);
+            ParameterExpression pe =
+                Expressions.parameter(declaration.parameter.type, newName);
+            DeclarationStatement newDeclaration =
+                Expressions.declare(declaration.modifiers, pe, declaration.initializer);
             x = pe;
             add(newDeclaration);
           }
@@ -166,15 +166,17 @@ public Expression append(String name, BlockStatement block,
           result = ((DeclarationStatement) statement).parameter;
         } else if (statement instanceof GotoStatement) {
           statements.remove(statements.size() - 1);
-          result = append_(name,
-              requireNonNull(((GotoStatement) statement).expression, "expression"),
-              optimize);
+          final GotoStatement gotoStatement = (GotoStatement) statement;
+          result =
+              append_(name,
+                  requireNonNull(gotoStatement.expression, "expression"),
+                  optimize);
           if (isSimpleExpression(result)) {
             // already simple; no need to declare a variable or
             // even to evaluate the expression
           } else {
-            DeclarationStatement declare = Expressions.declare(Modifier.FINAL,
-                newName(name, optimize), result);
+            DeclarationStatement declare =
+                Expressions.declare(Modifier.FINAL, newName(name, optimize), result);
             add(declare);
             result = declare.parameter;
           }
@@ -236,8 +238,8 @@ private Expression append_(String name, Expression expression,
         return decl.parameter;
       }
     }
-    DeclarationStatement declare = Expressions.declare(Modifier.FINAL,
-        newName(name, optimize), expression);
+    DeclarationStatement declare =
+        Expressions.declare(Modifier.FINAL, newName(name, optimize), expression);
     add(declare);
     return declare.parameter;
   }
@@ -367,8 +369,7 @@ private boolean optimize(Shuttle optimizer, boolean performInline) {
     }
     final IdentityHashMap<ParameterExpression, Expression> subMap =
         new IdentityHashMap<>(useCounter.map.size());
-    final Shuttle visitor = new InlineVariableVisitor(
-        subMap);
+    final Shuttle visitor = new InlineVariableVisitor(subMap);
     final ArrayList<Statement> oldStatements = new ArrayList<>(statements);
     statements.clear();
 
diff --git a/linq4j/src/main/java/org/apache/calcite/linq4j/tree/BlockStatement.java b/linq4j/src/main/java/org/apache/calcite/linq4j/tree/BlockStatement.java
index 1bec4f4e250..02dc1d244dc 100644
--- a/linq4j/src/main/java/org/apache/calcite/linq4j/tree/BlockStatement.java
+++ b/linq4j/src/main/java/org/apache/calcite/linq4j/tree/BlockStatement.java
@@ -43,8 +43,7 @@ public class BlockStatement extends Statement {
 
   private boolean distinctVariables(
       @UnderInitialization(BlockStatement.class) BlockStatement this,
-      boolean fail
-  ) {
+      boolean fail) {
     Set<String> names = new HashSet<>();
     for (Statement statement : statements) {
       if (statement instanceof DeclarationStatement) {
@@ -60,8 +59,8 @@ private boolean distinctVariables(
 
   @Override public BlockStatement accept(Shuttle shuttle) {
     shuttle = shuttle.preVisit(this);
-    List<Statement> newStatements = Expressions.acceptStatements(statements,
-        shuttle);
+    List<Statement> newStatements =
+        Expressions.acceptStatements(statements, shuttle);
     return shuttle.visit(this, newStatements);
   }
 
diff --git a/linq4j/src/main/java/org/apache/calcite/linq4j/tree/ClassDeclarationFinder.java b/linq4j/src/main/java/org/apache/calcite/linq4j/tree/ClassDeclarationFinder.java
index fe1a4554d3d..bb0d93b013d 100644
--- a/linq4j/src/main/java/org/apache/calcite/linq4j/tree/ClassDeclarationFinder.java
+++ b/linq4j/src/main/java/org/apache/calcite/linq4j/tree/ClassDeclarationFinder.java
@@ -161,8 +161,7 @@ protected ClassDeclarationFinder(ClassDeclarationFinder parent) {
     } else if (memberDeclarations != null) {
       // Arguments to new Test(1+2) { ... } should be optimized via parent
       // optimizer.
-      arguments = Expressions.acceptExpressions(newExpression.arguments,
-          parent);
+      arguments = Expressions.acceptExpressions(newExpression.arguments, parent);
     }
 
     Expression result =
diff --git a/linq4j/src/main/java/org/apache/calcite/linq4j/tree/Expressions.java b/linq4j/src/main/java/org/apache/calcite/linq4j/tree/Expressions.java
index 3389f9d91a4..9204ef047d5 100644
--- a/linq4j/src/main/java/org/apache/calcite/linq4j/tree/Expressions.java
+++ b/linq4j/src/main/java/org/apache/calcite/linq4j/tree/Expressions.java
@@ -445,8 +445,9 @@ public static MethodCallExpression call(Expression target, String methodName,
    */
   public static MethodCallExpression call(Type type, String methodName,
       Iterable<? extends Expression> arguments) {
-    Method method = Types.lookupMethod(Types.toClass(type), methodName,
-        Types.toClassArray(arguments));
+    Method method =
+        Types.lookupMethod(Types.toClass(type), methodName,
+            Types.toClassArray(arguments));
     return new MethodCallExpression(method, null, toList(arguments));
   }
 
diff --git a/linq4j/src/main/java/org/apache/calcite/linq4j/tree/FunctionExpression.java b/linq4j/src/main/java/org/apache/calcite/linq4j/tree/FunctionExpression.java
index c8d22b2a9c8..362e7fc8432 100644
--- a/linq4j/src/main/java/org/apache/calcite/linq4j/tree/FunctionExpression.java
+++ b/linq4j/src/main/java/org/apache/calcite/linq4j/tree/FunctionExpression.java
@@ -97,10 +97,12 @@ public F getFunction() {
     if (dynamicFunction == null) {
       final Invokable x = compile();
 
-      ClassLoader classLoader = requireNonNull(requireNonNull(getClass().getClassLoader()));
+      ClassLoader classLoader = requireNonNull(getClass().getClassLoader());
       //noinspection unchecked
-      dynamicFunction = (F) Proxy.newProxyInstance(classLoader,
-          new Class[]{Types.toClass(type)}, (proxy, method, args) -> x.dynamicInvoke(args));
+      dynamicFunction =
+          (F) Proxy.newProxyInstance(classLoader,
+              new Class[]{Types.toClass(type)},
+              (proxy, method, args) -> x.dynamicInvoke(args));
     }
     return dynamicFunction;
   }
diff --git a/linq4j/src/main/java/org/apache/calcite/linq4j/tree/IndexExpression.java b/linq4j/src/main/java/org/apache/calcite/linq4j/tree/IndexExpression.java
index c66221e1e45..f94047d5b06 100644
--- a/linq4j/src/main/java/org/apache/calcite/linq4j/tree/IndexExpression.java
+++ b/linq4j/src/main/java/org/apache/calcite/linq4j/tree/IndexExpression.java
@@ -44,8 +44,8 @@ public IndexExpression(Expression array, List<Expression> indexExpressions) {
   @Override public Expression accept(Shuttle shuttle) {
     shuttle = shuttle.preVisit(this);
     Expression array = this.array.accept(shuttle);
-    List<Expression> indexExpressions = Expressions.acceptExpressions(
-        this.indexExpressions, shuttle);
+    List<Expression> indexExpressions =
+        Expressions.acceptExpressions(this.indexExpressions, shuttle);
     return shuttle.visit(this, array, indexExpressions);
   }
 
diff --git a/linq4j/src/main/java/org/apache/calcite/linq4j/tree/MethodCallExpression.java b/linq4j/src/main/java/org/apache/calcite/linq4j/tree/MethodCallExpression.java
index f9b46af1cdc..12eddc67866 100644
--- a/linq4j/src/main/java/org/apache/calcite/linq4j/tree/MethodCallExpression.java
+++ b/linq4j/src/main/java/org/apache/calcite/linq4j/tree/MethodCallExpression.java
@@ -59,8 +59,8 @@ public class MethodCallExpression extends Expression {
         this.targetExpression == null
             ? null
             : this.targetExpression.accept(shuttle);
-    List<Expression> expressions = Expressions.acceptExpressions(
-        this.expressions, shuttle);
+    List<Expression> expressions =
+        Expressions.acceptExpressions(this.expressions, shuttle);
     return shuttle.visit(this, targetExpression, expressions);
   }
 
diff --git a/linq4j/src/main/java/org/apache/calcite/linq4j/tree/NewExpression.java b/linq4j/src/main/java/org/apache/calcite/linq4j/tree/NewExpression.java
index e1ed9d1fa20..f2d343ecdd3 100644
--- a/linq4j/src/main/java/org/apache/calcite/linq4j/tree/NewExpression.java
+++ b/linq4j/src/main/java/org/apache/calcite/linq4j/tree/NewExpression.java
@@ -46,8 +46,8 @@ public NewExpression(Type type, List<Expression> arguments,
 
   @Override public Expression accept(Shuttle shuttle) {
     shuttle = shuttle.preVisit(this);
-    final List<Expression> arguments = Expressions.acceptExpressions(
-        this.arguments, shuttle);
+    final List<Expression> arguments =
+        Expressions.acceptExpressions(this.arguments, shuttle);
     final List<MemberDeclaration> memberDeclarations =
         this.memberDeclarations == null
             ? null
@@ -99,8 +99,8 @@ public NewExpression(Type type, List<Expression> arguments,
   @Override public int hashCode() {
     int result = hash;
     if (result == 0) {
-      result = Objects.hash(nodeType, super.type, type, arguments,
-          memberDeclarations);
+      result =
+          Objects.hash(nodeType, super.type, type, arguments, memberDeclarations);
       if (result == 0) {
         result = 1;
       }
diff --git a/linq4j/src/main/java/org/apache/calcite/linq4j/tree/OptimizeShuttle.java b/linq4j/src/main/java/org/apache/calcite/linq4j/tree/OptimizeShuttle.java
index d81fc5085b9..ec902e64810 100644
--- a/linq4j/src/main/java/org/apache/calcite/linq4j/tree/OptimizeShuttle.java
+++ b/linq4j/src/main/java/org/apache/calcite/linq4j/tree/OptimizeShuttle.java
@@ -194,12 +194,14 @@ && eq(cmp.expression1, expression2)) {
         Expression expr = null;
         if (eq(ternary.expression1, expression1)) {
           // (a ? b : c) == b === a || c == b
-          expr = Expressions.orElse(ternary.expression0,
-              Expressions.equal(ternary.expression2, expression1));
+          expr =
+              Expressions.orElse(ternary.expression0,
+                  Expressions.equal(ternary.expression2, expression1));
         } else if (eq(ternary.expression2, expression1)) {
           // (a ? b : c) == c === !a || b == c
-          expr = Expressions.orElse(Expressions.not(ternary.expression0),
-              Expressions.equal(ternary.expression1, expression1));
+          expr =
+              Expressions.orElse(Expressions.not(ternary.expression0),
+                  Expressions.equal(ternary.expression1, expression1));
         }
         if (expr != null) {
           if (binary.getNodeType() == ExpressionType.NotEqual) {
diff --git a/linq4j/src/main/java/org/apache/calcite/linq4j/tree/TableExpressionFactory.java b/linq4j/src/main/java/org/apache/calcite/linq4j/tree/TableExpressionFactory.java
new file mode 100644
index 00000000000..e3ea73da8a3
--- /dev/null
+++ b/linq4j/src/main/java/org/apache/calcite/linq4j/tree/TableExpressionFactory.java
@@ -0,0 +1,33 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.linq4j.tree;
+
+/**
+ * Factory for creating table expressions that may be used in generated code
+ * for accessing table data.
+ */
+public interface TableExpressionFactory {
+
+  /**
+   * Creates {@link Expression} to be used in generated code for accessing table data.
+   *
+   * @param clazz Class that provides specific methods for accessing table data.
+   *
+   * @return {@link Expression} instance
+   */
+  Expression create(Class clazz);
+}
diff --git a/linq4j/src/test/java/org/apache/calcite/linq4j/test/BlockBuilderTest.java b/linq4j/src/test/java/org/apache/calcite/linq4j/test/BlockBuilderTest.java
index b12aeba6d1f..95ff073f457 100644
--- a/linq4j/src/test/java/org/apache/calcite/linq4j/test/BlockBuilderTest.java
+++ b/linq4j/src/test/java/org/apache/calcite/linq4j/test/BlockBuilderTest.java
@@ -112,8 +112,9 @@ private BlockBuilder appendBlockWithSameVariable(
   }
 
   @Test void testRenameVariablesWithInitializer() {
-    BlockBuilder outer = appendBlockWithSameVariable(
-        Expressions.constant(7), Expressions.constant(8));
+    BlockBuilder outer =
+        appendBlockWithSameVariable(Expressions.constant(7),
+            Expressions.constant(8));
 
     assertEquals("{\n"
             + "  int x = 7;\n"
diff --git a/linq4j/src/test/java/org/apache/calcite/linq4j/test/DeterministicTest.java b/linq4j/src/test/java/org/apache/calcite/linq4j/test/DeterministicTest.java
index 3d5dd51de30..1ec9de8a608 100644
--- a/linq4j/src/test/java/org/apache/calcite/linq4j/test/DeterministicTest.java
+++ b/linq4j/src/test/java/org/apache/calcite/linq4j/test/DeterministicTest.java
@@ -114,8 +114,7 @@ private boolean isConstant(Expression e) {
     assertThat(isAtomic(e), is(false));
     assertThat(isConstant(e), is(true));
 
-    e = Expressions.call(
-        Integer.class, "valueOf", Expressions.constant(0));
+    e = Expressions.call(Integer.class, "valueOf", Expressions.constant(0));
     assertThat(isAtomic(e), is(false));
     assertThat(isConstant(e), is(true));
 
diff --git a/linq4j/src/test/java/org/apache/calcite/linq4j/test/ExpressionTest.java b/linq4j/src/test/java/org/apache/calcite/linq4j/test/ExpressionTest.java
index e5fe9df5dc2..a616334cfa1 100644
--- a/linq4j/src/test/java/org/apache/calcite/linq4j/test/ExpressionTest.java
+++ b/linq4j/src/test/java/org/apache/calcite/linq4j/test/ExpressionTest.java
@@ -61,6 +61,7 @@
 import static org.apache.calcite.linq4j.test.BlockBuilderBase.TWO;
 
 import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.hasToString;
 import static org.hamcrest.core.Is.is;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
@@ -77,11 +78,10 @@ public class ExpressionTest {
 
     // This expression represents a lambda expression
     // that adds 1 to the parameter value.
-    FunctionExpression lambdaExpr = Expressions.lambda(
-        Expressions.add(
-            paramExpr,
-            Expressions.constant(2)),
-        Arrays.asList(paramExpr));
+    FunctionExpression lambdaExpr =
+        Expressions.lambda(
+            Expressions.add(paramExpr, Expressions.constant(2)),
+            Arrays.asList(paramExpr));
 
     // Print out the expression.
     String s = Expressions.toString(lambdaExpr);
@@ -120,11 +120,10 @@ public class ExpressionTest {
     // This expression represents a lambda expression
     // that adds 1 to the parameter value.
     Short a = 2;
-    FunctionExpression lambdaExpr = Expressions.lambda(
-        Expressions.add(
-            paramExpr,
-            Expressions.constant(a)),
-        Arrays.asList(paramExpr));
+    FunctionExpression lambdaExpr =
+        Expressions.lambda(
+            Expressions.add(paramExpr, Expressions.constant(a)),
+            Arrays.asList(paramExpr));
 
     // Print out the expression.
     String s = Expressions.toString(lambdaExpr);
@@ -163,11 +162,10 @@ public class ExpressionTest {
 
     // This expression represents a lambda expression
     // that adds 1 to the parameter value.
-    FunctionExpression lambdaExpr = Expressions.lambda(
-        Expressions.add(
-            paramExpr,
-            Expressions.constant(Byte.valueOf("2"))),
-        Arrays.asList(paramExpr));
+    FunctionExpression lambdaExpr =
+        Expressions.lambda(
+            Expressions.add(paramExpr, Expressions.constant(Byte.valueOf("2"))),
+            Arrays.asList(paramExpr));
 
     // Print out the expression.
     String s = Expressions.toString(lambdaExpr);
@@ -205,11 +203,10 @@ public class ExpressionTest {
 
     // This expression represents a lambda expression
     // that adds 1 to the parameter value.
-    FunctionExpression lambdaExpr = Expressions.lambda(
-        Expressions.add(
-            paramExpr,
-            Expressions.constant(2d)),
-        Arrays.asList(paramExpr));
+    FunctionExpression lambdaExpr =
+        Expressions.lambda(
+            Expressions.add(paramExpr, Expressions.constant(2d)),
+            Arrays.asList(paramExpr));
 
     // Print out the expression.
     String s = Expressions.toString(lambdaExpr);
@@ -247,11 +244,10 @@ public class ExpressionTest {
 
     // This expression represents a lambda expression
     // that adds 1L to the parameter value.
-    FunctionExpression lambdaExpr = Expressions.lambda(
-        Expressions.add(
-            paramExpr,
-            Expressions.constant(2L)),
-        Arrays.asList(paramExpr));
+    FunctionExpression lambdaExpr =
+        Expressions.lambda(
+            Expressions.add(paramExpr, Expressions.constant(2L)),
+            Arrays.asList(paramExpr));
     // Print out the expression.
     String s = Expressions.toString(lambdaExpr);
     assertEquals(
@@ -288,11 +284,10 @@ public class ExpressionTest {
 
     // This expression represents a lambda expression
     // that adds 1f to the parameter value.
-    FunctionExpression lambdaExpr = Expressions.lambda(
-        Expressions.add(
-            paramExpr,
-            Expressions.constant(2.0f)),
-        Arrays.asList(paramExpr));
+    FunctionExpression lambdaExpr =
+        Expressions.lambda(
+            Expressions.add(paramExpr, Expressions.constant(2.0f)),
+            Arrays.asList(paramExpr));
     // Print out the expression.
     String s = Expressions.toString(lambdaExpr);
     assertEquals(
@@ -329,11 +324,10 @@ public class ExpressionTest {
 
     // This expression represents a lambda expression
     // that adds (int)10 to the parameter value.
-    FunctionExpression lambdaExpr = Expressions.lambda(
-        Expressions.add(
-            paramExpr,
-            Expressions.constant(10)),
-        Arrays.asList(paramExpr));
+    FunctionExpression lambdaExpr =
+        Expressions.lambda(
+            Expressions.add(paramExpr, Expressions.constant(10)),
+            Arrays.asList(paramExpr));
     // Print out the expression.
     String s = Expressions.toString(lambdaExpr);
     assertEquals(
@@ -370,11 +364,10 @@ public class ExpressionTest {
 
     // This expression represents a lambda expression
     // that adds 10.1d to the parameter value.
-    FunctionExpression lambdaExpr = Expressions.lambda(
-        Expressions.add(
-            paramExpr,
-            Expressions.constant(10.1d)),
-        Arrays.asList(paramExpr));
+    FunctionExpression lambdaExpr =
+        Expressions.lambda(
+            Expressions.add(paramExpr, Expressions.constant(10.1d)),
+            Arrays.asList(paramExpr));
     // Print out the expression.
     String s = Expressions.toString(lambdaExpr);
     assertEquals(
@@ -411,12 +404,11 @@ public class ExpressionTest {
     ParameterExpression param2Expr =
         Expressions.parameter(int.class, "key2");
 
-    FunctionExpression lambdaExpr = Expressions.lambda(
-        Expressions.block(
-            (Type) null,
-            Expressions.return_(
-                null, paramExpr)),
-        Arrays.asList(paramExpr, param2Expr));
+    FunctionExpression lambdaExpr =
+        Expressions.lambda(
+            Expressions.block((Type) null,
+                Expressions.return_(null, paramExpr)),
+            Arrays.asList(paramExpr, param2Expr));
 
     // Print out the expression.
     String s = Expressions.toString(lambdaExpr);
@@ -989,33 +981,24 @@ public class ExpressionTest {
   }
 
   @Test void testWriteWhile() {
-    DeclarationStatement xDecl;
-    DeclarationStatement yDecl;
+    DeclarationStatement xDecl =
+        Expressions.declare(0, "x", Expressions.constant(10));
+    DeclarationStatement yDecl =
+        Expressions.declare(0, "y", Expressions.constant(0));
     Node node =
-        Expressions.block(
-            xDecl = Expressions.declare(
-                0,
-                "x",
-                Expressions.constant(10)),
-            yDecl = Expressions.declare(
-                0,
-                "y",
-                Expressions.constant(0)),
+        Expressions.block(xDecl, yDecl,
             Expressions.while_(
-                Expressions.lessThan(
-                    xDecl.parameter,
-                    Expressions.constant(5)),
+                Expressions.lessThan(xDecl.parameter, Expressions.constant(5)),
                 Expressions.statement(
                     Expressions.preIncrementAssign(yDecl.parameter))));
-    assertEquals(
-        "{\n"
-            + "  int x = 10;\n"
-            + "  int y = 0;\n"
-            + "  while (x < 5) {\n"
-            + "    ++y;\n"
-            + "  }\n"
-            + "}\n",
-        Expressions.toString(node));
+    assertThat(node,
+        hasToString("{\n"
+                + "  int x = 10;\n"
+                + "  int y = 0;\n"
+                + "  while (x < 5) {\n"
+                + "    ++y;\n"
+                + "  }\n"
+                + "}\n"));
   }
 
   @Test void testWriteTryCatchFinally() {
@@ -1300,8 +1283,8 @@ public void checkBlockBuilder(boolean optimizing, String expected) {
   }
 
   @Test void testConstantExpression() {
-    final Expression constant = Expressions.constant(
-        new Object[] {
+    final Expression constant =
+        Expressions.constant(new Object[] {
             1,
             new Object[] {
                 (byte) 1, (short) 2, (int) 3, (long) 4,
@@ -1443,43 +1426,39 @@ public void checkBlockBuilder(boolean optimizing, String expected) {
   @Test void testSubExpressionElimination() {
     final BlockBuilder builder = new BlockBuilder(true);
     ParameterExpression x = Expressions.parameter(Object.class, "p");
-    Expression current4 = builder.append(
-        "current4",
-        Expressions.convert_(x, Object[].class));
-    Expression v = builder.append(
-        "v",
-        Expressions.convert_(
-            Expressions.arrayIndex(
-                current4,
-                Expressions.constant(4)), Short.class));
-    Expression v0 = builder.append(
-        "v0",
-        Expressions.convert_(v, Number.class));
-    Expression v1 = builder.append(
-        "v1",
-        Expressions.convert_(
-            Expressions.arrayIndex(
-                current4,
-                Expressions.constant(4)), Short.class));
-    Expression v2 = builder.append(
-        "v2",
-        Expressions.convert_(v, Number.class));
-    Expression v3 = builder.append(
-        "v3",
+    Expression current4 =
+        builder.append("current4",
+            Expressions.convert_(x, Object[].class));
+    Expression v =
+        builder.append("v",
+            Expressions.convert_(
+                Expressions.arrayIndex(current4, Expressions.constant(4)),
+                Short.class));
+    Expression v0 =
+        builder.append("v0",
+            Expressions.convert_(v, Number.class));
+    Expression v1 =
+        builder.append("v1",
+            Expressions.convert_(
+                Expressions.arrayIndex(current4, Expressions.constant(4)),
+                Short.class));
+    Expression v2 =
+        builder.append("v2", Expressions.convert_(v, Number.class));
+    Expression v3 =
+        builder.append("v3",
         Expressions.convert_(
-            Expressions.arrayIndex(
-                current4,
-                Expressions.constant(4)), Short.class));
-    Expression v4 = builder.append(
-        "v4",
-        Expressions.convert_(v3, Number.class));
+            Expressions.arrayIndex(current4, Expressions.constant(4)),
+            Short.class));
+    Expression v4 =
+        builder.append("v4",
+            Expressions.convert_(v3, Number.class));
     Expression v5 = builder.append("v5", Expressions.call(v4, "intValue"));
-    Expression v6 = builder.append(
-        "v6",
-        Expressions.condition(
-            Expressions.equal(v2, Expressions.constant(null)),
-            Expressions.constant(null),
-            Expressions.equal(v5, Expressions.constant(1997))));
+    Expression v6 =
+        builder.append("v6",
+            Expressions.condition(
+                Expressions.equal(v2, Expressions.constant(null)),
+                Expressions.constant(null),
+                Expressions.equal(v5, Expressions.constant(1997))));
     builder.add(Expressions.return_(null, v6));
     assertEquals(
         "{\n"
diff --git a/linq4j/src/test/java/org/apache/calcite/linq4j/test/InlinerTest.java b/linq4j/src/test/java/org/apache/calcite/linq4j/test/InlinerTest.java
index 96eb5f57e54..737baae681f 100644
--- a/linq4j/src/test/java/org/apache/calcite/linq4j/test/InlinerTest.java
+++ b/linq4j/src/test/java/org/apache/calcite/linq4j/test/InlinerTest.java
@@ -50,8 +50,8 @@ public void prepareBuilder() {
   }
 
   @Test void testInlineSingleUsage() {
-    DeclarationStatement decl = Expressions.declare(16, "x",
-        Expressions.add(ONE, TWO));
+    DeclarationStatement decl =
+        Expressions.declare(16, "x", Expressions.add(ONE, TWO));
     b.add(decl);
     b.add(Expressions.return_(null, decl.parameter));
     assertEquals("{\n  return 1 + 2;\n}\n", b.toBlock().toString());
@@ -79,14 +79,13 @@ public void prepareBuilder() {
   @Test void testNoInlineMultipleUsage() {
     ParameterExpression p1 = Expressions.parameter(int.class, "p1");
     ParameterExpression p2 = Expressions.parameter(int.class, "p2");
-    DeclarationStatement decl = Expressions.declare(16, "x",
-        Expressions.subtract(p1, p2));
+    DeclarationStatement decl =
+        Expressions.declare(16, "x", Expressions.subtract(p1, p2));
     b.add(decl);
     b.add(
         Expressions.return_(null,
             Expressions.add(decl.parameter, decl.parameter)));
-    assertEquals(
-        "{\n"
+    assertEquals("{\n"
             + "  final int x = p1 - p2;\n"
             + "  return x + x;\n"
             + "}\n",
@@ -101,16 +100,16 @@ public void prepareBuilder() {
 
     builder.add(Expressions.declare(0, t, null));
 
-    Expression v = builder.append("v",
-        Expressions.makeTernary(ExpressionType.Conditional,
-            Expressions.makeBinary(ExpressionType.NotEqual,
-                Expressions.assign(t, Expressions.constant(1)),
-                Expressions.parameter(int.class, "a")),
-            t,
-            Expressions.parameter(int.class, "c")));
+    Expression v =
+        builder.append("v",
+            Expressions.makeTernary(ExpressionType.Conditional,
+                Expressions.makeBinary(ExpressionType.NotEqual,
+                    Expressions.assign(t, Expressions.constant(1)),
+                    Expressions.parameter(int.class, "a")),
+                t,
+                Expressions.parameter(int.class, "c")));
     builder.add(Expressions.return_(null, v));
-    assertEquals(
-        "{\n"
+    assertEquals("{\n"
             + "  int t;\n"
             + "  return (t = 1) != a ? t : c;\n"
             + "}\n",
@@ -141,13 +140,14 @@ void checkAssignInConditionOptimizedOut(int modifiers, String s) {
 
     builder.add(Expressions.declare(modifiers, t, null));
 
-    Expression v = builder.append("v",
-        Expressions.makeTernary(ExpressionType.Conditional,
-            Expressions.makeBinary(ExpressionType.NotEqual,
-                Expressions.assign(t, Expressions.constant(1)),
-                Expressions.parameter(int.class, "a")),
-            Expressions.parameter(int.class, "b"),
-            Expressions.parameter(int.class, "c")));
+    Expression v =
+        builder.append("v",
+            Expressions.makeTernary(ExpressionType.Conditional,
+                Expressions.makeBinary(ExpressionType.NotEqual,
+                    Expressions.assign(t, Expressions.constant(1)),
+                    Expressions.parameter(int.class, "a")),
+                Expressions.parameter(int.class, "b"),
+                Expressions.parameter(int.class, "c")));
     builder.add(Expressions.return_(null, v));
     assertThat(Expressions.toString(builder.toBlock()),
         CoreMatchers.equalTo(s));
@@ -161,16 +161,16 @@ void checkAssignInConditionOptimizedOut(int modifiers, String s) {
 
     builder.add(Expressions.declare(0, t, TWO));
 
-    Expression v = builder.append("v",
-        Expressions.makeTernary(ExpressionType.Conditional,
-            Expressions.makeBinary(ExpressionType.NotEqual,
-                Expressions.assign(t, Expressions.constant(1)),
-                Expressions.parameter(int.class, "a")),
-            t,
-            Expressions.parameter(int.class, "c")));
+    Expression v =
+        builder.append("v",
+            Expressions.makeTernary(ExpressionType.Conditional,
+                Expressions.makeBinary(ExpressionType.NotEqual,
+                    Expressions.assign(t, Expressions.constant(1)),
+                    Expressions.parameter(int.class, "a")),
+                t,
+                Expressions.parameter(int.class, "c")));
     builder.add(Expressions.return_(null, v));
-    assertEquals(
-        "{\n"
+    assertEquals("{\n"
             + "  int t = 2;\n"
             + "  return (t = 1) != a ? t : c;\n"
             + "}\n",
@@ -186,12 +186,12 @@ void checkAssignInConditionOptimizedOut(int modifiers, String s) {
     final ParameterExpression v = Expressions.parameter(int.class, "v");
 
     Expression t = builder.append("t", Expressions.add(u, v));
-    Expression b = builder.append("b",
-        Expressions.condition(Expressions.greaterThan(t, ONE), TRUE, TRUE));
+    Expression b =
+        builder.append("b",
+            Expressions.condition(Expressions.greaterThan(t, ONE), TRUE, TRUE));
 
     builder.add(Expressions.return_(null, Expressions.condition(b, t, TWO)));
-    assertEquals(
-        "{\n"
+    assertEquals("{\n"
             + "  return u + v;\n"
             + "}\n",
         Expressions.toString(builder.toBlock()));
@@ -203,15 +203,15 @@ void checkAssignInConditionOptimizedOut(int modifiers, String s) {
     builder.add(Expressions.declare(Modifier.FINAL, t, ONE));
     final ParameterExpression u = Expressions.parameter(int.class, "u");
     builder.add(Expressions.declare(Modifier.FINAL, u, null));
-    Statement st = Expressions.statement(
-        Expressions.assign(u,
-            Expressions.makeBinary(ExpressionType.Add, t, TWO)));
+    Statement st =
+        Expressions.statement(
+            Expressions.assign(u,
+                Expressions.makeBinary(ExpressionType.Add, t, TWO)));
     ParameterExpression e = Expressions.parameter(0, Exception.class, "e");
     CatchBlock cb = Expressions.catch_(e, Expressions.throw_(e));
     builder.add(Expressions.tryCatch(st, cb));
     builder.add(Expressions.return_(null, u));
-    assertEquals(
-        "{\n"
+    assertEquals("{\n"
             + "  final int u;\n"
             + "  try {\n"
             + "    u = 1 + 2;\n"
diff --git a/linq4j/src/test/java/org/apache/calcite/linq4j/test/JoinPreserveOrderTest.java b/linq4j/src/test/java/org/apache/calcite/linq4j/test/JoinPreserveOrderTest.java
index 5dc2171cff8..d58e2e556ca 100644
--- a/linq4j/src/test/java/org/apache/calcite/linq4j/test/JoinPreserveOrderTest.java
+++ b/linq4j/src/test/java/org/apache/calcite/linq4j/test/JoinPreserveOrderTest.java
@@ -106,15 +106,15 @@ private interface JoinAlgorithm<L, R, Result> {
   public static Stream<Arguments> data() {
     List<Arguments> data = new ArrayList<>();
     List<String> empOrderColNames = Arrays.asList("name", "deptno", "eid");
-    List<Function1<Employee, Comparable>> empOrderColSelectors = Arrays.asList(
-        Employee::getName,
-        Employee::getDeptno,
-        Employee::getEid);
+    List<Function1<Employee, Comparable>> empOrderColSelectors =
+        Arrays.asList(Employee::getName,
+            Employee::getDeptno,
+            Employee::getEid);
     List<String> deptOrderColNames = Arrays.asList("name", "deptno", "did");
-    List<Function1<Department, Comparable>> deptOrderColSelectors = Arrays.asList(
-        Department::getName,
-        Department::getDeptno,
-        Department::getDid);
+    List<Function1<Department, Comparable>> deptOrderColSelectors =
+        Arrays.asList(Department::getName,
+            Department::getDeptno,
+            Department::getDid);
     List<Boolean> trueFalse = Arrays.asList(true, false);
     for (int i = 0; i < empOrderColNames.size(); i++) {
       for (Boolean ascendingL : trueFalse) {
@@ -123,16 +123,16 @@ public static Stream<Arguments> data() {
             for (Boolean nullsFirstR : trueFalse) {
               for (Boolean ascendingR : trueFalse) {
                 Object[] params = new Object[2];
-                params[0] = new Field<>(
-                    empOrderColNames.get(i),
-                    empOrderColSelectors.get(i),
-                    ascendingL,
-                    nullsFirstL);
-                params[1] = new Field<>(
-                    deptOrderColNames.get(j),
-                    deptOrderColSelectors.get(j),
-                    ascendingR,
-                    nullsFirstR);
+                params[0] =
+                    new Field<>(empOrderColNames.get(i),
+                        empOrderColSelectors.get(i),
+                        ascendingL,
+                        nullsFirstL);
+                params[1] =
+                    new Field<>(deptOrderColNames.get(j),
+                        deptOrderColSelectors.get(j),
+                        ascendingR,
+                        nullsFirstR);
                 data.add(Arguments.of(params[0], params[1]));
               }
             }
diff --git a/linq4j/src/test/java/org/apache/calcite/linq4j/test/LimitSortTest.java b/linq4j/src/test/java/org/apache/calcite/linq4j/test/LimitSortTest.java
index 6b04c612b0f..ac8d92cb21b 100644
--- a/linq4j/src/test/java/org/apache/calcite/linq4j/test/LimitSortTest.java
+++ b/linq4j/src/test/java/org/apache/calcite/linq4j/test/LimitSortTest.java
@@ -83,12 +83,11 @@ private void randomizedTest(final long seed) {
     int offset = Math.max(0, (int) (tmp - .1 * tmp));
 
     Comparator<String> cmp = Comparator.<String>naturalOrder()::compare;
-    Enumerable<Row> ordered = EnumerableDefaults.orderBy(
-        this.enumerable(seed),
-        s -> s.key,
-        cmp,
-        offset, fetch
-    );
+    Enumerable<Row> ordered =
+        EnumerableDefaults.orderBy(this.enumerable(seed),
+            s -> s.key,
+            cmp,
+            offset, fetch);
 
     List<Row> result = ordered.toList();
     assertTrue(
diff --git a/linq4j/src/test/java/org/apache/calcite/linq4j/test/Linq4jTest.java b/linq4j/src/test/java/org/apache/calcite/linq4j/test/Linq4jTest.java
index 99176b0c20d..0e8bf5669d5 100644
--- a/linq4j/src/test/java/org/apache/calcite/linq4j/test/Linq4jTest.java
+++ b/linq4j/src/test/java/org/apache/calcite/linq4j/test/Linq4jTest.java
@@ -1517,11 +1517,11 @@ public boolean apply(Department v1, Integer v2) {
   }
 
   @Test void testList0() {
-    final List<Employee> employees = Arrays.asList(
-        new Employee(100, "Fred", 10),
-        new Employee(110, "Bill", 30),
-        new Employee(120, "Eric", 10),
-        new Employee(130, "Janet", 10));
+    final List<Employee> employees =
+        Arrays.asList(new Employee(100, "Fred", 10),
+            new Employee(110, "Bill", 30),
+            new Employee(120, "Eric", 10),
+            new Employee(130, "Janet", 10));
     final List<Employee> result = new ArrayList<>();
     Linq4j.asEnumerable(employees)
         .where(e -> e.name.contains("e"))
@@ -1532,11 +1532,11 @@ public boolean apply(Department v1, Integer v2) {
   }
 
   @Test void testList() {
-    final List<Employee> employees = Arrays.asList(
-        new Employee(100, "Fred", 10),
-        new Employee(110, "Bill", 30),
-        new Employee(120, "Eric", 10),
-        new Employee(130, "Janet", 10));
+    final List<Employee> employees =
+        Arrays.asList(new Employee(100, "Fred", 10),
+            new Employee(110, "Bill", 30),
+            new Employee(120, "Eric", 10),
+            new Employee(130, "Janet", 10));
     final Map<Employee, Department> empDepts = new HashMap<>();
     for (Employee employee : employees) {
       empDepts.put(employee, depts[(employee.deptno - 10) / 10]);
@@ -1780,12 +1780,18 @@ public boolean apply(Department v1, Integer v2) {
   }
 
   @Test void testSequenceEqual() {
-    final Enumerable<String> enumerable1 = Linq4j.asEnumerable(
-        Collections.unmodifiableCollection(Arrays.asList("ming", "foo", "bar")));
-    final Enumerable<String> enumerable2 = Linq4j.asEnumerable(
-        Collections.unmodifiableCollection(Arrays.asList("ming", "foo", "bar")));
+    final Enumerable<String> enumerable1 =
+        Linq4j.asEnumerable(
+            Collections.unmodifiableCollection(
+                Arrays.asList("ming", "foo", "bar")));
+    final Enumerable<String> enumerable2 =
+        Linq4j.asEnumerable(
+            Collections.unmodifiableCollection(
+                Arrays.asList("ming", "foo", "bar")));
     assertTrue(enumerable1.sequenceEqual(enumerable2));
-    assertFalse(enumerable1.sequenceEqual(Linq4j.asEnumerable(new String[]{"ming", "foo", "far"})));
+    assertFalse(
+        enumerable1.sequenceEqual(
+            Linq4j.asEnumerable(new String[]{"ming", "foo", "far"})));
 
     try {
       EnumerableDefaults.sequenceEqual(null, enumerable2);
@@ -1807,10 +1813,10 @@ public boolean apply(Department v1, Integer v2) {
   }
 
   @Test void testSequenceEqualWithoutCollection() {
-    final Enumerable<String> enumerable1 = Linq4j.asEnumerable(
-        () -> Arrays.asList("ming", "foo", "bar").iterator());
-    final Enumerable<String> enumerable2 = Linq4j.asEnumerable(
-        () -> Arrays.asList("ming", "foo", "bar").iterator());
+    final Enumerable<String> enumerable1 =
+        Linq4j.asEnumerable(() -> Arrays.asList("ming", "foo", "bar").iterator());
+    final Enumerable<String> enumerable2 =
+        Linq4j.asEnumerable(() -> Arrays.asList("ming", "foo", "bar").iterator());
     assertTrue(enumerable1.sequenceEqual(enumerable2));
     assertFalse(
         enumerable1.sequenceEqual(
@@ -1834,10 +1840,14 @@ public boolean apply(Department v1, Integer v2) {
   }
 
   @Test void testSequenceEqualWithComparer() {
-    final Enumerable<String> enumerable1 = Linq4j.asEnumerable(
-        Collections.unmodifiableCollection(Arrays.asList("ming", "foo", "bar")));
-    final Enumerable<String> enumerable2 = Linq4j.asEnumerable(
-        Collections.unmodifiableCollection(Arrays.asList("ming", "foo", "bar")));
+    final Enumerable<String> enumerable1 =
+        Linq4j.asEnumerable(
+            Collections.unmodifiableCollection(
+                Arrays.asList("ming", "foo", "bar")));
+    final Enumerable<String> enumerable2 =
+        Linq4j.asEnumerable(
+            Collections.unmodifiableCollection(
+                Arrays.asList("ming", "foo", "bar")));
     final EqualityComparer<String> equalityComparer = new EqualityComparer<String>() {
       public boolean equal(String v1, String v2) {
         return !Objects.equals(v1, v2); // reverse the equality.
@@ -1871,10 +1881,10 @@ public int hashCode(String s) {
   }
 
   @Test void testSequenceEqualWithComparerWithoutCollection() {
-    final Enumerable<String> enumerable1 = Linq4j.asEnumerable(
-        () -> Arrays.asList("ming", "foo", "bar").iterator());
-    final Enumerable<String> enumerable2 = Linq4j.asEnumerable(
-        () -> Arrays.asList("ming", "foo", "bar").iterator());
+    final Enumerable<String> enumerable1 =
+        Linq4j.asEnumerable(() -> Arrays.asList("ming", "foo", "bar").iterator());
+    final Enumerable<String> enumerable2 =
+        Linq4j.asEnumerable(() -> Arrays.asList("ming", "foo", "bar").iterator());
     final EqualityComparer<String> equalityComparer = new EqualityComparer<String>() {
       public boolean equal(String v1, String v2) {
         return !Objects.equals(v1, v2); // reverse the equality.
@@ -1884,8 +1894,8 @@ public int hashCode(String s) {
       }
     };
     assertFalse(enumerable1.sequenceEqual(enumerable2, equalityComparer));
-    final Enumerable<String> enumerable3 = Linq4j.asEnumerable(
-        () -> Arrays.asList("fun", "lol", "far").iterator());
+    final Enumerable<String> enumerable3 =
+        Linq4j.asEnumerable(() -> Arrays.asList("fun", "lol", "far").iterator());
     assertTrue(
         enumerable1.sequenceEqual(enumerable3, equalityComparer));
 
diff --git a/linq4j/src/test/java/org/apache/calcite/linq4j/test/LookupImplTest.java b/linq4j/src/test/java/org/apache/calcite/linq4j/test/LookupImplTest.java
index f2226dfce58..3e9417492d0 100644
--- a/linq4j/src/test/java/org/apache/calcite/linq4j/test/LookupImplTest.java
+++ b/linq4j/src/test/java/org/apache/calcite/linq4j/test/LookupImplTest.java
@@ -37,9 +37,10 @@ class LookupImplTest {
 
   @BeforeEach
   public void setUp() {
-    impl = Linq4j.asEnumerable(Linq4jTest.emps).toLookup(
-      Linq4jTest.EMP_DEPTNO_SELECTOR,
-      Linq4jTest.EMP_NAME_SELECTOR);
+    impl =
+        Linq4j.asEnumerable(Linq4jTest.emps)
+            .toLookup(Linq4jTest.EMP_DEPTNO_SELECTOR,
+                Linq4jTest.EMP_NAME_SELECTOR);
   }
 
   @Test void testPut() {
diff --git a/mongodb/src/main/java/org/apache/calcite/adapter/mongodb/MongoEnumerator.java b/mongodb/src/main/java/org/apache/calcite/adapter/mongodb/MongoEnumerator.java
index 0045044c349..0c3d327fa5f 100644
--- a/mongodb/src/main/java/org/apache/calcite/adapter/mongodb/MongoEnumerator.java
+++ b/mongodb/src/main/java/org/apache/calcite/adapter/mongodb/MongoEnumerator.java
@@ -129,7 +129,9 @@ private static Object convert(Object o, Class clazz) {
     if (clazz.isInstance(o)) {
       return o;
     }
-    if (o instanceof Date && primitive != null) {
+    if (o instanceof Date && clazz == Long.class) {
+      o = ((Date) o).getTime();
+    } else if (o instanceof Date && primitive != null) {
       o = ((Date) o).getTime() / DateTimeUtils.MILLIS_PER_DAY;
     }
     if (o instanceof Number && primitive != null) {
diff --git a/mongodb/src/main/java/org/apache/calcite/adapter/mongodb/MongoProject.java b/mongodb/src/main/java/org/apache/calcite/adapter/mongodb/MongoProject.java
index 55bce98e56e..ee0721fe4a9 100644
--- a/mongodb/src/main/java/org/apache/calcite/adapter/mongodb/MongoProject.java
+++ b/mongodb/src/main/java/org/apache/calcite/adapter/mongodb/MongoProject.java
@@ -30,6 +30,7 @@
 import org.apache.calcite.util.Util;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 
@@ -43,7 +44,7 @@
 public class MongoProject extends Project implements MongoRel {
   public MongoProject(RelOptCluster cluster, RelTraitSet traitSet,
       RelNode input, List<? extends RexNode> projects, RelDataType rowType) {
-    super(cluster, traitSet, ImmutableList.of(), input, projects, rowType);
+    super(cluster, traitSet, ImmutableList.of(), input, projects, rowType, ImmutableSet.of());
     assert getConvention() == MongoRel.CONVENTION;
     assert getConvention() == input.getConvention();
   }
diff --git a/mongodb/src/main/java/org/apache/calcite/adapter/mongodb/MongoRules.java b/mongodb/src/main/java/org/apache/calcite/adapter/mongodb/MongoRules.java
index 9e9ac37fca5..fa10035746c 100644
--- a/mongodb/src/main/java/org/apache/calcite/adapter/mongodb/MongoRules.java
+++ b/mongodb/src/main/java/org/apache/calcite/adapter/mongodb/MongoRules.java
@@ -21,6 +21,7 @@
 import org.apache.calcite.adapter.java.JavaTypeFactory;
 import org.apache.calcite.plan.Convention;
 import org.apache.calcite.plan.RelOptRule;
+import org.apache.calcite.plan.RelOptRuleCall;
 import org.apache.calcite.plan.RelTraitSet;
 import org.apache.calcite.rel.InvalidRelException;
 import org.apache.calcite.rel.RelCollations;
@@ -310,6 +311,11 @@ private static class MongoProjectRule extends MongoConverterRule {
       super(config);
     }
 
+    @Override public boolean matches(RelOptRuleCall call) {
+      final LogicalProject project = call.rel(0);
+      return project.getVariablesSet().isEmpty();
+    }
+
     @Override public RelNode convert(RelNode rel) {
       final LogicalProject project = (LogicalProject) rel;
       final RelTraitSet traitSet = project.getTraitSet().replace(out);
diff --git a/mongodb/src/test/java/org/apache/calcite/adapter/mongodb/MongoAdapterTest.java b/mongodb/src/test/java/org/apache/calcite/adapter/mongodb/MongoAdapterTest.java
index 79d5e81d260..d2e589985b7 100644
--- a/mongodb/src/test/java/org/apache/calcite/adapter/mongodb/MongoAdapterTest.java
+++ b/mongodb/src/test/java/org/apache/calcite/adapter/mongodb/MongoAdapterTest.java
@@ -32,6 +32,7 @@
 
 import net.hydromatic.foodmart.data.json.FoodmartJson;
 
+import org.bson.BsonArray;
 import org.bson.BsonDateTime;
 import org.bson.BsonDocument;
 import org.bson.BsonInt32;
@@ -107,6 +108,7 @@ public static void setUp() throws Exception {
     doc.put("date", new BsonDateTime(instant.toEpochMilli()));
     doc.put("value", new BsonInt32(1231));
     doc.put("ownerId", new BsonString("531e7789e4b0853ddb861313"));
+    doc.put("arr", new BsonArray(Arrays.asList(new BsonString("a"), new BsonString("b"))));
     datatypes.insertOne(doc);
 
     schema = new MongoSchema(database);
@@ -708,6 +710,52 @@ private void checkPredicate(int expected, String q) {
         .returnsUnordered("EXPR$0=2012-09-05");
   }
 
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5405">[CALCITE-5405]
+   * Error casting MongoDB dates to TIMESTAMP</a>. */
+  @Test void testDateConversion() {
+    assertModel("{\n"
+        + "  version: '1.0',\n"
+        + "  defaultSchema: 'test',\n"
+        + "   schemas: [\n"
+        + "     {\n"
+        + "       type: 'custom',\n"
+        + "       name: 'test',\n"
+        + "       factory: 'org.apache.calcite.adapter.mongodb.MongoSchemaFactory',\n"
+        + "       operand: {\n"
+        + "         host: 'localhost',\n"
+        + "         database: 'test'\n"
+        + "       }\n"
+        + "     }\n"
+        + "   ]\n"
+        + "}")
+        .query("select cast(_MAP['date'] as TIMESTAMP) from \"datatypes\"")
+        .returnsUnordered("EXPR$0=2012-09-05 00:00:00");
+  }
+
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5407">[CALCITE-5407]
+   * Error casting MongoDB array to VARCHAR ARRAY</a>. */
+  @Test void testArrayConversion() {
+    assertModel("{\n"
+        + "  version: '1.0',\n"
+        + "  defaultSchema: 'test',\n"
+        + "   schemas: [\n"
+        + "     {\n"
+        + "       type: 'custom',\n"
+        + "       name: 'test',\n"
+        + "       factory: 'org.apache.calcite.adapter.mongodb.MongoSchemaFactory',\n"
+        + "       operand: {\n"
+        + "         host: 'localhost',\n"
+        + "         database: 'test'\n"
+        + "       }\n"
+        + "     }\n"
+        + "   ]\n"
+        + "}")
+        .query("select cast(_MAP['arr'] as VARCHAR ARRAY) from \"datatypes\"")
+        .returnsUnordered("EXPR$0=[a, b]");
+  }
+
   /** Test case for
    * <a href="https://issues.apache.org/jira/browse/CALCITE-665">[CALCITE-665]
    * ClassCastException in MongoDB adapter</a>. */
diff --git a/pig/src/main/java/org/apache/calcite/adapter/pig/PigProject.java b/pig/src/main/java/org/apache/calcite/adapter/pig/PigProject.java
index 11d2e90fbd6..e62c9106a7c 100644
--- a/pig/src/main/java/org/apache/calcite/adapter/pig/PigProject.java
+++ b/pig/src/main/java/org/apache/calcite/adapter/pig/PigProject.java
@@ -25,6 +25,7 @@
 import org.apache.calcite.rex.RexNode;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
 
 import java.util.List;
 
@@ -35,7 +36,7 @@ public class PigProject extends Project implements PigRel {
   /** Creates a PigProject. */
   public PigProject(RelOptCluster cluster, RelTraitSet traitSet, RelNode input,
       List<? extends RexNode> projects, RelDataType rowType) {
-    super(cluster, traitSet, ImmutableList.of(), input, projects, rowType);
+    super(cluster, traitSet, ImmutableList.of(), input, projects, rowType, ImmutableSet.of());
     assert getConvention() == PigRel.CONVENTION;
   }
 
diff --git a/pig/src/main/java/org/apache/calcite/adapter/pig/PigRules.java b/pig/src/main/java/org/apache/calcite/adapter/pig/PigRules.java
index 3def5e0c720..d3daa3575cd 100644
--- a/pig/src/main/java/org/apache/calcite/adapter/pig/PigRules.java
+++ b/pig/src/main/java/org/apache/calcite/adapter/pig/PigRules.java
@@ -18,6 +18,7 @@
 
 import org.apache.calcite.plan.Convention;
 import org.apache.calcite.plan.RelOptRule;
+import org.apache.calcite.plan.RelOptRuleCall;
 import org.apache.calcite.plan.RelTraitSet;
 import org.apache.calcite.rel.RelNode;
 import org.apache.calcite.rel.convert.ConverterRule;
@@ -108,6 +109,11 @@ protected PigProjectRule(Config config) {
       super(config);
     }
 
+    @Override public boolean matches(RelOptRuleCall call) {
+      final LogicalProject project = call.rel(0);
+      return project.getVariablesSet().isEmpty();
+    }
+
     @Override public RelNode convert(RelNode rel) {
       final LogicalProject project = (LogicalProject) rel;
       final RelTraitSet traitSet = project.getTraitSet().replace(PigRel.CONVENTION);
diff --git a/pig/src/main/java/org/apache/calcite/adapter/pig/PigTableScan.java b/pig/src/main/java/org/apache/calcite/adapter/pig/PigTableScan.java
index 8424b46f2ea..13e1f7db376 100644
--- a/pig/src/main/java/org/apache/calcite/adapter/pig/PigTableScan.java
+++ b/pig/src/main/java/org/apache/calcite/adapter/pig/PigTableScan.java
@@ -62,8 +62,8 @@ private PigTable getPigTable(String name) {
   }
 
   private String getSchemaForPigStatement(Implementor implementor) {
-    final List<String> fieldNamesAndTypes = new ArrayList<>(
-        getTable().getRowType().getFieldList().size());
+    final List<String> fieldNamesAndTypes =
+        new ArrayList<>(getTable().getRowType().getFieldList().size());
     for (RelDataTypeField f : getTable().getRowType().getFieldList()) {
       fieldNamesAndTypes.add(getConcatenatedFieldNameAndTypeForPigSchema(implementor, f));
     }
diff --git a/piglet/src/main/java/org/apache/calcite/piglet/PigConverter.java b/piglet/src/main/java/org/apache/calcite/piglet/PigConverter.java
index 618fbc49727..61ecf7ff524 100644
--- a/piglet/src/main/java/org/apache/calcite/piglet/PigConverter.java
+++ b/piglet/src/main/java/org/apache/calcite/piglet/PigConverter.java
@@ -272,9 +272,10 @@ private List<RelNode> optimizePlans(List<RelNode> originalRels,
           ? ((Sort) rel).collation
           : RelCollations.EMPTY;
       // Apply the planner to obtain the physical plan
-      final RelNode physicalPlan = program.run(planner, rel,
-          rel.getTraitSet().replace(EnumerableConvention.INSTANCE)
-              .replace(collation).simplify(),
+      final RelNode physicalPlan =
+          program.run(planner, rel,
+              rel.getTraitSet().replace(EnumerableConvention.INSTANCE)
+                  .replace(collation).simplify(),
           ImmutableList.of(), ImmutableList.of());
 
       // Then convert the physical plan back to logical plan
diff --git a/piglet/src/main/java/org/apache/calcite/piglet/PigRelBuilder.java b/piglet/src/main/java/org/apache/calcite/piglet/PigRelBuilder.java
index 6b60beea329..79420e2c5cb 100644
--- a/piglet/src/main/java/org/apache/calcite/piglet/PigRelBuilder.java
+++ b/piglet/src/main/java/org/apache/calcite/piglet/PigRelBuilder.java
@@ -187,8 +187,9 @@ void registerPigUDF(String className, FuncSpec pigFunc) {
     if (udfClass == JythonFunction.class) {
       final String[] args = pigFunc.getCtorArgs();
       assert args != null && args.length == 2;
-      final String fileName = args[0].substring(args[0].lastIndexOf("/") + 1,
-          args[0].lastIndexOf(".py"));
+      final String fileName =
+          args[0].substring(args[0].lastIndexOf("/") + 1,
+              args[0].lastIndexOf(".py"));
       // key = [clas name]_[file name]_[function name]
       key = udfClass.getName() + "_" + fileName + "_" + args[1];
     }
@@ -262,8 +263,9 @@ public RelBuilder scan(RelOptTable userSchema, String... tableNames) {
    * @return This builder
    */
   private RelBuilder scan(RelOptTable tableSchema) {
-    final RelNode scan = getScanFactory().createScan(
-        ViewExpanders.simpleContext(cluster), tableSchema);
+    final RelNode scan =
+        getScanFactory()
+            .createScan(ViewExpanders.simpleContext(cluster), tableSchema);
     push(scan);
     return this;
   }
@@ -355,7 +357,8 @@ private List<RexNode> projects(RelDataType inputType, RelDataType outputType) {
           projectionExprs.add(fieldProject);
         } else {
           // Different types, CAST is required
-          projectionExprs.add(getRexBuilder().makeCast(outputField.getType(), fieldProject));
+          projectionExprs.add(
+              getRexBuilder().makeCast(outputField.getType(), fieldProject));
         }
       } else {
         final RelDataType columnType = outputField.getType();
@@ -505,11 +508,11 @@ public RelBuilder multiSetFlatten(List<Integer> flattenCols, List<String> flatte
   public RelBuilder multiSetFlatten() {
     // [CALCITE-3193] Add RelBuilder.uncollect method, and interface
     // UncollectFactory, to instantiate Uncollect
-    Uncollect uncollect = Uncollect.create(
-        cluster.traitSetOf(Convention.NONE),
-        build(),
-        false,
-        Collections.emptyList());
+    Uncollect uncollect =
+        Uncollect.create(cluster.traitSetOf(Convention.NONE),
+            build(),
+            false,
+            Collections.emptyList());
     push(uncollect);
     return this;
   }
@@ -541,8 +544,9 @@ public RelBuilder collect() {
     final  RelNode inputRel = peek();
 
     // First project out a combined column which is a of all other columns
-    final RexNode row = getRexBuilder().makeCall(inputRel.getRowType(),
-        SqlStdOperatorTable.ROW, fields());
+    final RexNode row =
+        getRexBuilder()
+            .makeCall(inputRel.getRowType(), SqlStdOperatorTable.ROW, fields());
     project(ImmutableList.of(literal("all"), row));
 
     // Update the alias map for the new projected rel.
diff --git a/piglet/src/main/java/org/apache/calcite/piglet/PigRelExVisitor.java b/piglet/src/main/java/org/apache/calcite/piglet/PigRelExVisitor.java
index f3ac7706780..86711d8a81a 100644
--- a/piglet/src/main/java/org/apache/calcite/piglet/PigRelExVisitor.java
+++ b/piglet/src/main/java/org/apache/calcite/piglet/PigRelExVisitor.java
@@ -397,11 +397,12 @@ private static int optSize(List<Operator> list) {
           relFields.add(builder.dot(parentField, col));
         }
 
-        final RelDataType newRelType = RexUtil.createStructType(
-            PigTypes.TYPE_FACTORY,
-            relFields);
+        final RelDataType newRelType =
+            RexUtil.createStructType(PigTypes.TYPE_FACTORY,
+                relFields);
         stack.push(
-            builder.getRexBuilder().makeCall(newRelType, SqlStdOperatorTable.ROW, relFields));
+            builder.getRexBuilder()
+                .makeCall(newRelType, SqlStdOperatorTable.ROW, relFields));
       }
     }
   }
@@ -439,8 +440,10 @@ private static int optSize(List<Operator> list) {
                && ((RexLiteral) operand2).getValue() instanceof BigDecimal;
     final int index = ((BigDecimal) ((RexLiteral) operand2).getValue()).intValue();
 
-    RelNode referencedRel = builder.getRel(
-        ((LogicalRelationalOperator) op.getImplicitReferencedOperator()).getAlias());
+    RelNode referencedRel =
+        builder.getRel(
+            ((LogicalRelationalOperator) op.getImplicitReferencedOperator())
+                .getAlias());
     builder.push(referencedRel);
     List<RexNode> projectCol = Lists.newArrayList(builder.field(index));
     builder.project(projectCol);
diff --git a/piglet/src/main/java/org/apache/calcite/piglet/PigRelOpInnerVisitor.java b/piglet/src/main/java/org/apache/calcite/piglet/PigRelOpInnerVisitor.java
index 727a187cff7..67948d4ca19 100644
--- a/piglet/src/main/java/org/apache/calcite/piglet/PigRelOpInnerVisitor.java
+++ b/piglet/src/main/java/org/apache/calcite/piglet/PigRelOpInnerVisitor.java
@@ -160,8 +160,8 @@ private void doGenerateWithoutMultisetFlatten(LOGenerate gen, List<Integer> mult
       }
 
       if (outputFieldSchema.size() == 1 && !gen.getFlattenFlags()[i]) {
-        final RelDataType scriptType = PigTypes.convertSchemaField(
-            outputFieldSchema.getField(0));
+        final RelDataType scriptType =
+            PigTypes.convertSchemaField(outputFieldSchema.getField(0));
         if (dataType.getSqlTypeName() == SqlTypeName.ANY
                 || !SqlTypeUtil.isComparable(dataType, scriptType)) {
           // Script schema is different from project expression schema, need to do type cast
@@ -174,10 +174,11 @@ private void doGenerateWithoutMultisetFlatten(LOGenerate gen, List<Integer> mult
         if (dataType instanceof DynamicTupleRecordType) {
           ((DynamicTupleRecordType) dataType).resize(outputFieldSchema.size());
           for (int j = 0; j < outputFieldSchema.size(); j++) {
-            final RelDataType scriptType = PigTypes.convertSchemaField(
-                outputFieldSchema.getField(j));
-            RexNode exp = builder.call(
-                SqlStdOperatorTable.ITEM, rexNode, builder.literal(j + 1));
+            final RelDataType scriptType =
+                PigTypes.convertSchemaField(outputFieldSchema.getField(j));
+            RexNode exp =
+                builder.call(SqlStdOperatorTable.ITEM, rexNode,
+                    builder.literal(j + 1));
             innerCols.add(builder.getRexBuilder().makeCast(scriptType, exp));
             fieldAlias.add(outputFieldSchema.getField(j).alias);
           }
diff --git a/piglet/src/main/java/org/apache/calcite/piglet/PigRelOpVisitor.java b/piglet/src/main/java/org/apache/calcite/piglet/PigRelOpVisitor.java
index 3b319773702..16eaaded9d4 100644
--- a/piglet/src/main/java/org/apache/calcite/piglet/PigRelOpVisitor.java
+++ b/piglet/src/main/java/org/apache/calcite/piglet/PigRelOpVisitor.java
@@ -160,8 +160,9 @@ List<RelNode> translate() throws FrontendException {
       // If Pig schema is provided in the load command, convert it into
       // relational row type
       final RelDataType rowType = PigTypes.convertSchema(pigSchema);
-      pigRelOptTable = PigTable.createRelOptTable(builder.getRelOptSchema(),
-          rowType, Arrays.asList(tableNames));
+      pigRelOptTable =
+          PigTable.createRelOptTable(builder.getRelOptSchema(), rowType,
+              Arrays.asList(tableNames));
     }
     builder.scan(pigRelOptTable, tableNames);
     builder.register(load);
@@ -230,8 +231,9 @@ private void projectGroup(int groupCount) {
       }
       RelDataType groupDataType =
           PigTypes.TYPE_FACTORY.createStructType(fieldTypes, fieldNames);
-      groupRex = builder.getRexBuilder().makeCall(
-          groupDataType, SqlStdOperatorTable.ROW, fieldRexes);
+      groupRex =
+          builder.getRexBuilder().makeCall(groupDataType,
+              SqlStdOperatorTable.ROW, fieldRexes);
     }
     List<RexNode> outputFields = new ArrayList<>();
     List<String> outputNames = new ArrayList<>();
@@ -354,8 +356,10 @@ private void preprocessCogroup(LOCogroup loCogroup, boolean isCubeRollup)
       for (LogicalExpressionPlan pigKey : pigGroupKeys) {
         fieldRels.add(PigRelExVisitor.translatePigEx(builder, pigKey));
       }
-      final RexNode row = builder.getRexBuilder().makeCall(getGroupRowType(fieldRels, isCubeRollup),
-          SqlStdOperatorTable.ROW, getGroupRowOperands(fieldRels, isCubeRollup));
+      final RexNode row =
+          builder.getRexBuilder().makeCall(
+              getGroupRowType(fieldRels, isCubeRollup), SqlStdOperatorTable.ROW,
+              getGroupRowOperands(fieldRels, isCubeRollup));
       fieldRels.add(row);
       builder.project(fieldRels);
       builder.updateAlias(builder.getPig(originalRel), builder.getAlias(originalRel), false);
diff --git a/piglet/src/main/java/org/apache/calcite/piglet/PigRelSqlUdfs.java b/piglet/src/main/java/org/apache/calcite/piglet/PigRelSqlUdfs.java
index c34425c39ca..3018929d511 100644
--- a/piglet/src/main/java/org/apache/calcite/piglet/PigRelSqlUdfs.java
+++ b/piglet/src/main/java/org/apache/calcite/piglet/PigRelSqlUdfs.java
@@ -220,14 +220,6 @@ private static SqlOperandMetadata multisetProjectionCheck() {
         return opName + "(...)";
       }
 
-      @Override public boolean isOptional(int i) {
-        return false;
-      }
-
-      @Override public Consistency getConsistency() {
-        return Consistency.NONE;
-      }
-
       @Override public List<RelDataType> paramTypes(
           RelDataTypeFactory typeFactory) {
         return Functions.generate(paramCount,
diff --git a/piglet/src/main/java/org/apache/calcite/piglet/PigRelToSqlConverter.java b/piglet/src/main/java/org/apache/calcite/piglet/PigRelToSqlConverter.java
index d2e7e084069..752cd7ccf93 100644
--- a/piglet/src/main/java/org/apache/calcite/piglet/PigRelToSqlConverter.java
+++ b/piglet/src/main/java/org/apache/calcite/piglet/PigRelToSqlConverter.java
@@ -105,16 +105,16 @@ public class PigRelToSqlConverter extends RelToSqlConverter {
         orderList.add(builder.context.toSql(orderKey));
       }
 
-      final SqlNode sqlWindow =  SqlWindow.create(
-          null, // Window declaration name
-          null, // Window reference name
-          new SqlNodeList(partitionList, POS),
-          new SqlNodeList(orderList, POS),
-          SqlLiteral.createBoolean(winGroup.isRows, POS),
-          builder.context.toSql(winGroup.lowerBound),
-          builder.context.toSql(winGroup.upperBound),
-          null, // allowPartial
-          POS);
+      final SqlNode sqlWindow =
+          SqlWindow.create(null, // Window declaration name
+              null, // Window reference name
+              new SqlNodeList(partitionList, POS),
+              new SqlNodeList(orderList, POS),
+              SqlLiteral.createBoolean(winGroup.isRows, POS),
+              builder.context.toSql(winGroup.lowerBound),
+              builder.context.toSql(winGroup.upperBound),
+              null, // allowPartial
+              POS);
 
       for (Window.RexWinAggCall winFunc : winGroup.aggCalls) {
         final List<SqlNode> winFuncOperands = Expressions.list();
diff --git a/piglet/src/main/java/org/apache/calcite/piglet/PigTable.java b/piglet/src/main/java/org/apache/calcite/piglet/PigTable.java
index 0ab303a5aea..94a8f7427f5 100644
--- a/piglet/src/main/java/org/apache/calcite/piglet/PigTable.java
+++ b/piglet/src/main/java/org/apache/calcite/piglet/PigTable.java
@@ -59,7 +59,7 @@ public static RelOptTable createRelOptTable(RelOptSchema schema,
       RelDataType rowType, List<String> names) {
     final PigTable pigTable = new PigTable(rowType);
     return RelOptTableImpl.create(schema, rowType, names, pigTable,
-        Expressions.constant(Boolean.TRUE));
+        c -> Expressions.constant(Boolean.TRUE));
   }
 
   @Override public RelDataType getRowType(final RelDataTypeFactory typeFactory) {
diff --git a/piglet/src/main/java/org/apache/calcite/piglet/PigToSqlAggregateRule.java b/piglet/src/main/java/org/apache/calcite/piglet/PigToSqlAggregateRule.java
index 1f7d9ba1a95..71f206d09af 100644
--- a/piglet/src/main/java/org/apache/calcite/piglet/PigToSqlAggregateRule.java
+++ b/piglet/src/main/java/org/apache/calcite/piglet/PigToSqlAggregateRule.java
@@ -207,8 +207,9 @@ private static class RexCallReplacer extends RexShuttle {
     }
     // If grouping aggregate is needed, project the whole ROW
     if (needGroupingCol) {
-      final RexNode row = relBuilder.getRexBuilder().makeCall(relBuilder.peek().getRowType(),
-          SqlStdOperatorTable.ROW, relBuilder.fields());
+      final RexNode row =
+          relBuilder.getRexBuilder().makeCall(relBuilder.peek().getRowType(),
+              SqlStdOperatorTable.ROW, relBuilder.fields());
       newBottomProjects.add(row);
     }
     final int groupCount = oldAgg.getGroupCount() + (needGroupingCol ? 1 : 0);
diff --git a/piglet/src/test/java/org/apache/calcite/test/PigRelOpTest.java b/piglet/src/test/java/org/apache/calcite/test/PigRelOpTest.java
index 7937be64ef8..f24bfdb8185 100644
--- a/piglet/src/test/java/org/apache/calcite/test/PigRelOpTest.java
+++ b/piglet/src/test/java/org/apache/calcite/test/PigRelOpTest.java
@@ -1362,7 +1362,7 @@ private Fluent pig(String script) {
         + "BIGINT) AS $f1, CAST(SUM(SAL) AS DECIMAL(19, 0)) AS salSum\n"
         + "FROM scott.EMP\n"
         + "GROUP BY DEPTNO, MGR, HIREDATE\n"
-        + "ORDER BY CAST(SUM(SAL) AS DECIMAL(19, 0))";
+        + "ORDER BY 3";
     pig(script).assertResult(is(result))
         .assertSql(is(sql));
   }
@@ -1480,7 +1480,7 @@ private Fluent pig(String script) {
         + "(19, 0)) AS salAvg\n"
         + "FROM scott.EMP\n"
         + "GROUP BY DEPTNO, MGR, HIREDATE\n"
-        + "ORDER BY CAST(SUM(SAL) AS DECIMAL(19, 0))";
+        + "ORDER BY 3";
     pig(script).assertRel(hasTree(plan))
         .assertOptimizedRel(hasTree(optimizedPlan))
         .assertResult(is(result))
@@ -1501,7 +1501,7 @@ private Fluent pig(String script) {
         + "AS A\n"
         + "FROM scott.EMP\n"
         + "GROUP BY DEPTNO, MGR, HIREDATE\n"
-        + "ORDER BY CAST(SUM(SAL) AS DECIMAL(19, 0))";
+        + "ORDER BY 3";
     pig(script2).assertSql(is(sql2));
 
     final String script3 = ""
@@ -1551,7 +1551,7 @@ private Fluent pig(String script) {
         + "COLLECT(COMM) AS comArray, CAST(SUM(SAL) AS DECIMAL(19, 0)) AS salSum\n"
         + "FROM scott.EMP\n"
         + "GROUP BY DEPTNO, MGR, HIREDATE\n"
-        + "ORDER BY CAST(SUM(SAL) AS DECIMAL(19, 0))";
+        + "ORDER BY 7";
     pig(script).assertRel(hasTree(plan))
         .assertOptimizedRel(hasTree(optimizedPlan))
         .assertSql(is(sql));
@@ -1610,7 +1610,7 @@ private Fluent pig(String script) {
         + "    FROM scott.DEPT\n"
         + "    WHERE DEPTNO >= 20\n"
         + "    GROUP BY CAST(DEPTNO AS INTEGER)) AS t7 ON t4.DEPTNO = t7.DEPTNO\n"
-        + "ORDER BY CASE WHEN t4.DEPTNO IS NOT NULL THEN t4.DEPTNO ELSE t7.DEPTNO END";
+        + "ORDER BY 1";
     pig(script).assertRel(hasTree(plan))
         .assertResult(is(result))
         .assertSql(is(sql));
diff --git a/piglet/src/test/java/org/apache/calcite/test/PigScriptTest.java b/piglet/src/test/java/org/apache/calcite/test/PigScriptTest.java
index 3496943f50d..e8fbdd7b645 100644
--- a/piglet/src/test/java/org/apache/calcite/test/PigScriptTest.java
+++ b/piglet/src/test/java/org/apache/calcite/test/PigScriptTest.java
@@ -46,8 +46,9 @@ class PigScriptTest extends PigRelTestBase {
   public static void setUpOnce() throws IOException {
     projectRootDir = System.getProperty("user.dir");
     dataFile = projectRootDir + "/src/test/resources/input.data";
-    List<String> lines = Arrays.asList("yahoo 10", "twitter 3", "facebook 10",
-        "yahoo 15", "facebook 5", "twitter 2");
+    List<String> lines =
+        Arrays.asList("yahoo 10", "twitter 3", "facebook 10",
+            "yahoo 15", "facebook 5", "twitter 2");
     Files.write(Paths.get(dataFile), lines, StandardCharsets.UTF_8);
   }
 
diff --git a/plus/src/main/java/org/apache/calcite/adapter/os/GitCommitsTableFunction.java b/plus/src/main/java/org/apache/calcite/adapter/os/GitCommitsTableFunction.java
index 6b5fa2a1ee5..28aa4fd5387 100644
--- a/plus/src/main/java/org/apache/calcite/adapter/os/GitCommitsTableFunction.java
+++ b/plus/src/main/java/org/apache/calcite/adapter/os/GitCommitsTableFunction.java
@@ -94,16 +94,20 @@ public static ScannableTable eval(boolean b) {
                       objects[3] = line.substring("parent ".length());
                     }
                   } else if (line.startsWith("author ")) {
-                    objects[4] = line.substring("author ".length(),
-                        line.length() - TS_OFF.length() - 1);
-                    objects[5] = Long.valueOf(
-                        line.substring(line.length() - TS_OFF.length(),
+                    objects[4] =
+                        line.substring("author ".length(),
+                            line.length() - TS_OFF.length() - 1);
+                    objects[5] =
+                        Long.parseLong(
+                            line.substring(line.length() - TS_OFF.length(),
                             line.length() - OFF.length() - 1)) * 1000;
                   } else if (line.startsWith("committer ")) {
-                    objects[6] = line.substring("committer ".length(),
-                        line.length() - TS_OFF.length() - 1);
-                    objects[7] = Long.valueOf(
-                        line.substring(line.length() - TS_OFF.length(),
+                    objects[6] =
+                        line.substring("committer ".length(),
+                            line.length() - TS_OFF.length() - 1);
+                    objects[7] =
+                        Long.parseLong(
+                            line.substring(line.length() - TS_OFF.length(),
                             line.length() - OFF.length() - 1)) * 1000;
                   }
                   if (!e.moveNext()) {
diff --git a/plus/src/main/java/org/apache/calcite/chinook/ChinookAvaticaServer.java b/plus/src/main/java/org/apache/calcite/chinook/ChinookAvaticaServer.java
index c110143117f..306008a2e4b 100644
--- a/plus/src/main/java/org/apache/calcite/chinook/ChinookAvaticaServer.java
+++ b/plus/src/main/java/org/apache/calcite/chinook/ChinookAvaticaServer.java
@@ -67,8 +67,9 @@ public static class CalciteChinookMetaFactory implements Meta.Factory {
     private static JdbcMeta getInstance() {
       if (instance == null) {
         try {
-          instance = new JdbcMeta(CalciteConnectionProvider.DRIVER_URL,
-              CONNECTION_PROVIDER.provideConnectionInfo());
+          instance =
+              new JdbcMeta(CalciteConnectionProvider.DRIVER_URL,
+                  CONNECTION_PROVIDER.provideConnectionInfo());
         } catch (SQLException | IOException e) {
           throw new RuntimeException(e);
         }
@@ -90,8 +91,9 @@ public static class RawChinookMetaFactory implements Meta.Factory {
     private static JdbcMeta getInstance() {
       if (instance == null) {
         try {
-          instance = new JdbcMeta(ChinookHsqldb.URI,
-              ChinookHsqldb.USER, ChinookHsqldb.PASSWORD);
+          instance =
+              new JdbcMeta(ChinookHsqldb.URI,
+                  ChinookHsqldb.USER, ChinookHsqldb.PASSWORD);
         } catch (SQLException e) {
           throw new RuntimeException(e);
         }
diff --git a/plus/src/test/java/org/apache/calcite/adapter/os/OsAdapterTest.java b/plus/src/test/java/org/apache/calcite/adapter/os/OsAdapterTest.java
index 0a4e9fed4d5..2831d984c7c 100644
--- a/plus/src/test/java/org/apache/calcite/adapter/os/OsAdapterTest.java
+++ b/plus/src/test/java/org/apache/calcite/adapter/os/OsAdapterTest.java
@@ -240,18 +240,18 @@ private static boolean checkProcessExists(String command) {
   }
 
   @Test void testStdin() throws SQLException {
-    try (Hook.Closeable ignore = Hook.STANDARD_STREAMS.addThread(
-        (Consumer<Holder<Object[]>>) o -> {
-          final Object[] values = o.get();
-          final InputStream in = (InputStream) values[0];
-          final String s = "First line\n"
-              + "Second line";
-          final ByteArrayInputStream in2 =
-              new ByteArrayInputStream(s.getBytes(StandardCharsets.UTF_8));
-          final OutputStream out = (OutputStream) values[1];
-          final OutputStream err = (OutputStream) values[2];
-          o.set(new Object[] {in2, out, err});
-        })) {
+    try (Hook.Closeable ignore =
+             Hook.STANDARD_STREAMS.addThread((Consumer<Holder<Object[]>>) o -> {
+               final Object[] values = o.get();
+               final InputStream in = (InputStream) values[0];
+               final String s = "First line\n"
+                   + "Second line";
+               final ByteArrayInputStream in2 =
+                   new ByteArrayInputStream(s.getBytes(StandardCharsets.UTF_8));
+               final OutputStream out = (OutputStream) values[1];
+               final OutputStream err = (OutputStream) values[2];
+               o.set(new Object[] {in2, out, err});
+             })) {
       assertThat(foo("select count(*) as c from stdin"), is("2\n"));
     }
   }
diff --git a/plus/src/test/java/org/apache/calcite/adapter/tpcds/TpcdsTest.java b/plus/src/test/java/org/apache/calcite/adapter/tpcds/TpcdsTest.java
index 5d04be4be4e..de85c177cfe 100644
--- a/plus/src/test/java/org/apache/calcite/adapter/tpcds/TpcdsTest.java
+++ b/plus/src/test/java/org/apache/calcite/adapter/tpcds/TpcdsTest.java
@@ -284,8 +284,9 @@ private CalciteAssert.AssertQuery checkQuery(int i) {
         sql = sql.replace(" = '", " = DATE '");
       } else {
         // Until TPC-DS generator can handle date(...).
-        sql = sql.replace("'date([YEAR]+\"-01-01\",[YEAR]+\"-07-24\",sales)'",
-            "DATE '1998-08-18'");
+        sql =
+            sql.replace("'date([YEAR]+\"-01-01\",[YEAR]+\"-07-24\",sales)'",
+                "DATE '1998-08-18'");
       }
       break;
     case 72:
diff --git a/plus/src/test/java/org/apache/calcite/adapter/tpch/TpchTest.java b/plus/src/test/java/org/apache/calcite/adapter/tpch/TpchTest.java
index a09f3ee5b98..3db9dd3dd7c 100644
--- a/plus/src/test/java/org/apache/calcite/adapter/tpch/TpchTest.java
+++ b/plus/src/test/java/org/apache/calcite/adapter/tpch/TpchTest.java
@@ -63,8 +63,7 @@ private static String schema(String name, String scaleFactor) {
       + "   ]\n"
       + "}";
 
-  static final List<String> QUERIES = ImmutableList.of(
-      // 01
+  private static final String[] QUERY_ARRAY = {
       "select\n"
           + "  l_returnflag,\n"
           + "  l_linestatus,\n"
@@ -749,7 +748,10 @@ private static String schema(String name, String scaleFactor) {
           + "group by\n"
           + "  cntrycode\n"
           + "order by\n"
-          + "  cntrycode");
+          + "  cntrycode"};
+
+  static final List<String> QUERIES =
+      ImmutableList.copyOf(QUERY_ARRAY);
 
   @Disabled("it's wasting time")
   @Test void testRegion() {
diff --git a/plus/src/test/java/org/apache/calcite/chinook/EndToEndTest.java b/plus/src/test/java/org/apache/calcite/chinook/EndToEndTest.java
index 5713f624670..6529f87a228 100644
--- a/plus/src/test/java/org/apache/calcite/chinook/EndToEndTest.java
+++ b/plus/src/test/java/org/apache/calcite/chinook/EndToEndTest.java
@@ -41,7 +41,7 @@ public static void main(String[] args) throws Exception {
   }
 
   /** For {@link QuidemTest#test(String)} parameters. */
-  public static Collection<Object[]> data() {
+  @Override public Collection<String> getPath() {
     // Start with a test file we know exists, then find the directory and list
     // its files.
     final String first = "sql/basic.iq";
diff --git a/plus/src/test/resources/sql/basic.iq b/plus/src/test/resources/sql/basic.iq
index da8a33fd7d6..230419fb4dc 100644
--- a/plus/src/test/resources/sql/basic.iq
+++ b/plus/src/test/resources/sql/basic.iq
@@ -32,7 +32,6 @@ FROM `chinook`.`Artist` AS ar
 JOIN `chinook`.`Album` AS al ON ar.`ArtistId` = al.`ArtistId`
 JOIN `chinook`.`Track` as tr ON al.`AlbumId` = tr.`AlbumId`
 GROUP BY ar.`Name`;
-
 +---------------------------------------------------------------------------------------+--------------+-----------+
 | NAME                                                                                  | TRACKS_COUNT | MS_TOTAL  |
 +---------------------------------------------------------------------------------------+--------------+-----------+
diff --git a/redis/src/main/java/org/apache/calcite/adapter/redis/RedisEnumerator.java b/redis/src/main/java/org/apache/calcite/adapter/redis/RedisEnumerator.java
index 5edb5d063e2..c55c616360a 100644
--- a/redis/src/main/java/org/apache/calcite/adapter/redis/RedisEnumerator.java
+++ b/redis/src/main/java/org/apache/calcite/adapter/redis/RedisEnumerator.java
@@ -36,8 +36,9 @@ class RedisEnumerator implements Enumerator<Object[]> {
   RedisEnumerator(RedisConfig redisConfig, RedisSchema schema, String tableName) {
     RedisTableFieldInfo tableFieldInfo = schema.getTableFieldInfo(tableName);
 
-    RedisJedisManager redisManager = new RedisJedisManager(redisConfig.getHost(),
-        redisConfig.getPort(), redisConfig.getDatabase(), redisConfig.getPassword());
+    RedisJedisManager redisManager =
+        new RedisJedisManager(redisConfig.getHost(), redisConfig.getPort(),
+            redisConfig.getDatabase(), redisConfig.getPassword());
 
     try (Jedis jedis = redisManager.getResource()) {
       if (StringUtils.isNotEmpty(redisConfig.getPassword())) {
diff --git a/redis/src/main/java/org/apache/calcite/adapter/redis/RedisSchema.java b/redis/src/main/java/org/apache/calcite/adapter/redis/RedisSchema.java
index 65ea2423c8c..30f4178e6a5 100644
--- a/redis/src/main/java/org/apache/calcite/adapter/redis/RedisSchema.java
+++ b/redis/src/main/java/org/apache/calcite/adapter/redis/RedisSchema.java
@@ -63,10 +63,10 @@ class RedisSchema extends AbstractSchema {
     JsonCustomTable[] jsonCustomTables = new JsonCustomTable[tables.size()];
     Set<String> tableNames = Arrays.stream(tables.toArray(jsonCustomTables))
         .map(e -> e.name).collect(Collectors.toSet());
-    tableMap = Maps.asMap(
-        ImmutableSet.copyOf(tableNames),
-        CacheBuilder.newBuilder()
-            .build(CacheLoader.from(this::table)));
+    tableMap =
+        Maps.asMap(ImmutableSet.copyOf(tableNames),
+            CacheBuilder.newBuilder()
+                .build(CacheLoader.from(this::table)));
     return tableMap;
   }
 
diff --git a/redis/src/main/java/org/apache/calcite/adapter/redis/RedisTable.java b/redis/src/main/java/org/apache/calcite/adapter/redis/RedisTable.java
index ddb3587958d..cca76898c54 100644
--- a/redis/src/main/java/org/apache/calcite/adapter/redis/RedisTable.java
+++ b/redis/src/main/java/org/apache/calcite/adapter/redis/RedisTable.java
@@ -97,8 +97,9 @@ static Table create(
       String tableName,
       Map operand,
       RelProtoDataType protoRowType) {
-    RedisConfig redisConfig = new RedisConfig(schema.host, schema.port,
-        schema.database, schema.password);
+    RedisConfig redisConfig =
+        new RedisConfig(schema.host, schema.port,
+            schema.database, schema.password);
     return create(schema, tableName, redisConfig, protoRowType);
   }
 
diff --git a/redis/src/test/java/org/apache/calcite/adapter/redis/RedisAdapterCaseBase.java b/redis/src/test/java/org/apache/calcite/adapter/redis/RedisAdapterCaseBase.java
index f1d564a64b0..1112c41b18c 100644
--- a/redis/src/test/java/org/apache/calcite/adapter/redis/RedisAdapterCaseBase.java
+++ b/redis/src/test/java/org/apache/calcite/adapter/redis/RedisAdapterCaseBase.java
@@ -102,8 +102,9 @@ private void readModelByJson() {
       File file = new File(filePath);
       if (file.exists()) {
         JsonNode rootNode = objMapper.readTree(file);
-        strResult = rootNode.toString().replace(Integer.toString(Protocol.DEFAULT_PORT),
-            Integer.toString(getRedisServerPort()));
+        strResult =
+            rootNode.toString().replace(Integer.toString(Protocol.DEFAULT_PORT),
+                Integer.toString(getRedisServerPort()));
       }
     } catch (Exception ignored) {
     }
diff --git a/server/src/main/codegen/config.fmpp b/server/src/main/codegen/config.fmpp
index 58d2bdf3eca..448357e9ec0 100644
--- a/server/src/main/codegen/config.fmpp
+++ b/server/src/main/codegen/config.fmpp
@@ -30,8 +30,6 @@ data: {
       "org.apache.calcite.sql.SqlCreate"
       "org.apache.calcite.sql.SqlDrop"
       "org.apache.calcite.sql.ddl.SqlDdlNodes"
-      "java.util.Map"
-      "java.util.HashMap"
     ]
 
     # List of new keywords. Example: "DATABASES", "TABLES". If the keyword is
diff --git a/server/src/main/codegen/includes/parserImpls.ftl b/server/src/main/codegen/includes/parserImpls.ftl
index 1c689c409fe..5802a728f04 100644
--- a/server/src/main/codegen/includes/parserImpls.ftl
+++ b/server/src/main/codegen/includes/parserImpls.ftl
@@ -121,7 +121,6 @@ void TableElement(List<SqlNode> list) :
     final SqlDataTypeSpec type;
     final boolean nullable;
     final SqlNode e;
-    final SqlNode constraint;
     SqlIdentifier name = null;
     final SqlNodeList columnList;
     final Span s = Span.of();
diff --git a/server/src/main/java/org/apache/calcite/server/ServerDdlExecutor.java b/server/src/main/java/org/apache/calcite/server/ServerDdlExecutor.java
index 6a0d1a01a98..c028ae386ee 100644
--- a/server/src/main/java/org/apache/calcite/server/ServerDdlExecutor.java
+++ b/server/src/main/java/org/apache/calcite/server/ServerDdlExecutor.java
@@ -89,6 +89,8 @@
 import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableList;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+
 import java.io.Reader;
 import java.sql.PreparedStatement;
 import java.sql.SQLException;
@@ -162,7 +164,8 @@ static SqlValidator validator(CalcitePrepare.Context context,
 
   /** Wraps a query to rename its columns. Used by CREATE VIEW and CREATE
    * MATERIALIZED VIEW. */
-  static SqlNode renameColumns(SqlNodeList columnList, SqlNode query) {
+  static SqlNode renameColumns(@Nullable SqlNodeList columnList,
+      SqlNode query) {
     if (columnList == null) {
       return query;
     }
@@ -176,7 +179,7 @@ static SqlNode renameColumns(SqlNodeList columnList, SqlNode query) {
                 .addAll(columnList)
                 .build());
     return new SqlSelect(p, null, selectList, from, null, null, null, null,
-        null, null, null, null);
+        null, null, null, null, null);
   }
 
   /** Populates the table called {@code name} by executing {@code query}. */
diff --git a/server/src/test/java/org/apache/calcite/test/ServerParserTest.java b/server/src/test/java/org/apache/calcite/test/ServerParserTest.java
index de03ef7317a..64ab59ef9cb 100644
--- a/server/src/test/java/org/apache/calcite/test/ServerParserTest.java
+++ b/server/src/test/java/org/apache/calcite/test/ServerParserTest.java
@@ -74,7 +74,7 @@ class ServerParserTest extends SqlParserTest {
         + "OPTIONS (`ABOOLEAN` TRUE,"
         + " `ANINTEGER` -45,"
         + " `ADATE` DATE '1970-03-21',"
-        + " `quoted.id` TIMESTAMP '1970-03-21 12:04:56.78',"
+        + " `quoted.id` TIMESTAMP '1970-03-21 12:4:56.78',"
         + " `ASTRING` 'foo''bar')";
     sql(sql).ok(expected);
   }
diff --git a/server/src/test/java/org/apache/calcite/test/ServerQuidemTest.java b/server/src/test/java/org/apache/calcite/test/ServerQuidemTest.java
index 982d1ab3aea..04e3f19dc91 100644
--- a/server/src/test/java/org/apache/calcite/test/ServerQuidemTest.java
+++ b/server/src/test/java/org/apache/calcite/test/ServerQuidemTest.java
@@ -48,7 +48,7 @@ public void setup() {
   }
 
   /** For {@link QuidemTest#test(String)} parameters. */
-  public static Collection<Object[]> data() {
+  @Override protected Collection<String> getPath() {
     // Start with a test file we know exists, then find the directory and list
     // its files.
     final String first = "sql/table.iq";
diff --git a/settings.gradle.kts b/settings.gradle.kts
index ad956b868b4..d5a9c5fe889 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -33,11 +33,13 @@ pluginManagement {
         idv("com.github.vlsi.stage-vote-release", "com.github.vlsi.vlsi-release-plugins")
         idv("com.google.protobuf")
         idv("de.thetaphi.forbiddenapis")
+        idv("jacoco")
         idv("me.champeau.gradle.jmh")
         idv("net.ltgt.errorprone")
         idv("org.jetbrains.gradle.plugin.idea-ext")
         idv("org.nosphere.apache.rat")
         idv("org.owasp.dependencycheck")
+        idv("org.sonarqube")
         kotlin("jvm") version "kotlin".v()
     }
     if (extra.has("enableMavenLocal") && extra["enableMavenLocal"].toString().ifBlank { "true" }.toBoolean()) {
diff --git a/site/README.md b/site/README.md
index 9cb7f54195f..68c482ec9a3 100644
--- a/site/README.md
+++ b/site/README.md
@@ -23,14 +23,6 @@ This directory contains the sources/templates for generating the Apache Calcite
 [calcite.apache.org](https://calcite.apache.org/). The actual generated content of the website
 is present in the [calcite-site](https://github.com/apache/calcite-site) repository.
 
-We want to deploy project changes (for example, new committers, PMC members or upcoming talks)
-immediately, but we want to deploy documentation of project features only when that feature appears
-in a release.
-
-The building and publishing of the website is completely automated using Github actions, so you should simply commit
-your changes to main. If you are committing a change to the website that needs to be published immediately, the
-Github action uses these [rules](../.github/workflows/publish-non-release-website-updates.yml#L7).
-
 # Previewing the website locally
 
 ## Manually
@@ -93,3 +85,26 @@ You can preview your work while working on the site.
 The web server will be started on [http://localhost:4000](http://localhost:4000)
 
 As you make changes to the site, the site will automatically rebuild.
+
+# Publishing the website
+
+We want to deploy project changes (for example, new committers, PMC members or upcoming talks)
+immediately, but we want to deploy documentation of project features only when that feature appears
+in a release.
+
+Calcite publishes the website automatically since [CALCITE-3129](https://issues.apache.org/jira/browse/CALCITE-3129),
+you do not need to do anything but just merge your changes to the `main` branch,
+Github workflows will identify changes to website and automatically cherry-pick it to the `site` branch,
+compile and publish it to [calcite-site](https://github.com/apache/calcite-site) repo.
+
+## Non-release publishing
+
+We'll publish the website changes such as community member changes and new blogs immediately after merging.
+The rules and scripts are in `.github/workflows/publish-non-release-website-updates.yml`.
+
+## Release publishing
+
+We identify release publishing by checking new release tags. If you are the Release Manager,
+you only need to push the new tag 'calcite-x.y.z' to [Calcite Github repo](https://github.com/apache/calcite),
+and the Github workflow will do all the rest.
+The rules and scripts are in `.github/workflows/publish-website-on-release.yml`.
diff --git a/site/_config.yml b/site/_config.yml
index 4641ac5e05a..4759a1864ec 100644
--- a/site/_config.yml
+++ b/site/_config.yml
@@ -40,7 +40,7 @@ avaticaApiRoot: /avatica/apidocs
 # avaticaApiRoot: http://calcite.apache.org/avatica/apidocs
 
 # The URL where the JDK's Javadocs are located
-jdkApiRoot: https://docs.oracle.com/javase/8/docs/api/
+jdkApiRoot: https://docs.oracle.com/en/java/javase/17/docs/api/java.base/
 
 # The base path where the website is deployed
 baseurl:
diff --git a/site/_data/contributors.yml b/site/_data/contributors.yml
index d8a1f525dde..7feb12789cc 100644
--- a/site/_data/contributors.yml
+++ b/site/_data/contributors.yml
@@ -39,12 +39,23 @@
   apacheId: sereda
   githubId: asereda-gs
   org:
-  role: Committer
+  role: PMC
 - name: Ashutosh Chauhan
   apacheId: hashutosh
   githubId: ashutoshc
   org: Hortonworks
   role: PMC
+- name: Benchao Li
+  apacheId: libenchao
+  githubId: libenchao
+  pronouns: he/him
+  org: ByteDance
+  role: PMC
+- name: Bertil Chapuis
+  apacheId: bchapuis
+  githubId: bchapuis
+  org: HEIG-VD
+  role: Committer
 - name: Chris Baynes
   apacheId: cbaynes
   githubId: chris-baynes
@@ -59,12 +70,17 @@
   apacheId: chunwei
   githubId: chunweilei
   org: Alibaba
-  role: Committer
+  role: PMC
 - name: Danny Chan
   apacheId: danny0405
   githubId: danny0405
   org: Alibaba
   role: PMC
+- name: Dmitry Sysolyatin
+  apacheId: dmsysolyatin
+  githubId: dssysolyatin
+  org: Intertrust Technologies
+  role: Committer
 - name: Edmon Begoli
   apacheId: ebegoli
   githubId: ebegoli
@@ -101,6 +117,11 @@
   githubId: zhztheplayer
   org: Tencent
   role: Committer
+- name: Istvan Toth
+  apacheId: stoty
+  githubId: stoty
+  org: Cloudera
+  role: Committer
 - name: James R. Taylor
   apacheId: jamestaylor
   githubId: JamesRTaylor
@@ -121,11 +142,21 @@
   githubId: jcamachor
   org: Hortonworks
   role: PMC
+- name: Jiajun Xie
+  apacheId: jiajunxie
+  githubId: jiajunbernoulli
+  org: ByteDance
+  role: Committer
 - name: Jinfeng Ni
   apacheId: jni
   githubId: jinfengni
   org: MapR
   role: PMC
+- name: Jing Zhang
+  apacheId: jingzhang
+  githubId: beyond1920
+  org: Kuaishou
+  role: Committer
 - name: Jin Xing
   apacheId: jinxing
   githubId: jinxing64
@@ -216,7 +247,7 @@
   apacheId: rubenql
   githubId: rubenada
   org: TIBCO
-  role: PMC Chair
+  role: PMC
 - name: Rui Wang
   apacheId: amaliujia
   githubId: amaliujia
@@ -242,7 +273,7 @@
   githubId: zabetak
   pronouns: he/him
   org: Cloudera
-  role: PMC
+  role: PMC Chair
   homepage: https://people.apache.org/~zabetak/
 - name: Steven Noels
   apacheId: stevenn
@@ -268,7 +299,7 @@
   apacheId: vozerov
   githubId: devozerov
   org: Querify Labs
-  role: Committer
+  role: PMC
 - name: Volodymyr Vysotskyi
   apacheId: volodymyr
   githubId: vvysotskyi
diff --git a/site/_docs/algebra.md b/site/_docs/algebra.md
index 66b2792779e..d11c69a756b 100644
--- a/site/_docs/algebra.md
+++ b/site/_docs/algebra.md
@@ -309,6 +309,10 @@ LogicalRepeatUnion(all=[true])
         LogicalTableScan(table=[[aux]])
 {% endhighlight %}
 
+Note that there is no support for recursive queries in the SQL layer yet
+([CALCITE-129](https://issues.apache.org/jira/browse/CALCITE-129));
+the `WITH RECURSIVE` query above is only for illustrative purposes.
+
 ### API summary
 
 #### Relational operators
diff --git a/site/_docs/file_adapter.md b/site/_docs/file_adapter.md
index 05181334aaf..a8125581799 100644
--- a/site/_docs/file_adapter.md
+++ b/site/_docs/file_adapter.md
@@ -219,7 +219,7 @@ within the selected element, match within the selected text, and
 choose a data type for the resulting database column.  Processing
 steps are applied in the order described and replace and match
 patterns are based on
-[Java regular expressions](https://docs.oracle.com/javase/7/docs/api/java/util/regex/Pattern.html).
+[Java regular expressions](https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/regex/Pattern.html).
 
 ### Further examples
 
diff --git a/site/_docs/history.md b/site/_docs/history.md
index eaa1a2efdcf..d82167ca02c 100644
--- a/site/_docs/history.md
+++ b/site/_docs/history.md
@@ -28,15 +28,660 @@ For a full list of releases, see
 Downloads are available on the
 [downloads page]({{ site.baseurl }}/downloads/).
 
-{% comment %}
-## <a href="https://github.com/apache/calcite/releases/tag/calcite-1.31.0">1.31.0</a> / TODO
+<!--
+## <a href="https://github.com/apache/calcite/releases/tag/calcite-1.35.0">1.35.0</a> / XXXX-XX-XX
+{: #v1-35-0}
+
+This release comes x months after [1.34.0](#v1-34-0),
+contains contributions from x contributors, and resolves x issues.
+
+Contributors to this release:
+x,
+y (release manager),
+z.
+
+#### Breaking Changes
+{: #breaking-1-35-0}
+
+Compatibility: This release is tested on Linux, macOS, Microsoft Windows;
+using JDK/OpenJDK versions 8 to 18;
+Guava versions 16.0.1 to 31.1-jre;
+other software versions as specified in gradle.properties.
+
+#### New features
+{: #new-features-1-35-0}
+
+#### Dependency version upgrade
+{: #dependency-1-35-0}
+
+#### Bug-fixes, API changes and minor enhancements
+{: #fixes-1-35-0}
+
+#### Build and test suite
+{: #build-1-35-0}
+
+#### Web site and documentation
+{: #site-1-35-0}
+-->
+
+## <a href="https://github.com/apache/calcite/releases/tag/calcite-1.34.0">1.34.0</a> / 2023-03-14
+{: #v1-34-0}
+
+This release comes 1 month after [1.33.0](#v1-33-0),
+contains contributions from 18 contributors, and resolves 34 issues. It's worth highlighting the
+introduction of QUALIFY clause ([<a href="https://issues.apache.org/jira/browse/CALCITE-5268">CALCITE-5268</a>]),
+which facilitates filtering the results of window functions. Among other improvements and fixes, it
+adds roughly 15 new functions in BigQuery library for handling dates, times, and timestamps, and 
+provides a fix ([<a href="https://issues.apache.org/jira/browse/CALCITE-5522">CALCITE-5522</a>])
+for a small breaking change in `DATE_TRUNC` function
+([<a href="https://issues.apache.org/jira/browse/CALCITE-5447">CALCITE-5447</a>]), which was
+introduced accidentally in [1.33.0](#v1-33-0). 
+
+Contributors to this release:
+Alessandro Solimando,
+Benchao Li,
+Brandon Chong,
+Dmitry Sysolyatin,
+Francis Chuang,
+Gian Merlino,
+Guillaume Massé,
+Jiajun Xie,
+Julian Hyde,
+Moritz Mack,
+Oliver Lee,
+Peng Wang,
+Stamatis Zampetakis (release manager),
+Tanner Clary,
+Tim Nieradzik,
+TJ Banghart,
+xinqiu.hu,
+Zou Dan.
+
+<!--
+Command used to generate the release notes
+git log b64cb1325cfe1a5143ea3ca534f991b6f881c3c5..ee9b80b0b68d442991dfaa142722e3488ec73e79 --format="%s" | sed 's|\[\(CALCITE-[0-9]\+\)\]|* [<a href="https://issues.apache.org/jira/browse/\1">\1</a>]\n|'git log b64cb1325cfe1a5143ea3ca534f991b6f881c3c5..ee9b80b0b68d442991dfaa142722e3488ec73e79 --format="%s" | sed 's|\[\(CALCITE-[0-9]\+\)\]|* [<a href="https://issues.apache.org/jira/browse/\1">\1</a>]\n|'
+-->
+
+#### Breaking Changes
+{: #breaking-1-34-0}
+
+[<a href="https://issues.apache.org/jira/browse/CALCITE-3870">CALCITE-3870</a>]
+  Change the default value of
+[SqlToRelConverter.Config.expand](https://calcite.apache.org/javadocAggregate/org/apache/calcite/sql2rel/SqlToRelConverter.Config.html#isExpand())
+from true to false. From  now on `SqlToRelConverter`, handles sub-queries (such
+as `IN`, `EXISTS`, and scalar sub-queries) by converting them to `RexSubQuery`
+expressions, rather than expanding them. To expand these `RexSubQuery`
+expressions, the `SubQueryRemoveRule` rule must be enabled in the planning
+phase.
+To keep the old behavior (which is discouraged but still supported),
+initialize `SqlToRelConverter` using `SqlToRelConverter.config().withExpand(true)` as the value for
+the `config` argument.
+
+Compatibility: This release is tested on Linux, macOS, Microsoft Windows;
+using JDK/OpenJDK versions 8 to 18;
+Guava versions 16.0.1 to 31.1-jre;
+other software versions as specified in gradle.properties.
+
+#### New features
+{: #new-features-1-34-0}
+
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5268">CALCITE-5268</a>]
+  Add `QUALIFY` clause
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5469">CALCITE-5469</a>]
+  Add `DATETIME_ADD`, `DATETIME_DIFF`, `DATE_ADD`, `DATE_DIFF` functions (enabled in BigQuery library)
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5484">CALCITE-5484</a>]
+  Add `DATETIME_SUB` function (enabled in BigQuery library)
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5357">CALCITE-5357</a>]
+  Add `FORMAT_TIME`, `FORMAT_DATE`, `FORMAT_DATETIME`, `FORMAT_TIMESTAMP` functions (enabled in BigQuery library)
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5508">CALCITE-5508</a>]
+  Add constructor functions for `DATE`, `TIME`, `TIMESTAMP`, `DATETIME` (enabled in BigQuery library)
+
+#### Dependency version upgrade
+{: #dependency-1-34-0}
+
+* Bump Quidem from 0.10 to 0.11
+
+#### Bug-fixes, API changes and minor enhancements
+{: #fixes-1-34-0}
+
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5545">CALCITE-5545</a>]
+  Allow for overriding `SqlValidator` to enable custom `SqlNode` validation
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5504">CALCITE-5504</a>]
+  Array value constructor is unparsed incorrectly for `SparkSqlDialect`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5518">CALCITE-5518</a>]
+  `RelToSqlConverter` generates invalid order of `ROLLUP` fields
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5510">CALCITE-5510</a>]
+  `RelToSqlConverter` should use ordinal for `ORDER BY` if the dialect allows
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5478">CALCITE-5478</a>]
+  Use highest input precision for datetimes in `SqlTypeFactoryImpl.leastRestrictive`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5522">CALCITE-5522</a>]
+  Babel parser cannot handle some overloads of the `DATE_TRUNC` function
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5531">CALCITE-5531</a>]
+  `COALESCE` function throws `ClassCastException`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5507">CALCITE-5507</a>]
+  `HAVING` alias fails for mixed usage of alias and aggregate function
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5503">CALCITE-5503</a>]
+  `CheapestPlanReplacer` should reuse repeated nodes in a DAG plan
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5468">CALCITE-5468</a>]
+  `SqlToRelConverter` throws if `ORDER BY` contains `IN`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5515">CALCITE-5515</a>]
+  Add keyspace parameter to `CassandraSchema` and `CassandraTable`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5416">CALCITE-5416</a>]
+  JDBC adapter for MySQL 5 incorrectly combines `GROUP BY ROLLUP` and `ORDER BY` clauses
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5505">CALCITE-5505</a>]
+  JavaCC warns about missing LOOKAHEAD directives in Parser.jj
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5514">CALCITE-5514</a>]
+  In `RelJson`, add a public `toRex()` instance method
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5442">CALCITE-5442</a>]
+  Tweak janino code generation in `EnumerableInterpretable` to allow debugging
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5521">CALCITE-5521</a>]
+  Remove redundant rowtype check in `RelSubset#add`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5483">CALCITE-5483</a>]
+  `ProjectAggregateMergeRule` throws exception if literal is non-numeric
+* `TryThreadLocal` values are now not-null by default
+
+#### Build and test suite
+{: #build-1-34-0}
+
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5546">CALCITE-5546</a>]
+  Code style: Break long assignment expressions after '='
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5501">CALCITE-5501</a>]
+  `SqlToRelConverterTest.checkActualAndReferenceFiles` fails intermittently in Jenkins CI
+* Add test for [<a href="https://issues.apache.org/jira/browse/CALCITE-5524">CALCITE-5524</a>] JDBC adapter generates `LIMIT`, `OFFSET` in wrong order for Presto dialect
+* Add tests for [<a href="https://issues.apache.org/jira/browse/CALCITE-2980">CALCITE-2980</a>] Implement the `FORMAT` clause of the `CAST` operator
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5537">CALCITE-5537</a>]
+  Slow test case failures in `LatticeSuggesterTest`
+* Autostyle: Disallow space or newline before ')' in method declaration or call
+
+#### Web site and documentation
+{: #site-1-34-0}
+
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5555">CALCITE-5555</a>]
+  Remove obsolete instructions for processing requests for new JIRA accounts
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5550">CALCITE-5550</a>]
+  Update instructions for requesting Jira account to use self-serve facility
+* `CompositeOperandTypeChecker`'s javadoc uses wrong class name
+
+## <a href="https://github.com/apache/calcite/releases/tag/calcite-1.33.0">1.33.0</a> / 2023-02-06
+{: #v1-33-0}
+
+This release comes five months after [1.32.0](#v1-32-0),
+contains contributions from 33 contributors, and resolves 107 issues.
+
+Among others, it is worth highlighting the following improvements:
+
+* Many improvements to the BigQuery dialect as part of [<a href="https://issues.apache.org/jira/browse/CALCITE-5180">CALCITE-5180</a>]
+  * [<a href="https://issues.apache.org/jira/browse/CALCITE-5269">CALCITE-5269</a>]
+    Implement BigQuery `TIME_TRUNC` and `TIMESTAMP_TRUNC` functions
+  * [<a href="https://issues.apache.org/jira/browse/CALCITE-5360">CALCITE-5360</a>]
+    Implement `TIMESTAMP_ADD` function (compatible with BigQuery)
+  * [<a href="https://issues.apache.org/jira/browse/CALCITE-5389">CALCITE-5389</a>]
+    Add `STARTS_WITH` and `ENDS_WITH` functions (for `BIG_QUERY` compatibility)
+  * [<a href="https://issues.apache.org/jira/browse/CALCITE-5404">CALCITE-5404</a>]
+    Implement BigQuery's `POW()` and `TRUNC()` math functions
+  * [<a href="https://issues.apache.org/jira/browse/CALCITE-5423">CALCITE-5423</a>]
+    Implement `TIMESTAMP_DIFF` function (compatible with BigQuery)
+  * [<a href="https://issues.apache.org/jira/browse/CALCITE-5430">CALCITE-5430</a>]
+    Implement `IFNULL()` for BigQuery dialect
+  * [<a href="https://issues.apache.org/jira/browse/CALCITE-5432">CALCITE-5432</a>]
+    Implement BigQuery `TIME_ADD`/`TIME_DIFF`
+  * [<a href="https://issues.apache.org/jira/browse/CALCITE-5436">CALCITE-5436</a>]
+    Implement `DATE_SUB`, `TIME_SUB`, `TIMESTAMP_SUB` (compatible w/ BigQuery)
+  * [<a href="https://issues.apache.org/jira/browse/CALCITE-5447">CALCITE-5447</a>]
+    Add `DATE_TRUNC` for BigQuery
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5105">CALCITE-5105</a>]
+  Add `MEASURE` type and `AGGREGATE` aggregate function
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5155">CALCITE-5155</a>]
+  Custom time frames
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5280">CALCITE-5280</a>]
+  Implement geometry aggregate functions
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5314">CALCITE-5314</a>]
+  Prune empty parts of a query by exploiting stats/metadata
+
+
+Contributors to this release:
+Aitozi,
+Aleksey Plekhanov,
+Alessandro Solimando,
+Benchao Li,
+Bertil Chapuis,
+Christophe Le Saec,
+Dmitry Sysolyatin,
+Francis Chuang,
+Gian Merlino,
+Greg Hart,
+Hanumath Maduri,
+Istvan Toth,
+Jake Xie,
+James Turton,
+Jasmin Trada,
+Jess Balint (release manager),
+Julian Hyde,
+Kevin Risden,
+Krisztian Kasa,
+Liya Fan,
+Mou Wu,
+Oliver Lee,
+Scott Reynolds,
+Sergey Nuyanzin,
+Stamatis Zampetakis,
+TJ Banghart,
+Tanner Clary,
+Thomas Rebele,
+Tim Nieradzik,
+Volodymyr Vysotskyi,
+Xurenhe,
+Zhengqiang Duan,
+Zou Dan.
+
+#### Breaking Changes
+{: #breaking-1-33-0}
+
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5293">CALCITE-5293</a>]
+  Support general set operators in `PruneEmptyRules`. The default configuration of `PruneEmptyRules` for Set operators has changed: the rules matching scope has increased.
+
+
+Compatibility: This release is tested on Linux, macOS, Microsoft Windows;
+using JDK/OpenJDK versions 8 to 18;
+Guava versions 16.0.1 to 31.1-jre;
+other software versions as specified in gradle.properties.
+
+#### New features
+{: #new-features-1-33-0}
+
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-2884">CALCITE-2884</a>]
+  Implement `JSON_INSERT`, `JSON_REPLACE`, `JSON_SET`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-4186">CALCITE-4186</a>]
+  Add `ST_CoveredBy` spatial function
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5105">CALCITE-5105</a>]
+  Add `MEASURE` type and `AGGREGATE` aggregate function
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5127">CALCITE-5127</a>]
+  Support correlation variables in Project
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5155">CALCITE-5155</a>]
+  Custom time frames
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5159">CALCITE-5159</a>]
+  `ARRAY` string constructor, and implicit cast from string literal (enabled in PostgreSQL conformance)
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5269">CALCITE-5269</a>]
+  Implement BigQuery `TIME_TRUNC` and `TIMESTAMP_TRUNC` functions
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5280">CALCITE-5280</a>]
+  Implement geometry aggregate functions
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5281">CALCITE-5281</a>]
+  Implement geometry set returning functions (SRF)
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5283">CALCITE-5283</a>]
+  Add `ARG_MIN`, `ARG_MAX` (aka `MIN_BY`, `MAX_BY`) aggregate functions
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5360">CALCITE-5360</a>]
+  Implement `TIMESTAMP_ADD` function (compatible with BigQuery)
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5362">CALCITE-5362</a>]
+  Implement geometry measurement functions
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5389">CALCITE-5389</a>]
+  Add `STARTS_WITH` and `ENDS_WITH` functions (for `BIG_QUERY` compatibility)
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5393">CALCITE-5393</a>]
+  `VALUE` as an synonym for `VALUES` keyword (enabled in MySQL conformance)
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5404">CALCITE-5404</a>]
+  Implement BigQuery's `POW()` and `TRUNC()` math functions
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5423">CALCITE-5423</a>]
+  Implement `TIMESTAMP_DIFF` function (compatible with BigQuery)
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5430">CALCITE-5430</a>]
+  Implement `IFNULL()` for BigQuery dialect
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5432">CALCITE-5432</a>]
+  Implement BigQuery `TIME_ADD`/`TIME_DIFF`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5436">CALCITE-5436</a>]
+  Implement `DATE_SUB`, `TIME_SUB`, `TIMESTAMP_SUB` (compatible w/ BigQuery)
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5447">CALCITE-5447</a>]
+  Add `DATE_TRUNC` for BigQuery
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5451">CALCITE-5451</a>]
+  Implement `LPAD()` and `RPAD()` functions
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5495">CALCITE-5495</a>]
+  Allow `WEEK` and `QUARTER` in `INTERVAL` literals
+
+#### Dependency version upgrade
+{: #dependency-1-33-0}
+
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5341">CALCITE-5341</a>]
+  Upgrade Calcite to Avatica 1.23.0
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5351">CALCITE-5351</a>]
+  Bump jackson to 2.13.4 and jackson databind to 2.13.4.2 to avoid CVEs
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5356">CALCITE-5356</a>]
+  Update junit4 to 4.13.2 and junit5 to 5.9.1
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5374">CALCITE-5374</a>]
+  Upgrade jackson version to 2.14.0
+
+#### Bug-fixes, API changes and minor enhancements
+{: #fixes-1-33-0}
+
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-4351">CALCITE-4351</a>]
+  `RelMdUtil#numDistinctVals` always returns 0 for large inputs
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-4632">CALCITE-4632</a>]
+  Exception in `RelToSqlConverter`: "Cannot convert x to DECIMAL(n, m) due to overflow"
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-4804">CALCITE-4804</a>]
+  Support `Snapshot` operator serialization and deserialization
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-4972">CALCITE-4972</a>]
+  Subfields of array columns containing structs are not qualified in `getFieldOrigins`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-4982">CALCITE-4982</a>]
+  Do not push 'cast to not null' through `Join` in `ProjectJoinTransposeRule`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5141">CALCITE-5141</a>]
+  Incomplete implicit type conversion for insert values
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5209">CALCITE-5209</a>]
+  Proper sub-query handling if it is used inside select list and group by
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5217">CALCITE-5217</a>]
+  Implement `unparseSqlIntervalLiteral` in the Firebolt dialect
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5230">CALCITE-5230</a>]
+  Return type of `PERCENTILE_DISC` should be the same as sort expression
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5252">CALCITE-5252</a>]
+  JDBC adapter sometimes miss parentheses around `SELECT` in `WITH_ITEM` body
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5253">CALCITE-5253</a>]
+  `NATURAL` join and `USING` should fail if join columns are not unique - expression validation partially broken
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5259">CALCITE-5259</a>]
+  Add `getParameterRowType` method to `Planner` interface
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5264">CALCITE-5264</a>]
+  `HintStrategy` rule exclusion does not match innermost rels
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5265">CALCITE-5265</a>]
+  JDBC adapter sometimes adds unnecessary parentheses around `SELECT` in `INSERT`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5267">CALCITE-5267</a>]
+  Remove unused variable 'newCasts' in `AggregateCaseToFilterRule`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5276">CALCITE-5276</a>]
+  Implicitly convert strings to geometries
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5286">CALCITE-5286</a>]
+  Join with parameterized `LIMIT` throws `AssertionError` "not a literal"
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5288">CALCITE-5288</a>]
+  Expression `(a > 5 and a < 15) or (a > 10 and a < 20)` should be simplified to `SEARCH(a, Sarg[(5..20)])`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5291">CALCITE-5291</a>]
+  Make BigQuery lexical policy case insensitive
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5293">CALCITE-5293</a>]
+  Support general set operators in `PruneEmptyRules`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5294">CALCITE-5294</a>]
+  Prune the null-generating side of an outer join if it is empty
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5296">CALCITE-5296</a>]
+  In a query with `ROLLUP`, validator wrongly infers that a column is `NOT NULL`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5297">CALCITE-5297</a>]
+  Casting dynamic variable twice throws exception
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5298">CALCITE-5298</a>]
+  CalciteSystemProperty `calcite.test.dataset` path check fails under Java Security Manager
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5299">CALCITE-5299</a>]
+  JDBC adapter sometimes adds unnecessary parentheses around `SELECT` in `WITH` body
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5305">CALCITE-5305</a>]
+  Character literals with C-style escapes
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5310">CALCITE-5310</a>]
+  `JSON_OBJECT` in scalar sub-query throws `AssertionError`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5314">CALCITE-5314</a>]
+  Prune empty parts of a query by exploiting stats/metadata
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5326">CALCITE-5326</a>]
+  `SqlMerge` generate extra bracket on `toSqlString`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5332">CALCITE-5332</a>]
+  Configuring `PruneEmptyRules` is cumbersome
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5336">CALCITE-5336</a>]
+  Support inferring constants from predicates with `IS NOT DISTINCT FROM` operator
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5337">CALCITE-5337</a>]
+  `UnionPullUpConstantsRule` produces an invalid plan when pulling up constants for nullable fields
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5339">CALCITE-5339</a>]
+  Use `Method#getParameterCount` rather than `Method#getParameters` to get length
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5342">CALCITE-5342</a>]
+  Refactor SqlFunctions `lastDay`, `addMonths`, `subtractMonths` to use `DateTimeUtils` from Avatica
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5348">CALCITE-5348</a>]
+  When translating `ORDER BY` in `OVER`, use the session's default null collation (e.g. `NULLS LAST`)
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5349">CALCITE-5349</a>]
+  `RelJson` deserialization should support `SqlLibraryOperators`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5355">CALCITE-5355</a>]
+  Use the Presto SQL dialect for AWS Athena
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5377">CALCITE-5377</a>]
+  `RelFieldTrimmer` support Sort with dynamic param
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5383">CALCITE-5383</a>]
+  Update `CONCAT` function to allow `BIG_QUERY`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5385">CALCITE-5385</a>]
+  Add BigQuery as supported library for implemented functions
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5388">CALCITE-5388</a>]
+  `tempList` expression inside `EnumerableWindow.getPartitionIterator` should be unoptimized
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5391">CALCITE-5391</a>]
+  `JoinOnUniqueToSemiJoinRule` should preserve field names, if possible
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5392">CALCITE-5392</a>]
+  Support `Snapshot` in `RelMdExpressionLineage`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5394">CALCITE-5394</a>]
+  `RelToSqlConverter` fails when semi-join is under a join node
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5395">CALCITE-5395</a>]
+  `RelToSqlConverter` fails when `SELECT *` is under a semi-join node
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5405">CALCITE-5405</a>]
+  MongoDB: Invalid `TIMESTAMP` conversion
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5407">CALCITE-5407</a>]
+  MongoDB: Invalid `ARRAY` conversion
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5408">CALCITE-5408</a>]
+  Return type of `PERCENTILE_CONT` should be the same as sort expression
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5410">CALCITE-5410</a>]
+  Assertion error on `PERCENT_REMAINDER` operator with `DECIMAL` type
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5414">CALCITE-5414</a>]
+  Use `DateTimeUtils` to correctly convert between `java.sql` types and Unix timestamps
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5424">CALCITE-5424</a>]
+  Customize handling of literals based on type system
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5439">CALCITE-5439</a>]
+  Validation of Pivot fails after creating a deep copy of `SqlNode`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5450">CALCITE-5450</a>]
+  Add support for `WEEK(WEEKDAY)` for custom time frames to relevant functions
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5452">CALCITE-5452</a>]
+  Add BigQuery `LENGTH()` as synonym for `CHAR_LENGTH()`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5454">CALCITE-5454</a>]
+  Update BigQuery Conformance for `!=` and `%` operators
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5466">CALCITE-5466</a>]
+  Constant condition can't be reduced after correlate
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5471">CALCITE-5471</a>]
+  `RelSupplier.SqlRelSupplier#apply` should use `.project()`, not `.rel`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5489">CALCITE-5489</a>]
+  When creating a `RexCall` to `TIMESTAMP_DIFF` function, cannot convert a `TIMESTAMP` literal to a `org.apache.calcite.avatica.util.TimeUnit`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5491">CALCITE-5491</a>]
+  Allow `TIME` and `DATE` to be args for `TIMESTAMPDIFF`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5493">CALCITE-5493</a>]
+  Time zone tests in `SqlFunctions` should pass in `Europe/London`
+
+#### Build and test suite
+{: #build-1-33-0}
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5197">CALCITE-5197</a>]
+  Bump gradle to 7.4.2 and add checksum autoupdate
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5306">CALCITE-5306</a>]
+  Remove JDK15/16 EOL non-LTS JDKs in CI
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5340">CALCITE-5340</a>]
+  Tests should fail when actual and expected XML reference files are not identical
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5417">CALCITE-5417</a>]
+  Include Proj4J as an api dependency once the license allows it
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5427">CALCITE-5427</a>]
+  Provide code quality/coverage metrics with SonarCloud and JaCoCo
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5428">CALCITE-5428</a>]
+  Reduce minimum Guava version to 16.0.1
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5433">CALCITE-5433</a>]
+  Druid tests hang/fail intermittently in CI
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5474">CALCITE-5474</a>]
+  Disable Sonar quality gates to avoid checks appearing as failures
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5475">CALCITE-5475</a>]
+  Improve test coverage accuracy by aggregating modules
+
+#### Web site and documentation
+{: #site-1-33-0}
+
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5239">CALCITE-5239</a>]
+  Site: JDBC Adapter's current limitations is incorrect
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5287">CALCITE-5287</a>]
+  SQL reference page is missing from website
+
+## <a href="https://github.com/apache/calcite/releases/tag/calcite-1.32.0">1.32.0</a> / 2022-09-10
+{: #v1-32-0}
+
+This release
+<a href="https://issues.apache.org/jira/browse/CALCITE-5263">fixes</a>
+<a href="http://cve.mitre.org/cgi-bin/cvename.cgi?name=2022-39135">CVE-2022-39135</a>,
+an XML External Entity (XEE) vulnerability that allows a SQL query to
+read the contents of files via the SQL functions `EXISTS_NODE`,
+`EXTRACT_XML`, `XML_TRANSFORM` or `EXTRACT_VALUE`.
+
+Coming 1 month after [1.31.0](#v1-31-0) with 19 issues fixed by 17
+contributors, this release also
+<a href="https://issues.apache.org/jira/browse/CALCITE-4294">replaces
+the ESRI spatial engine with JTS and proj4j</a>, adds
+<a href="https://issues.apache.org/jira/browse/CALCITE-5262">65
+spatial SQL functions</a> including `ST_Centroid`, `ST_Covers` and
+`ST_GeomFromGeoJSON`, adds the
+<a href="https://issues.apache.org/jira/browse/CALCITE-5241">CHAR</a>
+SQL function, and improves the return type of the
+<a href="https://issues.apache.org/jira/browse/CALCITE-4999">ARRAY and
+MULTISET</a> functions.
+
+Contributors to this release:
+Alessandro Solimando,
+Ali Mansour,
+Andrei Sereda,
+Benchao Li,
+Bertil Chapuis,
+Chunwei Lei,
+David Handermann,
+Dmitry Sysolyatin,
+Jiajun Bernoulli,
+Jing Zhang,
+Julian Hyde (release manager),
+Lincoln Lee,
+Mou Wu,
+Ruben Quesada Lopez,
+Stamatis Zampetakis,
+TJ Banghart,
+Zhengqiang Duan.
+
+{: #breaking-1-32-0}
+
+Compatibility: This release is tested on Linux, macOS, Microsoft Windows;
+using JDK/OpenJDK versions 8 to 18;
+Guava versions 19.0 to 31.1-jre;
+other software versions as specified in gradle.properties.
+
+#### New features
+{: #new-features-1-32-0}
+
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5262">CALCITE-5262</a>]
+  Add many spatial functions, including support for WKB (well-known binary) and
+  GeoJSON
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5241">CALCITE-5241</a>]
+  Implement `CHAR` function for MySQL and Spark, also JDBC `{fn CHAR(n)}`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5251">CALCITE-5251</a>]
+  Support SQL hint for `Snapshot`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-4802">CALCITE-4802</a>]
+  Support `IF(condition, then, else)` statements in Babel parser
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-4999">CALCITE-4999</a>]
+  `ARRAY`, `MULTISET` functions should return a collection of scalars if a
+  sub-query returns 1 column
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5126">CALCITE-5126</a>]
+  Implicit column alias for single-column `UNNEST` should work with any
+  single-column `UNNEST`'s input
+
+#### Dependency version upgrade
+{: #dependency-1-32-0}
+
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5278">CALCITE-5278</a>]
+  Upgrade Janino from 3.1.6 to 3.1.8
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5232">CALCITE-5232</a>]
+  Upgrade protobuf-java from 3.17.1 to 3.21.5
+
+#### Bug-fixes, API changes and minor enhancements
+{: #fixes-1-32-0}
+
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5270">CALCITE-5270</a>]
+  JDBC adapter should not generate `FILTER (WHERE ...)` in Firebolt dialect
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5277">CALCITE-5277</a>]
+  Increase `BINDABLE_CACHE` hit rate by making the order of
+  `EnumerableRelImplementor.stashedParameters` deterministic
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5263">CALCITE-5263</a>]
+  SQL functions `EXISTS_NODE`, `EXTRACT_XML`, `XML_TRANSFORM` and `EXTRACT_VALUE`
+  allow user files to be read via XML External Entity (XEE) vulnerability
+  <a href="http://cve.mitre.org/cgi-bin/cvename.cgi?name=2022-39135">CVE-2022-39135</a>
+  (fixed by using a secure implementation of XML `DocumentBuilder`)
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-4294">CALCITE-4294</a>]
+  Use JTS and proj4j rather than ESRI as the underlying library for geospatial
+  (`ST_`) functions
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5247">CALCITE-5247</a>]
+  `FilterJoinRule` cannot simplify left join to inner join for
+  `WHERE RHS.C1 IS NOT NULL OR RHS.C2 IS NOT NULL`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5243">CALCITE-5243</a>]
+  `SELECT NULL AS C` causes
+  `NoSuchMethodException: java.sql.ResultSet.getVoid(int)`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5201">CALCITE-5201</a>]
+  Improve `SemiJoinRule` to match `Join`'s right input which is unique for join
+  keys
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-4223">CALCITE-4223</a>]
+  Metadata handlers for `TableScan` should see whether the `RelOptTable`
+  implements the handler
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5178">CALCITE-5178</a>]
+  Single column with `ROW` type generates wrong plan
+
+#### Build and test suite
+{: #build-1-32-0}
+
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5274">CALCITE-5274</a>]
+  In `DiffRepository`, use a more secure `DocumentBuilderFactory` instance
+* Add tests for correlated CTEs
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5192">CALCITE-5192</a>]
+  `CodeGenerationBenchmark` throws `IllegalStateException`
+
+#### Web site and documentation
+{: #site-1-32-0}
+
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5275">CALCITE-5275</a>]
+  Release notes for Calcite 1.32.0
+* Cosmetic changes to release notes
+* Remove redundant 'the' in javadoc
+* Change sereda's role from Committer to PMC
+* Fix 1.31.0 release date to 2022-08-02 (was 2022-08-01)
+* Fix checkstyle violation for Calcite 1.31 release note
+
+## <a href="https://github.com/apache/calcite/releases/tag/calcite-1.31.0">1.31.0</a> / 2022-08-02
 {: #v1-31-0}
 
+This release comes four months after [1.30.0](#v1-30-0),
+contains contributions from 28 contributors, and resolves 81 issues.
+
+Among others, it is worth highlighting the following improvements:
+
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-4865">CALCITE-4865</a>]
+  Allow table functions to be polymorphic
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5107">CALCITE-5107</a>]
+  Support SQL hint for `Filter`, `SetOp`, `Sort`, `Window`, `Values`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-35">CALCITE-35</a>]
+  Support parsing parenthesized joins
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-3890">CALCITE-3890</a>]
+  Derive `IS NOT NULL` filter for the inputs of inner join
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5085">CALCITE-5085</a>]
+  Firebolt dialect implementation
+
+Contributors to this release:
+Ada Wang,
+Andrei Sereda (release manager),
+Benchao Li,
+Chunwei Lei,
+Daniel Henneberger,
+Dmitry Sysolyatin,
+Francis Chuang,
+godfreyhe,
+hannerwang,
+henneberger,
+Jing Zhang,
+Julian Hyde,
+Konstantin Orlov,
+Liya Fan,
+Michael Mior,
+NobiGo,
+onTheQT,
+Roman Kondakov,
+Ruben Quesada Lopez,
+Sergey Nuyanzin,
+Stamatis Zampetakis,
+Viliam Durina,
+Vladimir Ozerov,
+Volodymyr Vysotskyi,
+Wenrui Meng,
+xiejiajun,
+xurenhe,
+zhangyue.
+
 #### Breaking Changes
 {: #breaking-1-31-0}
 
 * [<a href="https://issues.apache.org/jira/browse/CALCITE-4936">CALCITE-4936</a>]
-  Generalize `FilterCalcMergeRule`/`ProjectCalcMergeRule` to accept any `Filter`/`Project`/`Calc` operator
+  Generalize `FilterCalcMergeRule`/`ProjectCalcMergeRule` to accept any
+  `Filter`/`Project`/`Calc` operator.
+  * Old behavior: The Project operator is transformed into Calc.
+  * New behavior: The Project operator is not transformed and the rule becomes NOOP.
 
 Compatibility: This release is tested on Linux, macOS, Microsoft Windows;
 using JDK/OpenJDK versions 8 to 18;
@@ -46,18 +691,214 @@ other software versions as specified in gradle.properties.
 #### New features
 {: #new-features-1-31-0}
 
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-4865">CALCITE-4865</a>]
+  Allow table functions to be polymorphic
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5089">CALCITE-5089</a>]
+  Allow `GROUP BY ALL` or `DISTINCT` set quantifier on `GROUPING SETS`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5085">CALCITE-5085</a>]
+  Firebolt dialect implementation
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5086">CALCITE-5086</a>]
+  SQL parser should allow `OFFSET` to occur before `LIMIT`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5125">CALCITE-5125</a>]
+  Extend `||` operator to work with arrays
+
+#### Dependency version upgrade
+{: #dependency-1-31-0}
+
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5196">CALCITE-5196</a>]
+  Bump apiguardian to 1.1.2
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5221">CALCITE-5221</a>]
+  Upgrade Avatica version to 1.22.0. Vulnerability fix
+  <a href="http://cve.mitre.org/cgi-bin/cvename.cgi?name=2022-36364">CVE-2022-36364</a>
+  (see <a href="https://issues.apache.org/jira/browse/CALCITE-5218">CALCITE-5218</a>)
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5115">CALCITE-5115</a>]
+  Upgrade jackson-databind from 2.9.10.1 to 2.13.2.1, and jackson from 2.10.0 to 2.13.2.1
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5112">CALCITE-5112</a>]
+  Upgrade Jetty from 9.4.15.v20190215 to 9.4.46.v20220331
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5070">CALCITE-5070</a>]
+  Upgrade Jekyll and ruby gems for site generation
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5037">CALCITE-5037</a>]
+  Upgrade HSQLDB to 2.5.2
+
+
 #### Bug-fixes, API changes and minor enhancements
 {: #fixes-1-31-0}
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-35">CALCITE-35</a>]
+  Support parsing parenthesized joins
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5169">CALCITE-5169</a>]
+  `xx < 1 OR xx > 1` cannot be simplified to `xx <> 1`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-4448">CALCITE-4448</a>]
+  Use `TableMacro` user-defined table functions with `QueryableTable`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5000">CALCITE-5000</a>]
+  Expand `AGGREGATE_REDUCE_FUNCTIONS`, when arg of agg-call exists in the
+  aggregate's group
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5091">CALCITE-5091</a>]
+  `RelMdRowCount` can return more accurate rowCount when fetch is deterministic
+  and offset is dynamic
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5149">CALCITE-5149</a>]
+  Refine `RelMdColumnUniqueness` for Aggregate by considering intersect keys
+  between target keys and group keys
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5036">CALCITE-5036</a>]
+  `RelMdPredicates` support to analyze constant key for the operator of
+  `IS_NOT_DISTINCT_FROM`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5044">CALCITE-5044</a>]
+  JDBC adapter generates integer literal in `ORDER BY`, which some dialects
+  wrongly interpret as a reference to a field
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-4936">CALCITE-4936</a>]
+  Generalize `FilterCalcMergeRule`/`ProjectCalcMergeRule` to accept any
+  `Filter`/`Project`/`Calc` operator
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5083">CALCITE-5083</a>]
+  In `RelBuilder.project_`, do not unwrap SARGs
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5061">CALCITE-5061</a>]
+  Improve recursive application of the field trimming
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-3890">CALCITE-3890</a>]
+  Derive `IS NOT NULL` filter for the inputs of inner join
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5118">CALCITE-5118</a>]
+  `SqlDatePartFunction#rewriteCall` should check operands length
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5162">CALCITE-5162</a>]
+  `RelMdUniqueKeys` can return more precise unique keys for Aggregate
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5073">CALCITE-5073</a>]
+  `JoinConditionPushRule` cannot infer `LHS.C1 = LHS.C2` from
+  `LHS.C1 = RHS.C1 AND LHS.C2 = RHS.C1`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5107">CALCITE-5107</a>]
+  Support SQL hint for `Filter`, `SetOp`, `Sort`, `Window`, `Values`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5194">CALCITE-5194</a>]
+  Cannot parse parenthesized `UNION` in `FROM`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5206">CALCITE-5206</a>]
+  Parser allows `MERGE` with mismatched parentheses
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-4746">CALCITE-4746</a>]
+  `PIVOT` with aggregate and no without alias fails in Babel parser
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5045">CALCITE-5045</a>]
+  Alias within GroupingSets throws type mis-match exception
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5145">CALCITE-5145</a>]
+  `CASE` statement within `GROUPING SETS` throws type mis-match exception
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5195">CALCITE-5195</a>]
+  `ArrayIndexOutOfBoundsException` when inferring more equal conditions from join
+  condition for semi join
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5157">CALCITE-5157</a>]
+  Query that applies dot operator (field access) to parenthesized expression
+  throws `ClassCastException`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5191">CALCITE-5191</a>]
+  Allow `ORDER BY` alias in BigQuery
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5134">CALCITE-5134</a>]
+  Queries with subquery inside select list does not work if subquery uses table
+  from left join
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5177">CALCITE-5177</a>]
+  Query loses hint after decorrelation
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5143">CALCITE-5143</a>]
+  Allow custom time unit abbreviations in `FLOOR`, `CEIL`, `EXTRACT`,
+  `DATE_PART`, `DATEADD`, `DATEDIFF` and similar functions
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5179">CALCITE-5179</a>]
+  In `RelToSqlConverter`, `AssertionError` for values with more than two items
+  when `SqlDialect#supportsAliasedValues` is false
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-4907">CALCITE-4907</a>]
+  JDBC adapter cannot push down join ON `TRUE` (cartesian product)
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5147">CALCITE-5147</a>]
+  Allow `DATE`, `TIME`, `TIMESTAMP`, `INTERVAL` literals in BigQuery dialect
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5013">CALCITE-5013</a>]
+  Unparse `SqlSetOperator` should be retained parentheses when generating SQL for
+  `UNION ... LIMIT`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-4897">CALCITE-4897</a>]
+  Implicit type conversion is not complete for set operation in DML
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5027">CALCITE-5027</a>]
+  Incorrect format for timestamp literals in `SqlDialect.quoteTimestampLiteral`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5153">CALCITE-5153</a>]
+  Create an immutable version of `ListSqlOperatorTable`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5139">CALCITE-5139</a>]
+  Improve Join print plan to add the `CorrelationId` info
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5003">CALCITE-5003</a>]
+  `MergeUnion` on types with different collators produces wrong result
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5117">CALCITE-5117</a>]
+  Optimize the `EXISTS` sub-query using `RelMdRowCount` metadata
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-4861">CALCITE-4861</a>]
+  Optimization of chained `CAST` calls can lead to unexpected behavior
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5048">CALCITE-5048</a>]
+  Query with parameterized `LIMIT` and correlated sub-query throws
+  `AssertionError`, "not a literal"
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5032">CALCITE-5032</a>]
+  `RelOptUtil#splitJoinCondition` returns wrong when there is no equal condition
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-4992">CALCITE-4992</a>]
+  Resource leak in Elasticsearch adapter
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-4401">CALCITE-4401</a>]
+  `SqlJoin.toString` throws `RuntimeException`, "No list started"
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5088">CALCITE-5088</a>]
+  `JsonBuilder` should escape backslashes in JSON strings
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5021">CALCITE-5021</a>]
+  Double `JOIN` is created for `NOT IN` when `IN`-list that the values all
+  non-nullable is converted to `Values`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5064">CALCITE-5064</a>]
+  Dialect factory returns ANSI SQL dialect for BigQuery
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-4989">CALCITE-4989</a>]
+  Nested JSON_OBJECT creation does not produce proper JSON
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5050">CALCITE-5050</a>]
+  Metadata (`RelMdRowCount`) should reflect the fact that an `Aggregate` with no
+  `GROUP BY` always returns 1 row
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-4913">CALCITE-4913</a>]
+  Deduplicate correlated variables in `SELECT` clause
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5150">CALCITE-5150</a>]
+  Parser should parse subquery with order by inside array constructor
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5171">CALCITE-5171</a>]
+  `NATURAL` join and `USING` should fail if join columns are not unique
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5170">CALCITE-5170</a>]
+  Assertion error on range distribution creation
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5163">CALCITE-5163</a>]
+  `MysqlSqlDialect` support to unparse `LISTAGG` aggregate function
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5166">CALCITE-5166</a>]
+  Method `accept(RelShuttle)` is not overridden in `LogicalCalc` and
+  `LogicalTableModify`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5137">CALCITE-5137</a>]
+  `EnumerableUncollect` throws `NullPointerException` if input has ((List) null)
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5081">CALCITE-5081</a>]
+  Group keys of Aggregate are wrongly changed during decorrelation
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5138">CALCITE-5138</a>]
+  Join on condition generates wrong plan when the condition is sub-query
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5131">CALCITE-5131</a>]
+  Remove redundant type cast
 
 #### Build and test suite
 {: #build-1-31-0}
 
-#### Dependency version upgrade
-{: #dependency-1-31-0}
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5095">CALCITE-5095</a>]
+  Support Java 18 and Guava 31.1-jre
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5140">CALCITE-5140</a>]
+  Spark, Piglet tests fail in GitHub CI with OpenJ9
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-4147">CALCITE-4147</a>]
+  Rename master branch to main
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5038">CALCITE-5038</a>]
+  Making `AGGREGATE_ANY_PULL_UP_CONSTANTS`'s test case more rigorous
 
 #### Web site and documentation
 {: #site-1-31-0}
-{% endcomment %}
+
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5092">CALCITE-5092</a>]
+  Update [site/README.md](https://github.com/apache/calcite/blob/main/site/README.md)
+  about how to release the site
+* Site: Add Jing Zhang as committer
+* Site: Add Benchao Li as committer
+* Site: Add Chunwei Lei and Vladimir Ozerov as PMC members
+* Site: Outline process for becoming Calcite committer by request
+* Site: Remove missing avatar for Ted Dunning
+* Site: Fix release announcement for 1.30.0
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5075">CALCITE-5075</a>]
+  Build fails due to rat check on Gemfile.lock
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5079">CALCITE-5079</a>]
+  Update code demo of tutorial
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5102">CALCITE-5102</a>]
+  Update github-pages gem for site build
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5106">CALCITE-5106</a>]
+  Upgrade to Jekyll 4 and remove unnecessary dependencies from gemfile for site
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5108">CALCITE-5108</a>]
+  Make website GDPR-compliant
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5110">CALCITE-5110</a>]
+  Geode adapter's java doc url is invalid
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5165">CALCITE-5165</a>]
+  Improve javadoc
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-3129">CALCITE-3129</a>]
+  Automate website builds
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5111">CALCITE-5111</a>]
+  jekyll-cache directory should be ignored by git
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5015">CALCITE-5015</a>]
+  Fix typo in `PartiallyOrderedSet`
 
 ## <a href="https://github.com/apache/calcite/releases/tag/calcite-1.30.0">1.30.0</a> / 2022-03-20
 {: #v1-30-0}
@@ -79,7 +920,6 @@ Guava versions 19.0 to 31.0.1-jre;
 other software versions as specified in gradle.properties.
 
 Contributors to this release:
-
 Alessandro Solimando,
 Bill Neil,
 Chen Kai,
@@ -91,8 +931,9 @@ Jay Narale,
 Jiatao Tao,
 Jing Zhang,
 Julian Hyde,
-LM Kang,
 Liya Fan (release manager),
+LM Kang,
+mans2singh,
 Marco Jorge,
 Marieke Gueye,
 NobiGo,
@@ -104,11 +945,10 @@ Stamatis Zampetakis,
 Vova Vysotskyi,
 Will Noble,
 Xiong Duan,
+Xurenhe,
 Yanjing Wang,
 Yiqun Zhang,
-Xurenhe,
-Zhe Hu,
-mans2singh.
+Zhe Hu.
 
 #### New features
 {: #new-features-1-30-0}
@@ -170,7 +1010,8 @@ mans2singh.
 * [<a href="https://issues.apache.org/jira/browse/CALCITE-4323">CALCITE-4323</a>]
   If a view definition has an `ORDER BY` clause, retain the sort if the view is used in a query at top level
 * [<a href="https://issues.apache.org/jira/browse/CALCITE-4054">CALCITE-4054</a>]
-  `RepeatUnion` containing a `Correlate` with a `transientScan` on its RHS causes NPE
+  `RepeatUnion` containing a `Correlate` with a `transientScan` on its RHS
+  causes `NullPointerException`
 * [<a href="https://issues.apache.org/jira/browse/CALCITE-3673">CALCITE-3673</a>]
   `ListTransientTable` should not leave tables in the schema
 * [<a href="https://issues.apache.org/jira/browse/CALCITE-3627">CALCITE-3627</a>]
@@ -928,7 +1769,8 @@ other software versions as specified in gradle.properties.
 * [<a href="https://issues.apache.org/jira/browse/CALCITE-4214">CALCITE-4214</a>]
   Make `RelDataType#getSqlTypeName` non-nullable
 * [<a href="https://issues.apache.org/jira/browse/CALCITE-4251">CALCITE-4251</a>]
-  `NPE` in `LoptMultiJoin` when `mq#getColumnOrigin(left, i)` returns `null`
+  `NullPointerException` in `LoptMultiJoin` when `mq#getColumnOrigin(left, i)`
+  returns `null`
 * [<a href="https://issues.apache.org/jira/browse/CALCITE-4415">CALCITE-4415</a>]
   `SqlStdOperatorTable.NOT_LIKE` has a wrong implementor
 * [<a href="https://issues.apache.org/jira/browse/CALCITE-4317">CALCITE-4317</a>]
@@ -941,8 +1783,8 @@ other software versions as specified in gradle.properties.
   Improve exception when `RelBuilder` tries to create a field on a non-struct
   expression
 * [<a href="https://issues.apache.org/jira/browse/CALCITE-4393">CALCITE-4393</a>]
-  `ExceptionInInitializerError` due to `NPE` in `SqlCallBinding` caused by circular
-  dependency
+  `ExceptionInInitializerError` due to `NullPointerException` in `SqlCallBinding`
+  caused by circular dependency
 * [<a href="https://issues.apache.org/jira/browse/CALCITE-4251">CALCITE-4251</a>]
   Support `Calc` and `SetOp` operator in `RelMdAllPredicates` (Xu Zhaohui)
 * [<a href="https://issues.apache.org/jira/browse/CALCITE-4402">CALCITE-4402</a>]
@@ -1025,8 +1867,8 @@ other software versions as specified in gradle.properties.
 * Remove the insecure, unused `TrustAllSslSocketFactory` class (intrigus-lgtm)
 * Remove multiple blank lines after package statements
 * Remove multiple blank lines after import statements
-* Cleanup code after errorprone upgrade: `IdentityHashMapUsage`, `JdkObsolete` ->
-  `JavaUtilDate`
+* Cleanup code after errorprone upgrade: `IdentityHashMapUsage`, `JdkObsolete`
+  &rarr; `JavaUtilDate`
 
 #### Build and test suite
 {: #build-1-27-0}
diff --git a/site/_docs/howto.md b/site/_docs/howto.md
index 6543995ca6d..02ee0cee9de 100644
--- a/site/_docs/howto.md
+++ b/site/_docs/howto.md
@@ -32,15 +32,15 @@ adapters.
 ## Building from a source distribution
 
 Prerequisite is Java (JDK 8, 9, 10, 11, 12, 13, 14, 15, 16, 17 or 18)
-and Gradle (version 7.3) on your path.
+and Gradle (version 7.4.2) on your path.
 
 Unpack the source distribution `.tar.gz` file,
 `cd` to the root directory of the unpacked source,
 then build using Gradle:
 
 {% highlight bash %}
-$ tar xvfz apache-calcite-1.30.0-src.tar.gz
-$ cd apache-calcite-1.30.0-src
+$ tar xvfz apache-calcite-1.34.0-src.tar.gz
+$ cd apache-calcite-1.34.0-src
 $ gradle build
 {% endhighlight %}
 
@@ -76,19 +76,45 @@ then you can call `./gradlew generateSources` tasks manually.
 [Running tests](#running-tests) describes how to run more or fewer
 tests.
 
-## Gradle vs Gradle wrapper
+## Gradle vs the Gradle Wrapper
 
-Calcite uses Gradle wrapper to make a consistent build environment.
+Calcite uses the Gradle Wrapper to make a consistent build environment.
 In the typical case you don't need to install Gradle manually, and
-`./gradlew` would download the proper version for you and verify the expected checksum.
+`./gradlew` downloads the proper version for you and verify the expected checksum.
 
-You can install Gradle manually, however please note that there might
-be impedance mismatch between different versions.
+If you like, you can install Gradle manually, but be aware that is might
+cause a version mismatch.
 
 For more information about Gradle, check the following links:
 [Gradle five things](https://docs.gradle.org/current/userguide/what_is_gradle.html#five_things);
 [Gradle multi-project builds](https://docs.gradle.org/current/userguide/intro_multi_project_builds.html).
 
+## Upgrade Gradle and the Gradle Wrapper
+
+Gradle's [documentation](https://docs.gradle.org/current/userguide/upgrading_version_7.html)
+provides detailed information about how to upgrade Gradle. Here is a list of steps:
+
+1. Run `./gradlew help --warning-mode=all` to find out whether you are
+   using any deprecated features.
+2. Fix the deprecations and repeat the previous step to confirm they are
+   fixed. This is a step where Gradle doc could be very helpful since it
+   contains info about deprecations and how to cope with them.
+3. Run `./gradlew wrapper --gradle-version <new_gradle_version>` to upgrade
+   Gradle. If necessary it will also upgrade the Gradle Wrapper.
+   This step also updates `gradle/wrapper/gradle-wrapper.properties`,
+   including the checksum.
+4. Check and update Kotlin version in `gradle.properties` if required.
+   Check should be done against [Kotlin compatibility matrix](https://docs.gradle.org/current/userguide/compatibility.html#kotlin).
+5. Step 3 will have removed the header from
+   `gradle/wrapper/gradle-wrapper.properties`,
+   so now run `./gradlew autostyleApply` to add it back.
+6. Check the updated Gradle version and checksum in
+   `gradle/wrapper/gradle-wrapper.properties` against the official
+   [Gradle release checksums](https://gradle.org/release-checksums/).
+7. Try to build the project and run tests; debug any errors using the
+   [Troubleshooting Guide](https://docs.gradle.org/current/userguide/troubleshooting.html#troubleshooting).
+8. Update the Gradle version in this howto.
+
 ## Running tests
 
 The test suite will run by default when you build, unless you specify
@@ -605,7 +631,7 @@ must:
  * resolve the issue (do not close it as this will be done by the release
 manager);
  * select "Fixed" as resolution cause;
- * mark the appropriate version (e.g., 1.30.0) in the "Fix version" field;
+ * mark the appropriate version (e.g., 1.20.0) in the "Fix version" field;
  * add a comment (e.g., "Fixed in ...") with a hyperlink pointing to the commit
 which resolves the issue (in GitHub or GitBox), and also thank the contributor
 for their contribution.
@@ -689,6 +715,9 @@ Note: release artifacts (dist.apache.org and repository.apache.org) are managed
 
 Before you start:
 
+* Consult the [release dashboard](https://issues.apache.org/jira/secure/Dashboard.jspa?selectPageId=12333950) to get a
+ quick overview about the state of the release and take appropriate actions in order to resolve pending tickets or
+ move them to another release/backlog.
 * Send an email to [dev@calcite.apache.org](mailto:dev@calcite.apache.org) notifying that RC build process
   is starting and therefore `main` branch is in code freeze until further notice.
 * Set up signing keys as described above.
@@ -755,7 +784,7 @@ The release candidate process does not add commits,
 so there's no harm if it fails. It might leave `-rc` tag behind
 which can be removed if required.
 
-You can perform a dry-run release with a help of
+If you wish, you can perform a dry-run release with a help of
 [asflike-release-environment](https://github.com/vlsi/asflike-release-environment);
 it would perform the same steps, but it would push changes to the mock Nexus, Git, and SVN servers.
 
@@ -788,13 +817,15 @@ installed in your machine.
 Log into [Nexus UI](https://repository.apache.org/#stagingRepositories) to see the actual error. In case of
 `Failed: Signature Validation. No public key: Key with id: ... was not able to be located`, make sure you have uploaded
 your key to the keyservers used by Nexus, see above.
+* [[CALCITE-5573]](https://issues.apache.org/jira/browse/CALCITE-5573) Gradle prepareVote fails when signing artifact
+* [[VLSI-RELEASE-PLUGINS-64]](https://github.com/vlsi/vlsi-release-plugins/issues/64) Execution failed for task ':releaseRepository due to missing nexus.txt
 
 #### Checking the artifacts
 
 * In the `release/build/distributions` directory should be these 3 files, among others:
   * `apache-calcite-X.Y.Z-src.tar.gz`
   * `apache-calcite-X.Y.Z-src.tar.gz.asc`
-  * `apache-calcite-X.Y.Z-src.tar.gz.sha256`
+  * `apache-calcite-X.Y.Z-src.tar.gz.sha512`
 * Note that the file names start `apache-calcite-`.
 * In the source distro `.tar.gz` (currently there is
   no binary distro), check that all files belong to a directory called
@@ -820,11 +851,8 @@ Verify the staged artifacts in the Nexus repository:
 * Go to [https://repository.apache.org/](https://repository.apache.org/) and login
 * Under `Build Promotion`, click `Staging Repositories`
 * In the `Staging Repositories` tab there should be a line with profile `org.apache.calcite`
+  and status `closed`
 * Navigate through the artifact tree and make sure the .jar, .pom, .asc files are present
-* Check the box on in the first column of the row,
-  and press the 'Close' button to publish the repository at
-  https://repository.apache.org/content/repositories/orgapachecalcite-1000
-  (or a similar URL)
 
 ## Cleaning up after a failed release attempt
 
@@ -923,6 +951,11 @@ Remember that UTC date changes at 4 pm Pacific time.
 ./gradlew publishDist -Prc=0 -Pasf -Pasf.git.pushRepositoryProvider=GITBOX
 {% endhighlight %}
 
+If for whatever reason the `publishDist` task fails
+(e.g. [failed to release nexus repository](https://github.com/vlsi/vlsi-release-plugins/issues/64),
+it is still possible to perform the publishing tasks manually. Ask for help in the dev list if
+you are not sure what needs to be done.
+
 Svnpubsub will publish to the
 [release repo](https://dist.apache.org/repos/dist/release/calcite) and propagate to the
 [mirrors](https://www.apache.org/dyn/closer.cgi/calcite) almost immediately.
@@ -942,15 +975,17 @@ The old releases will remain available in the
 You should receive an email from the [Apache Reporter Service](https://reporter.apache.org/).
 Make sure to add the version number and date of the latest release at the site linked to in the email.
 
-Update the site with the release note, the release announcement, and the javadoc of the new version.
+The release notes and the javadoc of the new version will be automatically deployed to the website
+once the release commits/tags reach the ASF remote and the respective
+[Gitub workflows](https://github.com/apache/calcite/blob/main/.github/workflows/) are triggered.
+
 Add a release announcement by copying
-[site/_posts/2016-10-12-release-1.10.0.md]({{ site.sourceRoot }}/site/_posts/2016-10-12-release-1.10.0.md).
-Generate the javadoc, and [preview](http://localhost:4000/news/) the site by following the
-instructions in [site/README.md]({{ site.sourceRoot }}/site/README.md). Ensure the announcement,
-javadoc, and release note appear correctly and then publish the site following the instructions
-in the same file. Rebase the `site` branch with `main` (e.g., `git checkout site && git rebase main`);
-at this point there shouldn't be any commits in `site` that are not in `main`, so the rebase is
-essentially a noop.
+[site/_posts/2016-10-12-release-1.10.0.md]({{ site.sourceRoot }}/site/_posts/2016-10-12-release-1.10.0.md),
+and adapt the release date in `history.md` if necessary. Preview the changes locally, by following the
+instructions in [site/README.md]({{ site.sourceRoot }}/site/README.md), and then commit and push
+the changes to the `main` branch.
+
+Ensure that all changes to the website (news, release notes, javadoc) are correctly displayed.
 
 In JIRA, search for
 [all issues resolved in this release](https://issues.apache.org/jira/issues/?jql=project%20%3D%20CALCITE%20and%20fixVersion%20%3D%201.5.0%20and%20status%20%3D%20Resolved%20and%20resolution%20%3D%20Fixed),
@@ -960,13 +995,9 @@ with a change comment
 (fill in release number and date appropriately).
 Uncheck "Send mail for this update". Under the [releases tab](https://issues.apache.org/jira/projects/CALCITE?selectedItem=com.atlassian.jira.jira-projects-plugin%3Arelease-page&status=released-unreleased)
 of the Calcite project mark the release X.Y.Z as released. If it does not already exist create also
-a new version (e.g., X.Y+1.Z) for the next release.
-
-After 24 hours, announce the release by sending an email to
-[announce@apache.org](https://mail-archives.apache.org/mod_mbox/www-announce/) using an `@apache.org`
-address. You can use
-[the 1.20.0 announcement](https://mail-archives.apache.org/mod_mbox/www-announce/201906.mbox/%3CCA%2BEpF8tcJcZ41rVuwJODJmyRy-qAxZUQm9OxKsoDi07c2SKs_A%40mail.gmail.com%3E)
-as a template. Be sure to include a brief description of the project.
+a new version (e.g., X.Y+1.Z) for the next release. In order to make the [release dashboard](https://issues.apache.org/jira/secure/Dashboard.jspa?selectPageId=12333950)
+reflect state of the next release, change the fixVersion in the [JIRA filter powering the dashboard](https://issues.apache.org/jira/issues/?filter=12346388)
+and save the changes.
 
 Increase the `calcite.version` value in `/gradle.properties`, commit and push
 the change with the message "Prepare for next development iteration"
@@ -975,8 +1006,49 @@ the change with the message "Prepare for next development iteration"
 Re-open the `main` branch. Send an email to [dev@calcite.apache.org](mailto:dev@calcite.apache.org) notifying
 that `main` code freeze is over and commits can resume.
 
+Announce the release by sending an email to
+[announce@apache.org](https://mail-archives.apache.org/mod_mbox/www-announce/) using an `@apache.org`
+address. You can use
+[the 1.20.0 announcement](https://mail-archives.apache.org/mod_mbox/www-announce/201906.mbox/%3CCA%2BEpF8tcJcZ41rVuwJODJmyRy-qAxZUQm9OxKsoDi07c2SKs_A%40mail.gmail.com%3E)
+as a template. Be sure to include a brief description of the project.
+
 ## Publishing the web site
 {: #publish-the-web-site}
 
 See instructions in
 [site/README.md]({{ site.sourceRoot }}/site/README.md).
+
+# Advanced topics for PMC members
+
+## Processing JIRA account requests
+Here are some email templates that can be used when processing requests for adding a JIRA account as a contributor.
+
+### Account added to contributor list
+{% highlight text %}
+Hello [INSERT NAME HERE],
+
+Thanks for your interest in becoming a Calcite contributor! I have added your username ([INSERT USERNAME HERE])
+to the contributors group in JIRA. Happy contributing!
+
+If you have not subscribed to our development list (dev@calcite.apache.org) yet, I encourage you to do so by
+emailing dev-subscribe@calcite.apache.org. Further information about our mailing lists is available here:
+https://calcite.apache.org/community/#mailing-lists
+
+Best regards,
+[INSERT YOUR NAME HERE]
+{% endhighlight %}
+
+### Account not found
+{% highlight text %}
+Hello [INSERT NAME HERE],
+
+Thanks for your interest in becoming a Calcite contributor! I am sorry to inform you that I was unable to
+find your account ([INSERT USERNAME HERE]) in JIRA and was not able to add you to the contributors group.
+Please let me know the correct username by return email and I will process your request again.
+
+If you do not have an ASF JIRA account, please follow the instructions here to request one:
+https://calcite.apache.org/develop/#i-do-not-have-an-asf-jira-account-want-to-request-an-account-and-be-added-as-a-contributor
+
+Best regards,
+[INSERT YOUR NAME HERE]
+{% endhighlight %}
diff --git a/site/_docs/reference.md b/site/_docs/reference.md
index 4f1de54526b..f9ea1d9d60c 100644
--- a/site/_docs/reference.md
+++ b/site/_docs/reference.md
@@ -38,6 +38,7 @@ here to appease testAllFunctionsAreDocumented:
 | JSON_OBJECTAGG_NULL_ON_NULL() | Covered by JSON_OBJECTAGG
 | JSON_VALUE_ANY() | Covered by JSON_VALUE
 | LAST()         | TODO: document with MATCH_RECOGNIZE
+| MATCH_NUMBER() | Documented with MATCH_RECOGNIZE
 | NEW            | TODO: document
 | NEXT()         | Documented with MATCH_RECOGNIZE
 | OVERLAPS       | Documented as a period operator
@@ -49,6 +50,12 @@ here to appease testAllFunctionsAreDocumented:
 | SUCCEEDS       | Documented as a period operator
 | TABLE          | Documented as part of FROM syntax
 | VARIANCE()     | In SqlStdOperatorTable, but not fully implemented
+
+Dialect-specific:
+
+| C | Function       | Reason not documented
+|:--|:-------------- |:---------------------
+
 {% endcomment %}
 -->
 
@@ -186,7 +193,7 @@ query:
       |   query INTERSECT [ ALL | DISTINCT ] query
       }
       [ ORDER BY orderItem [, orderItem ]* ]
-      [ LIMIT [ start, ] { count | ALL } ]
+      [ LIMIT { [ start, ] count | ALL } ]
       [ OFFSET start { ROW | ROWS } ]
       [ FETCH { FIRST | NEXT } [ count ] { ROW | ROWS } ONLY ]
 
@@ -203,9 +210,10 @@ select:
           { * | projectItem [, projectItem ]* }
       FROM tableExpression
       [ WHERE booleanExpression ]
-      [ GROUP BY { groupItem [, groupItem ]* } ]
+      [ GROUP BY [ ALL | DISTINCT ] { groupItem [, groupItem ]* } ]
       [ HAVING booleanExpression ]
       [ WINDOW windowName AS windowSpec [, windowName AS windowSpec ]* ]
+      [ QUALIFY booleanExpression ]
 
 selectWithoutFrom:
       SELECT [ ALL | DISTINCT ]
@@ -304,7 +312,7 @@ unpivotValue:
   |   '(' column [, column ]* ')' [ AS '(' literal [, literal ]* ')' ]
 
 values:
-      VALUES expression [, expression ]*
+      { VALUES | VALUE } expression [, expression ]*
 
 groupItem:
       expression
@@ -370,6 +378,11 @@ function).
 An IN, EXISTS, UNIQUE or scalar sub-query may be correlated; that is, it
 may refer to tables in the FROM clause of an enclosing query.
 
+GROUP BY DISTINCT removes duplicate grouping sets (for example,
+"GROUP BY DISTINCT GROUPING SETS ((a), (a, b), (a))" is equivalent to
+"GROUP BY GROUPING SETS ((a), (a, b))");
+GROUP BY ALL is equivalent to GROUP BY.
+
 *selectWithoutFrom* is equivalent to VALUES,
 but is not standard SQL and is only allowed in certain
 [conformance levels]({{ site.apiRoot }}/org/apache/calcite/sql/validate/SqlConformance.html#isFromRequired--).
@@ -385,6 +398,13 @@ CROSS APPLY and OUTER APPLY are only allowed in certain
 but is only allowed in certain
 [conformance levels]({{ site.apiRoot }}/org/apache/calcite/sql/validate/SqlConformance.html#isLimitStartCountAllowed--).
 
+"OFFSET start" may occur before "LIMIT count" in certain
+[conformance levels]({{ site.apiRoot }}/org/apache/calcite/sql/validate/SqlConformance.html#isOffsetLimitAllowed--).
+
+VALUE is equivalent to VALUES,
+but is not standard SQL and is only allowed in certain
+[conformance levels]({{ site.apiRoot }}/org/apache/calcite/sql/validate/SqlConformance.html#isValueAllowed--).
+
 ## Keywords
 
 The following is a list of SQL keywords.
@@ -523,9 +543,16 @@ CURSOR_NAME,
 DATA,
 DATABASE,
 **DATE**,
+**DATETIME**,
+DATETIME_DIFF,
 DATETIME_INTERVAL_CODE,
 DATETIME_INTERVAL_PRECISION,
+DATETIME_TRUNC,
+DATE_DIFF,
+DATE_TRUNC,
 **DAY**,
+DAYOFWEEK,
+DAYOFYEAR,
 DAYS,
 **DEALLOCATE**,
 **DEC**,
@@ -607,6 +634,7 @@ FOUND,
 FRAC_SECOND,
 **FRAME_ROW**,
 **FREE**,
+**FRIDAY**,
 **FROM**,
 **FULL**,
 **FUNCTION**,
@@ -726,6 +754,7 @@ MINVALUE,
 **MOD**,
 **MODIFIES**,
 **MODULE**,
+**MONDAY**,
 **MONTH**,
 MONTHS,
 MORE,
@@ -822,7 +851,9 @@ PRIOR,
 PRIVILEGES,
 **PROCEDURE**,
 PUBLIC,
+**QUALIFY**,
 QUARTER,
+QUARTERS,
 **RANGE**,
 **RANK**,
 READ,
@@ -872,6 +903,8 @@ ROUTINE_SCHEMA,
 ROW_COUNT,
 **ROW_NUMBER**,
 **RUNNING**,
+**SAFE_CAST**,
+**SATURDAY**,
 **SAVEPOINT**,
 SCALAR,
 SCALE,
@@ -984,6 +1017,7 @@ SUBSTITUTE,
 **SUBSTRING_REGEX**,
 **SUCCEEDS**,
 **SUM**,
+**SUNDAY**,
 **SYMMETRIC**,
 **SYSTEM**,
 **SYSTEM_TIME**,
@@ -993,13 +1027,18 @@ SUBSTITUTE,
 TABLE_NAME,
 TEMPORARY,
 **THEN**,
+**THURSDAY**,
 TIES,
 **TIME**,
 **TIMESTAMP**,
 TIMESTAMPADD,
 TIMESTAMPDIFF,
+TIMESTAMP_DIFF,
+TIMESTAMP_TRUNC,
 **TIMEZONE_HOUR**,
 **TIMEZONE_MINUTE**,
+TIME_DIFF,
+TIME_TRUNC,
 **TINYINT**,
 **TO**,
 TOP_LEVEL_COUNT,
@@ -1022,6 +1061,7 @@ TRIGGER_SCHEMA,
 **TRIM_ARRAY**,
 **TRUE**,
 **TRUNCATE**,
+**TUESDAY**,
 TUMBLE,
 TYPE,
 **UESCAPE**,
@@ -1059,7 +1099,9 @@ UTF8,
 VERSION,
 **VERSIONING**,
 VIEW,
+**WEDNESDAY**,
 WEEK,
+WEEKS,
 **WHEN**,
 **WHENEVER**,
 **WHERE**,
@@ -1113,7 +1155,7 @@ name will have been converted to upper case also.
 | NUMERIC     | Fixed point               |
 | REAL, FLOAT | 4 byte floating point     | 6 decimal digits precision
 | DOUBLE      | 8 byte floating point     | 15 decimal digits precision
-| CHAR(n), CHARACTER(n) | Fixed-width character string | 'Hello', '' (empty string), _latin1'Hello', n'Hello', _UTF16'Hello', 'Hello' 'there' (literal split into multiple parts)
+| CHAR(n), CHARACTER(n) | Fixed-width character string | 'Hello', '' (empty string), _latin1'Hello', n'Hello', _UTF16'Hello', 'Hello' 'there' (literal split into multiple parts), e'Hello\nthere' (literal containing C-style escapes)
 | VARCHAR(n), CHARACTER VARYING(n) | Variable-length character string | As CHAR(n)
 | BINARY(n)   | Fixed-width binary string | x'45F0AB', x'' (empty binary string), x'AB' 'CD' (multi-part binary string literal)
 | VARBINARY(n), BINARY VARYING(n) | Variable-length binary string | As BINARY(n)
@@ -1142,9 +1184,9 @@ Note:
 * GEOMETRY is allowed only in certain
   [conformance levels]({{ site.apiRoot }}/org/apache/calcite/sql/validate/SqlConformance.html#allowGeometry--).
 * Interval literals may only use time units
-  YEAR, MONTH, DAY, HOUR, MINUTE and SECOND. In certain
+  YEAR, QUARTER, MONTH, WEEK, DAY, HOUR, MINUTE and SECOND. In certain
   [conformance levels]({{ site.apiRoot }}/org/apache/calcite/sql/validate/SqlConformance.html#allowPluralTimeUnits--),
-  we also allow their plurals, YEARS, MONTHS, DAYS, HOURS, MINUTES and SECONDS.
+  we also allow their plurals, YEARS, QUARTERS, MONTHS, WEEKS, DAYS, HOURS, MINUTES and SECONDS.
 
 ### Non-scalar types
 
@@ -1173,11 +1215,11 @@ or binary strings encoded as
 Where you would use a literal, apply the `ST_GeomFromText` function,
 for example `ST_GeomFromText('POINT (30 10)')`.
 
-| Data type   | Type code | Examples in WKT
-|:----------- |:--------- |:---------------------
+| Data type          | Type code | Examples in WKT
+|:-------------------|:--------- |:---------------------
 | GEOMETRY           |  0 | generalization of Point, Curve, Surface, GEOMETRYCOLLECTION
 | POINT              |  1 | <code>ST_GeomFromText(&#8203;'POINT (30 10)')</code> is a point in 2D space; <code>ST_GeomFromText(&#8203;'POINT Z(30 10 2)')</code> is point in 3D space
-| CURVE            | 13 | generalization of LINESTRING
+| CURVE              | 13 | generalization of LINESTRING
 | LINESTRING         |  2 | <code>ST_GeomFromText(&#8203;'LINESTRING (30 10, 10 30, 40 40)')</code>
 | SURFACE            | 14 | generalization of Polygon, PolyhedralSurface
 | POLYGON            |  3 | <code>ST_GeomFromText(&#8203;'POLYGON ((30 10, 40 40, 20 40, 10 20, 30 10))')</code> is a pentagon; <code>ST_GeomFromText(&#8203;'POLYGON ((35 10, 45 45, 15 40, 10 20, 35 10), (20 30, 35 35, 30 20, 20 30))')</code> is a pentagon with a quadrilateral hole
@@ -1219,7 +1261,7 @@ completeness.
 |:------------------------------------------------- |:-----------
 | value1 = value2                                   | Equals
 | value1 <> value2                                  | Not equal
-| value1 != value2                                  | Not equal (only available at some conformance levels)
+| value1 != value2                                  | Not equal (only in certain [conformance levels]({{ site.apiRoot }}/org/apache/calcite/sql/validate/SqlConformance.html#isBangEqualAllowed--))
 | value1 > value2                                   | Greater than
 | value1 >= value2                                  | Greater than or equal
 | value1 < value2                                   | Less than
@@ -1239,9 +1281,9 @@ completeness.
 | value NOT IN (value [, value]*)                   | Whether *value* is not equal to every value in a list
 | value IN (sub-query)                              | Whether *value* is equal to a row returned by *sub-query*
 | value NOT IN (sub-query)                          | Whether *value* is not equal to every row returned by *sub-query*
-| value comparison SOME (sub-query)                 | Whether *value* *comparison* at least one row returned by *sub-query*
-| value comparison ANY (sub-query)                  | Synonym for `SOME`
-| value comparison ALL (sub-query)                  | Whether *value* *comparison* every row returned by *sub-query*
+| value comparison SOME (sub-query or collection)   | Whether *value* *comparison* at least one row returned by *sub-query* or *collection*
+| value comparison ANY (sub-query or collection)    | Synonym for `SOME`
+| value comparison ALL (sub-query or collection)    | Whether *value* *comparison* every row returned by *sub-query* or *collection*
 | EXISTS (sub-query)                                | Whether *sub-query* returns at least one row
 | UNIQUE (sub-query)                                | Whether the rows returned by *sub-query* are unique (ignoring null values)
 
@@ -1317,8 +1359,8 @@ comp:
 | CHARACTER_LENGTH(string)   | As CHAR_LENGTH(*string*)
 | UPPER(string)              | Returns a character string converted to upper case
 | LOWER(string)              | Returns a character string converted to lower case
-| POSITION(string1 IN string2) | Returns the position of the first occurrence of *string1* in *string2*
-| POSITION(string1 IN string2 FROM integer) | Returns the position of the first occurrence of *string1* in *string2* starting at a given point (not standard SQL)
+| POSITION(substring IN string) | Returns the position of the first occurrence of *substring* in *string*
+| POSITION(substring IN string FROM integer) | Returns the position of the first occurrence of *substring* in *string* starting at a given point (not standard SQL)
 | TRIM( { BOTH &#124; LEADING &#124; TRAILING } string1 FROM string2) | Removes the longest string containing only the characters in *string1* from the start/end/both ends of *string1*
 | OVERLAY(string1 PLACING string2 FROM integer [ FOR integer2 ]) | Replaces a substring of *string1* with *string2*
 | SUBSTRING(string FROM integer)  | Returns a substring of a character string starting at a given point
@@ -1505,23 +1547,25 @@ Calcite type conversions. The table shows all possible conversions,
 without regard to the context in which it is made. The rules governing
 these details follow the table.
 
-| FROM - TO           | NULL | BOOLEAN | TINYINT | SMALLINT | INT | BIGINT | DECIMAL | FLOAT or REAL | DOUBLE | INTERVAL | DATE | TIME | TIMESTAMP | CHAR or VARCHAR | BINARY or VARBINARY
-|:------------------- |:---- |:------- |:------- |:-------- |:--- |:------ |:------- |:------------- |:------ |:-------- |:---- |:---- |:--------- |:--------------- |:-----------
-| NULL                | i    | i       | i       | i        | i   | i      | i       | i             | i      | i        | i    | i    | i         | i               | i
-| BOOLEAN             | x    | i       | e       | e        | e   | e      | e       | e             | e      | x        | x    | x    | x         | i               | x
-| TINYINT             | x    | e       | i       | i        | i   | i      | i       | i             | i      | e        | x    | x    | e         | i               | x
-| SMALLINT            | x    | e       | i       | i        | i   | i      | i       | i             | i      | e        | x    | x    | e         | i               | x
-| INT                 | x    | e       | i       | i        | i   | i      | i       | i             | i      | e        | x    | x    | e         | i               | x
-| BIGINT              | x    | e       | i       | i        | i   | i      | i       | i             | i      | e        | x    | x    | e         | i               | x
-| DECIMAL             | x    | e       | i       | i        | i   | i      | i       | i             | i      | e        | x    | x    | e         | i               | x
-| FLOAT/REAL          | x    | e       | i       | i        | i   | i      | i       | i             | i      | x        | x    | x    | e         | i               | x
-| DOUBLE              | x    | e       | i       | i        | i   | i      | i       | i             | i      | x        | x    | x    | e         | i               | x
-| INTERVAL            | x    | x       | e       | e        | e   | e      | e       | x             | x      | i        | x    | x    | x         | e               | x
-| DATE                | x    | x       | x       | x        | x   | x      | x       | x             | x      | x        | i    | x    | i         | i               | x
-| TIME                | x    | x       | x       | x        | x   | x      | x       | x             | x      | x        | x    | i    | e         | i               | x
-| TIMESTAMP           | x    | x       | e       | e        | e   | e      | e       | e             | e      | x        | i    | e    | i         | i               | x
-| CHAR or VARCHAR     | x    | e       | i       | i        | i   | i      | i       | i             | i      | i        | i    | i    | i         | i               | i
-| BINARY or VARBINARY | x    | x       | x       | x        | x   | x      | x       | x             | x      | x        | e    | e    | e         | i               | i
+| FROM - TO           | NULL | BOOLEAN | TINYINT | SMALLINT | INT | BIGINT | DECIMAL | FLOAT or REAL | DOUBLE | INTERVAL | DATE | TIME | TIMESTAMP | CHAR or VARCHAR | BINARY or VARBINARY | GEOMETRY | ARRAY |
+|:--------------------|:-----|:--------|:--------|:---------|:----|:-------|:--------|:--------------|:-------|:---------|:-----|:-----|:----------|:----------------|:--------------------|:---------|:------|
+| NULL                | i    | i       | i       | i        | i   | i      | i       | i             | i      | i        | i    | i    | i         | i               | i                   | i        | x     |
+| BOOLEAN             | x    | i       | e       | e        | e   | e      | e       | e             | e      | x        | x    | x    | x         | i               | x                   | x        | x     |
+| TINYINT             | x    | e       | i       | i        | i   | i      | i       | i             | i      | e        | x    | x    | e         | i               | x                   | x        | x     |
+| SMALLINT            | x    | e       | i       | i        | i   | i      | i       | i             | i      | e        | x    | x    | e         | i               | x                   | x        | x     |
+| INT                 | x    | e       | i       | i        | i   | i      | i       | i             | i      | e        | x    | x    | e         | i               | x                   | x        | x     |
+| BIGINT              | x    | e       | i       | i        | i   | i      | i       | i             | i      | e        | x    | x    | e         | i               | x                   | x        | x     |
+| DECIMAL             | x    | e       | i       | i        | i   | i      | i       | i             | i      | e        | x    | x    | e         | i               | x                   | x        | x     |
+| FLOAT/REAL          | x    | e       | i       | i        | i   | i      | i       | i             | i      | x        | x    | x    | e         | i               | x                   | x        | x     |
+| DOUBLE              | x    | e       | i       | i        | i   | i      | i       | i             | i      | x        | x    | x    | e         | i               | x                   | x        | x     |
+| INTERVAL            | x    | x       | e       | e        | e   | e      | e       | x             | x      | i        | x    | x    | x         | e               | x                   | x        | x     |
+| DATE                | x    | x       | x       | x        | x   | x      | x       | x             | x      | x        | i    | x    | i         | i               | x                   | x        | x     |
+| TIME                | x    | x       | x       | x        | x   | x      | x       | x             | x      | x        | x    | i    | e         | i               | x                   | x        | x     |
+| TIMESTAMP           | x    | x       | e       | e        | e   | e      | e       | e             | e      | x        | i    | e    | i         | i               | x                   | x        | x     |
+| CHAR or VARCHAR     | x    | e       | i       | i        | i   | i      | i       | i             | i      | i        | i    | i    | i         | i               | i                   | i        | i     |
+| BINARY or VARBINARY | x    | x       | x       | x        | x   | x      | x       | x             | x      | x        | e    | e    | e         | i               | i                   | x        | x     |
+| GEOMETRY            | x    | x       | x       | x        | x   | x      | x       | x             | x      | x        | x    | x    | x         | i               | x                   | i        | x     |
+| ARRAY               | x    | x       | x       | x        | x   | x      | x       | x             | x      | x        | x    | x    | x         | x               | x                   | x        | i     |
 
 i: implicit cast / e: explicit cast / x: not allowed
 
@@ -1741,6 +1785,7 @@ period:
 | Operator syntax | Description
 |:--------------- |:-----------
 | {fn ASCII(string)} | Returns the ASCII code of the first character of *string*; if the first character is a non-ASCII character, returns its Unicode code point; returns 0 if *string* is empty
+| {fn CHAR(integer)} | Returns the character whose ASCII code is *integer* % 256, or null if *integer* &lt; 0
 | {fn CONCAT(character, character)} | Returns the concatenation of character strings
 | {fn INSERT(string1, start, length, string2)} | Inserts *string2* into a slot in *string1*
 | {fn LCASE(string)} | Returns a string in which all alphabetic characters in *string* have been converted to lower case
@@ -1750,15 +1795,11 @@ period:
 | {fn LTRIM(string)} | Returns *string* with leading space characters removed
 | {fn REPLACE(string, search, replacement)} | Returns a string in which all the occurrences of *search* in *string* are replaced with *replacement*; if *replacement* is the empty string, the occurrences of *search* are removed
 | {fn REVERSE(string)} | Returns *string* with the order of the characters reversed
-| {fn RIGHT(string, integer)} | Returns the rightmost *length* characters from *string*
+| {fn RIGHT(string, length)} | Returns the rightmost *length* characters from *string*
 | {fn RTRIM(string)} | Returns *string* with trailing space characters removed
 | {fn SUBSTRING(string, offset, length)} | Returns a character string that consists of *length* characters from *string* starting at the *offset* position
 | {fn UCASE(string)} | Returns a string in which all alphabetic characters in *string* have been converted to upper case
 
-Not implemented:
-
-* {fn CHAR(string)}
-
 #### Date/time
 
 | Operator syntax | Description
@@ -1829,6 +1870,8 @@ and `LISTAGG`).
 | Operator syntax                    | Description
 |:---------------------------------- |:-----------
 | ANY_VALUE( [ ALL &#124; DISTINCT ] value)     | Returns one of the values of *value* across all input values; this is NOT specified in the SQL standard
+| ARG_MAX(value, comp)                          | Returns *value* for the maximum value of *comp* in the group
+| ARG_MIN(value, comp)                          | Returns *value* for the minimum value of *comp* in the group
 | APPROX_COUNT_DISTINCT(value [, value ]*)      | Returns the approximate number of distinct values of *value*; the database is allowed to use an approximation but is not required to
 | AVG( [ ALL &#124; DISTINCT ] numeric)         | Returns the average (arithmetic mean) of *numeric* across all input values
 | BIT_AND( [ ALL &#124; DISTINCT ] value)       | Returns the bitwise AND of all non-null input values, or null if none; integer and binary types are supported
@@ -1953,12 +1996,46 @@ Not implemented:
 
 Table functions occur in the `FROM` clause.
 
+Table functions may have generic table parameters (i.e., no row type is
+declared when the table function is created), and the row type of the result
+ might depend on the row type(s) of the input tables.
+Besides, input tables are classified by three characteristics.
+The first characteristic is semantics. Input tables have either row semantics
+or set semantics, as follows:
+* Row semantics means that the result of the table function depends on a
+row-by-row basis.
+* Set semantics means that the outcome of the function depends on how the
+data is partitioned.
+
+The second characteristic, which applies only to input tables with
+set semantics, is whether the table function can generate a result row
+even if the input table is empty.
+* If the table function can generate a result row on empty input,
+the table is said to be "keep when empty".
+* The alternative is called "prune when empty", meaning that
+the result would be pruned out if the input table is empty.
+
+The third characteristic is whether the input table supports
+pass-through columns or not. Pass-through columns is a mechanism
+enabling the table function to copy every column of an input row
+into columns of an output row.
+
+The input tables with set semantics may be partitioned on one or more columns.
+The input tables with set semantics may be ordered on one or more columns.
+
+Note:
+* The input tables with row semantics may not be partitioned or ordered.
+* A polymorphic table function may have multiple input tables. However,
+at most one input table could have row semantics.
+
 #### TUMBLE
 
 In streaming queries, TUMBLE assigns a window for each row of a relation based
 on a timestamp column. An assigned window is specified by its beginning and
 ending. All assigned windows have the same length, and that's why tumbling
 sometimes is named as "fixed windowing".
+The first parameter of the TUMBLE table function is a generic table parameter.
+The input table has row semantics and supports pass-through columns.
 
 | Operator syntax      | Description
 |:-------------------- |:-----------
@@ -1990,7 +2067,8 @@ whether data is complete.
 
 In streaming queries, HOP assigns windows that cover rows within the interval of *size* and shifting every *slide* based
 on a timestamp column. Windows assigned could have overlapping so hopping sometime is named as "sliding windowing".
-
+The first parameter of the HOP table function is a generic table parameter.
+The input table has row semantics and supports pass-through columns.
 
 | Operator syntax      | Description
 |:-------------------- |:-----------
@@ -2024,7 +2102,10 @@ orders that tells data completeness.
 
 In streaming queries, SESSION assigns windows that cover rows based on *datetime*. Within a session window, distances
 of rows are less than *interval*. Session window is applied per *key*.
-
+The first parameter of the SESSION table function is a generic table parameter.
+The input table has set semantics and supports pass-through columns.
+Besides, the SESSION table function would not generate a result row
+if the input table is empty.
 
 | Operator syntax      | Description
 |:-------------------- |:-----------
@@ -2035,18 +2116,16 @@ Here is an example:
 {% highlight sql %}
 SELECT * FROM TABLE(
   SESSION(
-    TABLE orders,
+    TABLE orders PARTITION BY product,
     DESCRIPTOR(rowtime),
-    DESCRIPTOR(product),
     INTERVAL '20' MINUTE));
 
 -- or with the named params
 -- note: the DATA param must be the first
 SELECT * FROM TABLE(
   SESSION(
-    DATA => TABLE orders,
+    DATA => TABLE orders PARTITION BY product,
     TIMECOL => DESCRIPTOR(rowtime),
-    KEY => DESCRIPTOR(product),
     SIZE => INTERVAL '20' MINUTE));
 {% endhighlight %}
 
@@ -2118,59 +2197,68 @@ implements the OpenGIS Simple Features Implementation Specification for SQL,
 
 | C | Operator syntax      | Description
 |:- |:-------------------- |:-----------
+| p | ST_AsBinary(geom) | Synonym for `ST_AsWKB`
+| p | ST_AsEWKB(geom) | Synonym for `ST_AsWKB`
+| p | ST_AsEWKT(geom) | Converts GEOMETRY → EWKT
+| p | ST_AsGeoJSON(geom) | Converts GEOMETRY → GeoJSON
+| p | ST_AsGML(geom) | Converts GEOMETRY → GML
 | p | ST_AsText(geom) | Synonym for `ST_AsWKT`
-| o | ST_AsWKT(geom) | Converts *geom* → WKT
-| o | ST_GeomFromText(wkt [, srid ]) | Returns a specified GEOMETRY value from WKT representation
+| o | ST_AsWKB(geom) | Converts GEOMETRY → WKB
+| o | ST_AsWKT(geom) | Converts GEOMETRY → WKT
+| o | ST_Force2D(geom) | 3D GEOMETRY → 2D GEOMETRY
+| o | ST_GeomFromEWKB(wkb [, srid ]) | Synonym for `ST_GeomFromWKB`
+| o | ST_GeomFromEWKT(wkb [, srid ]) | Converts EWKT → GEOMETRY
+| o | ST_GeomFromGeoJSON(json) | Converts GeoJSON → GEOMETRY
+| o | ST_GeomFromGML(wkb [, srid ]) | Converts GML → GEOMETRY
+| o | ST_GeomFromText(wkt [, srid ]) | Synonym for `ST_GeomFromWKT`
+| o | ST_GeomFromWKB(wkb [, srid ]) | Converts WKB → GEOMETRY
+| o | ST_GeomFromWKT(wkb [, srid ]) | Converts WKT → GEOMETRY
 | o | ST_LineFromText(wkt [, srid ]) | Converts WKT → LINESTRING
+| o | ST_LineFromWKB(wkt [, srid ]) | Converts WKT → LINESTRING
 | o | ST_MLineFromText(wkt [, srid ]) | Converts WKT → MULTILINESTRING
 | o | ST_MPointFromText(wkt [, srid ]) | Converts WKT → MULTIPOINT
 | o | ST_MPolyFromText(wkt [, srid ]) Converts WKT → MULTIPOLYGON
 | o | ST_PointFromText(wkt [, srid ]) | Converts WKT → POINT
+| o | ST_PointFromWKB(wkt [, srid ]) | Converts WKB → POINT
 | o | ST_PolyFromText(wkt [, srid ]) | Converts WKT → POLYGON
+| o | ST_PolyFromWKB(wkt [, srid ]) | Converts WKB → POLYGON
+| p | ST_ReducePrecision(geom, gridSize) | Reduces the precision of a *geom* to the provided *gridSize*
+| h | ST_ToMultiPoint(geom) | Converts the coordinates of *geom* (which may be a GEOMETRYCOLLECTION) into a MULTIPOINT
+| h | ST_ToMultiLine(geom) | Converts the coordinates of *geom* (which may be a GEOMETRYCOLLECTION) into a MULTILINESTRING
+| h | ST_ToMultiSegments(geom) | Converts *geom* (which may be a GEOMETRYCOLLECTION) into a set of distinct segments stored in a MULTILINESTRING
 
 Not implemented:
 
-* ST_AsBinary(geom) GEOMETRY → WKB
-* ST_AsGML(geom) GEOMETRY → GML
-* ST_Force2D(geom) 3D GEOMETRY → 2D GEOMETRY
-* ST_GeomFromGML(gml [, srid ]) GML → GEOMETRY
-* ST_GeomFromWKB(wkb [, srid ]) WKB → GEOMETRY
 * ST_GoogleMapLink(geom [, layerType [, zoom ]]) GEOMETRY → Google map link
-* ST_LineFromWKB(wkb [, srid ]) WKB → LINESTRING
 * ST_OSMMapLink(geom [, marker ]) GEOMETRY → OSM map link
-* ST_PointFromWKB(wkb [, srid ]) WKB → POINT
-* ST_PolyFromWKB(wkb [, srid ]) WKB → POLYGON
-* ST_ToMultiLine(geom) Converts the coordinates of *geom* (which may be a GEOMETRYCOLLECTION) into a MULTILINESTRING
-* ST_ToMultiPoint(geom)) Converts the coordinates of *geom* (which may be a GEOMETRYCOLLECTION) into a MULTIPOINT
-* ST_ToMultiSegments(geom) Converts *geom* (which may be a GEOMETRYCOLLECTION) into a set of distinct segments stored in a MULTILINESTRING
 
 #### Geometry conversion functions (3D)
 
-Not implemented:
-
-* ST_Force3D(geom) 2D GEOMETRY → 3D GEOMETRY
+| C | Operator syntax      | Description
+|:- |:-------------------- |:-----------
+| o | ST_Force3D(geom) | 2D GEOMETRY → 3D GEOMETRY
 
 #### Geometry creation functions (2D)
 
 | C | Operator syntax      | Description
 |:- |:-------------------- |:-----------
+| h | ST_BoundingCircle(geom) | Returns the minimum bounding circle of *geom*
+| h | ST_Expand(geom, distance) | Expands *geom*'s envelope
+| h | ST_Expand(geom, deltaX, deltaY) | Expands *geom*'s envelope
+| h | ST_MakeEllipse(point, width, height) | Constructs an ellipse
 | p | ST_MakeEnvelope(xMin, yMin, xMax, yMax  [, srid ]) | Creates a rectangular POLYGON
 | h | ST_MakeGrid(geom, deltaX, deltaY) | Calculates a regular grid of POLYGONs based on *geom*
 | h | ST_MakeGridPoints(geom, deltaX, deltaY) | Calculates a regular grid of points based on *geom*
 | o | ST_MakeLine(point1 [, point ]*) | Creates a line-string from the given POINTs (or MULTIPOINTs)
 | p | ST_MakePoint(x, y [, z ]) | Synonym for `ST_Point`
+| p | ST_MakePolygon(lineString [, hole ]*)| Creates a POLYGON from *lineString* with the given holes (which are required to be closed LINESTRINGs)
+| h | ST_MinimumDiameter(geom) | Returns the minimum diameter of *geom*
+| h | ST_MinimumRectangle(geom) | Returns the minimum rectangle enclosing *geom*
+| h | ST_OctogonalEnvelope(geom) | Returns the octogonal envelope of *geom*
 | o | ST_Point(x, y [, z ]) | Constructs a point from two or three coordinates
 
 Not implemented:
 
-* ST_BoundingCircle(geom) Returns the minimum bounding circle of *geom*
-* ST_Expand(geom, distance) Expands *geom*'s envelope
-* ST_Expand(geom, deltaX, deltaY) Expands *geom*'s envelope
-* ST_MakeEllipse(point, width, height) Constructs an ellipse
-* ST_MakePolygon(lineString [, hole ]*) Creates a POLYGON from *lineString* with the given holes (which are required to be closed LINESTRINGs)
-* ST_MinimumDiameter(geom) Returns the minimum diameter of *geom*
-* ST_MinimumRectangle(geom) Returns the minimum rectangle enclosing *geom*
-* ST_OctogonalEnvelope(geom) Returns the octogonal envelope of *geom*
 * ST_RingBuffer(geom, distance, bufferCount [, endCapStyle [, doDifference]]) Returns a MULTIPOLYGON of buffers centered at *geom* and of increasing buffer size
 
 ### Geometry creation functions (3D)
@@ -2186,47 +2274,47 @@ Not implemented:
 | C | Operator syntax      | Description
 |:- |:-------------------- |:-----------
 | o | ST_Boundary(geom [, srid ]) | Returns the boundary of *geom*
+| o | ST_Centroid(geom) | Returns the centroid of *geom*
+| o | ST_CoordDim(geom) | Returns the dimension of the coordinates of *geom*
+| o | ST_Dimension(geom) | Returns the dimension of *geom*
 | o | ST_Distance(geom1, geom2) | Returns the distance between *geom1* and *geom2*
+| h | ST_ExteriorRing(geom) | Returns the exterior ring of *geom*, or null if *geom* is not a polygon
 | o | ST_GeometryType(geom) | Returns the type of *geom*
 | o | ST_GeometryTypeCode(geom) | Returns the OGC SFS type code of *geom*
+| p | ST_EndPoint(lineString) | Returns the last coordinate of *geom*
 | o | ST_Envelope(geom [, srid ]) | Returns the envelope of *geom* (which may be a GEOMETRYCOLLECTION) as a GEOMETRY
+| o | ST_Extent(geom) | Returns the minimum bounding box of *geom* (which may be a GEOMETRYCOLLECTION)
+| h | ST_GeometryN(geomCollection, n) | Returns the *n*th GEOMETRY of *geomCollection*
+| h | ST_InteriorRingN(geom) | Returns the nth interior ring of *geom*, or null if *geom* is not a polygon
+| h | ST_IsClosed(geom) | Returns whether *geom* is a closed LINESTRING or MULTILINESTRING
+| o | ST_IsEmpty(geom) | Returns whether *geom* is empty
+| o | ST_IsRectangle(geom) | Returns whether *geom* is a rectangle
+| h | ST_IsRing(geom) | Returns whether *geom* is a closed and simple line-string or MULTILINESTRING
+| o | ST_IsSimple(geom) | Returns whether *geom* is simple
+| o | ST_IsValid(geom) | Returns whether *geom* is valid
+| h | ST_NPoints(geom)  | Returns the number of points in *geom*
+| h | ST_NumGeometries(geom) | Returns the number of geometries in *geom* (1 if it is not a GEOMETRYCOLLECTION)
+| h | ST_NumInteriorRing(geom) | Synonym for `ST_NumInteriorRings`
+| h | ST_NumInteriorRings(geom) | Returns the number of interior rings of *geom*
+| h | ST_NumPoints(geom) | Returns the number of points in *geom*
+| p | ST_PointN(geom, n) | Returns the *n*th point of a *geom*
+| p | ST_PointOnSurface(geom) | Returns an interior or boundary point of *geom*
+| o | ST_SRID(geom) | Returns SRID value of *geom* or 0 if it does not have one
+| p | ST_StartPoint(geom) | Returns the first point of *geom*
 | o | ST_X(geom) | Returns the x-value of the first coordinate of *geom*
+| o | ST_XMax(geom) | Returns the maximum x-value of *geom*
+| o | ST_XMin(geom) | Returns the minimum x-value of *geom*
 | o | ST_Y(geom) | Returns the y-value of the first coordinate of *geom*
+| o | ST_YMax(geom) | Returns the maximum y-value of *geom*
+| o | ST_YMin(geom) | Returns the minimum y-value of *geom*
 
 Not implemented:
 
-* ST_Centroid(geom) Returns the centroid of *geom* (which may be a GEOMETRYCOLLECTION)
 * ST_CompactnessRatio(polygon) Returns the square root of *polygon*'s area divided by the area of the circle with circumference equal to its perimeter
-* ST_CoordDim(geom) Returns the dimension of the coordinates of *geom*
-* ST_Dimension(geom) Returns the dimension of *geom*
-* ST_EndPoint(lineString) Returns the last coordinate of *lineString*
-* ST_Envelope(geom [, srid ]) Returns the envelope of *geom* (which may be a GEOMETRYCOLLECTION) as a GEOMETRY
 * ST_Explode(query [, fieldName]) Explodes the GEOMETRYCOLLECTIONs in the *fieldName* column of a query into multiple geometries
-* ST_Extent(geom) Returns the minimum bounding box of *geom* (which may be a GEOMETRYCOLLECTION)
-* ST_ExteriorRing(polygon) Returns the exterior ring of *polygon* as a linear-ring
-* ST_GeometryN(geomCollection, n) Returns the *n*th GEOMETRY of *geomCollection*
-* ST_InteriorRingN(polygon, n) Returns the *n*th interior ring of *polygon*
-* ST_IsClosed(geom) Returns whether *geom* is a closed LINESTRING or MULTILINESTRING
-* ST_IsEmpty(geom) Returns whether *geom* is empty
-* ST_IsRectangle(geom) Returns whether *geom* is a rectangle
-* ST_IsRing(geom) Returns whether *geom* is a closed and simple line-string or MULTILINESTRING
-* ST_IsSimple(geom) Returns whether *geom* is simple
-* ST_IsValid(geom) Returns whether *geom* is valid
 * ST_IsValidDetail(geom [, selfTouchValid ]) Returns a valid detail as an array of objects
 * ST_IsValidReason(geom [, selfTouchValid ]) Returns text stating whether *geom* is valid, and if not valid, a reason why
-* ST_NPoints(geom) Returns the number of points in *geom*
-* ST_NumGeometries(geom) Returns the number of geometries in *geom* (1 if it is not a GEOMETRYCOLLECTION)
-* ST_NumInteriorRing(geom) Synonym for `ST_NumInteriorRings`
-* ST_NumInteriorRings(geom) Returns the number of interior rings of *geom*
-* ST_NumPoints(lineString) Returns the number of points in *lineString*
-* ST_PointN(geom, n) Returns the *n*th point of a *lineString*
-* ST_PointOnSurface(geom) Returns an interior or boundary point of *geom*
-* ST_SRID(geom) Returns SRID value of *geom* or 0 if it does not have one
-* ST_StartPoint(lineString) Returns the first coordinate of *lineString*
-* ST_XMax(geom) Returns the maximum x-value of *geom*
-* ST_XMin(geom) Returns the minimum x-value of *geom*
-* ST_YMax(geom) Returns the maximum y-value of *geom*
-* ST_YMin(geom) Returns the minimum y-value of *geom*
+
 
 #### Geometry properties (3D)
 
@@ -2234,11 +2322,8 @@ Not implemented:
 |:- |:-------------------- |:-----------
 | p | ST_Is3D(s) | Returns whether *geom* has at least one z-coordinate
 | o | ST_Z(geom) | Returns the z-value of the first coordinate of *geom*
-
-Not implemented:
-
-* ST_ZMax(geom) Returns the maximum z-value of *geom*
-* ST_ZMin(geom) Returns the minimum z-value of *geom*
+| o | ST_ZMax(geom) | Returns the maximum z-value of *geom*
+| o | ST_ZMin(geom) | Returns the minimum z-value of *geom*
 
 ### Geometry predicates
 
@@ -2246,6 +2331,8 @@ Not implemented:
 |:- |:-------------------- |:-----------
 | o | ST_Contains(geom1, geom2) | Returns whether *geom1* contains *geom2*
 | p | ST_ContainsProperly(geom1, geom2) | Returns whether *geom1* contains *geom2* but does not intersect its boundary
+| p | ST_CoveredBy(geom1, geom2) | Returns whether no point in *geom1* is outside *geom2*.
+| p | ST_Covers(geom1, geom2) | Returns whether no point in *geom2* is outside *geom1*
 | o | ST_Crosses(geom1, geom2) | Returns whether *geom1* crosses *geom2*
 | o | ST_Disjoint(geom1, geom2) | Returns whether *geom1* and *geom2* are disjoint
 | p | ST_DWithin(geom1, geom2, distance) | Returns whether *geom1* and *geom* are within *distance* of one another
@@ -2253,15 +2340,14 @@ Not implemented:
 | o | ST_Equals(geom1, geom2) | Returns whether *geom1* equals *geom2*
 | o | ST_Intersects(geom1, geom2) | Returns whether *geom1* intersects *geom2*
 | o | ST_Overlaps(geom1, geom2) | Returns whether *geom1* overlaps *geom2*
+| o | ST_Relate(geom1, geom2) | Returns the DE-9IM intersection matrix of *geom1* and *geom2*
+| o | ST_Relate(geom1, geom2, iMatrix) | Returns whether *geom1* and *geom2* are related by the given intersection matrix *iMatrix*
 | o | ST_Touches(geom1, geom2) | Returns whether *geom1* touches *geom2*
 | o | ST_Within(geom1, geom2) | Returns whether *geom1* is within *geom2*
 
 Not implemented:
 
-* ST_Covers(geom1, geom2) Returns whether no point in *geom2* is outside *geom1*
 * ST_OrderingEquals(geom1, geom2) Returns whether *geom1* equals *geom2* and their coordinates and component Geometries are listed in the same order
-* ST_Relate(geom1, geom2) Returns the DE-9IM intersection matrix of *geom1* and *geom2*
-* ST_Relate(geom1, geom2, iMatrix) Returns whether *geom1* and *geom2* are related by the given intersection matrix *iMatrix*
 
 #### Geometry operators (2D)
 
@@ -2269,24 +2355,30 @@ The following functions combine 2D geometries.
 
 | C | Operator syntax      | Description
 |:- |:-------------------- |:-----------
-| o | ST_Buffer(geom, distance [, quadSegs \| style ]) | Computes a buffer around *geom*
+| p | ST_Buffer(geom, distance [, quadSegs, endCapStyle ]) | Computes a buffer around *geom*
+| p | ST_Buffer(geom, distance [, bufferStyle ]) | Computes a buffer around *geom*
+| o | ST_ConvexHull(geom) | Computes the smallest convex polygon that contains all the points in *geom*
+| o | ST_Difference(geom1, geom2) | Computes the difference between two geometries
+| o | ST_SymDifference(geom1, geom2) | Computes the symmetric difference between two geometries
+| o | ST_Intersection(geom1, geom2) | Computes the intersection of *geom1* and *geom2*
+| p | ST_OffsetCurve(geom, distance, bufferStyle) | Computes an offset line for *linestring*
 | o | ST_Union(geom1, geom2) | Computes the union of *geom1* and *geom2*
 | o | ST_Union(geomCollection) | Computes the union of the geometries in *geomCollection*
 
 See also: the `ST_Union` aggregate function.
 
-Not implemented:
+#### Affine transformation functions (3D and 2D)
 
-* ST_ConvexHull(geom) Computes the smallest convex polygon that contains all the points in *geom*
-* ST_Difference(geom1, geom2) Computes the difference between two geometries
-* ST_Intersection(geom1, geom2) Computes the intersection of two geometries
-* ST_SymDifference(geom1, geom2) Computes the symmetric difference between two geometries
+The following functions transform 2D geometries.
 
-#### Affine transformation functions (3D and 2D)
+| C | Operator syntax      | Description
+|:- |:-------------------- |:-----------
+| o | ST_Rotate(geom, angle [, origin \| x, y]) | Rotates a *geom* counter-clockwise by *angle* (in radians) about *origin* (or the point (*x*, *y*))
+| o | ST_Scale(geom, xFactor, yFactor) | Scales *geom* by multiplying the ordinates by the indicated scale factors
+| o | ST_Translate(geom, x, y) | Translates *geom* by the vector (x, y)
 
 Not implemented:
 
-* ST_Rotate(geom, angle [, origin \| x, y]) Rotates a *geom* counter-clockwise by *angle* (in radians) about *origin* (or the point (*x*, *y*))
 * ST_Scale(geom, xFactor, yFactor [, zFactor ]) Scales *geom* by multiplying the ordinates by the indicated scale factors
 * ST_Translate(geom, x, y, [, z]) Translates *geom*
 
@@ -2294,27 +2386,33 @@ Not implemented:
 
 The following functions modify 2D geometries.
 
+| C | Operator syntax      | Description
+|:- |:-------------------- |:-----------
+| p | ST_AddPoint(linestring, point [, index]) | Adds *point* to *linestring* at a given *index* (or at the end if *index* is not specified)
+| h | ST_Densify(geom, tolerance) | Densifies a *geom* by inserting extra vertices along the line segments
+| h | ST_FlipCoordinates(geom) | Flips the X and Y coordinates of the *geom*
+| h | ST_Holes(geom) | Returns the holes in the *geom* (which may be a GEOMETRYCOLLECTION)
+| h | ST_Normalize(geom) | Converts the *geom* to normal form
+| p | ST_RemoveRepeatedPoints(geom [, tolerance]) | Removes duplicated coordinates from the *geom*
+| h | ST_RemoveHoles(geom) | Removes the holes of the *geom*
+| p | ST_RemovePoint(linestring, index) | Remove *point* at given *index* in *linestring*
+| h | ST_Reverse(geom) | Reverses the order of the coordinates of the *geom*
+
 Not implemented:
 
-* ST_AddPoint(geom, point [, tolerance ]) Adds *point* to *geom* with a given *tolerance* (default 0)
 * ST_CollectionExtract(geom, dimension) Filters *geom*, returning a multi-geometry of those members with a given *dimension* (1 = point, 2 = line-string, 3 = polygon)
-* ST_Densify(geom, tolerance) Inserts extra vertices every *tolerance* along the line segments of *geom*
-* ST_FlipCoordinates(geom) Flips the X and Y coordinates of *geom*
-* ST_Holes(geom) Returns the holes in *geom* (which may be a GEOMETRYCOLLECTION)
-* ST_Normalize(geom) Converts *geom* to normal form
-* ST_RemoveDuplicatedCoordinates(geom) Removes duplicated coordinates from *geom*
-* ST_RemoveHoles(geom) Removes a *geom*'s holes
-* ST_RemovePoints(geom, poly) Removes all coordinates of *geom* located within *poly*; null if all coordinates are removed
-* ST_RemoveRepeatedPoints(geom, tolerance) Removes from *geom* all repeated points (or points within *tolerance* of another point)
-* ST_Reverse(geom) Reverses the vertex order of *geom*
 
 #### Geometry editing functions (3D)
 
 The following functions modify 3D geometries.
 
+
+| C | Operator syntax      | Description
+|:- |:-------------------- |:-----------
+| h | ST_AddZ(geom, zToAdd) | Adds *zToAdd* to the z-coordinate of *geom*
+
 Not implemented:
 
-* ST_AddZ(geom, zToAdd) Adds *zToAdd* to the z-coordinate of *geom*
 * ST_Interpolate3DLine(geom) Returns *geom* with an interpolation of z values, or null if it is not a line-string or MULTILINESTRING
 * ST_MultiplyZ(geom, zFactor) Returns *geom* with its z-values multiplied by *zFactor*
 * ST_Reverse3DLine(geom [, sortOrder ]) Potentially reverses *geom* according to the z-values of its first and last coordinates
@@ -2323,18 +2421,20 @@ Not implemented:
 
 #### Geometry measurement functions (2D)
 
-Not implemented:
+The following functions measure geometries.
 
-* ST_Area(geom) Returns the area of *geom* (which may be a GEOMETRYCOLLECTION)
-* ST_ClosestCoordinate(geom, point) Returns the coordinate(s) of *geom* closest to *point*
-* ST_ClosestPoint(geom1, geom2) Returns the point of *geom1* closest to *geom2*
-* ST_FurthestCoordinate(geom, point) Returns the coordinate(s) of *geom* that are furthest from *point*
-* ST_Length(lineString) Returns the length of *lineString*
-* ST_LocateAlong(geom, segmentLengthFraction, offsetDistance) Returns a MULTIPOINT containing points along the line segments of *geom* at *segmentLengthFraction* and *offsetDistance*
-* ST_LongestLine(geom1, geom2) Returns the 2-dimensional longest line-string between the points of *geom1* and *geom2*
-* ST_MaxDistance(geom1, geom2) Computes the maximum distance between *geom1* and *geom2*
-* ST_Perimeter(polygon) Returns the length of the perimeter of *polygon* (which may be a MULTIPOLYGON)
-* ST_ProjectPoint(point, lineString) Projects *point* onto a *lineString* (which may be a MULTILINESTRING)
+| C | Operator syntax      | Description
+|:- |:-------------------- |:-----------
+| o | ST_Area(geom) | Returns the area of *geom* (which may be a GEOMETRYCOLLECTION)
+| h | ST_ClosestCoordinate(point, geom) | Returns the coordinate(s) of *geom* closest to *point*
+| h | ST_ClosestPoint(geom1, geom2) | Returns the point of *geom1* closest to *geom2*
+| h | ST_FurthestCoordinate(geom, point) | Returns the coordinate(s) of *geom* that are furthest from *point*
+| h | ST_Length(geom) | Returns the length of *geom*
+| h | ST_LocateAlong(geom, segmentLengthFraction, offsetDistance) | Returns a MULTIPOINT containing points along the line segments of *geom* at *segmentLengthFraction* and *offsetDistance*
+| h | ST_LongestLine(geom1, geom2) | Returns the 2-dimensional longest line-string between the points of *geom1* and *geom2*
+| h | ST_MaxDistance(geom1, geom2) | Computes the maximum distance between *geom1* and *geom2*
+| h | ST_Perimeter(polygon) | Returns the length of the perimeter of *polygon* (which may be a MULTIPOLYGON)
+| h | ST_ProjectPoint(point, lineString) | Projects *point* onto a *lineString* (which may be a MULTILINESTRING)
 
 #### Geometry measurement functions (3D)
 
@@ -2349,22 +2449,32 @@ Not implemented:
 
 The following functions process geometries.
 
+| C | Operator syntax      | Description
+|:- |:-------------------- |:-----------
+| o | ST_LineMerge(geom)  | Merges a collection of linear components to form a line-string of maximal length
+| o | ST_MakeValid(geom)  | Makes a valid geometry of a given invalid geometry
+| o | ST_Polygonize(geom)  | Creates a MULTIPOLYGON from edges of *geom*
+| o | ST_PrecisionReducer(geom, n) | Reduces *geom*'s precision to *n* decimal places
+| o | ST_Simplify(geom, distance)  | Simplifies *geom* using the [Douglas-Peuker algorithm](https://en.wikipedia.org/wiki/Ramer%E2%80%93Douglas%E2%80%93Peucker_algorithm) with a *distance* tolerance
+| o | ST_SimplifyPreserveTopology(geom, distance) | Simplifies *geom*, preserving its topology
+| o | ST_Snap(geom1, geom2, tolerance) | Snaps *geom1* and *geom2* together
+| p | ST_Split(geom, blade) | Splits *geom* by *blade*
+
 Not implemented:
 
 * ST_LineIntersector(geom1, geom2) Splits *geom1* (a line-string) with *geom2*
 * ST_LineMerge(geom) Merges a collection of linear components to form a line-string of maximal length
 * ST_MakeValid(geom [, preserveGeomDim [, preserveDuplicateCoord [, preserveCoordDim]]]) Makes *geom* valid
-* ST_Polygonize(geom) Creates a MULTIPOLYGON from edges of *geom*
-* ST_PrecisionReducer(geom, n) Reduces *geom*'s precision to *n* decimal places
 * ST_RingSideBuffer(geom, distance, bufferCount [, endCapStyle [, doDifference]]) Computes a ring buffer on one side
 * ST_SideBuffer(geom, distance [, bufferStyle ]) Compute a single buffer on one side
-* ST_Simplify(geom, distance) Simplifies *geom* using the [Douglas-Peuker algorithm](https://en.wikipedia.org/wiki/Ramer%E2%80%93Douglas%E2%80%93Peucker_algorithm) with a *distance* tolerance
-* ST_SimplifyPreserveTopology(geom) Simplifies *geom*, preserving its topology
-* ST_Snap(geom1, geom2, tolerance) Snaps *geom1* and *geom2* together
-* ST_Split(geom1, geom2 [, tolerance]) Splits *geom1* by *geom2* using *tolerance* (default 1E-6) to determine where the point splits the line
 
 #### Geometry projection functions
 
+The EPSG dataset is released separately from Proj4J due
+to its restrictive [terms of use](https://epsg.org/terms-of-use.html).
+In order to use the projection functions in Apache Calcite,
+users must include the EPSG dataset in their dependencies.
+
 | C | Operator syntax      | Description
 |:- |:-------------------- |:-----------
 | o | ST_SetSRID(geom, srid) | Returns a copy of *geom* with a new SRID
@@ -2388,19 +2498,22 @@ Not implemented:
 
 #### Triangulation functions
 
+| C | Operator syntax      | Description
+|:- |:-------------------- |:-----------
+| h | ST_ConstrainedDelaunay(geom [, flag]) | Computes a constrained Delaunay triangulation based on *geom*
+| h | ST_Delaunay(geom [, flag]) | Computes a Delaunay triangulation based on points in *geom*
+
 Not implemented:
 
-* ST_ConstrainedDelaunay(geom [, flag [, quality ]]) Computes a constrained Delaunay triangulation based on *geom*
-* ST_Delaunay(geom [, flag [, quality ]]) Computes a Delaunay triangulation based on points
 * ST_Tessellate(polygon) Tessellates *polygon* (may be MULTIPOLYGON) with adaptive triangles
 
 #### Geometry aggregate functions
 
-Not implemented:
-
-* ST_Accum(geom) Accumulates *geom* into a GEOMETRYCOLLECTION (or MULTIPOINT, MULTILINESTRING or MULTIPOLYGON if possible)
-* ST_Collect(geom) Synonym for `ST_Accum`
-* ST_Union(geom) Computes the union of geometries
+| C | Operator syntax      | Description
+|:- |:-------------------- |:-----------
+| h | ST_Accum(geom) | Accumulates *geom* into an array
+| h | ST_Collect(geom) | Collects *geom* into a GeometryCollection
+| h | ST_Union(geom) | Computes the union of the geometries in *geom*
 
 ### JSON Functions
 
@@ -2504,8 +2617,10 @@ connect string parameter.
 
 The 'C' (compatibility) column contains value:
 * 'b' for Google BigQuery ('fun=bigquery' in the connect string),
+* 'c' for Apache Calcite ('fun=calcite' in the connect string),
 * 'h' for Apache Hive ('fun=hive' in the connect string),
 * 'm' for MySQL ('fun=mysql' in the connect string),
+* 'q' for Microsoft SQL Server ('fun=mssql' in the connect string),
 * 'o' for Oracle ('fun=oracle' in the connect string),
 * 'p' for PostgreSQL ('fun=postgresql' in the connect string),
 * 's' for Apache Spark ('fun=spark' in the connect string).
@@ -2513,6 +2628,17 @@ The 'C' (compatibility) column contains value:
 One operator name may correspond to multiple SQL dialects, but with different
 semantics.
 
+BigQuery's type system uses confusingly different names for types and functions:
+* BigQuery's `DATETIME` type represents a local date time, and corresponds to
+  Calcite's `TIMESTAMP` type;
+* BigQuery's `TIMESTAMP` type represents an instant, and corresponds to
+  Calcite's `TIMESTAMP WITH LOCAL TIME ZONE` type;
+* The *timestampLtz* parameter, for instance in `DATE(timestampLtz)`, has
+  Calcite type `TIMESTAMP WITH LOCAL TIME ZONE`;
+* The `TIMESTAMP(string)` function, designed to be compatible the BigQuery
+  function, return a Calcite `TIMESTAMP WITH LOCAL TIME ZONE`;
+* Similarly, `DATETIME(string)` returns a Calcite `TIMESTAMP`.
+
 | C | Operator syntax                                | Description
 |:- |:-----------------------------------------------|:-----------
 | p | expr :: type                                   | Casts *expr* to *type*
@@ -2520,60 +2646,119 @@ semantics.
 | b | ARRAY_CONCAT(array [, array ]*)                | Concatenates one or more arrays. If any input argument is `NULL` the function returns `NULL`
 | b | ARRAY_LENGTH(array)                            | Synonym for `CARDINALITY`
 | b | ARRAY_REVERSE(array)                           | Reverses elements of *array*
-| o | CHR(integer) | Returns the character having the binary equivalent to *integer* as a CHAR value
-| o | COSH(numeric)                                  | Returns the hyperbolic cosine of *numeric*
+| 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*
+| b o | COSH(numeric)                                | Returns the hyperbolic cosine of *numeric*
 | o | CONCAT(string, string)                         | Concatenates two strings
-| m p | CONCAT(string [, string ]*)                  | Concatenates two or more strings
-| m | COMPRESS(string)                               | Compresses a string using zlib compression and returns the result as a binary string.
+| b m p | CONCAT(string [, string ]*)                | Concatenates two or more strings
+| m | COMPRESS(string)                               | Compresses a string using zlib compression and returns the result as a binary string
+| q | CONVERT(type, expression [ , style ])          | Equivalent to `CAST(expression AS type)`; ignores the *style* operand
 | p | CONVERT_TIMEZONE(tz1, tz2, datetime)           | Converts the timezone of *datetime* from *tz1* to *tz2*
-| b | CURRENT_DATETIME([timezone])                   | Returns the current time as a TIMESTAMP from *timezone*
+| b | CURRENT_DATETIME([ timeZone ])                 | Returns the current time as a TIMESTAMP from *timezone*
 | m | DAYNAME(datetime)                              | Returns the name, in the connection's locale, of the weekday in *datetime*; for example, it returns '星期日' for both DATE '2020-02-10' and TIMESTAMP '2020-02-10 10:10:10'
+| b | DATE(timestamp)                                | Extracts the DATE from a *timestamp*
+| b | DATE(timestampLtz)                             | Extracts the DATE from *timestampLtz* (an instant; BigQuery's TIMESTAMP type), assuming UTC
+| b | DATE(timestampLtz, timeZone)                   | Extracts the DATE from *timestampLtz* (an instant; BigQuery's TIMESTAMP type) in *timeZone*
 | b | DATE(string)                                   | Equivalent to `CAST(string AS DATE)`
+| b | DATE(year, month, day)                         | Returns a DATE value for *year*, *month*, and *day* (all of type INTEGER)
+| p q | DATEADD(timeUnit, integer, datetime)         | Equivalent to `TIMESTAMPADD(timeUnit, integer, datetime)`
+| p q | DATEDIFF(timeUnit, datetime, datetime2)      | Equivalent to `TIMESTAMPDIFF(timeUnit, datetime, datetime2)`
+| q | DATEPART(timeUnit, datetime)                   | Equivalent to `EXTRACT(timeUnit FROM  datetime)`
+| b | DATETIME(date, time)                           | Converts *date* and *time* to a TIMESTAMP
+| b | DATETIME(date)                                 | Converts *date* to a TIMESTAMP value (at midnight)
+| b | DATETIME(date, timeZone)                       | Converts *date* to a TIMESTAMP value (at midnight), in *timeZone*
+| b | DATETIME(year, month, day, hour, minute, second) | Creates a TIMESTAMP for *year*, *month*, *day*, *hour*, *minute*, *second* (all of type INTEGER)
+| b | DATETIME_ADD(timestamp, interval)              | Returns the TIMESTAMP value that occurs *interval* after *timestamp*
+| b | DATETIME_DIFF(timestamp, timestamp2, timeUnit) | Returns the whole number of *timeUnit* between *timestamp* and *timestamp2*
+| b | DATETIME_SUB(timestamp, interval)              | Returns the TIMESTAMP that occurs *interval* before *timestamp*
+| b | DATETIME_TRUNC(timestamp, timeUnit)            | Truncates *timestamp* to the granularity of *timeUnit*, rounding to the beginning of the unit
 | b | DATE_FROM_UNIX_DATE(integer)                   | Returns the DATE that is *integer* days after 1970-01-01
+| p | DATE_PART(timeUnit, datetime)                  | Equivalent to `EXTRACT(timeUnit FROM  datetime)`
+| b | DATE_ADD(date, interval)                       | Returns the DATE value that occurs *interval* after *date*
+| b | DATE_DIFF(date, date2, timeUnit)               | Returns the whole number of *timeUnit* between *date* and *date2*
+| b | DATE_SUB(date, interval)                       | Returns the DATE value that occurs *interval* before *date*
+| b | DATE_TRUNC(date, timeUnit)                     | Truncates *date* to the granularity of *timeUnit*, rounding to the beginning of the unit
 | o | DECODE(value, value1, result1 [, valueN, resultN ]* [, default ]) | Compares *value* to each *valueN* value one by one; if *value* is equal to a *valueN*, returns the corresponding *resultN*, else returns *default*, or NULL if *default* is not specified
 | p | DIFFERENCE(string, string)                     | Returns a measure of the similarity of two strings, namely the number of character positions that their `SOUNDEX` values have in common: 4 if the `SOUNDEX` values are same and 0 if the `SOUNDEX` values are totally different
+| b | ENDS_WITH(string1, string2)                    | Returns whether *string2* is a suffix of *string1*
 | 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.
-| o | GREATEST(expr [, expr ]*)                      | Returns the greatest of the expressions
+| 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*
+| b | FORMAT_TIMESTAMP(string timestamp)             | Formats *timestamp* according to the specified format *string*
+| b o | GREATEST(expr [, expr ]*)                    | Returns the greatest of the expressions
 | b h s | IF(condition, value1, value2)              | Returns *value1* if *condition* is TRUE, *value2* otherwise
+| b | IFNULL(value1, value2)                         | Equivalent to `NVL(value1, value2)`
 | p | string1 ILIKE string2 [ ESCAPE string3 ]       | Whether *string1* matches pattern *string2*, ignoring case (similar to `LIKE`)
 | p | string1 NOT ILIKE string2 [ ESCAPE string3 ]   | Whether *string1* does not match pattern *string2*, ignoring case (similar to `NOT LIKE`)
 | m | JSON_TYPE(jsonValue)                           | Returns a string value indicating the type of *jsonValue*
 | m | JSON_DEPTH(jsonValue)                          | Returns an integer value indicating the depth of *jsonValue*
 | m | JSON_PRETTY(jsonValue)                         | Returns a pretty-printing of *jsonValue*
 | m | JSON_LENGTH(jsonValue [, path ])               | Returns a integer indicating the length of *jsonValue*
+| m | JSON_INSERT(jsonValue, path, val[, path, val]*)  | Returns a JSON document insert a data of *jsonValue*, *path*, *val*
 | m | JSON_KEYS(jsonValue [, path ])                 | Returns a string indicating the keys of a JSON *jsonValue*
 | m | JSON_REMOVE(jsonValue, path[, path])           | Removes data from *jsonValue* using a series of *path* expressions and returns the result
+| m | JSON_REPLACE(jsonValue, path, val[, path, val]*)  | Returns a JSON document replace a data of *jsonValue*, *path*, *val*
+| m | JSON_SET(jsonValue, path, val[, path, val]*)  | Returns a JSON document set a data of *jsonValue*, *path*, *val*
 | m | JSON_STORAGE_SIZE(jsonValue)                   | Returns the number of bytes used to store the binary representation of *jsonValue*
-| o | LEAST(expr [, expr ]* )                        | Returns the least of the expressions
-| m p | LEFT(string, length)                         | Returns the leftmost *length* characters from the *string*
+| b o | LEAST(expr [, expr ]* )                      | Returns the least of the expressions
+| b m p | LEFT(string, length)                       | Returns the leftmost *length* characters from the *string*
+| b | LENGTH(string)                                 | Equivalent to `CHAR_LENGTH(string)`
+| b | LOG(numeric1 [, numeric2 ])                    | Returns the logarithm of *numeric1* to base *numeric2*, or base e if *numeric2* is not present
+| b o | LPAD(string, length[, pattern ])             | Returns a string or bytes value that consists of *string* prepended to *length* with *pattern*
 | m | TO_BASE64(string)                              | Converts the *string* to base-64 encoded form and returns a encoded string
-| m | FROM_BASE64(string)                            | Returns the decoded result of a base-64 *string* as a string
-| o | LTRIM(string)                                  | Returns *string* with all blanks removed from the start
-| m p | MD5(string)                                  | Calculates an MD5 128-bit checksum of *string* and returns it as a hex string
+| b m | FROM_BASE64(string)                          | Returns the decoded result of a base-64 *string* as a string
+| b o | LTRIM(string)                                | Returns *string* with all blanks removed from the start
+| b m p | MD5(string)                                | Calculates an MD5 128-bit checksum of *string* and returns it as a hex string
 | m | MONTHNAME(date)                                | Returns the name, in the connection's locale, of the month in *datetime*; for example, it returns '二月' for both DATE '2020-02-10' and TIMESTAMP '2020-02-10 10:10:10'
 | o | NVL(value1, value2)                            | Returns *value1* if *value1* is not null, otherwise *value2*
+| b | POW(numeric1, numeric2)                        | Returns *numeric1* raised to the power *numeric2*
 | m o | REGEXP_REPLACE(string, regexp, rep, [, pos [, occurrence [, matchType]]]) | Replaces all substrings of *string* that match *regexp* with *rep* at the starting *pos* in expr (if omitted, the default is 1), *occurrence* means which occurrence of a match to search for (if omitted, the default is 1), *matchType* specifies how to perform matching
-| m p | REPEAT(string, integer)                      | Returns a string consisting of *string* repeated of *integer* times; returns an empty string if *integer* is less than 1
-| m | REVERSE(string)                                | Returns *string* with the order of the characters reversed
-| m p | RIGHT(string, length)                        | Returns the rightmost *length* characters from the *string*
+| b m p | REPEAT(string, integer)                    | Returns a string consisting of *string* repeated of *integer* times; returns an empty string if *integer* is less than 1
+| b m | REVERSE(string)                              | Returns *string* with the order of the characters reversed
+| b m p | RIGHT(string, length)                      | Returns the rightmost *length* characters from the *string*
 | h s | string1 RLIKE string2                        | Whether *string1* matches regex pattern *string2* (similar to `LIKE`, but uses Java regex)
 | h s | string1 NOT RLIKE string2                    | Whether *string1* does not match regex pattern *string2* (similar to `NOT LIKE`, but uses Java regex)
-| o | RTRIM(string)                                  | Returns *string* with all blanks removed from the end
-| m p | SHA1(string)                                 | Calculates a SHA-1 hash value of *string* and returns it as a hex string
-| o | SINH(numeric)                                  | Returns the hyperbolic sine of *numeric*
-| m o p | SOUNDEX(string)                            | Returns the phonetic representation of *string*; throws if *string* is encoded with multi-byte encoding such as UTF-8
+| b o | RPAD(string, length[, pattern ])             | Returns a string or bytes value that consists of *string* appended to *length* with *pattern*
+| b o | RTRIM(string)                                | Returns *string* with all blanks removed from the end
+| b | SAFE_CAST(value AS type)                       | Converts *value* to *type*, returning NULL if conversion fails
+| b m p | SHA1(string)                               | Calculates a SHA-1 hash value of *string* and returns it as a hex string
+| b o | SINH(numeric)                                | Returns the hyperbolic sine of *numeric*
+| b m o p | SOUNDEX(string)                          | Returns the phonetic representation of *string*; throws if *string* is encoded with multi-byte encoding such as UTF-8
 | m | SPACE(integer)                                 | Returns a string of *integer* spaces; returns an empty string if *integer* is less than 1
-| b m o p | SUBSTR(string, position [, substringLength ]) | Returns a portion of *string*, beginning at character *position*, *substringLength* characters long. SUBSTR calculates lengths using characters as defined by the input character set
+| b | SPLIT(string [, delimiter ])                   | Returns the string array of *string* split at *delimiter* (if omitted, default is comma)
+| b | STARTS_WITH(string1, string2)                  | Returns whether *string2* is a prefix of *string1*
 | m | STRCMP(string, string)                         | Returns 0 if both of the strings are same and returns -1 when the first argument is smaller than the second and 1 when the second one is smaller than the first one
-| o | TANH(numeric)                                  | Returns the hyperbolic tangent of *numeric*
+| b p | STRPOS(string, substring)                    | Equivalent to `POSITION(substring IN string)`
+| b m o p | SUBSTR(string, position [, substringLength ]) | Returns a portion of *string*, beginning at character *position*, *substringLength* characters long. SUBSTR calculates lengths using characters as defined by the input character set
+| b o | TANH(numeric)                                | Returns the hyperbolic tangent of *numeric*
+| b | TIME(hour, minute, second)                     | Returns a TIME value *hour*, *minute*, *second* (all of type INTEGER)
+| b | TIME(timestamp)                                | Extracts the TIME from *timestamp* (a local time; BigQuery's DATETIME type)
+| b | TIME(instant)                                  | Extracts the TIME from *timestampLtz* (an instant; BigQuery's TIMESTAMP type), assuming UTC
+| b | TIME(instant, timeZone)                        | Extracts the time from *timestampLtz* (an instant; BigQuery's TIMESTAMP type), in *timeZone*
+| b | TIMESTAMP(string)                              | Equivalent to `CAST(string AS TIMESTAMP WITH LOCAL TIME ZONE)`
+| b | TIMESTAMP(string, timeZone)                    | Equivalent to `CAST(string AS TIMESTAMP WITH LOCAL TIME ZONE)`, converted to *timeZone*
+| b | TIMESTAMP(date)                                | Converts *date* to a TIMESTAMP WITH LOCAL TIME ZONE value (at midnight)
+| b | TIMESTAMP(date, timeZone)                      | Converts *date* to a TIMESTAMP WITH LOCAL TIME ZONE value (at midnight), in *timeZone*
+| b | TIMESTAMP(timestamp)                           | Converts *timestamp* to a TIMESTAMP WITH LOCAL TIME ZONE, assuming a UTC
+| b | TIMESTAMP(timestamp, timeZone)                 | Converts *timestamp* to a TIMESTAMP WITH LOCAL TIME ZONE, in *timeZone*
+| b | TIMESTAMP_ADD(timestamp, interval)             | Returns the TIMESTAMP value that occurs *interval* after *timestamp*
+| b | TIMESTAMP_DIFF(timestamp, timestamp2, timeUnit) | Returns the whole number of *timeUnit* between *timestamp* and *timestamp2*. Equivalent to `TIMESTAMPDIFF(timeUnit, timestamp2, timestamp)` and `(timestamp - timestamp2) timeUnit`
 | b | TIMESTAMP_MICROS(integer)                      | Returns the TIMESTAMP that is *integer* microseconds after 1970-01-01 00:00:00
 | b | TIMESTAMP_MILLIS(integer)                      | Returns the TIMESTAMP that is *integer* milliseconds after 1970-01-01 00:00:00
 | b | TIMESTAMP_SECONDS(integer)                     | Returns the TIMESTAMP that is *integer* seconds after 1970-01-01 00:00:00
+| b | TIMESTAMP_SUB(timestamp, interval)             | Returns the TIMESTAMP value that is *interval* before *timestamp*
+| b | TIMESTAMP_TRUNC(timestamp, timeUnit)           | Truncates *timestamp* to the granularity of *timeUnit*, rounding to the beginning of the unit
+| b | TIME_ADD(time, interval)                       | Adds *interval* to *time*, independent of any time zone
+| b | TIME_DIFF(time, time2, timeUnit)               | Returns the whole number of *timeUnit* between *time* and *time2*
+| b | TIME_SUB(time, interval)                       | Returns the TIME value that is *interval* before *time*
+| b | TIME_TRUNC(time, timeUnit)                     | Truncates *time* to the granularity of *timeUnit*, rounding to the beginning of the unit
 | o p | TO_DATE(string, format)                      | Converts *string* to a date using the format *format*
 | o p | TO_TIMESTAMP(string, format)                 | Converts *string* to a timestamp using the format *format*
-| o p | TRANSLATE(expr, fromString, toString)        | Returns *expr* with all occurrences of each character in *fromString* replaced by its corresponding character in *toString*. Characters in *expr* that are not in *fromString* are not replaced
+| b o p | TRANSLATE(expr, fromString, toString)      | Returns *expr* with all occurrences of each character in *fromString* replaced by its corresponding character in *toString*. Characters in *expr* that are not in *fromString* are not replaced
+| b | TRUNC(numeric1 [, numeric2 ])                  | Truncates *numeric1* to optionally *numeric2* (if not specified 0) places right to the decimal point
 | b | UNIX_MICROS(timestamp)                         | Returns the number of microseconds since 1970-01-01 00:00:00
 | b | UNIX_MILLIS(timestamp)                         | Returns the number of milliseconds since 1970-01-01 00:00:00
 | b | UNIX_SECONDS(timestamp)                        | Returns the number of seconds since 1970-01-01 00:00:00
@@ -2582,6 +2767,11 @@ semantics.
 
 Note:
 
+* Calcite has no Redshift library, so the Postgres library
+  is used instead. The functions `DATEADD`, `DATEDIFF` are
+  implemented in Redshift and not Postgres but nevertheless
+  appear in Calcite's Postgres library
+* Functions `DATEADD`, `DATEDIFF`, `DATE_PART` require the Babel parser
 * `JSON_TYPE` / `JSON_DEPTH` / `JSON_PRETTY` / `JSON_STORAGE_SIZE` return null if the argument is null
 * `JSON_LENGTH` / `JSON_KEYS` / `JSON_REMOVE` return null if the first argument is null
 * `JSON_TYPE` generally returns an upper-case string flag indicating the type of the JSON input. Currently supported supported type flags are:
@@ -2607,6 +2797,7 @@ Dialect-specific aggregate functions.
 
 | C | Operator syntax                                | Description
 |:- |:-----------------------------------------------|:-----------
+| c | AGGREGATE(m)                                   | Computes measure *m* in the context of the current GROUP BY key
 | b p | ARRAY_AGG( [ ALL &#124; DISTINCT ] value [ RESPECT NULLS &#124; IGNORE NULLS ] [ ORDER BY orderItem [, orderItem ]* ] ) | Gathers values into arrays
 | b p | ARRAY_CONCAT_AGG( [ ALL &#124; DISTINCT ] value [ ORDER BY orderItem [, orderItem ]* ] ) | Concatenates arrays into arrays
 | p | BOOL_AND(condition)                            | Synonym for `EVERY`
@@ -2615,6 +2806,8 @@ Dialect-specific aggregate functions.
 | m | GROUP_CONCAT( [ ALL &#124; DISTINCT ] value [, value ]* [ ORDER BY orderItem [, orderItem ]* ] [ SEPARATOR separator ] ) | MySQL-specific variant of `LISTAGG`
 | b | LOGICAL_AND(condition)                         | Synonym for `EVERY`
 | b | LOGICAL_OR(condition)                          | Synonym for `SOME`
+| s | MAX_BY(value, comp)                            | Synonym for `ARG_MAX`
+| s | MIN_BY(value, comp)                            | Synonym for `ARG_MIN`
 | b p | STRING_AGG( [ ALL &#124; DISTINCT ] value [, separator] [ ORDER BY orderItem [, orderItem ]* ] ) | Synonym for `LISTAGG`
 
 Usage Examples:
@@ -2676,6 +2869,23 @@ Result
 |:------:|:-----:|:-------:|:-------:|
 | 1      | 2     | 1       | 1       |
 
+##### JSON_INSERT example
+
+SQL
+
+```SQL
+SELECT JSON_INSERT(v, '$.a', 10, '$.c', '[1]') AS c1,
+  JSON_INSERT(v, '$', 10, '$.c', '[1]') AS c2
+FROM (VALUES ('{"a": [10, true]}')) AS t(v)
+LIMIT 10;
+```
+
+Result
+
+| c1                             | c2                            |
+| ------------------------------ | ----------------------------- |
+| {"a":1 , "b":[2] , "c":"[1]"}  | {"a":1 , "b":[2] , "c":"[1]"} |
+
 ##### JSON_KEYS example
 
 SQL
@@ -2712,6 +2922,41 @@ LIMIT 10;
 |:----------:|
 | ["a", "d"] |
 
+##### JSON_REPLACE example
+
+SQL
+
+ ```SQL
+SELECT
+JSON_REPLACE(v, '$.a', 10, '$.c', '[1]') AS c1,
+JSON_REPLACE(v, '$', 10, '$.c', '[1]') AS c2
+FROM (VALUES ('{\"a\": 1,\"b\":[2]}')) AS t(v)
+limit 10;
+```
+
+ Result
+
+| c1                             | c2                              |
+| ------------------------------ | ------------------------------- |
+| {"a":1 , "b":[2] , "c":"[1]"}  | {"a":1 , "b":[2] , "c":"[1]"}") |
+
+##### JSON_SET example
+
+SQL
+
+ ```SQL
+SELECT
+JSON_SET(v, '$.a', 10, '$.c', '[1]') AS c1,
+JSON_SET(v, '$', 10, '$.c', '[1]') AS c2
+FROM (VALUES ('{\"a\": 1,\"b\":[2]}')) AS t(v)
+limit 10;
+```
+
+ Result
+
+| c1                 | c2 |
+| -------------------| -- |
+| {"a":10, "b":[2]}  | 10 |
 
 ##### JSON_STORAGE_SIZE example
 
@@ -2770,12 +3015,6 @@ Result
 |:-----------:|:-----------:|:-----------:|:-----------:|
 | Aa_Bb_CcD_d | Aa_Bb_CcD_d | Aa_Bb_CcD_d | Aa_Bb_CcD_d |
 
-Not implemented:
-
-* JSON_INSERT
-* JSON_SET
-* JSON_REPLACE
-
 ## User-defined functions
 
 Calcite is extensible. You can define each kind of function using user code.
diff --git a/site/_docs/spatial.md b/site/_docs/spatial.md
index a74e4ce7585..d0b2ec85d44 100644
--- a/site/_docs/spatial.md
+++ b/site/_docs/spatial.md
@@ -151,7 +151,7 @@ But for safety, Calcite applies the original predicate, to remove false positive
 ## Acknowledgements
 
 Calcite's OpenGIS implementation uses the
-[Esri geometry API](https://github.com/Esri/geometry-api-java). Thanks for the
+[JTS Topology Suite](https://github.com/locationtech/jts). Thanks for the
 help we received from their community.
 
 While developing this feature, we made extensive use of the
diff --git a/site/_docs/tutorial.md b/site/_docs/tutorial.md
index 7b509bd629d..01a3ea87dc1 100644
--- a/site/_docs/tutorial.md
+++ b/site/_docs/tutorial.md
@@ -90,7 +90,7 @@ sqlline> !tables
 {% endhighlight %}
 
 (JDBC experts, note: sqlline's <code>!tables</code> command is just executing
-<a href="https://docs.oracle.com/javase/7/docs/api/java/sql/DatabaseMetaData.html#getTables(java.lang.String, java.lang.String, java.lang.String, java.lang.String[])"><code>DatabaseMetaData.getTables()</code></a>
+<a href="https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/sql/DatabaseMetaData.html#getTables(java.lang.String, java.lang.String, java.lang.String, java.lang.String[])"><code>DatabaseMetaData.getTables()</code></a>
 behind the scenes.
 It has other commands to query JDBC metadata, such as <code>!columns</code> and <code>!describe</code>.)
 
@@ -573,7 +573,7 @@ public class CsvProjectTableScanRule
       return new CsvProjectTableScanRule(this);
     }
   }
-} 
+}
 {% endhighlight %}
 
 The default instance of the rule resides in the `CsvRules` holder class:
@@ -665,9 +665,7 @@ set. To load the data set, follow <a
 href="https://mondrian.pentaho.com/documentation/installation.php#2_Set_up_test_data">Mondrian's
 installation instructions</a>.)
 
-<b>Current limitations</b>: The JDBC adapter currently only pushes
-down table scan operations; all other processing (filtering, joins,
-aggregations and so forth) occurs within Calcite. Our goal is to push
+The JDBC adapter will push
 down as much processing as possible to the source system, translating
 syntax, data types and built-in functions as we go. If a Calcite query
 is based on tables from a single JDBC database, in principle the whole
diff --git a/site/_posts/2022-08-02-release-1.31.0.md b/site/_posts/2022-08-02-release-1.31.0.md
new file mode 100644
index 00000000000..7108b9c3965
--- /dev/null
+++ b/site/_posts/2022-08-02-release-1.31.0.md
@@ -0,0 +1,47 @@
+---
+layout: news_item
+date: "2022-08-02 12:00:00 +0000"
+author: sereda
+version: 1.31.0
+categories: [release]
+tag: v1-31-0
+sha: 86d1bf40
+---
+<!--
+{% 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 %}
+-->
+
+The [Apache Calcite PMC]({{ site.baseurl }})
+is pleased to announce
+[Apache Calcite release 1.31.0]({{ site.baseurl }}/docs/history.html#v1-31-0).
+
+This release comes four months after [1.30.0](#v1-30-0),
+contains contributions from 28 contributors, and resolves 81 issues.
+
+Among others, it is worth highlighting the following improvements:
+
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-4865">CALCITE-4865</a>]
+ Allow table functions to be polymorphic
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5107">CALCITE-5107</a>]
+ Support SQL hint for `Filter`, `SetOp`, `Sort`, `Window`, `Values`
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-35">CALCITE-35</a>]
+ Support parsing parenthesized joins
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-3890">CALCITE-3890</a>]
+ Derive `IS NOT NULL` filter for the inputs of inner join
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5085">CALCITE-5085</a>]
+ Firebolt dialect implementation
diff --git a/site/_posts/2022-09-10-release-1.32.0.md b/site/_posts/2022-09-10-release-1.32.0.md
new file mode 100644
index 00000000000..a5bed4f7e4a
--- /dev/null
+++ b/site/_posts/2022-09-10-release-1.32.0.md
@@ -0,0 +1,50 @@
+---
+layout: news_item
+date: "2022-09-10 12:00:00 +0000"
+author: jhyde
+version: 1.32.0
+categories: [release]
+tag: v1-32-0
+sha: 413eded6
+---
+<!--
+{% 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 %}
+-->
+
+The [Apache Calcite PMC]({{ site.baseurl }})
+is pleased to announce
+[Apache Calcite release 1.32.0]({{ site.baseurl }}/docs/history.html#v1-32-0).
+
+This release
+<a href="https://issues.apache.org/jira/browse/CALCITE-5263">fixes</a>
+<a href="http://cve.mitre.org/cgi-bin/cvename.cgi?name=2022-39135">CVE-2022-39135</a>,
+an XML External Entity (XEE) vulnerability that allows a SQL query to
+read the contents of files via the SQL functions `EXISTS_NODE`,
+`EXTRACT_XML`, `XML_TRANSFORM` or `EXTRACT_VALUE`.
+
+Coming 1 month after [1.31.0]({{ site.baseurl }}/docs/history.html#v1-31-0)
+with 19 issues fixed by 17 contributors, this release also
+<a href="https://issues.apache.org/jira/browse/CALCITE-4294">replaces
+the ESRI spatial engine with JTS and proj4j</a>, adds
+<a href="https://issues.apache.org/jira/browse/CALCITE-5262">65
+spatial SQL functions</a> including `ST_Centroid`, `ST_Covers` and
+`ST_GeomFromGeoJSON`, adds the
+<a href="https://issues.apache.org/jira/browse/CALCITE-5241">CHAR</a>
+SQL function, and improves the return type of the
+<a href="https://issues.apache.org/jira/browse/CALCITE-4999">ARRAY and
+MULTISET</a> functions.
diff --git a/site/_posts/2023-02-07-release_1.33.0.md b/site/_posts/2023-02-07-release_1.33.0.md
new file mode 100644
index 00000000000..3d595242ffc
--- /dev/null
+++ b/site/_posts/2023-02-07-release_1.33.0.md
@@ -0,0 +1,65 @@
+---
+layout: news_item
+date: "2023-02-07 12:00:00 +0000"
+author: jbalint
+version: 1.33.0
+categories: [release]
+tag: v1-33-0
+sha: 5ad825c
+---
+<!--
+{% 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 %}
+-->
+
+The [Apache Calcite PMC]({{ site.baseurl }})
+is pleased to announce
+[Apache Calcite release 1.33.0]({{ site.baseurl }}/docs/history.html#v1-33-0).
+
+This release comes five months after [1.32.0](#v1-32-0),
+contains contributions from 33 contributors, and resolves 107 issues.
+
+Among others, it is worth highlighting the following improvements:
+
+
+* Many improvements to the BigQuery dialect as part of [<a href="https://issues.apache.org/jira/browse/CALCITE-5180">CALCITE-5180</a>]
+  * [<a href="https://issues.apache.org/jira/browse/CALCITE-5269">CALCITE-5269</a>]
+    Implement BigQuery `TIME_TRUNC` and `TIMESTAMP_TRUNC` functions
+  * [<a href="https://issues.apache.org/jira/browse/CALCITE-5360">CALCITE-5360</a>]
+    Implement `TIMESTAMP_ADD` function (compatible with BigQuery)
+  * [<a href="https://issues.apache.org/jira/browse/CALCITE-5389">CALCITE-5389</a>]
+    Add `STARTS_WITH` and `ENDS_WITH` functions (for `BIG_QUERY` compatibility)
+  * [<a href="https://issues.apache.org/jira/browse/CALCITE-5404">CALCITE-5404</a>]
+    Implement BigQuery's `POW()` and `TRUNC()` math functions
+  * [<a href="https://issues.apache.org/jira/browse/CALCITE-5423">CALCITE-5423</a>]
+    Implement `TIMESTAMP_DIFF` function (compatible with BigQuery)
+  * [<a href="https://issues.apache.org/jira/browse/CALCITE-5430">CALCITE-5430</a>]
+    Implement `IFNULL()` for BigQuery dialect
+  * [<a href="https://issues.apache.org/jira/browse/CALCITE-5432">CALCITE-5432</a>]
+    Implement BigQuery `TIME_ADD`/`TIME_DIFF`
+  * [<a href="https://issues.apache.org/jira/browse/CALCITE-5436">CALCITE-5436</a>]
+    Implement `DATE_SUB`, `TIME_SUB`, `TIMESTAMP_SUB` (compatible w/ BigQuery)
+  * [<a href="https://issues.apache.org/jira/browse/CALCITE-5447">CALCITE-5447</a>]
+    Add `DATE_TRUNC` for BigQuery
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5105">CALCITE-5105</a>]
+  Add `MEASURE` type and `AGGREGATE` aggregate function
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5155">CALCITE-5155</a>]
+  Custom time frames
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5280">CALCITE-5280</a>]
+  Implement geometry aggregate functions
+* [<a href="https://issues.apache.org/jira/browse/CALCITE-5314">CALCITE-5314</a>]
+  Prune empty parts of a query by exploiting stats/metadata
diff --git a/site/_posts/2023-03-14-release-1.34.0.md b/site/_posts/2023-03-14-release-1.34.0.md
new file mode 100644
index 00000000000..62237d70e8b
--- /dev/null
+++ b/site/_posts/2023-03-14-release-1.34.0.md
@@ -0,0 +1,40 @@
+---
+layout: news_item
+date: "2023-03-14 12:00:00 +0000"
+author: zabetak
+version: 1.34.0
+categories: [release]
+tag: v1-34-0
+sha: 7dfd641baeb0e1b26dec04da5241c3999fe0ac6a
+---
+<!--
+{% 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 %}
+-->
+
+The [Apache Calcite PMC]({{ site.baseurl }}) is pleased to announce
+[Apache Calcite release 1.34.0]({{ site.baseurl }}/docs/history.html#v1-34-0).
+
+This release comes 1 month after [1.33.0](#v1-33-0),
+contains contributions from 18 contributors, and resolves 34 issues.
+
+It's worth highlighting the introduction of QUALIFY clause ([<a href="https://issues.apache.org/jira/browse/CALCITE-5268">CALCITE-5268</a>]),
+which facilitates filtering the results of window functions. Among other improvements and fixes, it
+adds roughly 15 new functions in BigQuery library for handling dates, times, and timestamps, and
+provides a fix ([<a href="https://issues.apache.org/jira/browse/CALCITE-5522">CALCITE-5522</a>])
+for a small breaking change in `DATE_TRUNC` function ([<a href="https://issues.apache.org/jira/browse/CALCITE-5447">CALCITE-5447</a>]), which was
+introduced accidentally in [1.33.0](#v1-33-0).
diff --git a/site/community/index.md b/site/community/index.md
index f4b78acf9cf..ad7018f61f4 100644
--- a/site/community/index.md
+++ b/site/community/index.md
@@ -87,12 +87,32 @@ Want to learn more about Calcite?
 Watch some presentations and read through some slide decks about
 Calcite, or attend one of the [upcoming talks](#upcoming-talks).
 
+## Adding measures to Calcite SQL
+
+At [Calcite Virtual Meetup](https://www.meetup.com/apache-calcite/events/291489488/), March 2023;
+[[slides](https://www.slideshare.net/julianhyde/adding-measures-to-calcite-sql)],
+[[video](https://youtu.be/COFQrSEX_iI)].
+
+## Building a streaming incremental view maintenance engine with Calcite
+
+At [Calcite Virtual Meetup](https://www.meetup.com/apache-calcite/events/291489488/), March 2023;
+[[slides](http://budiu.info/work/dbsp-calcite23.pptx)],
+[[video](https://youtu.be/iT4k5DCnvPU)].
+
+## Debugging planning issues using Calcite's built in loggers
+
+At [Calcite Virtual Meetup](https://www.meetup.com/apache-calcite/events/291489488/), March 2023;
+[[summary](https://github.com/zabetak/slides/blob/master/2023/calcite-meetup-march/debugging-planning-issues-using-calcites-built-in-loggers.md)],
+[[slides](https://www.slideshare.net/StamatisZampetakis/debugging-planning-issues-using-calcites-builtin-loggers)],
+[[pdf](https://github.com/zabetak/slides/blob/master/2023/calcite-meetup-march/debugging-planning-issues-using-calcites-built-in-loggers.pdf)],
+[[video](https://youtu.be/_phzRNCWJfw)].
+
 ## calcite-clj - Use Calcite with Clojure
 
-At [Apache Calcite Online Meetup January 2022](https://www.meetup.com/Apache-Calcite/events/282836907/)
-[[slides]](https://ieugen.github.io/calcite-clj/)
-[[video]](https://www.youtube.com/watch?v=9CUWX8JHA90)
-[[code]](https://github.com/ieugen/calcite-clj)
+At [Calcite Virtual Meetup](https://www.meetup.com/Apache-Calcite/events/282836907/), January 2022;
+[[slides](https://ieugen.github.io/calcite-clj/)],
+[[video](https://www.youtube.com/watch?v=9CUWX8JHA90)],
+[[code](https://github.com/ieugen/calcite-clj)].
 
 ## Morel, a functional query language (Julian Hyde)
 
@@ -109,7 +129,8 @@ At [ApacheCon 2021](https://www.apachecon.com/acah2021/tracks/bigdatasql.html),
 At [BOSS 2021](https://boss-workshop.github.io/boss-2021/), Copenhagen, Denmark, August 16, 2021;
 [[summary](https://github.com/zabetak/slides/blob/master/2021/boss-workshop/apache-calcite-tutorial.md)],
 [[slides](https://www.slideshare.net/StamatisZampetakis/apache-calcite-tutorial-boss-21)],
-[[pdf](https://github.com/zabetak/slides/blob/master/2021/boss-workshop/apache-calcite-tutorial.pdf)].
+[[pdf](https://github.com/zabetak/slides/blob/master/2021/boss-workshop/apache-calcite-tutorial.pdf)],
+[[video](https://youtu.be/meI0W12f_nw)].
 
 ## An introduction to query processing & Apache Calcite
 
diff --git a/site/develop/index.md b/site/develop/index.md
index 0a74ce19111..4ed681157f9 100644
--- a/site/develop/index.md
+++ b/site/develop/index.md
@@ -65,6 +65,33 @@ The HOWTO describes how to
 [run more or fewer tests]({{ site.baseurl }}/docs/howto.html#running-tests) and
 [run integration tests]({{ site.baseurl }}/docs/howto.html#running-integration-tests).
 
+## JIRA accounts
+Calcite uses [JIRA](https://issues.apache.org/jira/browse/CALCITE) for issues/case management.
+You must have a JIRA account in order to log cases and issues.
+
+### I already have an ASF JIRA account and want to be added as a contributor
+If you already have an ASF JIRA account, you do not need to sign up for a
+new account. Please email [jira-requests@calcite.apache.org](mailto:jira-requests@calcite.apache.org)
+using the following template, so that we can add your account to the
+contributors list in JIRA:
+
+[**[Open the template in your email client]**](mailto:jira-requests@calcite.apache.org?subject=Add%20me%20as%20a%20contributor%20to%20JIRA&body=Hello,%0A%0APlease%20add%20me%20as%20a%20contributor%20to%20JIRA.%0AMy%20JIRA%20username%20is:%20[INSERT%20YOUR%20JIRA%20USERNAME%20HERE]%0A%0AThanks,%0A[INSERT%20YOUR%20NAME%20HERE])
+{% highlight text %}
+Subject: Add me as a contributor to JIRA
+
+Hello,
+
+Please add me as a contributor to JIRA.
+My JIRA username is: [INSERT YOUR JIRA USERNAME HERE]
+
+Thanks,
+[INSERT YOUR NAME HERE]
+{% endhighlight %}
+
+
+### I do not have an ASF JIRA account, want to request an account and be added as a contributor
+Please request an account using the [ASF's self-serve facility](https://selfserve.apache.org/jira-account.html).
+
 ## Contributing
 
 We welcome contributions.
@@ -88,7 +115,7 @@ summary line. If you remove information while clarifying, put it in
 the description of the case.
 
 Design discussions may happen in various places (email threads,
-github reviews) but the JIRA case is the canonical place for those
+Github reviews) but the JIRA case is the canonical place for those
 discussions. Link to them or summarize them in the case.
 
 When implementing a case, especially a new feature, make sure
@@ -112,8 +139,8 @@ feel free to tag the respective contributor(s) in the discussion.
 
 If you are going to take on the issue right away assign it to yourself.
 To assign issues to yourself you have to be registered in JIRA as a contributor.
-In order to do that, send an email to the developers list
-and provide your JIRA username.
+In order to do that, please follow the instructions outlined in the
+[JIRA Accounts](#jira-accounts) section.
 
 If you are committed to fixing the issue before the upcoming release set
 the fix version accordingly (e.g., 1.20.0), otherwise leave it as blank.
@@ -307,12 +334,10 @@ so it is better to stick with `org.checkerframework.checker.nullness.qual.Nullab
                 String value = holder.get();
             }
 
-## Continuous Integration Testing
+## Continuous integration testing
 
-Calcite exploits [GitHub actions](https://github.com/apache/calcite/actions?query=branch%3Amain)
-and [Travis](https://app.travis-ci.com/github/apache/calcite) for continuous integration testing.
-In the past, there were also Jenkins jobs on the [ASF-hosted](https://builds.apache.org/)
-infrastructure, but they are not maintained anymore.
+Calcite exploits [GitHub actions](https://github.com/apache/calcite/actions?query=branch%3Amain) for continuous
+integration testing.
 
 ## Getting started
 
@@ -329,9 +354,54 @@ such as a bug fix or a [Jira task that we have labeled
 "newbie"](https://issues.apache.org/jira/issues/?jql=labels%20%3D%20newbie%20%26%20project%20%3D%20Calcite%20%26%20status%20%3D%20Open).
 Follow the [contributing guidelines](#contributing) to get your change committed.
 
-After you have made several useful contributions we may
-[invite you to become a committer](https://community.apache.org/contributors/).
 We value all contributions that help to build a vibrant community, not just code.
-You can contribute by testing the code, helping verify a release,
-writing documentation or the web site,
-or just by answering questions on the list.
+You can contribute by testing the code, helping verify a release, writing documentation, improving
+the web site, or just by answering questions on the list.
+
+After you have made several useful contributions we may invite you to become a [committer](https://community.apache.org/contributors/).
+The most common way of becoming a committer is by contributing regularly to the project. In some
+exceptional cases you can bypass the invitation process as described below.
+
+If you are a committer in another **ASF project** (such as Drill, Flink, Hive, Ignite, Phoenix, etc.)
+and you are familiar with the Calcite codebase you can request explicitly from the Calcite PMC to
+consider your for committership. You can do that by sending an email to [private@calcite.apache.org](mailto:private@calcite.apache.org)
+including the following information (template below):
+* Apache ID, you must have one if you are committer;
+* links to commits, discussions, presentations, blogs, etc., demonstrating your experience with
+Calcite.
+
+{% highlight text %}
+Subject: [REQUEST] New committer: Stamatis Zampetakis
+To: private@calcite.apache.org
+
+Hi all,
+
+My name is Stamatis Zampetakis and my Apache ID is zabetak:
+https://home.apache.org/phonebook.html?uid=zabetak
+
+I am a Hive committer and have been working with Calcite for the past 2 years.
+I contributed various improvements and fixes in the cost based optimizer of
+Hive, which relies on Calcite, and I am pretty familiar with the Calcite
+codebase. Below you can find a list of contributions in the Hive repo that are
+related with Calcite:
+
+* https://github.com/apache/hive/commit/f29cb2245c97102975ea0dd73783049eaa0947a0
+* https://github.com/apache/hive/commit/efae863fe010ed5c4b7de1874a336ed93b3c60b8
+* https://github.com/apache/hive/commit/587c698fa25ca6da46d9c02e4199689426fec40f
+* https://github.com/apache/hive/commit/9087fa93cd785223f4f2552ec836e7580c78830a
+* https://github.com/apache/hive/commit/0616bcaa2436ccbf388b635bfea160b47849553c
+* https://github.com/apache/hive/commit/6f7c55ab9bc4fd7c3d0c2a6ba3095275b17b3d2d
+* https://github.com/apache/hive/commit/a0faf5ecb196a20cfef64d554df54961e8c074a7
+* https://github.com/apache/hive/commit/4f4cbeda00d5ebb7d0b8cedee5daa2c03df4a755
+* https://github.com/apache/hive/commit/6f2b8883c44edcf57538f3b1da2c5a599b0c5862
+* https://github.com/apache/hive/commit/170d5b4c3edf2daaa47ef3299277d44def4d39a7
+
+I would like to become a Calcite committer and help the project as much as I can.
+
+Best,
+Stamatis
+
+{% endhighlight %}
+
+After receiving your email the PMC will evaluate your request and get back to you in 1-2 weeks
+(usually a vote for adding a new committer takes ~7days).
diff --git a/spark/src/main/java/org/apache/calcite/adapter/spark/SparkHandlerImpl.java b/spark/src/main/java/org/apache/calcite/adapter/spark/SparkHandlerImpl.java
index ba318ce9b2c..4cdb715ccc2 100644
--- a/spark/src/main/java/org/apache/calcite/adapter/spark/SparkHandlerImpl.java
+++ b/spark/src/main/java/org/apache/calcite/adapter/spark/SparkHandlerImpl.java
@@ -73,10 +73,10 @@ private SparkHandlerImpl() {
     // previous classes. A better solution would be to clear the class directory
     // on startup.
     final Calendar calendar = Util.calendar();
-    classId = new AtomicInteger(
-        calendar.get(Calendar.HOUR_OF_DAY) * 10000
-        + calendar.get(Calendar.MINUTE) * 100
-        + calendar.get(Calendar.SECOND));
+    classId =
+        new AtomicInteger(calendar.get(Calendar.HOUR_OF_DAY) * 10000
+            + calendar.get(Calendar.MINUTE) * 100
+            + calendar.get(Calendar.SECOND));
   }
 
   /** Creates a SparkHandlerImpl, initializing on first call. Calcite-core calls
diff --git a/spark/src/main/java/org/apache/calcite/adapter/spark/SparkRules.java b/spark/src/main/java/org/apache/calcite/adapter/spark/SparkRules.java
index 69c237ab2f7..1d8e0404cc3 100644
--- a/spark/src/main/java/org/apache/calcite/adapter/spark/SparkRules.java
+++ b/spark/src/main/java/org/apache/calcite/adapter/spark/SparkRules.java
@@ -436,8 +436,8 @@ public static void main(String[] args) {
             pair._1() + ":" + Iterables.size(pair._2())).collect().toString();
     System.out.print(s);
 
-    final JavaRDD<Integer> rdd = sc.parallelize(
-        new AbstractList<Integer>() {
+    final JavaRDD<Integer> rdd =
+        sc.parallelize(new AbstractList<Integer>() {
           final Random random = new Random();
           @Override public Integer get(int index) {
             System.out.println("get(" + index + ")");
diff --git a/splunk/src/main/java/org/apache/calcite/adapter/splunk/SplunkPushDownRule.java b/splunk/src/main/java/org/apache/calcite/adapter/splunk/SplunkPushDownRule.java
index 0e7c737822a..5422472c999 100644
--- a/splunk/src/main/java/org/apache/calcite/adapter/splunk/SplunkPushDownRule.java
+++ b/splunk/src/main/java/org/apache/calcite/adapter/splunk/SplunkPushDownRule.java
@@ -305,7 +305,7 @@ private static RelNode addProjectionRule(LogicalProject proj, RelNode rel) {
       return rel;
     }
     return LogicalProject.create(rel, proj.getHints(),
-        proj.getProjects(), proj.getRowType());
+        proj.getProjects(), proj.getRowType(), proj.getVariablesSet());
   }
 
   // TODO: use StringBuilder instead of String
diff --git a/splunk/src/main/java/org/apache/calcite/adapter/splunk/search/SplunkConnectionImpl.java b/splunk/src/main/java/org/apache/calcite/adapter/splunk/search/SplunkConnectionImpl.java
index 818cb015216..f2919675917 100644
--- a/splunk/src/main/java/org/apache/calcite/adapter/splunk/search/SplunkConnectionImpl.java
+++ b/splunk/src/main/java/org/apache/calcite/adapter/splunk/search/SplunkConnectionImpl.java
@@ -182,9 +182,10 @@ private Enumerator<Object> getSearchResults_(
   }
 
   private static void parseResults(InputStream in, SearchResultListener srl) {
-    try (CSVReader r = new CSVReader(
-        new BufferedReader(
-            new InputStreamReader(in, StandardCharsets.UTF_8)))) {
+    try (CSVReader r =
+             new CSVReader(
+                 new BufferedReader(
+                     new InputStreamReader(in, StandardCharsets.UTF_8)))) {
       String[] header = r.readNext();
       if (header != null
           && header.length > 0
diff --git a/src/main/config/checkstyle/suppressions.xml b/src/main/config/checkstyle/suppressions.xml
index c51a9c370fc..73a1cdaba0b 100644
--- a/src/main/config/checkstyle/suppressions.xml
+++ b/src/main/config/checkstyle/suppressions.xml
@@ -45,7 +45,7 @@ limitations under the License.
   <suppress checks="JavadocPackage" files="src[/\\]main[/\\]java[/\\]org[/\\]apache[/\\]calcite[/\\]test[/\\]schemata[/\\]"/>
 
   <!-- Don't complain about method names in a class full of UDFs -->
-  <suppress checks="MethodName" files="GeoFunctions.java"/>
+  <suppress checks="MethodName" files="SpatialTypeFunctions.java"/>
 
   <!-- Suppress JavadocPackage in the test packages,
        and in the 'org.apache.calcite.server' package, which is split between
diff --git a/testkit/src/main/java/org/apache/calcite/sql/parser/SqlParserFixture.java b/testkit/src/main/java/org/apache/calcite/sql/parser/SqlParserFixture.java
index 9c45c2bbba3..34fc7ac1140 100644
--- a/testkit/src/main/java/org/apache/calcite/sql/parser/SqlParserFixture.java
+++ b/testkit/src/main/java/org/apache/calcite/sql/parser/SqlParserFixture.java
@@ -72,10 +72,17 @@ public class SqlParserFixture {
   }
 
   public SqlParserFixture same() {
-    return ok(sap.sql);
+    return compare(sap.sql);
   }
 
   public SqlParserFixture ok(String expected) {
+    if (expected.equals(sap.sql)) {
+      throw new AssertionError("you should call same()");
+    }
+    return compare(expected);
+  }
+
+  public SqlParserFixture compare(String expected) {
     final UnaryOperator<String> converter = SqlParserTest.linux(convertToLinux);
     if (expression) {
       tester.checkExp(factory, sap, converter, expected, parserChecker);
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 0dd79138ea1..8468edf79d7 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
@@ -27,15 +27,19 @@
 import org.apache.calcite.sql.SqlNodeList;
 import org.apache.calcite.sql.SqlSelect;
 import org.apache.calcite.sql.SqlSetOption;
+import org.apache.calcite.sql.SqlUnknownLiteral;
 import org.apache.calcite.sql.SqlWriterConfig;
 import org.apache.calcite.sql.dialect.AnsiSqlDialect;
 import org.apache.calcite.sql.dialect.SparkSqlDialect;
+import org.apache.calcite.sql.parser.SqlParser.Config;
 import org.apache.calcite.sql.pretty.SqlPrettyWriter;
 import org.apache.calcite.sql.test.SqlTestFactory;
 import org.apache.calcite.sql.test.SqlTests;
+import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.sql.util.SqlShuttle;
 import org.apache.calcite.sql.validate.SqlConformanceEnum;
 import org.apache.calcite.test.DiffTestCase;
+import org.apache.calcite.test.IntervalTest;
 import org.apache.calcite.tools.Hoist;
 import org.apache.calcite.util.Bug;
 import org.apache.calcite.util.ConversionUtil;
@@ -43,8 +47,8 @@
 import org.apache.calcite.util.TestUtil;
 import org.apache.calcite.util.Util;
 
+import com.google.common.annotations.VisibleForTesting;
 import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSortedSet;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
@@ -58,10 +62,8 @@
 import java.io.Reader;
 import java.io.StringReader;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 import java.util.Locale;
-import java.util.Map;
 import java.util.Random;
 import java.util.SortedSet;
 import java.util.TreeSet;
@@ -69,6 +71,7 @@
 import java.util.function.UnaryOperator;
 import java.util.stream.Collectors;
 
+import static org.apache.calcite.util.Static.RESOURCE;
 import static org.apache.calcite.util.Util.toLinux;
 
 import static org.hamcrest.CoreMatchers.containsString;
@@ -109,7 +112,7 @@ public class SqlParserTest {
    * this list, flagged "c". If the keyword is not intended to be a reserved
    * keyword, add it to the non-reserved keyword list in the parser.
    */
-  private static final List<String> RESERVED_KEYWORDS = ImmutableList.of(
+  private static final String[] RESERVED_KEYWORDS = {
       "ABS",                                               "2011", "2014", "c",
       "ABSOLUTE",                      "92", "99",
       "ACTION",                        "92", "99",
@@ -206,6 +209,7 @@ public class SqlParserTest {
       "CYCLE",                               "99", "2003", "2011", "2014", "c",
       "DATA",                                "99",
       "DATE",                          "92", "99", "2003", "2011", "2014", "c",
+      "DATETIME",                                                          "c",
       "DAY",                           "92", "99", "2003", "2011", "2014", "c",
       "DAYS",                                              "2011",
       "DEALLOCATE",                    "92", "99", "2003", "2011", "2014", "c",
@@ -269,6 +273,7 @@ public class SqlParserTest {
       "FOUND",                         "92", "99",
       "FRAME_ROW",                                                 "2014", "c",
       "FREE",                                "99", "2003", "2011", "2014", "c",
+      "FRIDAY",                                                            "c",
       "FROM",                          "92", "99", "2003", "2011", "2014", "c",
       "FULL",                          "92", "99", "2003", "2011", "2014", "c",
       "FUNCTION",                      "92", "99", "2003", "2011", "2014", "c",
@@ -360,6 +365,7 @@ public class SqlParserTest {
       "MOD",                                               "2011", "2014", "c",
       "MODIFIES",                            "99", "2003", "2011", "2014", "c",
       "MODULE",                        "92", "99", "2003", "2011", "2014", "c",
+      "MONDAY",                                                            "c",
       "MONTH",                         "92", "99", "2003", "2011", "2014", "c",
       "MULTISET",                                  "2003", "2011", "2014", "c",
       "NAMES",                         "92", "99",
@@ -464,6 +470,7 @@ public class SqlParserTest {
       "ROWS",                          "92", "99", "2003", "2011", "2014", "c",
       "ROW_NUMBER",                                        "2011", "2014", "c",
       "RUNNING",                                                   "2014", "c",
+      "SATURDAY",                                                          "c",
       "SAVEPOINT",                           "99", "2003", "2011", "2014", "c",
       "SCHEMA",                        "92", "99",
       "SCOPE",                               "99", "2003", "2011", "2014", "c",
@@ -508,6 +515,7 @@ public class SqlParserTest {
       "SUBSTRING_REGEX",                                   "2011", "2014", "c",
       "SUCCEEDS",                                                  "2014", "c",
       "SUM",                           "92",               "2011", "2014", "c",
+      "SUNDAY",                                                            "c",
       "SYMMETRIC",                           "99", "2003", "2011", "2014", "c",
       "SYSTEM",                              "99", "2003", "2011", "2014", "c",
       "SYSTEM_TIME",                                               "2014", "c",
@@ -516,6 +524,7 @@ public class SqlParserTest {
       "TABLESAMPLE",                               "2003", "2011", "2014", "c",
       "TEMPORARY",                     "92", "99",
       "THEN",                          "92", "99", "2003", "2011", "2014", "c",
+      "THURSDAY",                                                          "c",
       "TIME",                          "92", "99", "2003", "2011", "2014", "c",
       "TIMESTAMP",                     "92", "99", "2003", "2011", "2014", "c",
       "TIMEZONE_HOUR",                 "92", "99", "2003", "2011", "2014", "c",
@@ -533,6 +542,7 @@ public class SqlParserTest {
       "TRIM_ARRAY",                                        "2011", "2014", "c",
       "TRUE",                          "92", "99", "2003", "2011", "2014", "c",
       "TRUNCATE",                                          "2011", "2014", "c",
+      "TUESDAY",                                                           "c",
       "UESCAPE",                                           "2011", "2014", "c",
       "UNDER",                               "99",
       "UNDO",                          "92", "99", "2003",
@@ -559,6 +569,7 @@ public class SqlParserTest {
       "VERSIONING",                                        "2011", "2014", "c",
       "VERSIONS",                                          "2011",
       "VIEW",                          "92", "99",
+      "WEDNESDAY",                                                         "c",
       "WHEN",                          "92", "99", "2003", "2011", "2014", "c",
       "WHENEVER",                      "92", "99", "2003", "2011", "2014", "c",
       "WHERE",                         "92", "99", "2003", "2011", "2014", "c",
@@ -572,7 +583,8 @@ public class SqlParserTest {
       "WRITE",                         "92", "99",
       "YEAR",                          "92", "99", "2003", "2011", "2014", "c",
       "YEARS",                                             "2011",
-      "ZONE",                          "92", "99");
+      "ZONE",                          "92", "99",
+  };
 
   private static final String ANY = "(?s).*";
 
@@ -583,7 +595,7 @@ public class SqlParserTest {
           .withFromFolding(SqlWriterConfig.LineFolding.TALL)
           .withIndentation(0);
 
-  private static final SqlDialect BIG_QUERY =
+  protected static final SqlDialect BIG_QUERY =
       SqlDialect.DatabaseProduct.BIG_QUERY.getDialect();
   private static final SqlDialect CALCITE =
       SqlDialect.DatabaseProduct.CALCITE.getDialect();
@@ -821,7 +833,7 @@ protected static SortedSet<String> keywords(@Nullable String dialect) {
         + " salary = (t.salary * 0.1)\n"
         + "WHEN NOT MATCHED THEN"
         + " INSERT (name, dept, salary)"
-        + " (VALUES (t.name, 10, (t.salary * 0.15)))";
+        + " VALUES (t.name, 10, (t.salary * 0.15))";
     sql(mergeSql)
         .fails("(?s)Encountered \"-\" at .*")
         .withDialect(BIG_QUERY)
@@ -1284,11 +1296,20 @@ protected static SortedSet<String> keywords(@Nullable String dialect) {
 
   @Test void testRowWithDot() {
     sql("select (1,2).a from c.t")
-        .ok("SELECT ((ROW(1, 2)).`A`)\nFROM `C`.`T`");
+        .ok("SELECT ((ROW(1, 2)).`A`)\n"
+            + "FROM `C`.`T`");
     sql("select row(1,2).a from c.t")
-        .ok("SELECT ((ROW(1, 2)).`A`)\nFROM `C`.`T`");
+        .ok("SELECT ((ROW(1, 2)).`A`)\n"
+            + "FROM `C`.`T`");
     sql("select tbl.foo(0).col.bar from tbl")
-        .ok("SELECT ((`TBL`.`FOO`(0).`COL`).`BAR`)\nFROM `TBL`");
+        .ok("SELECT ((`TBL`.`FOO`(0).`COL`).`BAR`)\n"
+            + "FROM `TBL`");
+  }
+
+  @Test void testDotAfterParenthesizedIdentifier() {
+    sql("select (a).c.d from c.t")
+        .ok("SELECT ((`A`.`C`).`D`)\n"
+            + "FROM `C`.`T`");
   }
 
   @Test void testPeriod() {
@@ -1693,6 +1714,25 @@ void checkPeriodPredicate(Checker checker) {
         .fails("(?s).*Encountered \"without\" at line 1, column 23.\n.*");
   }
 
+  /** Test for MSSQL CONVERT parsing, with focus on iffy DATE type and
+   * testing that the extra "style" operand is parsed
+   * Other tests are defined in functions.iq
+   */
+  @Test void testMssqlConvert() {
+    expr("CONVERT(VARCHAR(5), 'xx')")
+        .same();
+    expr("CONVERT(VARCHAR(5), 'xx')")
+        .same();
+    expr("CONVERT(VARCHAR(5), NULL)")
+        .same();
+    expr("CONVERT(VARCHAR(5), NULL, NULL)")
+        .same();
+    expr("CONVERT(DATE, 'xx', 121)")
+        .same();
+    expr("CONVERT(DATE, 'xx')")
+        .same();
+  }
+
   @Test void testLikeAndSimilar() {
     sql("select * from t where x like '%abc%'")
         .ok("SELECT *\n"
@@ -1888,8 +1928,75 @@ void checkPeriodPredicate(Checker checker) {
     expr("'a' || 'b'").ok("('a' || 'b')");
   }
 
+  @Test void testCStyleEscapedString() {
+    expr("E'Apache\\tCalcite'")
+        .ok("_UTF16'Apache\tCalcite'");
+    expr("E'Apache\\bCalcite'")
+        .ok("_UTF16'Apache\bCalcite'");
+    expr("E'Apache\\fCalcite'")
+        .ok("_UTF16'Apache\fCalcite'");
+    expr("E'Apache\\nCalcite'")
+        .ok("_UTF16'Apache\nCalcite'");
+    expr("E'Apache\\rCalcite'")
+        .ok("_UTF16'Apache\rCalcite'");
+    expr("E'\\t\\n\\f'")
+        .ok("_UTF16'\t\n\f'");
+    expr("E'\\Apache Calcite'")
+        .ok("_UTF16'\\Apache Calcite'");
+
+    expr("E'\141'")
+        .ok("_UTF16'a'");
+    expr("E'\141\141\141'")
+        .ok("_UTF16'aaa'");
+    expr("E'\1411'")
+        .ok("_UTF16'a1'");
+
+    expr("E'\\x61'")
+        .ok("_UTF16'a'");
+    expr("E'\\x61\\x61\\x61'")
+        .ok("_UTF16'aaa'");
+    expr("E'\\x61\\x61\\x61'")
+        .ok("_UTF16'aaa'");
+    expr("E'\\xDg0000'")
+        .ok("_UTF16'\rg0000'");
+
+    expr("E'\\u0061'")
+        .ok("_UTF16'a'");
+    expr("E'\\u0061\\u0061\\u0061'")
+        .ok("_UTF16'aaa'");
+
+    expr("E'\\U00000061'")
+        .ok("_UTF16'a'");
+    expr("E'\\U00000061\\U00000061\\U00000061'")
+        .ok("_UTF16'aaa'");
+
+    expr("E'\\0'")
+        .ok("_UTF16'\u0000'");
+    expr("E'\\07'")
+        .ok("_UTF16'\u0007'");
+    expr("E'\\07'")
+        .ok("_UTF16'\u0007'");
+
+    expr("E'a\\'a\\'a\\''")
+        .ok("_UTF16'a''a''a'''");
+    expr("E'a''a''a'''")
+        .ok("_UTF16'a''a''a'''");
+
+    expr("E^'\\'^")
+        .fails("(?s).*Encountered .*");
+    expr("E^'a\\'^")
+        .fails("(?s).*Encountered.*");
+    expr("E'a\\''^a^'")
+        .fails("(?s).*Encountered.*");
+
+    expr("^E'A\\U0061'^")
+        .fails(RESOURCE.unicodeEscapeMalformed(1).str());
+    expr("^E'AB\\U0000006G'^")
+        .fails(RESOURCE.unicodeEscapeMalformed(2).str());
+  }
+
   @Test void testReverseSolidus() {
-    expr("'\\'").ok("'\\'");
+    expr("'\\'").same();
   }
 
   @Test void testSubstring() {
@@ -2122,6 +2229,29 @@ void checkPeriodPredicate(Checker checker) {
     sql(sql).ok(expected);
   }
 
+  @Test void testGroupByAllOrDistinct() {
+    final String sql = "select deptno from emp\n"
+        + "group by all cube (a, b), rollup (a, b)";
+    final String expected = "SELECT `DEPTNO`\n"
+        + "FROM `EMP`\n"
+        + "GROUP BY CUBE(`A`, `B`), ROLLUP(`A`, `B`)";
+    sql(sql).ok(expected);
+
+    final String sql1 = "select deptno from emp\n"
+        + "group by distinct cube (a, b), rollup (a, b)";
+    final String expected1 = "SELECT `DEPTNO`\n"
+        + "FROM `EMP`\n"
+        + "GROUP BY DISTINCT CUBE(`A`, `B`), ROLLUP(`A`, `B`)";
+    sql(sql1).ok(expected1);
+
+    final String sql2 = "select deptno from emp\n"
+        + "group by cube (a, b), rollup (a, b)";
+    final String expected2 = "SELECT `DEPTNO`\n"
+        + "FROM `EMP`\n"
+        + "GROUP BY CUBE(`A`, `B`), ROLLUP(`A`, `B`)";
+    sql(sql2).ok(expected2);
+  }
+
   @Test void testGroupByCube2() {
     final String sql = "select deptno from emp\n"
         + "group by cube ((a, b), (c, d)) order by a";
@@ -2164,8 +2294,8 @@ void checkPeriodPredicate(Checker checker) {
         + "select deptno from femaleEmps";
     final String expected = "WITH `FEMALEEMPS` AS (SELECT *\n"
         + "FROM `EMPS`\n"
-        + "WHERE (`GENDER` = 'F')) (SELECT `DEPTNO`\n"
-        + "FROM `FEMALEEMPS`)";
+        + "WHERE (`GENDER` = 'F')) SELECT `DEPTNO`\n"
+        + "FROM `FEMALEEMPS`";
     sql(sql).ok(expected);
   }
 
@@ -2177,8 +2307,8 @@ void checkPeriodPredicate(Checker checker) {
         + "FROM `EMPS`\n"
         + "WHERE (`GENDER` = 'F')), `MARRIEDFEMALEEMPS` (`X`, `Y`) AS (SELECT *\n"
         + "FROM `FEMALEEMPS`\n"
-        + "WHERE (`MARITASTATUS` = 'M')) (SELECT `DEPTNO`\n"
-        + "FROM `FEMALEEMPS`)";
+        + "WHERE (`MARITASTATUS` = 'M')) SELECT `DEPTNO`\n"
+        + "FROM `FEMALEEMPS`";
     sql(sql).ok(expected);
   }
 
@@ -2193,8 +2323,8 @@ void checkPeriodPredicate(Checker checker) {
     final String sql = "with v(i,c) as (values (1, 'a'), (2, 'bb'))\n"
         + "select c, i from v";
     final String expected = "WITH `V` (`I`, `C`) AS (VALUES (ROW(1, 'a')),\n"
-        + "(ROW(2, 'bb'))) (SELECT `C`, `I`\n"
-        + "FROM `V`)";
+        + "(ROW(2, 'bb'))) SELECT `C`, `I`\n"
+        + "FROM `V`";
     sql(sql).ok(expected);
   }
 
@@ -2206,6 +2336,31 @@ void checkPeriodPredicate(Checker checker) {
     sql(sql).fails("(?s)Encountered \"with\" at .*");
   }
 
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5299">[CALCITE-5299]
+   * JDBC adapter sometimes adds unnecessary parentheses around SELECT in WITH body</a>. */
+  @Test void testWithSelect() {
+    final String sql = "with emp2 as (select * from emp)\n"
+        + "select * from emp2\n";
+    final String expected = "WITH `EMP2` AS (SELECT *\n"
+        + "FROM `EMP`) SELECT *\n"
+        + "FROM `EMP2`";
+    sql(sql).ok(expected);
+  }
+
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5299">[CALCITE-5299]
+   * JDBC adapter sometimes adds unnecessary parentheses around SELECT in WITH body</a>. */
+  @Test void testWithOrderBy() {
+    final String sql = "with emp2 as (select * from emp)\n"
+        + "select * from emp2 order by deptno\n";
+    final String expected = "WITH `EMP2` AS (SELECT *\n"
+        + "FROM `EMP`) SELECT *\n"
+        + "FROM `EMP2`\n"
+        + "ORDER BY `DEPTNO`";
+    sql(sql).ok(expected);
+  }
+
   @Test void testWithNestedInSubQuery() {
     // SQL standard does not allow sub-query to contain WITH but we do
     final String sql = "with emp2 as (select * from emp)\n"
@@ -2214,8 +2369,8 @@ void checkPeriodPredicate(Checker checker) {
         + "  select 1 as uno from empDept)";
     final String expected = "WITH `EMP2` AS (SELECT *\n"
         + "FROM `EMP`) (WITH `DEPT2` AS (SELECT *\n"
-        + "FROM `DEPT`) (SELECT 1 AS `UNO`\n"
-        + "FROM `EMPDEPT`))";
+        + "FROM `DEPT`) SELECT 1 AS `UNO`\n"
+        + "FROM `EMPDEPT`)";
     sql(sql).ok(expected);
   }
 
@@ -2226,11 +2381,65 @@ void checkPeriodPredicate(Checker checker) {
         + "union\n"
         + "select * from emp2\n";
     final String expected = "WITH `EMP2` AS (SELECT *\n"
-        + "FROM `EMP`) (SELECT *\n"
+        + "FROM `EMP`) SELECT *\n"
         + "FROM `EMP2`\n"
         + "UNION\n"
         + "SELECT *\n"
-        + "FROM `EMP2`)";
+        + "FROM `EMP2`";
+    sql(sql).ok(expected);
+  }
+
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5252">[CALCITE-5252]
+   * JDBC adapter sometimes miss parentheses around SELECT in WITH_ITEM body</a>. */
+  @Test void testWithAsUnion() {
+    final String sql = "with emp2 as (select * from emp union select * from emp)\n"
+        + "select * from emp2\n";
+    final String expected = "WITH `EMP2` AS (SELECT *\n"
+        + "FROM `EMP`\n"
+        + "UNION\n"
+        + "SELECT *\n"
+        + "FROM `EMP`) SELECT *\n"
+        + "FROM `EMP2`";
+    sql(sql).ok(expected);
+  }
+
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5252">[CALCITE-5252]
+   * JDBC adapter sometimes miss parentheses around SELECT in WITH_ITEM body</a>. */
+  @Test void testWithAsOrderBy() {
+    final String sql = "with emp2 as (select * from emp order by deptno)\n"
+        + "select * from emp2\n";
+    final String expected = "WITH `EMP2` AS (SELECT *\n"
+        + "FROM `EMP`\n"
+        + "ORDER BY `DEPTNO`) SELECT *\n"
+        + "FROM `EMP2`";
+    sql(sql).ok(expected);
+  }
+
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5252">[CALCITE-5252]
+   * JDBC adapter sometimes miss parentheses around SELECT in WITH_ITEM body</a>. */
+  @Test void testWithAsJoin() {
+    final String sql = "with emp2 as (select * from emp e1 join emp e2 on e1.deptno = e2.deptno)\n"
+        + "select * from emp2\n";
+    final String expected = "WITH `EMP2` AS (SELECT *\n"
+        + "FROM `EMP` AS `E1`\n"
+        + "INNER JOIN `EMP` AS `E2` ON (`E1`.`DEPTNO` = `E2`.`DEPTNO`)) SELECT *\n"
+        + "FROM `EMP2`";
+    sql(sql).ok(expected);
+  }
+
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5252">[CALCITE-5252]
+   * JDBC adapter sometimes miss parentheses around SELECT in WITH_ITEM body</a>. */
+  @Test void testWithAsNestedInSubQuery() {
+    final String sql = "with emp3 as (with emp2 as (select * from emp) select * from emp2)\n"
+        + "select * from emp3\n";
+    final String expected = "WITH `EMP3` AS (WITH `EMP2` AS (SELECT *\n"
+        + "FROM `EMP`) SELECT *\n"
+        + "FROM `EMP2`) SELECT *\n"
+        + "FROM `EMP3`";
     sql(sql).ok(expected);
   }
 
@@ -2262,7 +2471,7 @@ void checkPeriodPredicate(Checker checker) {
         .fails("(?s).*Encountered.*");
 
     f.sql("^\"^x`y`z\"").fails("(?s).*Encountered.*");
-    f.sql("`x``y``z`").ok("`x``y``z`");
+    f.sql("`x``y``z`").same();
     f.sql("`x\\`^y^\\`z`").fails("(?s).*Encountered.*");
 
     f.sql("myMap[field] + myArray[1 + 2]")
@@ -2372,8 +2581,8 @@ void checkPeriodPredicate(Checker checker) {
         .withConfig(c -> c.withQuoting(Quoting.BRACKET)
             .withConformance(SqlConformanceEnum.DEFAULT));
     f2.fails(expectingAlias);
-    final String sql2b = "WITH `T` AS (SELECT 1 AS `x'y`) (SELECT `x'y`\n"
-        + "FROM `T` AS `u`)";
+    final String sql2b = "WITH `T` AS (SELECT 1 AS `x'y`) SELECT `x'y`\n"
+        + "FROM `T` AS `u`";
     f2.withConformance(SqlConformanceEnum.MYSQL_5)
         .ok(sql2b);
     f2.withConformance(SqlConformanceEnum.BIG_QUERY)
@@ -2383,8 +2592,8 @@ void checkPeriodPredicate(Checker checker) {
 
     // also valid on MSSQL
     final String sql3 = "with [t] as (select 1 as [x]) select [x] from [t]";
-    final String sql3b = "WITH `t` AS (SELECT 1 AS `x`) (SELECT `x`\n"
-        + "FROM `t`)";
+    final String sql3b = "WITH `t` AS (SELECT 1 AS `x`) SELECT `x`\n"
+        + "FROM `t`";
     final SqlParserFixture f3 = sql(sql3)
         .withConfig(c -> c.withQuoting(Quoting.BRACKET)
             .withConformance(SqlConformanceEnum.DEFAULT));
@@ -2470,11 +2679,11 @@ void checkPeriodPredicate(Checker checker) {
         + "select * from dept) and false")
         .ok("SELECT *\n"
             + "FROM `EMP`\n"
-            + "WHERE ((`DEPTNO` IN ((SELECT `DEPTNO`\n"
+            + "WHERE ((`DEPTNO` IN (SELECT `DEPTNO`\n"
             + "FROM `DEPT`\n"
             + "UNION\n"
             + "SELECT *\n"
-            + "FROM `DEPT`)\n"
+            + "FROM `DEPT`\n"
             + "EXCEPT\n"
             + "SELECT *\n"
             + "FROM `DEPT`)) AND FALSE)");
@@ -2534,23 +2743,23 @@ void checkPeriodPredicate(Checker checker) {
 
   @Test void testUnion() {
     sql("select * from a union select * from a")
-        .ok("(SELECT *\n"
+        .ok("SELECT *\n"
             + "FROM `A`\n"
             + "UNION\n"
             + "SELECT *\n"
-            + "FROM `A`)");
+            + "FROM `A`");
     sql("select * from a union all select * from a")
-        .ok("(SELECT *\n"
+        .ok("SELECT *\n"
             + "FROM `A`\n"
             + "UNION ALL\n"
             + "SELECT *\n"
-            + "FROM `A`)");
+            + "FROM `A`");
     sql("select * from a union distinct select * from a")
-        .ok("(SELECT *\n"
+        .ok("SELECT *\n"
             + "FROM `A`\n"
             + "UNION\n"
             + "SELECT *\n"
-            + "FROM `A`)");
+            + "FROM `A`");
   }
 
   @Test void testUnionOrder() {
@@ -2558,11 +2767,11 @@ void checkPeriodPredicate(Checker checker) {
         + "union all "
         + "select x, y from u "
         + "order by 1 asc, 2 desc")
-        .ok("(SELECT `A`, `B`\n"
+        .ok("SELECT `A`, `B`\n"
             + "FROM `T`\n"
             + "UNION ALL\n"
             + "SELECT `X`, `Y`\n"
-            + "FROM `U`)\n"
+            + "FROM `U`\n"
             + "ORDER BY 1, 2 DESC");
   }
 
@@ -2582,6 +2791,116 @@ void checkPeriodPredicate(Checker checker) {
         .fails("(?s).*Encountered \"union\" at .*");
   }
 
+  @Test void testLimitUnion2() {
+    // LIMIT is allowed in a parenthesized sub-query inside UNION;
+    // the result probably has more parentheses than strictly necessary.
+    final String sql = "(select a from t limit 10)\n"
+        + "union all\n"
+        + "(select b from t offset 20)";
+    final String expected = "(SELECT `A`\n"
+        + "FROM `T`\n"
+        + "FETCH NEXT 10 ROWS ONLY)\n"
+        + "UNION ALL\n"
+        + "(SELECT `B`\n"
+        + "FROM `T`\n"
+        + "OFFSET 20 ROWS)";
+    sql(sql).ok(expected);
+  }
+
+  @Test void testUnionOffset() {
+    // Note that the second sub-query has parentheses, to ensure that ORDER BY,
+    // OFFSET, FETCH are associated with just that sub-query, not the UNION.
+    final String sql = "select a from t\n"
+        + "union all\n"
+        + "(select b from t order by b offset 3 fetch next 5 rows only)";
+    final String expected = "SELECT `A`\n"
+        + "FROM `T`\n"
+        + "UNION ALL\n"
+        + "(SELECT `B`\n"
+        + "FROM `T`\n"
+        + "ORDER BY `B`\n"
+        + "OFFSET 3 ROWS\n"
+        + "FETCH NEXT 5 ROWS ONLY)";
+    sql(sql).ok(expected);
+
+    // as above, just ORDER BY
+    final String sql2 = "select a from t\n"
+        + "union all\n"
+        + "(select b from t order by b)";
+    final String expected2 = "SELECT `A`\n"
+        + "FROM `T`\n"
+        + "UNION ALL\n"
+        + "(SELECT `B`\n"
+        + "FROM `T`\n"
+        + "ORDER BY `B`)";
+    sql(sql2).ok(expected2);
+
+    // as above, just OFFSET
+    final String sql3 = "select a from t\n"
+        + "union all\n"
+        + "(select b from t offset 3)";
+    final String expected3 = "SELECT `A`\n"
+        + "FROM `T`\n"
+        + "UNION ALL\n"
+        + "(SELECT `B`\n"
+        + "FROM `T`\n"
+        + "OFFSET 3 ROWS)";
+    sql(sql3).ok(expected3);
+
+    // as above, just FETCH
+    final String sql4 = "select a from t\n"
+        + "union all\n"
+        + "(select b from t fetch next 5 rows only)";
+    final String expected4 = "SELECT `A`\n"
+        + "FROM `T`\n"
+        + "UNION ALL\n"
+        + "(SELECT `B`\n"
+        + "FROM `T`\n"
+        + "FETCH NEXT 5 ROWS ONLY)";
+    sql(sql4).ok(expected4);
+
+    // as above, just FETCH and OFFSET
+    final String sql5 = "select a from t\n"
+        + "union all\n"
+        + "(select b from t offset 3 fetch next 5 rows only)";
+    final String expected5 = "SELECT `A`\n"
+        + "FROM `T`\n"
+        + "UNION ALL\n"
+        + "(SELECT `B`\n"
+        + "FROM `T`\n"
+        + "OFFSET 3 ROWS\n"
+        + "FETCH NEXT 5 ROWS ONLY)";
+    sql(sql5).ok(expected5);
+
+    // as previous, INTERSECT
+    final String sql6 = "select a from t\n"
+        + "intersect\n"
+        + "(select b from t offset 3 fetch next 5 rows only)";
+    final String expected6 = "SELECT `A`\n"
+        + "FROM `T`\n"
+        + "INTERSECT\n"
+        + "(SELECT `B`\n"
+        + "FROM `T`\n"
+        + "OFFSET 3 ROWS\n"
+        + "FETCH NEXT 5 ROWS ONLY)";
+    sql(sql6).ok(expected6);
+  }
+
+  @Test void testUnionIntersect() {
+    // Note that the union sub-query has parentheses.
+    final String sql = "(select * from a union select * from b)\n"
+        + "intersect select * from c";
+    final String expected = "(SELECT *\n"
+        + "FROM `A`\n"
+        + "UNION\n"
+        + "SELECT *\n"
+        + "FROM `B`)\n"
+        + "INTERSECT\n"
+        + "SELECT *\n"
+        + "FROM `C`";
+    sql(sql).ok(expected);
+  }
+
   @Test void testUnionOfNonQueryFails() {
     sql("select 1 from emp union ^2^ + 5")
         .fails("Non-query expression encountered in illegal context");
@@ -2600,23 +2919,23 @@ void checkPeriodPredicate(Checker checker) {
 
   @Test void testExcept() {
     sql("select * from a except select * from a")
-        .ok("(SELECT *\n"
+        .ok("SELECT *\n"
             + "FROM `A`\n"
             + "EXCEPT\n"
             + "SELECT *\n"
-            + "FROM `A`)");
+            + "FROM `A`");
     sql("select * from a except all select * from a")
-        .ok("(SELECT *\n"
+        .ok("SELECT *\n"
             + "FROM `A`\n"
             + "EXCEPT ALL\n"
             + "SELECT *\n"
-            + "FROM `A`)");
+            + "FROM `A`");
     sql("select * from a except distinct select * from a")
-        .ok("(SELECT *\n"
+        .ok("SELECT *\n"
             + "FROM `A`\n"
             + "EXCEPT\n"
             + "SELECT *\n"
-            + "FROM `A`)");
+            + "FROM `A`");
   }
 
   /** Tests MINUS, which is equivalent to EXCEPT but only supported in some
@@ -2627,22 +2946,22 @@ void checkPeriodPredicate(Checker checker) {
     final String sql = "select col1 from table1 ^MINUS^ select col1 from table2";
     sql(sql).fails(pattern);
 
-    final String expected = "(SELECT `COL1`\n"
+    final String expected = "SELECT `COL1`\n"
         + "FROM `TABLE1`\n"
         + "EXCEPT\n"
         + "SELECT `COL1`\n"
-        + "FROM `TABLE2`)";
+        + "FROM `TABLE2`";
     sql(sql)
         .withConformance(SqlConformanceEnum.ORACLE_10)
         .ok(expected);
 
     final String sql2 =
         "select col1 from table1 MINUS ALL select col1 from table2";
-    final String expected2 = "(SELECT `COL1`\n"
+    final String expected2 = "SELECT `COL1`\n"
         + "FROM `TABLE1`\n"
         + "EXCEPT ALL\n"
         + "SELECT `COL1`\n"
-        + "FROM `TABLE2`)";
+        + "FROM `TABLE2`";
     sql(sql2)
         .withConformance(SqlConformanceEnum.ORACLE_10)
         .ok(expected2);
@@ -2663,23 +2982,23 @@ void checkPeriodPredicate(Checker checker) {
 
   @Test void testIntersect() {
     sql("select * from a intersect select * from a")
-        .ok("(SELECT *\n"
+        .ok("SELECT *\n"
             + "FROM `A`\n"
             + "INTERSECT\n"
             + "SELECT *\n"
-            + "FROM `A`)");
+            + "FROM `A`");
     sql("select * from a intersect all select * from a")
-        .ok("(SELECT *\n"
+        .ok("SELECT *\n"
             + "FROM `A`\n"
             + "INTERSECT ALL\n"
             + "SELECT *\n"
-            + "FROM `A`)");
+            + "FROM `A`");
     sql("select * from a intersect distinct select * from a")
-        .ok("(SELECT *\n"
+        .ok("SELECT *\n"
             + "FROM `A`\n"
             + "INTERSECT\n"
             + "SELECT *\n"
-            + "FROM `A`)");
+            + "FROM `A`");
   }
 
   @Test void testJoinCross() {
@@ -2769,7 +3088,7 @@ void checkPeriodPredicate(Checker checker) {
   @Test void testFullInnerJoinFails() {
     // cannot have more than one of INNER, FULL, LEFT, RIGHT, CROSS
     sql("select * from a ^full^ inner join b")
-        .fails("(?s).*Encountered \"full inner\" at line 1, column 17.*");
+        .fails("(?s).*Encountered \"full inner\" at line .*");
   }
 
   @Test void testFullOuterJoin() {
@@ -2782,26 +3101,39 @@ void checkPeriodPredicate(Checker checker) {
 
   @Test void testInnerOuterJoinFails() {
     sql("select * from a ^inner^ outer join b")
-        .fails("(?s).*Encountered \"inner outer\" at line 1, column 17.*");
+        .fails("(?s).*Encountered \"inner outer\" at line .*");
   }
 
-  @Disabled
   @Test void testJoinAssociativity() {
     // joins are left-associative
     // 1. no parens needed
+    String expected = "SELECT *\n"
+        + "FROM `A`\n"
+        + "NATURAL LEFT JOIN `B`\n"
+        + "LEFT JOIN `C` ON (`B`.`C1` = `C`.`C1`)";
     sql("select * from (a natural left join b) left join c on b.c1 = c.c1")
-        .ok("SELECT *\n"
-            + "FROM (`A` NATURAL LEFT JOIN `B`) LEFT JOIN `C` ON (`B`.`C1` = `C`.`C1`)\n");
+        .ok(expected);
 
     // 2. parens needed
+    String expected2 = "SELECT *\n"
+        + "FROM `A`\n"
+        + "NATURAL LEFT JOIN (`B` LEFT JOIN `C` ON (`B`.`C1` = `C`.`C1`))";
     sql("select * from a natural left join (b left join c on b.c1 = c.c1)")
-        .ok("SELECT *\n"
-            + "FROM (`A` NATURAL LEFT JOIN `B`) LEFT JOIN `C` ON (`B`.`C1` = `C`.`C1`)\n");
+        .ok(expected2);
 
     // 3. same as 1
     sql("select * from a natural left join b left join c on b.c1 = c.c1")
-        .ok("SELECT *\n"
-            + "FROM (`A` NATURAL LEFT JOIN `B`) LEFT JOIN `C` ON (`B`.`C1` = `C`.`C1`)\n");
+        .ok(expected);
+
+    // bushy
+    String sql4 = "select *\n"
+        + "from (a cross join b)\n"
+        + "cross join (c cross join d)";
+    String expected4 = "SELECT *\n"
+        + "FROM `A`\n"
+        + "CROSS JOIN `B`\n"
+        + "CROSS JOIN (`C` CROSS JOIN `D`)";
+    sql(sql4).ok(expected4);
   }
 
   // Note: "select * from a natural cross join b" is actually illegal SQL
@@ -2967,26 +3299,20 @@ void checkPeriodPredicate(Checker checker) {
             + "FROM `EMP`");
 
     // Even though it looks like a date, it's just a string.
-    expr("'2004-06-01'")
-        .ok("'2004-06-01'");
+    expr("'2004-06-01'").same();
     expr("-.25")
         .ok("-0.25");
     expr("TIMESTAMP '2004-06-01 15:55:55'").same();
     expr("TIMESTAMP '2004-06-01 15:55:55.900'").same();
-    expr("TIMESTAMP '2004-06-01 15:55:55.1234'")
-        .ok("TIMESTAMP '2004-06-01 15:55:55.1234'");
-    expr("TIMESTAMP '2004-06-01 15:55:55.1236'")
-        .ok("TIMESTAMP '2004-06-01 15:55:55.1236'");
-    expr("TIMESTAMP '2004-06-01 15:55:55.9999'")
-        .ok("TIMESTAMP '2004-06-01 15:55:55.9999'");
+    expr("TIMESTAMP '2004-06-01 15:55:55.1234'").same();
+    expr("TIMESTAMP '2004-06-01 15:55:55.1236'").same();
+    expr("TIMESTAMP '2004-06-01 15:55:55.9999'").same();
     expr("NULL").same();
   }
 
   @Test void testContinuedLiteral() {
-    expr("'abba'\n'abba'")
-        .ok("'abba'\n'abba'");
-    expr("'abba'\n'0001'")
-        .ok("'abba'\n'0001'");
+    expr("'abba'\n'abba'").same();
+    expr("'abba'\n'0001'").same();
     expr("N'yabba'\n'dabba'\n'doo'")
         .ok("_ISO-8859-1'yabba'\n'dabba'\n'doo'");
     expr("_iso-8859-1'yabba'\n'dabba'\n'don''t'")
@@ -3066,7 +3392,6 @@ void checkPeriodPredicate(Checker checker) {
   }
 
   @Test void testMixedFrom() {
-    // REVIEW: Is this syntax even valid?
     sql("select * from a join b using (x), c join d using (y)")
         .ok("SELECT *\n"
             + "FROM `A`\n"
@@ -3132,12 +3457,12 @@ void checkPeriodPredicate(Checker checker) {
 
   @Test void testOrderInternal() {
     sql("(select * from emp order by empno) union select * from emp")
-        .ok("((SELECT *\n"
+        .ok("(SELECT *\n"
             + "FROM `EMP`\n"
             + "ORDER BY `EMPNO`)\n"
             + "UNION\n"
             + "SELECT *\n"
-            + "FROM `EMP`)");
+            + "FROM `EMP`");
 
     sql("select * from (select * from t order by x, y) where a = b")
         .ok("SELECT *\n"
@@ -3287,11 +3612,11 @@ void checkPeriodPredicate(Checker checker) {
         + "union\n"
         + "select b from baz\n"
         + "limit 3";
-    final String expected5 = "(SELECT A\n"
+    final String expected5 = "SELECT A\n"
         + "FROM FOO\n"
         + "UNION\n"
         + "SELECT B\n"
-        + "FROM BAZ)\n"
+        + "FROM BAZ\n"
         + "LIMIT 3";
     sql(sql5).withDialect(SparkSqlDialect.DEFAULT).ok(expected5);
   }
@@ -3319,7 +3644,7 @@ void checkPeriodPredicate(Checker checker) {
   @Test void testLimitStartCount() {
     final String error = "'LIMIT start, count' is not allowed under the "
         + "current SQL conformance level";
-    sql("select a from foo limit 1,^2^")
+    sql("select a from foo ^limit 1,2^")
         .withConformance(SqlConformanceEnum.DEFAULT)
         .fails(error);
 
@@ -3354,17 +3679,51 @@ void checkPeriodPredicate(Checker checker) {
         .withConformance(SqlConformanceEnum.LENIENT)
         .ok(expected3);
 
-    // "fetch next 4" overrides the earlier "limit 3"
-    final String expected4 = "SELECT `A`\n"
+    // "fetch next 4" is invalid after "limit 3"
+    sql("select a from foo limit 2,3 ^fetch^ next 4 rows only")
+        .withConformance(SqlConformanceEnum.LENIENT)
+        .fails("(?s).*Encountered \"fetch\" at line 1.*");
+
+    // "limit start, all" is not valid
+    sql("select a from foo limit 2, ^all^")
+        .withConformance(SqlConformanceEnum.LENIENT)
+        .fails("(?s).*Encountered \"all\" at line 1.*");
+  }
+
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5086">[CALCITE-5086]
+   * Calcite supports OFFSET start LIMIT count expression</a>. */
+  @Test void testOffsetStartLimitCount() {
+    final String error = "'OFFSET start LIMIT count' is not allowed under the "
+        + "current SQL conformance level";
+    sql("select a from foo order by b, c offset 1 limit 2")
+        .withConformance(SqlConformanceEnum.LENIENT)
+        .ok("SELECT `A`\n"
+            + "FROM `FOO`\n"
+            + "ORDER BY `B`, `C`\n"
+            + "OFFSET 1 ROWS\n"
+            + "FETCH NEXT 2 ROWS ONLY");
+
+    sql("select a from foo order by b, c ^offset 1 limit 2^")
+        .withConformance(SqlConformanceEnum.DEFAULT)
+        .fails(error);
+
+    // "limit 2" overrides the earlier "offset 4"
+    final String expected3 = "SELECT `A`\n"
         + "FROM `FOO`\n"
         + "OFFSET 2 ROWS\n"
-        + "FETCH NEXT 4 ROWS ONLY";
-    sql("select a from foo limit 2,3 fetch next 4 rows only")
+        + "FETCH NEXT 3 ROWS ONLY";
+    sql("select a from foo offset 4 limit 2,3")
+        .withConformance(SqlConformanceEnum.LENIENT)
+        .ok(expected3);
+
+    // "fetch next 4" is illegal following "limit 3"
+    sql("select a from foo offset 2 limit 3 ^fetch^ next 4 rows only")
         .withConformance(SqlConformanceEnum.LENIENT)
-        .ok(expected4);
+        .fails("(?s).*Encountered \"fetch\" at line 1.*");
 
     // "limit start, all" is not valid
-    sql("select a from foo limit 2, ^all^")
+    sql("select a from foo offset 1 limit 2, ^all^")
         .withConformance(SqlConformanceEnum.LENIENT)
         .fails("(?s).*Encountered \"all\" at line 1.*");
   }
@@ -3485,16 +3844,16 @@ void checkPeriodPredicate(Checker checker) {
   // expressions
   @Test void testParseNumber() {
     // Exacts
-    expr("1").ok("1");
+    expr("1").same();
     expr("+1.").ok("1");
-    expr("-1").ok("-1");
+    expr("-1").same();
     expr("- -1").ok("1");
-    expr("1.0").ok("1.0");
-    expr("-3.2").ok("-3.2");
+    expr("1.0").same();
+    expr("-3.2").same();
     expr("1.").ok("1");
     expr(".1").ok("0.1");
-    expr("2500000000").ok("2500000000");
-    expr("5000000000").ok("5000000000");
+    expr("2500000000").same();
+    expr("5000000000").same();
 
     // Approximates
     expr("1e1").ok("1E1");
@@ -3573,26 +3932,26 @@ void checkPeriodPredicate(Checker checker) {
         + "select * from e except "
         + "select * from f union "
         + "select * from g";
-    final String expected = "((((SELECT *\n"
+    final String expected = "SELECT *\n"
         + "FROM `A`\n"
         + "UNION\n"
-        + "((SELECT *\n"
+        + "SELECT *\n"
         + "FROM `B`\n"
         + "INTERSECT\n"
         + "SELECT *\n"
-        + "FROM `C`)\n"
+        + "FROM `C`\n"
         + "INTERSECT\n"
         + "SELECT *\n"
-        + "FROM `D`))\n"
+        + "FROM `D`\n"
         + "EXCEPT\n"
         + "SELECT *\n"
-        + "FROM `E`)\n"
+        + "FROM `E`\n"
         + "EXCEPT\n"
         + "SELECT *\n"
-        + "FROM `F`)\n"
+        + "FROM `F`\n"
         + "UNION\n"
         + "SELECT *\n"
-        + "FROM `G`)";
+        + "FROM `G`";
     sql(sql).ok(expected);
   }
 
@@ -3607,14 +3966,10 @@ void checkPeriodPredicate(Checker checker) {
   }
 
   @Test void testQuotesInString() {
-    expr("'a''b'")
-        .ok("'a''b'");
-    expr("'''x'")
-        .ok("'''x'");
-    expr("''")
-        .ok("''");
-    expr("'Quoted strings aren''t \"hard\"'")
-        .ok("'Quoted strings aren''t \"hard\"'");
+    expr("'a''b'").same();
+    expr("'''x'").same();
+    expr("''").same();
+    expr("'Quoted strings aren''t \"hard\"'").same();
   }
 
   @Test void testScalarQueryInWhere() {
@@ -3739,8 +4094,17 @@ void checkPeriodPredicate(Checker checker) {
   }
 
   @Test void testValues() {
+    final String expected = "VALUES (ROW(1, 'two'))";
+    final String pattern =
+        "VALUE is not allowed under the current SQL conformance level";
     sql("values(1,'two')")
-        .ok("VALUES (ROW(1, 'two'))");
+        .ok(expected);
+    sql("value(1,'two')")
+        .withConformance(SqlConformanceEnum.MYSQL_5)
+        .ok(expected)
+        .node(not(isDdl()));
+    sql("^value^(1,'two')")
+        .fails(pattern);
   }
 
   @Test void testValuesExplicitRow() {
@@ -3840,8 +4204,8 @@ void checkPeriodPredicate(Checker checker) {
     sql("select * from table ^emp^")
         .fails("(?s).*Encountered \"emp\" at .*");
 
-    sql("select * from (table ^(^select empno from emp))")
-        .fails("(?s)Encountered \"\\(\".*");
+    sql("select * from (table (^select^ empno from emp))")
+        .fails("(?s)Encountered \"select\".*");
   }
 
   @Test void testCollectionTable() {
@@ -3898,8 +4262,8 @@ void checkPeriodPredicate(Checker checker) {
     sql("select * from lateral table(ramp(1)) as t(x)")
         .ok(expected + " AS `T` (`X`)");
     // Bad: Parentheses make it look like a sub-query
-    sql("select * from lateral (table^(^ramp(1)))")
-        .fails("(?s)Encountered \"\\(\" at .*");
+    sql("select * from lateral (^table (ramp(1))^)")
+        .fails("Expected query or join");
 
     // Good: LATERAL (subQuery)
     final String expected2 = "SELECT *\n"
@@ -3988,6 +4352,95 @@ void checkPeriodPredicate(Checker checker) {
     sql(sql).ok(expected);
   }
 
+  @Test void testTableFunction() {
+    final String sql = "select * from table(score(table orders))";
+    final String expected = "SELECT *\n"
+        + "FROM TABLE(`SCORE`((TABLE `ORDERS`)))";
+    sql(sql).ok(expected);
+  }
+
+  @Test void testTableFunctionWithPartitionKey() {
+    // test one partition key for input table
+    final String sql = "select * from table(topn(table orders partition by productid, 3))";
+    final String expected = "SELECT *\n"
+        + "FROM TABLE(`TOPN`(((TABLE `ORDERS`) PARTITION BY `PRODUCTID`), 3))";
+    sql(sql).ok(expected);
+  }
+
+  @Test void testTableFunctionWithMultiplePartitionKeys() {
+    // test multiple partition keys for input table
+    final String sql =
+        "select * from table(topn(table orders partition by (orderId, productid), 3))";
+    final String expected = "SELECT *\n"
+        + "FROM TABLE(`TOPN`(((TABLE `ORDERS`) PARTITION BY `ORDERID`, `PRODUCTID`), 3))";
+    sql(sql).ok(expected);
+  }
+
+  @Test void testTableFunctionWithOrderKey() {
+    // test one order key for input table
+    final String sql =
+        "select * from table(topn(table orders order by orderId, 3))";
+    final String expected = "SELECT *\n"
+        + "FROM TABLE(`TOPN`(((TABLE `ORDERS`) ORDER BY `ORDERID`), 3))";
+    sql(sql).ok(expected);
+  }
+
+  @Test void testTableFunctionWithMultipleOrderKeys() {
+    // test multiple order keys for input table
+    final String sql =
+        "select * from table(topn(table orders order by (orderId, productid), 3))";
+    final String expected = "SELECT *\n"
+        + "FROM TABLE(`TOPN`(((TABLE `ORDERS`) ORDER BY `ORDERID`, `PRODUCTID`), 3))";
+    sql(sql).ok(expected);
+  }
+
+  @Test void testTableFunctionWithComplexOrderBy() {
+    // test complex order-by clause for input table
+    final String sql =
+        "select * from table(topn(table orders order by (orderId desc, productid asc), 3))";
+    final String expected = "SELECT *\n"
+        + "FROM TABLE(`TOPN`(((TABLE `ORDERS`) ORDER BY `ORDERID` DESC, `PRODUCTID`), 3))";
+    sql(sql).ok(expected);
+  }
+
+  @Test void testTableFunctionWithPartitionKeyAndOrderKey() {
+    // test partition by clause and order by clause for input table
+    final String sql =
+        "select * from table(topn(table orders partition by productid order by orderId, 3))";
+    final String expected = "SELECT *\n"
+        + "FROM TABLE(`TOPN`(((TABLE `ORDERS`) PARTITION BY `PRODUCTID` ORDER BY `ORDERID`), 3))";
+    sql(sql).ok(expected);
+  }
+
+  @Test void testTableFunctionWithSubQuery() {
+    // test partition by clause and order by clause for subquery
+    final String sql =
+        "select * from table(topn(select * from Orders partition by productid "
+            + "order by orderId, 3))";
+    final String expected = "SELECT *\n"
+        + "FROM TABLE(`TOPN`(((SELECT *\n"
+        + "FROM `ORDERS`) PARTITION BY `PRODUCTID` ORDER BY `ORDERID`), 3))";
+    sql(sql).ok(expected);
+  }
+
+  @Test void testTableFunctionWithMultipleInputTables() {
+    final String sql = "select * from table(similarlity(table emp, table emp_b))";
+    final String expected = "SELECT *\n"
+        + "FROM TABLE(`SIMILARLITY`((TABLE `EMP`), (TABLE `EMP_B`)))";
+    sql(sql).ok(expected);
+  }
+
+  @Test void testTableFunctionWithMultipleInputTablesAndSubClauses() {
+    final String sql = "select * from table("
+        + "similarlity("
+        + "  table emp partition by deptno order by empno, "
+        + "  table emp_b partition by deptno order by empno))";
+    final String expected = "SELECT *\n"
+        + "FROM TABLE(`SIMILARLITY`(((TABLE `EMP`) PARTITION BY `DEPTNO` ORDER BY `EMPNO`), "
+        + "((TABLE `EMP_B`) PARTITION BY `DEPTNO` ORDER BY `EMPNO`)))";
+    sql(sql).ok(expected);
+  }
+
   @Test void testIllegalCursors() {
     sql("select ^cursor^(select * from emps) from emps")
         .fails("CURSOR expression encountered in illegal context");
@@ -4120,11 +4573,11 @@ void checkPeriodPredicate(Checker checker) {
     sql("describe statement (select * from emps)").ok(expected0);
     final String expected2 = ""
         + "EXPLAIN PLAN INCLUDING ATTRIBUTES WITH IMPLEMENTATION FOR\n"
-        + "(SELECT `DEPTNO`\n"
+        + "SELECT `DEPTNO`\n"
         + "FROM `EMPS`\n"
         + "UNION\n"
         + "SELECT `DEPTNO`\n"
-        + "FROM `DEPTS`)";
+        + "FROM `DEPTS`";
     sql("describe select deptno from emps union select deptno from depts").ok(expected2);
     final String expected3 = ""
         + "EXPLAIN PLAN INCLUDING ATTRIBUTES WITH IMPLEMENTATION FOR\n"
@@ -4145,8 +4598,8 @@ void checkPeriodPredicate(Checker checker) {
 
   @Test void testInsertSelect() {
     final String expected = "INSERT INTO `EMPS`\n"
-        + "(SELECT *\n"
-        + "FROM `EMPS`)";
+        + "SELECT *\n"
+        + "FROM `EMPS`";
     sql("insert into emps select * from emps")
         .ok(expected)
         .node(not(isDdl()));
@@ -4154,11 +4607,11 @@ void checkPeriodPredicate(Checker checker) {
 
   @Test void testInsertUnion() {
     final String expected = "INSERT INTO `EMPS`\n"
-        + "(SELECT *\n"
+        + "SELECT *\n"
         + "FROM `EMPS1`\n"
         + "UNION\n"
         + "SELECT *\n"
-        + "FROM `EMPS2`)";
+        + "FROM `EMPS2`";
     sql("insert into emps select * from emps1 union select * from emps2")
         .ok(expected);
   }
@@ -4166,9 +4619,17 @@ void checkPeriodPredicate(Checker checker) {
   @Test void testInsertValues() {
     final String expected = "INSERT INTO `EMPS`\n"
         + "VALUES (ROW(1, 'Fredkin'))";
+    final String pattern =
+        "VALUE is not allowed under the current SQL conformance level";
     sql("insert into emps values (1,'Fredkin')")
         .ok(expected)
         .node(not(isDdl()));
+    sql("insert into emps value (1, 'Fredkin')")
+        .withConformance(SqlConformanceEnum.MYSQL_5)
+        .ok(expected)
+        .node(not(isDdl()));
+    sql("insert into emps ^value^ (1, 'Fredkin')")
+        .fails(pattern);
   }
 
   @Test void testInsertValuesDefault() {
@@ -4191,29 +4652,29 @@ void checkPeriodPredicate(Checker checker) {
 
   @Test void testInsertColumnList() {
     final String expected = "INSERT INTO `EMPS` (`X`, `Y`)\n"
-        + "(SELECT *\n"
-        + "FROM `EMPS`)";
+        + "SELECT *\n"
+        + "FROM `EMPS`";
     sql("insert into emps(x,y) select * from emps")
         .ok(expected);
   }
 
   @Test void testInsertCaseSensitiveColumnList() {
     final String expected = "INSERT INTO `emps` (`x`, `y`)\n"
-        + "(SELECT *\n"
-        + "FROM `EMPS`)";
+        + "SELECT *\n"
+        + "FROM `EMPS`";
     sql("insert into \"emps\"(\"x\",\"y\") select * from emps")
         .ok(expected);
   }
 
   @Test void testInsertExtendedColumnList() {
     String expected = "INSERT INTO `EMPS` EXTEND (`Z` BOOLEAN) (`X`, `Y`)\n"
-        + "(SELECT *\n"
-        + "FROM `EMPS`)";
+        + "SELECT *\n"
+        + "FROM `EMPS`";
     sql("insert into emps(z boolean)(x,y) select * from emps")
         .ok(expected);
     expected = "INSERT INTO `EMPS` EXTEND (`Z` BOOLEAN) (`X`, `Y`, `Z`)\n"
-        + "(SELECT *\n"
-        + "FROM `EMPS`)";
+        + "SELECT *\n"
+        + "FROM `EMPS`";
     sql("insert into emps(x, y, z boolean) select * from emps")
         .withConformance(SqlConformanceEnum.LENIENT)
         .ok(expected);
@@ -4250,13 +4711,13 @@ void checkPeriodPredicate(Checker checker) {
 
   @Test void testInsertCaseSensitiveExtendedColumnList() {
     String expected = "INSERT INTO `emps` EXTEND (`z` BOOLEAN) (`x`, `y`)\n"
-        + "(SELECT *\n"
-        + "FROM `EMPS`)";
+        + "SELECT *\n"
+        + "FROM `EMPS`";
     sql("insert into \"emps\"(\"z\" boolean)(\"x\",\"y\") select * from emps")
         .ok(expected);
     expected = "INSERT INTO `emps` EXTEND (`z` BOOLEAN) (`x`, `y`, `z`)\n"
-        + "(SELECT *\n"
-        + "FROM `EMPS`)";
+        + "SELECT *\n"
+        + "FROM `EMPS`";
     sql("insert into \"emps\"(\"x\", \"y\", \"z\" boolean) select * from emps")
         .withConformance(SqlConformanceEnum.LENIENT)
         .ok(expected);
@@ -4266,8 +4727,8 @@ void checkPeriodPredicate(Checker checker) {
     final String expected = "EXPLAIN PLAN INCLUDING ATTRIBUTES"
         + " WITH IMPLEMENTATION FOR\n"
         + "INSERT INTO `EMPS1`\n"
-        + "(SELECT *\n"
-        + "FROM `EMPS2`)";
+        + "SELECT *\n"
+        + "FROM `EMPS2`";
     sql("explain plan for insert into emps1 select * from emps2")
         .ok(expected)
         .node(not(isDdl()));
@@ -4287,8 +4748,8 @@ void checkPeriodPredicate(Checker checker) {
   @Test void testUpsertSelect() {
     final String sql = "upsert into emps select * from emp as e";
     final String expected = "UPSERT INTO `EMPS`\n"
-        + "(SELECT *\n"
-        + "FROM `EMP` AS `E`)";
+        + "SELECT *\n"
+        + "FROM `EMP` AS `E`";
     if (isReserved("UPSERT")) {
       sql(sql).ok(expected);
     }
@@ -4341,7 +4802,7 @@ void checkPeriodPredicate(Checker checker) {
         + ", `DEPTNO` = `T`.`DEPTNO`"
         + ", `SALARY` = (`T`.`SALARY` * 0.1)\n"
         + "WHEN NOT MATCHED THEN INSERT (`NAME`, `DEPT`, `SALARY`) "
-        + "(VALUES (ROW(`T`.`NAME`, 10, (`T`.`SALARY` * 0.15))))";
+        + "VALUES (ROW(`T`.`NAME`, 10, (`T`.`SALARY` * 0.15)))";
     sql(sql).ok(expected)
         .node(not(isDdl()));
   }
@@ -4364,7 +4825,7 @@ void checkPeriodPredicate(Checker checker) {
         + ", `E`.`DEPTNO` = `T`.`DEPTNO`"
         + ", `E`.`SALARY` = (`T`.`SALARY` * 0.1)\n"
         + "WHEN NOT MATCHED THEN INSERT (`NAME`, `DEPT`, `SALARY`) "
-        + "(VALUES (ROW(`T`.`NAME`, 10, (`T`.`SALARY` * 0.15))))";
+        + "VALUES (ROW(`T`.`NAME`, 10, (`T`.`SALARY` * 0.15)))";
     sql(sql).ok(expected)
         .node(not(isDdl()));
   }
@@ -4384,7 +4845,7 @@ void checkPeriodPredicate(Checker checker) {
         + ", `DEPTNO` = `T`.`DEPTNO`"
         + ", `SALARY` = (`T`.`SALARY` * 0.1)\n"
         + "WHEN NOT MATCHED THEN INSERT (`NAME`, `DEPT`, `SALARY`) "
-        + "(VALUES (ROW(`T`.`NAME`, 10, (`T`.`SALARY` * 0.15))))";
+        + "VALUES (ROW(`T`.`NAME`, 10, (`T`.`SALARY` * 0.15)))";
     sql(sql).ok(expected);
   }
 
@@ -4404,10 +4865,44 @@ void checkPeriodPredicate(Checker checker) {
         + ", `E`.`DEPTNO` = `T`.`DEPTNO`"
         + ", `E`.`SALARY` = (`T`.`SALARY` * 0.1)\n"
         + "WHEN NOT MATCHED THEN INSERT (`NAME`, `DEPT`, `SALARY`) "
-        + "(VALUES (ROW(`T`.`NAME`, 10, (`T`.`SALARY` * 0.15))))";
+        + "VALUES (ROW(`T`.`NAME`, 10, (`T`.`SALARY` * 0.15)))";
     sql(sql).ok(expected);
   }
 
+  @Test void testMergeMismatchedParentheses() {
+    // Invalid; more '(' than ')'
+    final String sql1 = "merge into emps as e\n"
+        + "using temps as t on e.empno = t.empno\n"
+        + "when not matched\n"
+        + "then insert (a, b) (values (1, 2^)^";
+    sql(sql1).fails("(?s)Encountered \"<EOF>\" at .*");
+
+    // Invalid; more ')' than '('
+    final String sql1b = "merge into emps as e\n"
+        + "using temps as t on e.empno = t.empno\n"
+        + "when not matched\n"
+        + "then insert (a, b) values (1, 2)^)^";
+    sql(sql1b).fails("(?s)Encountered \"\\)\" at .*");
+
+    // As sql1, with extra ')', therefore valid
+    final String sql2 = "merge into emps as e\n"
+        + "using temps as t on e.empno = t.empno\n"
+        + "when not matched\n"
+        + "then insert (a, b) (values (1, 2))";
+    final String expected = "MERGE INTO `EMPS` AS `E`\n"
+        + "USING `TEMPS` AS `T`\n"
+        + "ON (`E`.`EMPNO` = `T`.`EMPNO`)\n"
+        + "WHEN NOT MATCHED THEN INSERT (`A`, `B`) VALUES (ROW(1, 2))";
+    sql(sql2).ok(expected);
+
+    // As sql1, removing unmatched '(', therefore valid
+    final String sql3 = "merge into emps as e\n"
+        + "using temps as t on e.empno = t.empno\n"
+        + "when not matched\n"
+        + "then insert (a, b) values (1, 2)";
+    sql(sql3).ok(expected);
+  }
+
   @Test void testBitStringNotImplemented() {
     // Bit-string is longer part of the SQL standard. We do not support it.
     sql("select (B^'1011'^ || 'foobar') from (values (true))")
@@ -4457,12 +4952,10 @@ void checkPeriodPredicate(Checker checker) {
         .ok("_ISO-8859-1'is it a plane? no it''s superman!'");
     expr("n'lowercase n'")
         .ok("_ISO-8859-1'lowercase n'");
-    expr("'boring string'")
-        .ok("'boring string'");
+    expr("'boring string'").same();
     expr("_iSo-8859-1'bye'")
         .ok("_ISO-8859-1'bye'");
-    expr("'three'\n' blind'\n' mice'")
-        .ok("'three'\n' blind'\n' mice'");
+    expr("'three'\n' blind'\n' mice'").same();
     expr("'three' -- comment\n' blind'\n' mice'")
         .ok("'three'\n' blind'\n' mice'");
     expr("N'bye' \t\r\f\f\n' bye'")
@@ -4473,15 +4966,13 @@ void checkPeriodPredicate(Checker checker) {
         .ok("_UTF8'hi'");
 
     // newline in string literal
-    expr("'foo\rbar'")
-        .ok("'foo\rbar'");
-    expr("'foo\nbar'")
-        .ok("'foo\nbar'");
+    expr("'foo\rbar'").same();
+    expr("'foo\nbar'").same();
 
     expr("'foo\r\nbar'")
         // prevent test infrastructure from converting '\r\n' to '\n'
         .withConvertToLinux(false)
-        .ok("'foo\r\nbar'");
+        .same();
   }
 
   @Test void testStringLiteralFails() {
@@ -4570,7 +5061,8 @@ private static Matcher<SqlNode> isCharLiteral(String s) {
     };
   }
 
-  @Test void testCaseExpression() {
+  @VisibleForTesting
+  @Test public void testCaseExpression() {
     // implicit simple "ELSE NULL" case
     expr("case \t col1 when 1 then 'one' end")
         .ok("(CASE WHEN (`COL1` = 1) THEN 'one' ELSE NULL END)");
@@ -4616,6 +5108,18 @@ private static Matcher<SqlNode> isCharLiteral(String s) {
         .fails("(?s).*when1.*");
   }
 
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-4802">[CALCITE-4802]
+   * Babel parser doesn't parse IF(condition, then, else) statements </a>.
+   */
+  @Test void testIf() {
+    expr("if(true, 1, 0)")
+        .ok("`IF`(TRUE, 1, 0)");
+
+    sql("select 1 as if")
+        .ok("SELECT 1 AS `IF`");
+  }
+
   @Test void testNullIf() {
     expr("nullif(v1,v2)")
         .ok("NULLIF(`V1`, `V2`)");
@@ -4690,104 +5194,119 @@ private static Matcher<SqlNode> isCharLiteral(String s) {
     sql("select interval '5:6' hour to minute from t").ok(expected4);
   }
 
+  /** Tests that on BigQuery, DATE, TIME and TIMESTAMP literals can use
+   * single- or double-quoted strings. */
+  @Test void testDateLiteralBigQuery() {
+    final SqlParserFixture f = fixture().withDialect(BIG_QUERY);
+    f.sql("select date '2020-10-10'")
+        .ok("SELECT DATE '2020-10-10'");
+    f.sql("select date\"2020-10-10\"")
+        .ok("SELECT DATE '2020-10-10'");
+    f.sql("select timestamp '2018-02-17 13:22:04'")
+        .ok("SELECT TIMESTAMP '2018-02-17 13:22:04'");
+    f.sql("select timestamp \"2018-02-17 13:22:04\"")
+        .ok("SELECT TIMESTAMP '2018-02-17 13:22:04'");
+    f.sql("select time '13:22:04'")
+        .ok("SELECT TIME '13:22:04'");
+    f.sql("select time \"13:22:04\"")
+        .ok("SELECT TIME '13:22:04'");
+  }
+
+  @Test void testIntervalLiteralBigQuery() {
+    final SqlParserFixture f = fixture().withDialect(BIG_QUERY)
+        .expression(true);
+    f.sql("interval '1' day")
+        .ok("INTERVAL '1' DAY");
+    f.sql("interval \"1\" day")
+        .ok("INTERVAL '1' DAY");
+    f.sql("interval '1:2:3' hour to second")
+        .ok("INTERVAL '1:2:3' HOUR TO SECOND");
+    f.sql("interval \"1:2:3\" hour to second")
+        .ok("INTERVAL '1:2:3' HOUR TO SECOND");
+  }
+
   // check date/time functions.
   @Test void testTimeDate() {
     // CURRENT_TIME - returns time w/ timezone
-    expr("CURRENT_TIME(3)")
-        .ok("CURRENT_TIME(3)");
+    expr("CURRENT_TIME(3)").same();
 
     // checkFails("SELECT CURRENT_TIME() FROM foo",
     //     "SELECT CURRENT_TIME() FROM `FOO`");
 
-    expr("CURRENT_TIME")
-        .ok("CURRENT_TIME");
+    expr("CURRENT_TIME").same();
     expr("CURRENT_TIME(x+y)")
         .ok("CURRENT_TIME((`X` + `Y`))");
 
     // LOCALTIME returns time w/o TZ
-    expr("LOCALTIME(3)")
-        .ok("LOCALTIME(3)");
+    expr("LOCALTIME(3)").same();
 
     // checkFails("SELECT LOCALTIME() FROM foo",
     //     "SELECT LOCALTIME() FROM `FOO`");
 
-    expr("LOCALTIME")
-        .ok("LOCALTIME");
+    expr("LOCALTIME").same();
     expr("LOCALTIME(x+y)")
         .ok("LOCALTIME((`X` + `Y`))");
 
     // LOCALTIMESTAMP - returns timestamp w/o TZ
-    expr("LOCALTIMESTAMP(3)")
-        .ok("LOCALTIMESTAMP(3)");
+    expr("LOCALTIMESTAMP(3)").same();
 
     // checkFails("SELECT LOCALTIMESTAMP() FROM foo",
     //     "SELECT LOCALTIMESTAMP() FROM `FOO`");
 
-    expr("LOCALTIMESTAMP")
-        .ok("LOCALTIMESTAMP");
+    expr("LOCALTIMESTAMP").same();
     expr("LOCALTIMESTAMP(x+y)")
         .ok("LOCALTIMESTAMP((`X` + `Y`))");
 
     // CURRENT_DATE - returns DATE
-    expr("CURRENT_DATE(3)")
-        .ok("CURRENT_DATE(3)");
+    expr("CURRENT_DATE(3)").same();
 
     // checkFails("SELECT CURRENT_DATE() FROM foo",
     //     "SELECT CURRENT_DATE() FROM `FOO`");
-    expr("CURRENT_DATE")
-        .ok("CURRENT_DATE");
+    expr("CURRENT_DATE").same();
 
     // checkFails("SELECT CURRENT_DATE(x+y) FROM foo",
     //     "CURRENT_DATE((`X` + `Y`))");
 
     // CURRENT_TIMESTAMP - returns timestamp w/ TZ
-    expr("CURRENT_TIMESTAMP(3)")
-        .ok("CURRENT_TIMESTAMP(3)");
+    expr("CURRENT_TIMESTAMP(3)").same();
 
     // checkFails("SELECT CURRENT_TIMESTAMP() FROM foo",
     //     "SELECT CURRENT_TIMESTAMP() FROM `FOO`");
 
-    expr("CURRENT_TIMESTAMP")
-        .ok("CURRENT_TIMESTAMP");
+    expr("CURRENT_TIMESTAMP").same();
     expr("CURRENT_TIMESTAMP(x+y)")
         .ok("CURRENT_TIMESTAMP((`X` + `Y`))");
 
     // Date literals
-    expr("DATE '2004-12-01'")
-        .ok("DATE '2004-12-01'");
+    expr("DATE '2004-12-01'").same();
 
     // Time literals
-    expr("TIME '12:01:01'")
-        .ok("TIME '12:01:01'");
-    expr("TIME '12:01:01.'")
-        .ok("TIME '12:01:01'");
-    expr("TIME '12:01:01.000'")
-        .ok("TIME '12:01:01.000'");
-    expr("TIME '12:01:01.001'")
-        .ok("TIME '12:01:01.001'");
-    expr("TIME '12:01:01.01023456789'")
-        .ok("TIME '12:01:01.01023456789'");
+    expr("TIME '12:01:01'").same();
+    expr("TIME '12:01:01.'").same();
+    expr("TIME '12:01:01.000'").same();
+    expr("TIME '12:01:01.001'").same();
+    expr("TIME '12:01:01.01023456789'").same();
 
     // Timestamp literals
-    expr("TIMESTAMP '2004-12-01 12:01:01'")
-        .ok("TIMESTAMP '2004-12-01 12:01:01'");
-    expr("TIMESTAMP '2004-12-01 12:01:01.1'")
-        .ok("TIMESTAMP '2004-12-01 12:01:01.1'");
-    expr("TIMESTAMP '2004-12-01 12:01:01.'")
-        .ok("TIMESTAMP '2004-12-01 12:01:01'");
+    expr("TIMESTAMP '2004-12-01 12:01:01'").same();
+    expr("TIMESTAMP '2004-12-01 12:01:01.1'").same();
+    expr("TIMESTAMP '2004-12-01 12:01:01.'").same();
     expr("TIMESTAMP  '2004-12-01 12:01:01.010234567890'")
         .ok("TIMESTAMP '2004-12-01 12:01:01.010234567890'");
     expr("TIMESTAMP '2004-12-01 12:01:01.01023456789'").same();
 
-    // Failures.
-    sql("^DATE '12/21/99'^")
-        .fails("(?s).*Illegal DATE literal.*");
-    sql("^TIME '1230:33'^")
-        .fails("(?s).*Illegal TIME literal.*");
-    sql("^TIME '12:00:00 PM'^")
-        .fails("(?s).*Illegal TIME literal.*");
-    sql("^TIMESTAMP '12-21-99, 12:30:00'^")
-        .fails("(?s).*Illegal TIMESTAMP literal.*");
+    // Datetime, Timestamp with local time zone literals.
+    expr("DATETIME '2004-12-01 12:01:01'")
+        .same();
+
+    // Value strings that are illegal for their type are considered valid at
+    // parse time, invalid at validate time. See SqlValidatorTest.testLiteral.
+    expr("^DATE '12/21/99'^").same();
+    expr("^TIME '1230:33'^").same();
+    expr("^TIME '12:00:00 PM'^").same();
+    expr("TIMESTAMP '12-21-99, 12:30:00'").same();
+    expr("TIMESTAMP WITH LOCAL TIME ZONE '12-21-99, 12:30:00'").same();
+    expr("DATETIME '12-21-99, 12:30:00'").same();
   }
 
   /**
@@ -4796,10 +5315,8 @@ private static Matcher<SqlNode> isCharLiteral(String s) {
   @Test void testDateTimeCast() {
     //   checkExp("CAST(DATE '2001-12-21' AS CHARACTER VARYING)",
     // "CAST(2001-12-21)");
-    expr("CAST('2001-12-21' AS DATE)")
-        .ok("CAST('2001-12-21' AS DATE)");
-    expr("CAST(12 AS DATE)")
-        .ok("CAST(12 AS DATE)");
+    expr("CAST('2001-12-21' AS DATE)").same();
+    expr("CAST(12 AS DATE)").same();
     sql("CAST('2000-12-21' AS DATE ^NOT^ NULL)")
         .fails("(?s).*Encountered \"NOT\" at line 1, column 27.*");
     sql("CAST('foo' as ^1^)")
@@ -4996,6 +5513,72 @@ private static Matcher<SqlNode> isCharLiteral(String s) {
             + "FROM `BIDS`");
   }
 
+  @Test void testQualify() {
+    final String sql = "SELECT empno, ename,\n"
+        + " ROW_NUMBER() over (partition by ename order by deptno) as rn\n"
+        + "FROM emp\n"
+        + "QUALIFY rn = 1";
+    final String expected = "SELECT `EMPNO`, `ENAME`,"
+        + " (ROW_NUMBER() OVER (PARTITION BY `ENAME` ORDER BY `DEPTNO`)) AS `RN`\n"
+        + "FROM `EMP`\n"
+        + "QUALIFY (`RN` = 1)";
+    sql(sql).ok(expected);
+  }
+
+  @Test void testQualifyWithoutAlias() {
+    final String sql = "SELECT empno, ename\n"
+        + "FROM emp\n"
+        + "QUALIFY ROW_NUMBER() over (partition by ename order by deptno) = 1";
+    final String expected = "SELECT `EMPNO`, `ENAME`\n"
+        + "FROM `EMP`\n"
+        + "QUALIFY ((ROW_NUMBER() OVER (PARTITION BY `ENAME` ORDER BY `DEPTNO`)) = 1)";
+    sql(sql).ok(expected);
+  }
+
+  @Test void testQualifyWithWindowClause() {
+    final String sql = "SELECT empno, ename,\n"
+        + " SUM(deptno) OVER myWindow as sumDeptNo\n"
+        + "FROM emp\n"
+        + "WINDOW myWindow AS (PARTITION BY ename ORDER BY empno)\n"
+        + "QUALIFY sumDeptNo = 1";
+    final String expected = "SELECT `EMPNO`, `ENAME`,"
+        + " (SUM(`DEPTNO`) OVER `MYWINDOW`) AS `SUMDEPTNO`\n"
+        + "FROM `EMP`\n"
+        + "WINDOW `MYWINDOW` AS (PARTITION BY `ENAME` ORDER BY `EMPNO`)\n"
+        + "QUALIFY (`SUMDEPTNO` = 1)";
+    sql(sql).ok(expected);
+  }
+
+  @Test void testQualifyWithEverything() {
+    final String sql = "SELECT DISTINCT ename,\n"
+        + " SUM(deptno) OVER (PARTITION BY ename) as r\n"
+        + "FROM emp\n"
+        + "WHERE deptno > 3\n"
+        + "GROUP BY ename, deptno\n"
+        + "HAVING SUM(empno) > 4\n"
+        + "QUALIFY sumDeptNo = 1\n"
+        + "ORDER BY ename\n"
+        + "LIMIT 5\n";
+    final String expected = "SELECT DISTINCT `ENAME`,"
+        + " (SUM(`DEPTNO`) OVER (PARTITION BY `ENAME`)) AS `R`\n"
+        + "FROM `EMP`\n"
+        + "WHERE (`DEPTNO` > 3)\n"
+        + "GROUP BY `ENAME`, `DEPTNO`\n"
+        + "HAVING (SUM(`EMPNO`) > 4)\n"
+        + "QUALIFY (`SUMDEPTNO` = 1)\n"
+        + "ORDER BY `ENAME`\n"
+        + "FETCH NEXT 5 ROWS ONLY";
+    sql(sql).ok(expected);
+  }
+
+  @Test void testQualifyIllegalAfterOrder() {
+    final String sql = "SELECT x\n"
+        + "FROM t\n"
+        + "ORDER BY 1 DESC\n"
+        + "^QUALIFY^ x = 1";
+    sql(sql).fails("(?s).*Encountered \"QUALIFY\" at .*");
+  }
+
   @Test void testNullTreatment() {
     sql("select lead(x) respect nulls over (w) from t")
         .ok("SELECT (LEAD(`X`) RESPECT NULLS OVER (`W`))\n"
@@ -5277,6 +5860,16 @@ private static Matcher<SqlNode> isCharLiteral(String s) {
         .ok("(ARRAY[(ROW(1, 'a')), (ROW(2, 'b'))])");
   }
 
+  @Test void testArrayQueryConstructor() {
+    sql("SELECT array(SELECT x FROM (VALUES(1)) x)")
+        .ok("SELECT (ARRAY ((SELECT `X`\n"
+            + "FROM (VALUES (ROW(1))) AS `X`)))");
+    sql("SELECT array(SELECT x FROM (VALUES(1)) x ORDER BY x)")
+        .ok("SELECT (ARRAY (SELECT `X`\n"
+            + "FROM (VALUES (ROW(1))) AS `X`\n"
+            + "ORDER BY `X`))");
+  }
+
   @Test void testCastAsCollectionType() {
     // test array type.
     expr("cast(a as int array)")
@@ -5337,966 +5930,6 @@ private static Matcher<SqlNode> isCharLiteral(String s) {
         .ok("(MAP[])");
   }
 
-  /**
-   * Runs tests for INTERVAL... YEAR that should pass both parser and
-   * validator. A substantially identical set of tests exists in
-   * SqlValidatorTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXPositive() tests.
-   */
-  public void subTestIntervalYearPositive() {
-    // default precision
-    expr("interval '1' year")
-        .ok("INTERVAL '1' YEAR");
-    expr("interval '99' year")
-        .ok("INTERVAL '99' YEAR");
-
-    // explicit precision equal to default
-    expr("interval '1' year(2)")
-        .ok("INTERVAL '1' YEAR(2)");
-    expr("interval '99' year(2)")
-        .ok("INTERVAL '99' YEAR(2)");
-
-    // max precision
-    expr("interval '2147483647' year(10)")
-        .ok("INTERVAL '2147483647' YEAR(10)");
-
-    // min precision
-    expr("interval '0' year(1)")
-        .ok("INTERVAL '0' YEAR(1)");
-
-    // alternate precision
-    expr("interval '1234' year(4)")
-        .ok("INTERVAL '1234' YEAR(4)");
-
-    // sign
-    expr("interval '+1' year")
-        .ok("INTERVAL '+1' YEAR");
-    expr("interval '-1' year")
-        .ok("INTERVAL '-1' YEAR");
-    expr("interval +'1' year")
-        .ok("INTERVAL '1' YEAR");
-    expr("interval +'+1' year")
-        .ok("INTERVAL '+1' YEAR");
-    expr("interval +'-1' year")
-        .ok("INTERVAL '-1' YEAR");
-    expr("interval -'1' year")
-        .ok("INTERVAL -'1' YEAR");
-    expr("interval -'+1' year")
-        .ok("INTERVAL -'+1' YEAR");
-    expr("interval -'-1' year")
-        .ok("INTERVAL -'-1' YEAR");
-  }
-
-  /**
-   * Runs tests for INTERVAL... YEAR TO MONTH that should pass both parser and
-   * validator. A substantially identical set of tests exists in
-   * SqlValidatorTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXPositive() tests.
-   */
-  public void subTestIntervalYearToMonthPositive() {
-    // default precision
-    expr("interval '1-2' year to month")
-        .ok("INTERVAL '1-2' YEAR TO MONTH");
-    expr("interval '99-11' year to month")
-        .ok("INTERVAL '99-11' YEAR TO MONTH");
-    expr("interval '99-0' year to month")
-        .ok("INTERVAL '99-0' YEAR TO MONTH");
-
-    // explicit precision equal to default
-    expr("interval '1-2' year(2) to month")
-        .ok("INTERVAL '1-2' YEAR(2) TO MONTH");
-    expr("interval '99-11' year(2) to month")
-        .ok("INTERVAL '99-11' YEAR(2) TO MONTH");
-    expr("interval '99-0' year(2) to month")
-        .ok("INTERVAL '99-0' YEAR(2) TO MONTH");
-
-    // max precision
-    expr("interval '2147483647-11' year(10) to month")
-        .ok("INTERVAL '2147483647-11' YEAR(10) TO MONTH");
-
-    // min precision
-    expr("interval '0-0' year(1) to month")
-        .ok("INTERVAL '0-0' YEAR(1) TO MONTH");
-
-    // alternate precision
-    expr("interval '2006-2' year(4) to month")
-        .ok("INTERVAL '2006-2' YEAR(4) TO MONTH");
-
-    // sign
-    expr("interval '-1-2' year to month")
-        .ok("INTERVAL '-1-2' YEAR TO MONTH");
-    expr("interval '+1-2' year to month")
-        .ok("INTERVAL '+1-2' YEAR TO MONTH");
-    expr("interval +'1-2' year to month")
-        .ok("INTERVAL '1-2' YEAR TO MONTH");
-    expr("interval +'-1-2' year to month")
-        .ok("INTERVAL '-1-2' YEAR TO MONTH");
-    expr("interval +'+1-2' year to month")
-        .ok("INTERVAL '+1-2' YEAR TO MONTH");
-    expr("interval -'1-2' year to month")
-        .ok("INTERVAL -'1-2' YEAR TO MONTH");
-    expr("interval -'-1-2' year to month")
-        .ok("INTERVAL -'-1-2' YEAR TO MONTH");
-    expr("interval -'+1-2' year to month")
-        .ok("INTERVAL -'+1-2' YEAR TO MONTH");
-  }
-
-  /**
-   * Runs tests for INTERVAL... MONTH that should pass both parser and
-   * validator. A substantially identical set of tests exists in
-   * SqlValidatorTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXPositive() tests.
-   */
-  public void subTestIntervalMonthPositive() {
-    // default precision
-    expr("interval '1' month")
-        .ok("INTERVAL '1' MONTH");
-    expr("interval '99' month")
-        .ok("INTERVAL '99' MONTH");
-
-    // explicit precision equal to default
-    expr("interval '1' month(2)")
-        .ok("INTERVAL '1' MONTH(2)");
-    expr("interval '99' month(2)")
-        .ok("INTERVAL '99' MONTH(2)");
-
-    // max precision
-    expr("interval '2147483647' month(10)")
-        .ok("INTERVAL '2147483647' MONTH(10)");
-
-    // min precision
-    expr("interval '0' month(1)")
-        .ok("INTERVAL '0' MONTH(1)");
-
-    // alternate precision
-    expr("interval '1234' month(4)")
-        .ok("INTERVAL '1234' MONTH(4)");
-
-    // sign
-    expr("interval '+1' month")
-        .ok("INTERVAL '+1' MONTH");
-    expr("interval '-1' month")
-        .ok("INTERVAL '-1' MONTH");
-    expr("interval +'1' month")
-        .ok("INTERVAL '1' MONTH");
-    expr("interval +'+1' month")
-        .ok("INTERVAL '+1' MONTH");
-    expr("interval +'-1' month")
-        .ok("INTERVAL '-1' MONTH");
-    expr("interval -'1' month")
-        .ok("INTERVAL -'1' MONTH");
-    expr("interval -'+1' month")
-        .ok("INTERVAL -'+1' MONTH");
-    expr("interval -'-1' month")
-        .ok("INTERVAL -'-1' MONTH");
-  }
-
-  /**
-   * Runs tests for INTERVAL... DAY that should pass both parser and
-   * validator. A substantially identical set of tests exists in
-   * SqlValidatorTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXPositive() tests.
-   */
-  public void subTestIntervalDayPositive() {
-    // default precision
-    expr("interval '1' day")
-        .ok("INTERVAL '1' DAY");
-    expr("interval '99' day")
-        .ok("INTERVAL '99' DAY");
-
-    // explicit precision equal to default
-    expr("interval '1' day(2)")
-        .ok("INTERVAL '1' DAY(2)");
-    expr("interval '99' day(2)")
-        .ok("INTERVAL '99' DAY(2)");
-
-    // max precision
-    expr("interval '2147483647' day(10)")
-        .ok("INTERVAL '2147483647' DAY(10)");
-
-    // min precision
-    expr("interval '0' day(1)")
-        .ok("INTERVAL '0' DAY(1)");
-
-    // alternate precision
-    expr("interval '1234' day(4)")
-        .ok("INTERVAL '1234' DAY(4)");
-
-    // sign
-    expr("interval '+1' day")
-        .ok("INTERVAL '+1' DAY");
-    expr("interval '-1' day")
-        .ok("INTERVAL '-1' DAY");
-    expr("interval +'1' day")
-        .ok("INTERVAL '1' DAY");
-    expr("interval +'+1' day")
-        .ok("INTERVAL '+1' DAY");
-    expr("interval +'-1' day")
-        .ok("INTERVAL '-1' DAY");
-    expr("interval -'1' day")
-        .ok("INTERVAL -'1' DAY");
-    expr("interval -'+1' day")
-        .ok("INTERVAL -'+1' DAY");
-    expr("interval -'-1' day")
-        .ok("INTERVAL -'-1' DAY");
-  }
-
-  /**
-   * Runs tests for INTERVAL... DAY TO HOUR that should pass both parser and
-   * validator. A substantially identical set of tests exists in
-   * SqlValidatorTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXPositive() tests.
-   */
-  public void subTestIntervalDayToHourPositive() {
-    // default precision
-    expr("interval '1 2' day to hour")
-        .ok("INTERVAL '1 2' DAY TO HOUR");
-    expr("interval '99 23' day to hour")
-        .ok("INTERVAL '99 23' DAY TO HOUR");
-    expr("interval '99 0' day to hour")
-        .ok("INTERVAL '99 0' DAY TO HOUR");
-
-    // explicit precision equal to default
-    expr("interval '1 2' day(2) to hour")
-        .ok("INTERVAL '1 2' DAY(2) TO HOUR");
-    expr("interval '99 23' day(2) to hour")
-        .ok("INTERVAL '99 23' DAY(2) TO HOUR");
-    expr("interval '99 0' day(2) to hour")
-        .ok("INTERVAL '99 0' DAY(2) TO HOUR");
-
-    // max precision
-    expr("interval '2147483647 23' day(10) to hour")
-        .ok("INTERVAL '2147483647 23' DAY(10) TO HOUR");
-
-    // min precision
-    expr("interval '0 0' day(1) to hour")
-        .ok("INTERVAL '0 0' DAY(1) TO HOUR");
-
-    // alternate precision
-    expr("interval '2345 2' day(4) to hour")
-        .ok("INTERVAL '2345 2' DAY(4) TO HOUR");
-
-    // sign
-    expr("interval '-1 2' day to hour")
-        .ok("INTERVAL '-1 2' DAY TO HOUR");
-    expr("interval '+1 2' day to hour")
-        .ok("INTERVAL '+1 2' DAY TO HOUR");
-    expr("interval +'1 2' day to hour")
-        .ok("INTERVAL '1 2' DAY TO HOUR");
-    expr("interval +'-1 2' day to hour")
-        .ok("INTERVAL '-1 2' DAY TO HOUR");
-    expr("interval +'+1 2' day to hour")
-        .ok("INTERVAL '+1 2' DAY TO HOUR");
-    expr("interval -'1 2' day to hour")
-        .ok("INTERVAL -'1 2' DAY TO HOUR");
-    expr("interval -'-1 2' day to hour")
-        .ok("INTERVAL -'-1 2' DAY TO HOUR");
-    expr("interval -'+1 2' day to hour")
-        .ok("INTERVAL -'+1 2' DAY TO HOUR");
-  }
-
-  /**
-   * Runs tests for INTERVAL... DAY TO MINUTE that should pass both parser and
-   * validator. A substantially identical set of tests exists in
-   * SqlValidatorTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXPositive() tests.
-   */
-  public void subTestIntervalDayToMinutePositive() {
-    // default precision
-    expr("interval '1 2:3' day to minute")
-        .ok("INTERVAL '1 2:3' DAY TO MINUTE");
-    expr("interval '99 23:59' day to minute")
-        .ok("INTERVAL '99 23:59' DAY TO MINUTE");
-    expr("interval '99 0:0' day to minute")
-        .ok("INTERVAL '99 0:0' DAY TO MINUTE");
-
-    // explicit precision equal to default
-    expr("interval '1 2:3' day(2) to minute")
-        .ok("INTERVAL '1 2:3' DAY(2) TO MINUTE");
-    expr("interval '99 23:59' day(2) to minute")
-        .ok("INTERVAL '99 23:59' DAY(2) TO MINUTE");
-    expr("interval '99 0:0' day(2) to minute")
-        .ok("INTERVAL '99 0:0' DAY(2) TO MINUTE");
-
-    // max precision
-    expr("interval '2147483647 23:59' day(10) to minute")
-        .ok("INTERVAL '2147483647 23:59' DAY(10) TO MINUTE");
-
-    // min precision
-    expr("interval '0 0:0' day(1) to minute")
-        .ok("INTERVAL '0 0:0' DAY(1) TO MINUTE");
-
-    // alternate precision
-    expr("interval '2345 6:7' day(4) to minute")
-        .ok("INTERVAL '2345 6:7' DAY(4) TO MINUTE");
-
-    // sign
-    expr("interval '-1 2:3' day to minute")
-        .ok("INTERVAL '-1 2:3' DAY TO MINUTE");
-    expr("interval '+1 2:3' day to minute")
-        .ok("INTERVAL '+1 2:3' DAY TO MINUTE");
-    expr("interval +'1 2:3' day to minute")
-        .ok("INTERVAL '1 2:3' DAY TO MINUTE");
-    expr("interval +'-1 2:3' day to minute")
-        .ok("INTERVAL '-1 2:3' DAY TO MINUTE");
-    expr("interval +'+1 2:3' day to minute")
-        .ok("INTERVAL '+1 2:3' DAY TO MINUTE");
-    expr("interval -'1 2:3' day to minute")
-        .ok("INTERVAL -'1 2:3' DAY TO MINUTE");
-    expr("interval -'-1 2:3' day to minute")
-        .ok("INTERVAL -'-1 2:3' DAY TO MINUTE");
-    expr("interval -'+1 2:3' day to minute")
-        .ok("INTERVAL -'+1 2:3' DAY TO MINUTE");
-  }
-
-  /**
-   * Runs tests for INTERVAL... DAY TO SECOND that should pass both parser and
-   * validator. A substantially identical set of tests exists in
-   * SqlValidatorTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXPositive() tests.
-   */
-  public void subTestIntervalDayToSecondPositive() {
-    // default precision
-    expr("interval '1 2:3:4' day to second")
-        .ok("INTERVAL '1 2:3:4' DAY TO SECOND");
-    expr("interval '99 23:59:59' day to second")
-        .ok("INTERVAL '99 23:59:59' DAY TO SECOND");
-    expr("interval '99 0:0:0' day to second")
-        .ok("INTERVAL '99 0:0:0' DAY TO SECOND");
-    expr("interval '99 23:59:59.999999' day to second")
-        .ok("INTERVAL '99 23:59:59.999999' DAY TO SECOND");
-    expr("interval '99 0:0:0.0' day to second")
-        .ok("INTERVAL '99 0:0:0.0' DAY TO SECOND");
-
-    // explicit precision equal to default
-    expr("interval '1 2:3:4' day(2) to second")
-        .ok("INTERVAL '1 2:3:4' DAY(2) TO SECOND");
-    expr("interval '99 23:59:59' day(2) to second")
-        .ok("INTERVAL '99 23:59:59' DAY(2) TO SECOND");
-    expr("interval '99 0:0:0' day(2) to second")
-        .ok("INTERVAL '99 0:0:0' DAY(2) TO SECOND");
-    expr("interval '99 23:59:59.999999' day to second(6)")
-        .ok("INTERVAL '99 23:59:59.999999' DAY TO SECOND(6)");
-    expr("interval '99 0:0:0.0' day to second(6)")
-        .ok("INTERVAL '99 0:0:0.0' DAY TO SECOND(6)");
-
-    // max precision
-    expr("interval '2147483647 23:59:59' day(10) to second")
-        .ok("INTERVAL '2147483647 23:59:59' DAY(10) TO SECOND");
-    expr("interval '2147483647 23:59:59.999999999' day(10) to second(9)")
-        .ok("INTERVAL '2147483647 23:59:59.999999999' DAY(10) TO SECOND(9)");
-
-    // min precision
-    expr("interval '0 0:0:0' day(1) to second")
-        .ok("INTERVAL '0 0:0:0' DAY(1) TO SECOND");
-    expr("interval '0 0:0:0.0' day(1) to second(1)")
-        .ok("INTERVAL '0 0:0:0.0' DAY(1) TO SECOND(1)");
-
-    // alternate precision
-    expr("interval '2345 6:7:8' day(4) to second")
-        .ok("INTERVAL '2345 6:7:8' DAY(4) TO SECOND");
-    expr("interval '2345 6:7:8.9012' day(4) to second(4)")
-        .ok("INTERVAL '2345 6:7:8.9012' DAY(4) TO SECOND(4)");
-
-    // sign
-    expr("interval '-1 2:3:4' day to second")
-        .ok("INTERVAL '-1 2:3:4' DAY TO SECOND");
-    expr("interval '+1 2:3:4' day to second")
-        .ok("INTERVAL '+1 2:3:4' DAY TO SECOND");
-    expr("interval +'1 2:3:4' day to second")
-        .ok("INTERVAL '1 2:3:4' DAY TO SECOND");
-    expr("interval +'-1 2:3:4' day to second")
-        .ok("INTERVAL '-1 2:3:4' DAY TO SECOND");
-    expr("interval +'+1 2:3:4' day to second")
-        .ok("INTERVAL '+1 2:3:4' DAY TO SECOND");
-    expr("interval -'1 2:3:4' day to second")
-        .ok("INTERVAL -'1 2:3:4' DAY TO SECOND");
-    expr("interval -'-1 2:3:4' day to second")
-        .ok("INTERVAL -'-1 2:3:4' DAY TO SECOND");
-    expr("interval -'+1 2:3:4' day to second")
-        .ok("INTERVAL -'+1 2:3:4' DAY TO SECOND");
-  }
-
-  /**
-   * Runs tests for INTERVAL... HOUR that should pass both parser and
-   * validator. A substantially identical set of tests exists in
-   * SqlValidatorTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXPositive() tests.
-   */
-  public void subTestIntervalHourPositive() {
-    // default precision
-    expr("interval '1' hour")
-        .ok("INTERVAL '1' HOUR");
-    expr("interval '99' hour")
-        .ok("INTERVAL '99' HOUR");
-
-    // explicit precision equal to default
-    expr("interval '1' hour(2)")
-        .ok("INTERVAL '1' HOUR(2)");
-    expr("interval '99' hour(2)")
-        .ok("INTERVAL '99' HOUR(2)");
-
-    // max precision
-    expr("interval '2147483647' hour(10)")
-        .ok("INTERVAL '2147483647' HOUR(10)");
-
-    // min precision
-    expr("interval '0' hour(1)")
-        .ok("INTERVAL '0' HOUR(1)");
-
-    // alternate precision
-    expr("interval '1234' hour(4)")
-        .ok("INTERVAL '1234' HOUR(4)");
-
-    // sign
-    expr("interval '+1' hour")
-        .ok("INTERVAL '+1' HOUR");
-    expr("interval '-1' hour")
-        .ok("INTERVAL '-1' HOUR");
-    expr("interval +'1' hour")
-        .ok("INTERVAL '1' HOUR");
-    expr("interval +'+1' hour")
-        .ok("INTERVAL '+1' HOUR");
-    expr("interval +'-1' hour")
-        .ok("INTERVAL '-1' HOUR");
-    expr("interval -'1' hour")
-        .ok("INTERVAL -'1' HOUR");
-    expr("interval -'+1' hour")
-        .ok("INTERVAL -'+1' HOUR");
-    expr("interval -'-1' hour")
-        .ok("INTERVAL -'-1' HOUR");
-  }
-
-  /**
-   * Runs tests for INTERVAL... HOUR TO MINUTE that should pass both parser
-   * and validator. A substantially identical set of tests exists in
-   * SqlValidatorTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXPositive() tests.
-   */
-  public void subTestIntervalHourToMinutePositive() {
-    // default precision
-    expr("interval '2:3' hour to minute")
-        .ok("INTERVAL '2:3' HOUR TO MINUTE");
-    expr("interval '23:59' hour to minute")
-        .ok("INTERVAL '23:59' HOUR TO MINUTE");
-    expr("interval '99:0' hour to minute")
-        .ok("INTERVAL '99:0' HOUR TO MINUTE");
-
-    // explicit precision equal to default
-    expr("interval '2:3' hour(2) to minute")
-        .ok("INTERVAL '2:3' HOUR(2) TO MINUTE");
-    expr("interval '23:59' hour(2) to minute")
-        .ok("INTERVAL '23:59' HOUR(2) TO MINUTE");
-    expr("interval '99:0' hour(2) to minute")
-        .ok("INTERVAL '99:0' HOUR(2) TO MINUTE");
-
-    // max precision
-    expr("interval '2147483647:59' hour(10) to minute")
-        .ok("INTERVAL '2147483647:59' HOUR(10) TO MINUTE");
-
-    // min precision
-    expr("interval '0:0' hour(1) to minute")
-        .ok("INTERVAL '0:0' HOUR(1) TO MINUTE");
-
-    // alternate precision
-    expr("interval '2345:7' hour(4) to minute")
-        .ok("INTERVAL '2345:7' HOUR(4) TO MINUTE");
-
-    // sign
-    expr("interval '-1:3' hour to minute")
-        .ok("INTERVAL '-1:3' HOUR TO MINUTE");
-    expr("interval '+1:3' hour to minute")
-        .ok("INTERVAL '+1:3' HOUR TO MINUTE");
-    expr("interval +'2:3' hour to minute")
-        .ok("INTERVAL '2:3' HOUR TO MINUTE");
-    expr("interval +'-2:3' hour to minute")
-        .ok("INTERVAL '-2:3' HOUR TO MINUTE");
-    expr("interval +'+2:3' hour to minute")
-        .ok("INTERVAL '+2:3' HOUR TO MINUTE");
-    expr("interval -'2:3' hour to minute")
-        .ok("INTERVAL -'2:3' HOUR TO MINUTE");
-    expr("interval -'-2:3' hour to minute")
-        .ok("INTERVAL -'-2:3' HOUR TO MINUTE");
-    expr("interval -'+2:3' hour to minute")
-        .ok("INTERVAL -'+2:3' HOUR TO MINUTE");
-  }
-
-  /**
-   * Runs tests for INTERVAL... HOUR TO SECOND that should pass both parser
-   * and validator. A substantially identical set of tests exists in
-   * SqlValidatorTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXPositive() tests.
-   */
-  public void subTestIntervalHourToSecondPositive() {
-    // default precision
-    expr("interval '2:3:4' hour to second")
-        .ok("INTERVAL '2:3:4' HOUR TO SECOND");
-    expr("interval '23:59:59' hour to second")
-        .ok("INTERVAL '23:59:59' HOUR TO SECOND");
-    expr("interval '99:0:0' hour to second")
-        .ok("INTERVAL '99:0:0' HOUR TO SECOND");
-    expr("interval '23:59:59.999999' hour to second")
-        .ok("INTERVAL '23:59:59.999999' HOUR TO SECOND");
-    expr("interval '99:0:0.0' hour to second")
-        .ok("INTERVAL '99:0:0.0' HOUR TO SECOND");
-
-    // explicit precision equal to default
-    expr("interval '2:3:4' hour(2) to second")
-        .ok("INTERVAL '2:3:4' HOUR(2) TO SECOND");
-    expr("interval '99:59:59' hour(2) to second")
-        .ok("INTERVAL '99:59:59' HOUR(2) TO SECOND");
-    expr("interval '99:0:0' hour(2) to second")
-        .ok("INTERVAL '99:0:0' HOUR(2) TO SECOND");
-    expr("interval '23:59:59.999999' hour to second(6)")
-        .ok("INTERVAL '23:59:59.999999' HOUR TO SECOND(6)");
-    expr("interval '99:0:0.0' hour to second(6)")
-        .ok("INTERVAL '99:0:0.0' HOUR TO SECOND(6)");
-
-    // max precision
-    expr("interval '2147483647:59:59' hour(10) to second")
-        .ok("INTERVAL '2147483647:59:59' HOUR(10) TO SECOND");
-    expr("interval '2147483647:59:59.999999999' hour(10) to second(9)")
-        .ok("INTERVAL '2147483647:59:59.999999999' HOUR(10) TO SECOND(9)");
-
-    // min precision
-    expr("interval '0:0:0' hour(1) to second")
-        .ok("INTERVAL '0:0:0' HOUR(1) TO SECOND");
-    expr("interval '0:0:0.0' hour(1) to second(1)")
-        .ok("INTERVAL '0:0:0.0' HOUR(1) TO SECOND(1)");
-
-    // alternate precision
-    expr("interval '2345:7:8' hour(4) to second")
-        .ok("INTERVAL '2345:7:8' HOUR(4) TO SECOND");
-    expr("interval '2345:7:8.9012' hour(4) to second(4)")
-        .ok("INTERVAL '2345:7:8.9012' HOUR(4) TO SECOND(4)");
-
-    // sign
-    expr("interval '-2:3:4' hour to second")
-        .ok("INTERVAL '-2:3:4' HOUR TO SECOND");
-    expr("interval '+2:3:4' hour to second")
-        .ok("INTERVAL '+2:3:4' HOUR TO SECOND");
-    expr("interval +'2:3:4' hour to second")
-        .ok("INTERVAL '2:3:4' HOUR TO SECOND");
-    expr("interval +'-2:3:4' hour to second")
-        .ok("INTERVAL '-2:3:4' HOUR TO SECOND");
-    expr("interval +'+2:3:4' hour to second")
-        .ok("INTERVAL '+2:3:4' HOUR TO SECOND");
-    expr("interval -'2:3:4' hour to second")
-        .ok("INTERVAL -'2:3:4' HOUR TO SECOND");
-    expr("interval -'-2:3:4' hour to second")
-        .ok("INTERVAL -'-2:3:4' HOUR TO SECOND");
-    expr("interval -'+2:3:4' hour to second")
-        .ok("INTERVAL -'+2:3:4' HOUR TO SECOND");
-  }
-
-  /**
-   * Runs tests for INTERVAL... MINUTE that should pass both parser and
-   * validator. A substantially identical set of tests exists in
-   * SqlValidatorTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXPositive() tests.
-   */
-  public void subTestIntervalMinutePositive() {
-    // default precision
-    expr("interval '1' minute")
-        .ok("INTERVAL '1' MINUTE");
-    expr("interval '99' minute")
-        .ok("INTERVAL '99' MINUTE");
-
-    // explicit precision equal to default
-    expr("interval '1' minute(2)")
-        .ok("INTERVAL '1' MINUTE(2)");
-    expr("interval '99' minute(2)")
-        .ok("INTERVAL '99' MINUTE(2)");
-
-    // max precision
-    expr("interval '2147483647' minute(10)")
-        .ok("INTERVAL '2147483647' MINUTE(10)");
-
-    // min precision
-    expr("interval '0' minute(1)")
-        .ok("INTERVAL '0' MINUTE(1)");
-
-    // alternate precision
-    expr("interval '1234' minute(4)")
-        .ok("INTERVAL '1234' MINUTE(4)");
-
-    // sign
-    expr("interval '+1' minute")
-        .ok("INTERVAL '+1' MINUTE");
-    expr("interval '-1' minute")
-        .ok("INTERVAL '-1' MINUTE");
-    expr("interval +'1' minute")
-        .ok("INTERVAL '1' MINUTE");
-    expr("interval +'+1' minute")
-        .ok("INTERVAL '+1' MINUTE");
-    expr("interval +'+1' minute")
-        .ok("INTERVAL '+1' MINUTE");
-    expr("interval -'1' minute")
-        .ok("INTERVAL -'1' MINUTE");
-    expr("interval -'+1' minute")
-        .ok("INTERVAL -'+1' MINUTE");
-    expr("interval -'-1' minute")
-        .ok("INTERVAL -'-1' MINUTE");
-  }
-
-  /**
-   * Runs tests for INTERVAL... MINUTE TO SECOND that should pass both parser
-   * and validator. A substantially identical set of tests exists in
-   * SqlValidatorTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXPositive() tests.
-   */
-  public void subTestIntervalMinuteToSecondPositive() {
-    // default precision
-    expr("interval '2:4' minute to second")
-        .ok("INTERVAL '2:4' MINUTE TO SECOND");
-    expr("interval '59:59' minute to second")
-        .ok("INTERVAL '59:59' MINUTE TO SECOND");
-    expr("interval '99:0' minute to second")
-        .ok("INTERVAL '99:0' MINUTE TO SECOND");
-    expr("interval '59:59.999999' minute to second")
-        .ok("INTERVAL '59:59.999999' MINUTE TO SECOND");
-    expr("interval '99:0.0' minute to second")
-        .ok("INTERVAL '99:0.0' MINUTE TO SECOND");
-
-    // explicit precision equal to default
-    expr("interval '2:4' minute(2) to second")
-        .ok("INTERVAL '2:4' MINUTE(2) TO SECOND");
-    expr("interval '59:59' minute(2) to second")
-        .ok("INTERVAL '59:59' MINUTE(2) TO SECOND");
-    expr("interval '99:0' minute(2) to second")
-        .ok("INTERVAL '99:0' MINUTE(2) TO SECOND");
-    expr("interval '99:59.999999' minute to second(6)")
-        .ok("INTERVAL '99:59.999999' MINUTE TO SECOND(6)");
-    expr("interval '99:0.0' minute to second(6)")
-        .ok("INTERVAL '99:0.0' MINUTE TO SECOND(6)");
-
-    // max precision
-    expr("interval '2147483647:59' minute(10) to second")
-        .ok("INTERVAL '2147483647:59' MINUTE(10) TO SECOND");
-    expr("interval '2147483647:59.999999999' minute(10) to second(9)")
-        .ok("INTERVAL '2147483647:59.999999999' MINUTE(10) TO SECOND(9)");
-
-    // min precision
-    expr("interval '0:0' minute(1) to second")
-        .ok("INTERVAL '0:0' MINUTE(1) TO SECOND");
-    expr("interval '0:0.0' minute(1) to second(1)")
-        .ok("INTERVAL '0:0.0' MINUTE(1) TO SECOND(1)");
-
-    // alternate precision
-    expr("interval '2345:8' minute(4) to second")
-        .ok("INTERVAL '2345:8' MINUTE(4) TO SECOND");
-    expr("interval '2345:7.8901' minute(4) to second(4)")
-        .ok("INTERVAL '2345:7.8901' MINUTE(4) TO SECOND(4)");
-
-    // sign
-    expr("interval '-3:4' minute to second")
-        .ok("INTERVAL '-3:4' MINUTE TO SECOND");
-    expr("interval '+3:4' minute to second")
-        .ok("INTERVAL '+3:4' MINUTE TO SECOND");
-    expr("interval +'3:4' minute to second")
-        .ok("INTERVAL '3:4' MINUTE TO SECOND");
-    expr("interval +'-3:4' minute to second")
-        .ok("INTERVAL '-3:4' MINUTE TO SECOND");
-    expr("interval +'+3:4' minute to second")
-        .ok("INTERVAL '+3:4' MINUTE TO SECOND");
-    expr("interval -'3:4' minute to second")
-        .ok("INTERVAL -'3:4' MINUTE TO SECOND");
-    expr("interval -'-3:4' minute to second")
-        .ok("INTERVAL -'-3:4' MINUTE TO SECOND");
-    expr("interval -'+3:4' minute to second")
-        .ok("INTERVAL -'+3:4' MINUTE TO SECOND");
-  }
-
-  /**
-   * Runs tests for INTERVAL... SECOND that should pass both parser and
-   * validator. A substantially identical set of tests exists in
-   * SqlValidatorTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXPositive() tests.
-   */
-  public void subTestIntervalSecondPositive() {
-    // default precision
-    expr("interval '1' second")
-        .ok("INTERVAL '1' SECOND");
-    expr("interval '99' second")
-        .ok("INTERVAL '99' SECOND");
-
-    // explicit precision equal to default
-    expr("interval '1' second(2)")
-        .ok("INTERVAL '1' SECOND(2)");
-    expr("interval '99' second(2)")
-        .ok("INTERVAL '99' SECOND(2)");
-    expr("interval '1' second(2,6)")
-        .ok("INTERVAL '1' SECOND(2, 6)");
-    expr("interval '99' second(2,6)")
-        .ok("INTERVAL '99' SECOND(2, 6)");
-
-    // max precision
-    expr("interval '2147483647' second(10)")
-        .ok("INTERVAL '2147483647' SECOND(10)");
-    expr("interval '2147483647.999999999' second(9,9)")
-        .ok("INTERVAL '2147483647.999999999' SECOND(9, 9)");
-
-    // min precision
-    expr("interval '0' second(1)")
-        .ok("INTERVAL '0' SECOND(1)");
-    expr("interval '0.0' second(1,1)")
-        .ok("INTERVAL '0.0' SECOND(1, 1)");
-
-    // alternate precision
-    expr("interval '1234' second(4)")
-        .ok("INTERVAL '1234' SECOND(4)");
-    expr("interval '1234.56789' second(4,5)")
-        .ok("INTERVAL '1234.56789' SECOND(4, 5)");
-
-    // sign
-    expr("interval '+1' second")
-        .ok("INTERVAL '+1' SECOND");
-    expr("interval '-1' second")
-        .ok("INTERVAL '-1' SECOND");
-    expr("interval +'1' second")
-        .ok("INTERVAL '1' SECOND");
-    expr("interval +'+1' second")
-        .ok("INTERVAL '+1' SECOND");
-    expr("interval +'-1' second")
-        .ok("INTERVAL '-1' SECOND");
-    expr("interval -'1' second")
-        .ok("INTERVAL -'1' SECOND");
-    expr("interval -'+1' second")
-        .ok("INTERVAL -'+1' SECOND");
-    expr("interval -'-1' second")
-        .ok("INTERVAL -'-1' SECOND");
-  }
-
-  /**
-   * Runs tests for INTERVAL... YEAR that should pass parser but fail
-   * validator. A substantially identical set of tests exists in
-   * SqlValidatorTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXFailsValidation() tests.
-   */
-  public void subTestIntervalYearFailsValidation() {
-    // Qualifier - field mismatches
-    expr("INTERVAL '-' YEAR")
-        .ok("INTERVAL '-' YEAR");
-    expr("INTERVAL '1-2' YEAR")
-        .ok("INTERVAL '1-2' YEAR");
-    expr("INTERVAL '1.2' YEAR")
-        .ok("INTERVAL '1.2' YEAR");
-    expr("INTERVAL '1 2' YEAR")
-        .ok("INTERVAL '1 2' YEAR");
-    expr("INTERVAL '1-2' YEAR(2)")
-        .ok("INTERVAL '1-2' YEAR(2)");
-    expr("INTERVAL 'bogus text' YEAR")
-        .ok("INTERVAL 'bogus text' YEAR");
-
-    // negative field values
-    expr("INTERVAL '--1' YEAR")
-        .ok("INTERVAL '--1' YEAR");
-
-    // Field value out of range
-    //  (default, explicit default, alt, neg alt, max, neg max)
-    expr("INTERVAL '100' YEAR")
-        .ok("INTERVAL '100' YEAR");
-    expr("INTERVAL '100' YEAR(2)")
-        .ok("INTERVAL '100' YEAR(2)");
-    expr("INTERVAL '1000' YEAR(3)")
-        .ok("INTERVAL '1000' YEAR(3)");
-    expr("INTERVAL '-1000' YEAR(3)")
-        .ok("INTERVAL '-1000' YEAR(3)");
-    expr("INTERVAL '2147483648' YEAR(10)")
-        .ok("INTERVAL '2147483648' YEAR(10)");
-    expr("INTERVAL '-2147483648' YEAR(10)")
-        .ok("INTERVAL '-2147483648' YEAR(10)");
-
-    // precision > maximum
-    expr("INTERVAL '1' YEAR(11)")
-        .ok("INTERVAL '1' YEAR(11)");
-
-    // precision < minimum allowed)
-    // note: parser will catch negative values, here we
-    // just need to check for 0
-    expr("INTERVAL '0' YEAR(0)")
-        .ok("INTERVAL '0' YEAR(0)");
-  }
-
-  /**
-   * Runs tests for INTERVAL... YEAR TO MONTH that should pass parser but fail
-   * validator. A substantially identical set of tests exists in
-   * SqlValidatorTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXFailsValidation() tests.
-   */
-  public void subTestIntervalYearToMonthFailsValidation() {
-    // Qualifier - field mismatches
-    expr("INTERVAL '-' YEAR TO MONTH")
-        .ok("INTERVAL '-' YEAR TO MONTH");
-    expr("INTERVAL '1' YEAR TO MONTH")
-        .ok("INTERVAL '1' YEAR TO MONTH");
-    expr("INTERVAL '1:2' YEAR TO MONTH")
-        .ok("INTERVAL '1:2' YEAR TO MONTH");
-    expr("INTERVAL '1.2' YEAR TO MONTH")
-        .ok("INTERVAL '1.2' YEAR TO MONTH");
-    expr("INTERVAL '1 2' YEAR TO MONTH")
-        .ok("INTERVAL '1 2' YEAR TO MONTH");
-    expr("INTERVAL '1:2' YEAR(2) TO MONTH")
-        .ok("INTERVAL '1:2' YEAR(2) TO MONTH");
-    expr("INTERVAL 'bogus text' YEAR TO MONTH")
-        .ok("INTERVAL 'bogus text' YEAR TO MONTH");
-
-    // negative field values
-    expr("INTERVAL '--1-2' YEAR TO MONTH")
-        .ok("INTERVAL '--1-2' YEAR TO MONTH");
-    expr("INTERVAL '1--2' YEAR TO MONTH")
-        .ok("INTERVAL '1--2' YEAR TO MONTH");
-
-    // Field value out of range
-    //  (default, explicit default, alt, neg alt, max, neg max)
-    //  plus >max value for mid/end fields
-    expr("INTERVAL '100-0' YEAR TO MONTH")
-        .ok("INTERVAL '100-0' YEAR TO MONTH");
-    expr("INTERVAL '100-0' YEAR(2) TO MONTH")
-        .ok("INTERVAL '100-0' YEAR(2) TO MONTH");
-    expr("INTERVAL '1000-0' YEAR(3) TO MONTH")
-        .ok("INTERVAL '1000-0' YEAR(3) TO MONTH");
-    expr("INTERVAL '-1000-0' YEAR(3) TO MONTH")
-        .ok("INTERVAL '-1000-0' YEAR(3) TO MONTH");
-    expr("INTERVAL '2147483648-0' YEAR(10) TO MONTH")
-        .ok("INTERVAL '2147483648-0' YEAR(10) TO MONTH");
-    expr("INTERVAL '-2147483648-0' YEAR(10) TO MONTH")
-        .ok("INTERVAL '-2147483648-0' YEAR(10) TO MONTH");
-    expr("INTERVAL '1-12' YEAR TO MONTH")
-        .ok("INTERVAL '1-12' YEAR TO MONTH");
-
-    // precision > maximum
-    expr("INTERVAL '1-1' YEAR(11) TO MONTH")
-        .ok("INTERVAL '1-1' YEAR(11) TO MONTH");
-
-    // precision < minimum allowed)
-    // note: parser will catch negative values, here we
-    // just need to check for 0
-    expr("INTERVAL '0-0' YEAR(0) TO MONTH")
-        .ok("INTERVAL '0-0' YEAR(0) TO MONTH");
-  }
-
-  /**
-   * Runs tests for INTERVAL... MONTH that should pass parser but fail
-   * validator. A substantially identical set of tests exists in
-   * SqlValidatorTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXFailsValidation() tests.
-   */
-  public void subTestIntervalMonthFailsValidation() {
-    // Qualifier - field mismatches
-    expr("INTERVAL '-' MONTH")
-        .ok("INTERVAL '-' MONTH");
-    expr("INTERVAL '1-2' MONTH")
-        .ok("INTERVAL '1-2' MONTH");
-    expr("INTERVAL '1.2' MONTH")
-        .ok("INTERVAL '1.2' MONTH");
-    expr("INTERVAL '1 2' MONTH")
-        .ok("INTERVAL '1 2' MONTH");
-    expr("INTERVAL '1-2' MONTH(2)")
-        .ok("INTERVAL '1-2' MONTH(2)");
-    expr("INTERVAL 'bogus text' MONTH")
-        .ok("INTERVAL 'bogus text' MONTH");
-
-    // negative field values
-    expr("INTERVAL '--1' MONTH")
-        .ok("INTERVAL '--1' MONTH");
-
-    // Field value out of range
-    //  (default, explicit default, alt, neg alt, max, neg max)
-    expr("INTERVAL '100' MONTH")
-        .ok("INTERVAL '100' MONTH");
-    expr("INTERVAL '100' MONTH(2)")
-        .ok("INTERVAL '100' MONTH(2)");
-    expr("INTERVAL '1000' MONTH(3)")
-        .ok("INTERVAL '1000' MONTH(3)");
-    expr("INTERVAL '-1000' MONTH(3)")
-        .ok("INTERVAL '-1000' MONTH(3)");
-    expr("INTERVAL '2147483648' MONTH(10)")
-        .ok("INTERVAL '2147483648' MONTH(10)");
-    expr("INTERVAL '-2147483648' MONTH(10)")
-        .ok("INTERVAL '-2147483648' MONTH(10)");
-
-    // precision > maximum
-    expr("INTERVAL '1' MONTH(11)")
-        .ok("INTERVAL '1' MONTH(11)");
-
-    // precision < minimum allowed)
-    // note: parser will catch negative values, here we
-    // just need to check for 0
-    expr("INTERVAL '0' MONTH(0)")
-        .ok("INTERVAL '0' MONTH(0)");
-  }
-
-  /**
-   * Runs tests for INTERVAL... DAY that should pass parser but fail
-   * validator. A substantially identical set of tests exists in
-   * SqlValidatorTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXFailsValidation() tests.
-   */
-  public void subTestIntervalDayFailsValidation() {
-    // Qualifier - field mismatches
-    expr("INTERVAL '-' DAY")
-        .ok("INTERVAL '-' DAY");
-    expr("INTERVAL '1-2' DAY")
-        .ok("INTERVAL '1-2' DAY");
-    expr("INTERVAL '1.2' DAY")
-        .ok("INTERVAL '1.2' DAY");
-    expr("INTERVAL '1 2' DAY")
-        .ok("INTERVAL '1 2' DAY");
-    expr("INTERVAL '1:2' DAY")
-        .ok("INTERVAL '1:2' DAY");
-    expr("INTERVAL '1-2' DAY(2)")
-        .ok("INTERVAL '1-2' DAY(2)");
-    expr("INTERVAL 'bogus text' DAY")
-        .ok("INTERVAL 'bogus text' DAY");
-
-    // negative field values
-    expr("INTERVAL '--1' DAY")
-        .ok("INTERVAL '--1' DAY");
-
-    // Field value out of range
-    //  (default, explicit default, alt, neg alt, max, neg max)
-    expr("INTERVAL '100' DAY")
-        .ok("INTERVAL '100' DAY");
-    expr("INTERVAL '100' DAY(2)")
-        .ok("INTERVAL '100' DAY(2)");
-    expr("INTERVAL '1000' DAY(3)")
-        .ok("INTERVAL '1000' DAY(3)");
-    expr("INTERVAL '-1000' DAY(3)")
-        .ok("INTERVAL '-1000' DAY(3)");
-    expr("INTERVAL '2147483648' DAY(10)")
-        .ok("INTERVAL '2147483648' DAY(10)");
-    expr("INTERVAL '-2147483648' DAY(10)")
-        .ok("INTERVAL '-2147483648' DAY(10)");
-
-    // precision > maximum
-    expr("INTERVAL '1' DAY(11)")
-        .ok("INTERVAL '1' DAY(11)");
-
-    // precision < minimum allowed)
-    // note: parser will catch negative values, here we
-    // just need to check for 0
-    expr("INTERVAL '0' DAY(0)")
-        .ok("INTERVAL '0' DAY(0)");
-  }
-
   @Test void testVisitSqlInsertWithSqlShuttle() {
     final String sql = "insert into emps select * from emps";
     final SqlNode sqlNode = sql(sql).node();
@@ -6320,8 +5953,8 @@ public void subTestIntervalDayFailsValidation() {
       }
     });
     final String str0 = "INSERT INTO `EMPS`\n"
-        + "(SELECT *\n"
-        + "FROM `EMPS`)";
+        + "SELECT *\n"
+        + "FROM `EMPS`";
     assertThat(str0, is(toLinux(sqlNodeVisited0.toString())));
 
     final String sql1 = "insert into emps select empno from emps";
@@ -6333,8 +5966,8 @@ public void subTestIntervalDayFailsValidation() {
       }
     });
     final String str1 = "INSERT INTO `EMPS`\n"
-        + "(SELECT `EMPNO`\n"
-        + "FROM `EMPS`)";
+        + "SELECT `EMPNO`\n"
+        + "FROM `EMPS`";
     assertThat(str1, is(toLinux(sqlNodeVisited1.toString())));
   }
 
@@ -6357,646 +5990,6 @@ public void subTestIntervalDayFailsValidation() {
     assertNotSame(sqlNodeVisited, sqlNode);
   }
 
-  /**
-   * Runs tests for INTERVAL... DAY TO HOUR that should pass parser but fail
-   * validator. A substantially identical set of tests exists in
-   * SqlValidatorTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXFailsValidation() tests.
-   */
-  public void subTestIntervalDayToHourFailsValidation() {
-    // Qualifier - field mismatches
-    expr("INTERVAL '-' DAY TO HOUR")
-        .ok("INTERVAL '-' DAY TO HOUR");
-    expr("INTERVAL '1' DAY TO HOUR")
-        .ok("INTERVAL '1' DAY TO HOUR");
-    expr("INTERVAL '1:2' DAY TO HOUR")
-        .ok("INTERVAL '1:2' DAY TO HOUR");
-    expr("INTERVAL '1.2' DAY TO HOUR")
-        .ok("INTERVAL '1.2' DAY TO HOUR");
-    expr("INTERVAL '1 x' DAY TO HOUR")
-        .ok("INTERVAL '1 x' DAY TO HOUR");
-    expr("INTERVAL ' ' DAY TO HOUR")
-        .ok("INTERVAL ' ' DAY TO HOUR");
-    expr("INTERVAL '1:2' DAY(2) TO HOUR")
-        .ok("INTERVAL '1:2' DAY(2) TO HOUR");
-    expr("INTERVAL 'bogus text' DAY TO HOUR")
-        .ok("INTERVAL 'bogus text' DAY TO HOUR");
-
-    // negative field values
-    expr("INTERVAL '--1 1' DAY TO HOUR")
-        .ok("INTERVAL '--1 1' DAY TO HOUR");
-    expr("INTERVAL '1 -1' DAY TO HOUR")
-        .ok("INTERVAL '1 -1' DAY TO HOUR");
-
-    // Field value out of range
-    //  (default, explicit default, alt, neg alt, max, neg max)
-    //  plus >max value for mid/end fields
-    expr("INTERVAL '100 0' DAY TO HOUR")
-        .ok("INTERVAL '100 0' DAY TO HOUR");
-    expr("INTERVAL '100 0' DAY(2) TO HOUR")
-        .ok("INTERVAL '100 0' DAY(2) TO HOUR");
-    expr("INTERVAL '1000 0' DAY(3) TO HOUR")
-        .ok("INTERVAL '1000 0' DAY(3) TO HOUR");
-    expr("INTERVAL '-1000 0' DAY(3) TO HOUR")
-        .ok("INTERVAL '-1000 0' DAY(3) TO HOUR");
-    expr("INTERVAL '2147483648 0' DAY(10) TO HOUR")
-        .ok("INTERVAL '2147483648 0' DAY(10) TO HOUR");
-    expr("INTERVAL '-2147483648 0' DAY(10) TO HOUR")
-        .ok("INTERVAL '-2147483648 0' DAY(10) TO HOUR");
-    expr("INTERVAL '1 24' DAY TO HOUR")
-        .ok("INTERVAL '1 24' DAY TO HOUR");
-
-    // precision > maximum
-    expr("INTERVAL '1 1' DAY(11) TO HOUR")
-        .ok("INTERVAL '1 1' DAY(11) TO HOUR");
-
-    // precision < minimum allowed)
-    // note: parser will catch negative values, here we
-    // just need to check for 0
-    expr("INTERVAL '0 0' DAY(0) TO HOUR")
-        .ok("INTERVAL '0 0' DAY(0) TO HOUR");
-  }
-
-  /**
-   * Runs tests for INTERVAL... DAY TO MINUTE that should pass parser but fail
-   * validator. A substantially identical set of tests exists in
-   * SqlValidatorTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXFailsValidation() tests.
-   */
-  public void subTestIntervalDayToMinuteFailsValidation() {
-    // Qualifier - field mismatches
-    expr("INTERVAL ' :' DAY TO MINUTE")
-        .ok("INTERVAL ' :' DAY TO MINUTE");
-    expr("INTERVAL '1' DAY TO MINUTE")
-        .ok("INTERVAL '1' DAY TO MINUTE");
-    expr("INTERVAL '1 2' DAY TO MINUTE")
-        .ok("INTERVAL '1 2' DAY TO MINUTE");
-    expr("INTERVAL '1:2' DAY TO MINUTE")
-        .ok("INTERVAL '1:2' DAY TO MINUTE");
-    expr("INTERVAL '1.2' DAY TO MINUTE")
-        .ok("INTERVAL '1.2' DAY TO MINUTE");
-    expr("INTERVAL 'x 1:1' DAY TO MINUTE")
-        .ok("INTERVAL 'x 1:1' DAY TO MINUTE");
-    expr("INTERVAL '1 x:1' DAY TO MINUTE")
-        .ok("INTERVAL '1 x:1' DAY TO MINUTE");
-    expr("INTERVAL '1 1:x' DAY TO MINUTE")
-        .ok("INTERVAL '1 1:x' DAY TO MINUTE");
-    expr("INTERVAL '1 1:2:3' DAY TO MINUTE")
-        .ok("INTERVAL '1 1:2:3' DAY TO MINUTE");
-    expr("INTERVAL '1 1:1:1.2' DAY TO MINUTE")
-        .ok("INTERVAL '1 1:1:1.2' DAY TO MINUTE");
-    expr("INTERVAL '1 1:2:3' DAY(2) TO MINUTE")
-        .ok("INTERVAL '1 1:2:3' DAY(2) TO MINUTE");
-    expr("INTERVAL '1 1' DAY(2) TO MINUTE")
-        .ok("INTERVAL '1 1' DAY(2) TO MINUTE");
-    expr("INTERVAL 'bogus text' DAY TO MINUTE")
-        .ok("INTERVAL 'bogus text' DAY TO MINUTE");
-
-    // negative field values
-    expr("INTERVAL '--1 1:1' DAY TO MINUTE")
-        .ok("INTERVAL '--1 1:1' DAY TO MINUTE");
-    expr("INTERVAL '1 -1:1' DAY TO MINUTE")
-        .ok("INTERVAL '1 -1:1' DAY TO MINUTE");
-    expr("INTERVAL '1 1:-1' DAY TO MINUTE")
-        .ok("INTERVAL '1 1:-1' DAY TO MINUTE");
-
-    // Field value out of range
-    //  (default, explicit default, alt, neg alt, max, neg max)
-    //  plus >max value for mid/end fields
-    expr("INTERVAL '100 0' DAY TO MINUTE")
-        .ok("INTERVAL '100 0' DAY TO MINUTE");
-    expr("INTERVAL '100 0' DAY(2) TO MINUTE")
-        .ok("INTERVAL '100 0' DAY(2) TO MINUTE");
-    expr("INTERVAL '1000 0' DAY(3) TO MINUTE")
-        .ok("INTERVAL '1000 0' DAY(3) TO MINUTE");
-    expr("INTERVAL '-1000 0' DAY(3) TO MINUTE")
-        .ok("INTERVAL '-1000 0' DAY(3) TO MINUTE");
-    expr("INTERVAL '2147483648 0' DAY(10) TO MINUTE")
-        .ok("INTERVAL '2147483648 0' DAY(10) TO MINUTE");
-    expr("INTERVAL '-2147483648 0' DAY(10) TO MINUTE")
-        .ok("INTERVAL '-2147483648 0' DAY(10) TO MINUTE");
-    expr("INTERVAL '1 24:1' DAY TO MINUTE")
-        .ok("INTERVAL '1 24:1' DAY TO MINUTE");
-    expr("INTERVAL '1 1:60' DAY TO MINUTE")
-        .ok("INTERVAL '1 1:60' DAY TO MINUTE");
-
-    // precision > maximum
-    expr("INTERVAL '1 1' DAY(11) TO MINUTE")
-        .ok("INTERVAL '1 1' DAY(11) TO MINUTE");
-
-    // precision < minimum allowed)
-    // note: parser will catch negative values, here we
-    // just need to check for 0
-    expr("INTERVAL '0 0' DAY(0) TO MINUTE")
-        .ok("INTERVAL '0 0' DAY(0) TO MINUTE");
-  }
-
-  /**
-   * Runs tests for INTERVAL... DAY TO SECOND that should pass parser but fail
-   * validator. A substantially identical set of tests exists in
-   * SqlValidatorTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXFailsValidation() tests.
-   */
-  public void subTestIntervalDayToSecondFailsValidation() {
-    // Qualifier - field mismatches
-    expr("INTERVAL ' ::' DAY TO SECOND")
-        .ok("INTERVAL ' ::' DAY TO SECOND");
-    expr("INTERVAL ' ::.' DAY TO SECOND")
-        .ok("INTERVAL ' ::.' DAY TO SECOND");
-    expr("INTERVAL '1' DAY TO SECOND")
-        .ok("INTERVAL '1' DAY TO SECOND");
-    expr("INTERVAL '1 2' DAY TO SECOND")
-        .ok("INTERVAL '1 2' DAY TO SECOND");
-    expr("INTERVAL '1:2' DAY TO SECOND")
-        .ok("INTERVAL '1:2' DAY TO SECOND");
-    expr("INTERVAL '1.2' DAY TO SECOND")
-        .ok("INTERVAL '1.2' DAY TO SECOND");
-    expr("INTERVAL '1 1:2' DAY TO SECOND")
-        .ok("INTERVAL '1 1:2' DAY TO SECOND");
-    expr("INTERVAL '1 1:2:x' DAY TO SECOND")
-        .ok("INTERVAL '1 1:2:x' DAY TO SECOND");
-    expr("INTERVAL '1:2:3' DAY TO SECOND")
-        .ok("INTERVAL '1:2:3' DAY TO SECOND");
-    expr("INTERVAL '1:1:1.2' DAY TO SECOND")
-        .ok("INTERVAL '1:1:1.2' DAY TO SECOND");
-    expr("INTERVAL '1 1:2' DAY(2) TO SECOND")
-        .ok("INTERVAL '1 1:2' DAY(2) TO SECOND");
-    expr("INTERVAL '1 1' DAY(2) TO SECOND")
-        .ok("INTERVAL '1 1' DAY(2) TO SECOND");
-    expr("INTERVAL 'bogus text' DAY TO SECOND")
-        .ok("INTERVAL 'bogus text' DAY TO SECOND");
-    expr("INTERVAL '2345 6:7:8901' DAY TO SECOND(4)")
-        .ok("INTERVAL '2345 6:7:8901' DAY TO SECOND(4)");
-
-    // negative field values
-    expr("INTERVAL '--1 1:1:1' DAY TO SECOND")
-        .ok("INTERVAL '--1 1:1:1' DAY TO SECOND");
-    expr("INTERVAL '1 -1:1:1' DAY TO SECOND")
-        .ok("INTERVAL '1 -1:1:1' DAY TO SECOND");
-    expr("INTERVAL '1 1:-1:1' DAY TO SECOND")
-        .ok("INTERVAL '1 1:-1:1' DAY TO SECOND");
-    expr("INTERVAL '1 1:1:-1' DAY TO SECOND")
-        .ok("INTERVAL '1 1:1:-1' DAY TO SECOND");
-    expr("INTERVAL '1 1:1:1.-1' DAY TO SECOND")
-        .ok("INTERVAL '1 1:1:1.-1' DAY TO SECOND");
-
-    // Field value out of range
-    //  (default, explicit default, alt, neg alt, max, neg max)
-    //  plus >max value for mid/end fields
-    expr("INTERVAL '100 0' DAY TO SECOND")
-        .ok("INTERVAL '100 0' DAY TO SECOND");
-    expr("INTERVAL '100 0' DAY(2) TO SECOND")
-        .ok("INTERVAL '100 0' DAY(2) TO SECOND");
-    expr("INTERVAL '1000 0' DAY(3) TO SECOND")
-        .ok("INTERVAL '1000 0' DAY(3) TO SECOND");
-    expr("INTERVAL '-1000 0' DAY(3) TO SECOND")
-        .ok("INTERVAL '-1000 0' DAY(3) TO SECOND");
-    expr("INTERVAL '2147483648 0' DAY(10) TO SECOND")
-        .ok("INTERVAL '2147483648 0' DAY(10) TO SECOND");
-    expr("INTERVAL '-2147483648 0' DAY(10) TO SECOND")
-        .ok("INTERVAL '-2147483648 0' DAY(10) TO SECOND");
-    expr("INTERVAL '1 24:1:1' DAY TO SECOND")
-        .ok("INTERVAL '1 24:1:1' DAY TO SECOND");
-    expr("INTERVAL '1 1:60:1' DAY TO SECOND")
-        .ok("INTERVAL '1 1:60:1' DAY TO SECOND");
-    expr("INTERVAL '1 1:1:60' DAY TO SECOND")
-        .ok("INTERVAL '1 1:1:60' DAY TO SECOND");
-    expr("INTERVAL '1 1:1:1.0000001' DAY TO SECOND")
-        .ok("INTERVAL '1 1:1:1.0000001' DAY TO SECOND");
-    expr("INTERVAL '1 1:1:1.0001' DAY TO SECOND(3)")
-        .ok("INTERVAL '1 1:1:1.0001' DAY TO SECOND(3)");
-
-    // precision > maximum
-    expr("INTERVAL '1 1' DAY(11) TO SECOND")
-        .ok("INTERVAL '1 1' DAY(11) TO SECOND");
-    expr("INTERVAL '1 1' DAY TO SECOND(10)")
-        .ok("INTERVAL '1 1' DAY TO SECOND(10)");
-
-    // precision < minimum allowed)
-    // note: parser will catch negative values, here we
-    // just need to check for 0
-    expr("INTERVAL '0 0:0:0' DAY(0) TO SECOND")
-        .ok("INTERVAL '0 0:0:0' DAY(0) TO SECOND");
-    expr("INTERVAL '0 0:0:0' DAY TO SECOND(0)")
-        .ok("INTERVAL '0 0:0:0' DAY TO SECOND(0)");
-  }
-
-  /**
-   * Runs tests for INTERVAL... HOUR that should pass parser but fail
-   * validator. A substantially identical set of tests exists in
-   * SqlValidatorTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXFailsValidation() tests.
-   */
-  public void subTestIntervalHourFailsValidation() {
-    // Qualifier - field mismatches
-    expr("INTERVAL '-' HOUR")
-        .ok("INTERVAL '-' HOUR");
-    expr("INTERVAL '1-2' HOUR")
-        .ok("INTERVAL '1-2' HOUR");
-    expr("INTERVAL '1.2' HOUR")
-        .ok("INTERVAL '1.2' HOUR");
-    expr("INTERVAL '1 2' HOUR")
-        .ok("INTERVAL '1 2' HOUR");
-    expr("INTERVAL '1:2' HOUR")
-        .ok("INTERVAL '1:2' HOUR");
-    expr("INTERVAL '1-2' HOUR(2)")
-        .ok("INTERVAL '1-2' HOUR(2)");
-    expr("INTERVAL 'bogus text' HOUR")
-        .ok("INTERVAL 'bogus text' HOUR");
-
-    // negative field values
-    expr("INTERVAL '--1' HOUR")
-        .ok("INTERVAL '--1' HOUR");
-
-    // Field value out of range
-    //  (default, explicit default, alt, neg alt, max, neg max)
-    expr("INTERVAL '100' HOUR")
-        .ok("INTERVAL '100' HOUR");
-    expr("INTERVAL '100' HOUR(2)")
-        .ok("INTERVAL '100' HOUR(2)");
-    expr("INTERVAL '1000' HOUR(3)")
-        .ok("INTERVAL '1000' HOUR(3)");
-    expr("INTERVAL '-1000' HOUR(3)")
-        .ok("INTERVAL '-1000' HOUR(3)");
-    expr("INTERVAL '2147483648' HOUR(10)")
-        .ok("INTERVAL '2147483648' HOUR(10)");
-    expr("INTERVAL '-2147483648' HOUR(10)")
-        .ok("INTERVAL '-2147483648' HOUR(10)");
-
-    // negative field values
-    expr("INTERVAL '--1' HOUR")
-        .ok("INTERVAL '--1' HOUR");
-
-    // precision > maximum
-    expr("INTERVAL '1' HOUR(11)")
-        .ok("INTERVAL '1' HOUR(11)");
-
-    // precision < minimum allowed)
-    // note: parser will catch negative values, here we
-    // just need to check for 0
-    expr("INTERVAL '0' HOUR(0)")
-        .ok("INTERVAL '0' HOUR(0)");
-  }
-
-  /**
-   * Runs tests for INTERVAL... HOUR TO MINUTE that should pass parser but
-   * fail validator. A substantially identical set of tests exists in
-   * SqlValidatorTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXFailsValidation() tests.
-   */
-  public void subTestIntervalHourToMinuteFailsValidation() {
-    // Qualifier - field mismatches
-    expr("INTERVAL ':' HOUR TO MINUTE")
-        .ok("INTERVAL ':' HOUR TO MINUTE");
-    expr("INTERVAL '1' HOUR TO MINUTE")
-        .ok("INTERVAL '1' HOUR TO MINUTE");
-    expr("INTERVAL '1:x' HOUR TO MINUTE")
-        .ok("INTERVAL '1:x' HOUR TO MINUTE");
-    expr("INTERVAL '1.2' HOUR TO MINUTE")
-        .ok("INTERVAL '1.2' HOUR TO MINUTE");
-    expr("INTERVAL '1 2' HOUR TO MINUTE")
-        .ok("INTERVAL '1 2' HOUR TO MINUTE");
-    expr("INTERVAL '1:2:3' HOUR TO MINUTE")
-        .ok("INTERVAL '1:2:3' HOUR TO MINUTE");
-    expr("INTERVAL '1 2' HOUR(2) TO MINUTE")
-        .ok("INTERVAL '1 2' HOUR(2) TO MINUTE");
-    expr("INTERVAL 'bogus text' HOUR TO MINUTE")
-        .ok("INTERVAL 'bogus text' HOUR TO MINUTE");
-
-    // negative field values
-    expr("INTERVAL '--1:1' HOUR TO MINUTE")
-        .ok("INTERVAL '--1:1' HOUR TO MINUTE");
-    expr("INTERVAL '1:-1' HOUR TO MINUTE")
-        .ok("INTERVAL '1:-1' HOUR TO MINUTE");
-
-    // Field value out of range
-    //  (default, explicit default, alt, neg alt, max, neg max)
-    //  plus >max value for mid/end fields
-    expr("INTERVAL '100:0' HOUR TO MINUTE")
-        .ok("INTERVAL '100:0' HOUR TO MINUTE");
-    expr("INTERVAL '100:0' HOUR(2) TO MINUTE")
-        .ok("INTERVAL '100:0' HOUR(2) TO MINUTE");
-    expr("INTERVAL '1000:0' HOUR(3) TO MINUTE")
-        .ok("INTERVAL '1000:0' HOUR(3) TO MINUTE");
-    expr("INTERVAL '-1000:0' HOUR(3) TO MINUTE")
-        .ok("INTERVAL '-1000:0' HOUR(3) TO MINUTE");
-    expr("INTERVAL '2147483648:0' HOUR(10) TO MINUTE")
-        .ok("INTERVAL '2147483648:0' HOUR(10) TO MINUTE");
-    expr("INTERVAL '-2147483648:0' HOUR(10) TO MINUTE")
-        .ok("INTERVAL '-2147483648:0' HOUR(10) TO MINUTE");
-    expr("INTERVAL '1:24' HOUR TO MINUTE")
-        .ok("INTERVAL '1:24' HOUR TO MINUTE");
-
-    // precision > maximum
-    expr("INTERVAL '1:1' HOUR(11) TO MINUTE")
-        .ok("INTERVAL '1:1' HOUR(11) TO MINUTE");
-
-    // precision < minimum allowed)
-    // note: parser will catch negative values, here we
-    // just need to check for 0
-    expr("INTERVAL '0:0' HOUR(0) TO MINUTE")
-        .ok("INTERVAL '0:0' HOUR(0) TO MINUTE");
-  }
-
-  /**
-   * Runs tests for INTERVAL... HOUR TO SECOND that should pass parser but
-   * fail validator. A substantially identical set of tests exists in
-   * SqlValidatorTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXFailsValidation() tests.
-   */
-  public void subTestIntervalHourToSecondFailsValidation() {
-    // Qualifier - field mismatches
-    expr("INTERVAL '::' HOUR TO SECOND")
-        .ok("INTERVAL '::' HOUR TO SECOND");
-    expr("INTERVAL '::.' HOUR TO SECOND")
-        .ok("INTERVAL '::.' HOUR TO SECOND");
-    expr("INTERVAL '1' HOUR TO SECOND")
-        .ok("INTERVAL '1' HOUR TO SECOND");
-    expr("INTERVAL '1 2' HOUR TO SECOND")
-        .ok("INTERVAL '1 2' HOUR TO SECOND");
-    expr("INTERVAL '1:2' HOUR TO SECOND")
-        .ok("INTERVAL '1:2' HOUR TO SECOND");
-    expr("INTERVAL '1.2' HOUR TO SECOND")
-        .ok("INTERVAL '1.2' HOUR TO SECOND");
-    expr("INTERVAL '1 1:2' HOUR TO SECOND")
-        .ok("INTERVAL '1 1:2' HOUR TO SECOND");
-    expr("INTERVAL '1:2:x' HOUR TO SECOND")
-        .ok("INTERVAL '1:2:x' HOUR TO SECOND");
-    expr("INTERVAL '1:x:3' HOUR TO SECOND")
-        .ok("INTERVAL '1:x:3' HOUR TO SECOND");
-    expr("INTERVAL '1:1:1.x' HOUR TO SECOND")
-        .ok("INTERVAL '1:1:1.x' HOUR TO SECOND");
-    expr("INTERVAL '1 1:2' HOUR(2) TO SECOND")
-        .ok("INTERVAL '1 1:2' HOUR(2) TO SECOND");
-    expr("INTERVAL '1 1' HOUR(2) TO SECOND")
-        .ok("INTERVAL '1 1' HOUR(2) TO SECOND");
-    expr("INTERVAL 'bogus text' HOUR TO SECOND")
-        .ok("INTERVAL 'bogus text' HOUR TO SECOND");
-    expr("INTERVAL '6:7:8901' HOUR TO SECOND(4)")
-        .ok("INTERVAL '6:7:8901' HOUR TO SECOND(4)");
-
-    // negative field values
-    expr("INTERVAL '--1:1:1' HOUR TO SECOND")
-        .ok("INTERVAL '--1:1:1' HOUR TO SECOND");
-    expr("INTERVAL '1:-1:1' HOUR TO SECOND")
-        .ok("INTERVAL '1:-1:1' HOUR TO SECOND");
-    expr("INTERVAL '1:1:-1' HOUR TO SECOND")
-        .ok("INTERVAL '1:1:-1' HOUR TO SECOND");
-    expr("INTERVAL '1:1:1.-1' HOUR TO SECOND")
-        .ok("INTERVAL '1:1:1.-1' HOUR TO SECOND");
-
-    // Field value out of range
-    //  (default, explicit default, alt, neg alt, max, neg max)
-    //  plus >max value for mid/end fields
-    expr("INTERVAL '100:0:0' HOUR TO SECOND")
-        .ok("INTERVAL '100:0:0' HOUR TO SECOND");
-    expr("INTERVAL '100:0:0' HOUR(2) TO SECOND")
-        .ok("INTERVAL '100:0:0' HOUR(2) TO SECOND");
-    expr("INTERVAL '1000:0:0' HOUR(3) TO SECOND")
-        .ok("INTERVAL '1000:0:0' HOUR(3) TO SECOND");
-    expr("INTERVAL '-1000:0:0' HOUR(3) TO SECOND")
-        .ok("INTERVAL '-1000:0:0' HOUR(3) TO SECOND");
-    expr("INTERVAL '2147483648:0:0' HOUR(10) TO SECOND")
-        .ok("INTERVAL '2147483648:0:0' HOUR(10) TO SECOND");
-    expr("INTERVAL '-2147483648:0:0' HOUR(10) TO SECOND")
-        .ok("INTERVAL '-2147483648:0:0' HOUR(10) TO SECOND");
-    expr("INTERVAL '1:60:1' HOUR TO SECOND")
-        .ok("INTERVAL '1:60:1' HOUR TO SECOND");
-    expr("INTERVAL '1:1:60' HOUR TO SECOND")
-        .ok("INTERVAL '1:1:60' HOUR TO SECOND");
-    expr("INTERVAL '1:1:1.0000001' HOUR TO SECOND")
-        .ok("INTERVAL '1:1:1.0000001' HOUR TO SECOND");
-    expr("INTERVAL '1:1:1.0001' HOUR TO SECOND(3)")
-        .ok("INTERVAL '1:1:1.0001' HOUR TO SECOND(3)");
-
-    // precision > maximum
-    expr("INTERVAL '1:1:1' HOUR(11) TO SECOND")
-        .ok("INTERVAL '1:1:1' HOUR(11) TO SECOND");
-    expr("INTERVAL '1:1:1' HOUR TO SECOND(10)")
-        .ok("INTERVAL '1:1:1' HOUR TO SECOND(10)");
-
-    // precision < minimum allowed)
-    // note: parser will catch negative values, here we
-    // just need to check for 0
-    expr("INTERVAL '0:0:0' HOUR(0) TO SECOND")
-        .ok("INTERVAL '0:0:0' HOUR(0) TO SECOND");
-    expr("INTERVAL '0:0:0' HOUR TO SECOND(0)")
-        .ok("INTERVAL '0:0:0' HOUR TO SECOND(0)");
-  }
-
-  /**
-   * Runs tests for INTERVAL... MINUTE that should pass parser but fail
-   * validator. A substantially identical set of tests exists in
-   * SqlValidatorTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXFailsValidation() tests.
-   */
-  public void subTestIntervalMinuteFailsValidation() {
-    // Qualifier - field mismatches
-    expr("INTERVAL '-' MINUTE")
-        .ok("INTERVAL '-' MINUTE");
-    expr("INTERVAL '1-2' MINUTE")
-        .ok("INTERVAL '1-2' MINUTE");
-    expr("INTERVAL '1.2' MINUTE")
-        .ok("INTERVAL '1.2' MINUTE");
-    expr("INTERVAL '1 2' MINUTE")
-        .ok("INTERVAL '1 2' MINUTE");
-    expr("INTERVAL '1:2' MINUTE")
-        .ok("INTERVAL '1:2' MINUTE");
-    expr("INTERVAL '1-2' MINUTE(2)")
-        .ok("INTERVAL '1-2' MINUTE(2)");
-    expr("INTERVAL 'bogus text' MINUTE")
-        .ok("INTERVAL 'bogus text' MINUTE");
-
-    // negative field values
-    expr("INTERVAL '--1' MINUTE")
-        .ok("INTERVAL '--1' MINUTE");
-
-    // Field value out of range
-    //  (default, explicit default, alt, neg alt, max, neg max)
-    expr("INTERVAL '100' MINUTE")
-        .ok("INTERVAL '100' MINUTE");
-    expr("INTERVAL '100' MINUTE(2)")
-        .ok("INTERVAL '100' MINUTE(2)");
-    expr("INTERVAL '1000' MINUTE(3)")
-        .ok("INTERVAL '1000' MINUTE(3)");
-    expr("INTERVAL '-1000' MINUTE(3)")
-        .ok("INTERVAL '-1000' MINUTE(3)");
-    expr("INTERVAL '2147483648' MINUTE(10)")
-        .ok("INTERVAL '2147483648' MINUTE(10)");
-    expr("INTERVAL '-2147483648' MINUTE(10)")
-        .ok("INTERVAL '-2147483648' MINUTE(10)");
-
-    // precision > maximum
-    expr("INTERVAL '1' MINUTE(11)")
-        .ok("INTERVAL '1' MINUTE(11)");
-
-    // precision < minimum allowed)
-    // note: parser will catch negative values, here we
-    // just need to check for 0
-    expr("INTERVAL '0' MINUTE(0)")
-        .ok("INTERVAL '0' MINUTE(0)");
-  }
-
-  /**
-   * Runs tests for INTERVAL... MINUTE TO SECOND that should pass parser but
-   * fail validator. A substantially identical set of tests exists in
-   * SqlValidatorTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXFailsValidation() tests.
-   */
-  public void subTestIntervalMinuteToSecondFailsValidation() {
-    // Qualifier - field mismatches
-    expr("INTERVAL ':' MINUTE TO SECOND")
-        .ok("INTERVAL ':' MINUTE TO SECOND");
-    expr("INTERVAL ':.' MINUTE TO SECOND")
-        .ok("INTERVAL ':.' MINUTE TO SECOND");
-    expr("INTERVAL '1' MINUTE TO SECOND")
-        .ok("INTERVAL '1' MINUTE TO SECOND");
-    expr("INTERVAL '1 2' MINUTE TO SECOND")
-        .ok("INTERVAL '1 2' MINUTE TO SECOND");
-    expr("INTERVAL '1.2' MINUTE TO SECOND")
-        .ok("INTERVAL '1.2' MINUTE TO SECOND");
-    expr("INTERVAL '1 1:2' MINUTE TO SECOND")
-        .ok("INTERVAL '1 1:2' MINUTE TO SECOND");
-    expr("INTERVAL '1:x' MINUTE TO SECOND")
-        .ok("INTERVAL '1:x' MINUTE TO SECOND");
-    expr("INTERVAL 'x:3' MINUTE TO SECOND")
-        .ok("INTERVAL 'x:3' MINUTE TO SECOND");
-    expr("INTERVAL '1:1.x' MINUTE TO SECOND")
-        .ok("INTERVAL '1:1.x' MINUTE TO SECOND");
-    expr("INTERVAL '1 1:2' MINUTE(2) TO SECOND")
-        .ok("INTERVAL '1 1:2' MINUTE(2) TO SECOND");
-    expr("INTERVAL '1 1' MINUTE(2) TO SECOND")
-        .ok("INTERVAL '1 1' MINUTE(2) TO SECOND");
-    expr("INTERVAL 'bogus text' MINUTE TO SECOND")
-        .ok("INTERVAL 'bogus text' MINUTE TO SECOND");
-    expr("INTERVAL '7:8901' MINUTE TO SECOND(4)")
-        .ok("INTERVAL '7:8901' MINUTE TO SECOND(4)");
-
-    // negative field values
-    expr("INTERVAL '--1:1' MINUTE TO SECOND")
-        .ok("INTERVAL '--1:1' MINUTE TO SECOND");
-    expr("INTERVAL '1:-1' MINUTE TO SECOND")
-        .ok("INTERVAL '1:-1' MINUTE TO SECOND");
-    expr("INTERVAL '1:1.-1' MINUTE TO SECOND")
-        .ok("INTERVAL '1:1.-1' MINUTE TO SECOND");
-
-    // Field value out of range
-    //  (default, explicit default, alt, neg alt, max, neg max)
-    //  plus >max value for mid/end fields
-    expr("INTERVAL '100:0' MINUTE TO SECOND")
-        .ok("INTERVAL '100:0' MINUTE TO SECOND");
-    expr("INTERVAL '100:0' MINUTE(2) TO SECOND")
-        .ok("INTERVAL '100:0' MINUTE(2) TO SECOND");
-    expr("INTERVAL '1000:0' MINUTE(3) TO SECOND")
-        .ok("INTERVAL '1000:0' MINUTE(3) TO SECOND");
-    expr("INTERVAL '-1000:0' MINUTE(3) TO SECOND")
-        .ok("INTERVAL '-1000:0' MINUTE(3) TO SECOND");
-    expr("INTERVAL '2147483648:0' MINUTE(10) TO SECOND")
-        .ok("INTERVAL '2147483648:0' MINUTE(10) TO SECOND");
-    expr("INTERVAL '-2147483648:0' MINUTE(10) TO SECOND")
-        .ok("INTERVAL '-2147483648:0' MINUTE(10) TO SECOND");
-    expr("INTERVAL '1:60' MINUTE TO SECOND")
-        .ok("INTERVAL '1:60' MINUTE TO SECOND");
-    expr("INTERVAL '1:1.0000001' MINUTE TO SECOND")
-        .ok("INTERVAL '1:1.0000001' MINUTE TO SECOND");
-    expr("INTERVAL '1:1:1.0001' MINUTE TO SECOND(3)")
-        .ok("INTERVAL '1:1:1.0001' MINUTE TO SECOND(3)");
-
-    // precision > maximum
-    expr("INTERVAL '1:1' MINUTE(11) TO SECOND")
-        .ok("INTERVAL '1:1' MINUTE(11) TO SECOND");
-    expr("INTERVAL '1:1' MINUTE TO SECOND(10)")
-        .ok("INTERVAL '1:1' MINUTE TO SECOND(10)");
-
-    // precision < minimum allowed)
-    // note: parser will catch negative values, here we
-    // just need to check for 0
-    expr("INTERVAL '0:0' MINUTE(0) TO SECOND")
-        .ok("INTERVAL '0:0' MINUTE(0) TO SECOND");
-    expr("INTERVAL '0:0' MINUTE TO SECOND(0)")
-        .ok("INTERVAL '0:0' MINUTE TO SECOND(0)");
-  }
-
-  /**
-   * Runs tests for INTERVAL... SECOND that should pass parser but fail
-   * validator. A substantially identical set of tests exists in
-   * SqlValidatorTest, and any changes here should be synchronized there.
-   * Similarly, any changes to tests here should be echoed appropriately to
-   * each of the other 12 subTestIntervalXXXFailsValidation() tests.
-   */
-  public void subTestIntervalSecondFailsValidation() {
-    // Qualifier - field mismatches
-    expr("INTERVAL ':' SECOND")
-        .ok("INTERVAL ':' SECOND");
-    expr("INTERVAL '.' SECOND")
-        .ok("INTERVAL '.' SECOND");
-    expr("INTERVAL '1-2' SECOND")
-        .ok("INTERVAL '1-2' SECOND");
-    expr("INTERVAL '1.x' SECOND")
-        .ok("INTERVAL '1.x' SECOND");
-    expr("INTERVAL 'x.1' SECOND")
-        .ok("INTERVAL 'x.1' SECOND");
-    expr("INTERVAL '1 2' SECOND")
-        .ok("INTERVAL '1 2' SECOND");
-    expr("INTERVAL '1:2' SECOND")
-        .ok("INTERVAL '1:2' SECOND");
-    expr("INTERVAL '1-2' SECOND(2)")
-        .ok("INTERVAL '1-2' SECOND(2)");
-    expr("INTERVAL 'bogus text' SECOND")
-        .ok("INTERVAL 'bogus text' SECOND");
-
-    // negative field values
-    expr("INTERVAL '--1' SECOND")
-        .ok("INTERVAL '--1' SECOND");
-    expr("INTERVAL '1.-1' SECOND")
-        .ok("INTERVAL '1.-1' SECOND");
-
-    // Field value out of range
-    //  (default, explicit default, alt, neg alt, max, neg max)
-    expr("INTERVAL '100' SECOND")
-        .ok("INTERVAL '100' SECOND");
-    expr("INTERVAL '100' SECOND(2)")
-        .ok("INTERVAL '100' SECOND(2)");
-    expr("INTERVAL '1000' SECOND(3)")
-        .ok("INTERVAL '1000' SECOND(3)");
-    expr("INTERVAL '-1000' SECOND(3)")
-        .ok("INTERVAL '-1000' SECOND(3)");
-    expr("INTERVAL '2147483648' SECOND(10)")
-        .ok("INTERVAL '2147483648' SECOND(10)");
-    expr("INTERVAL '-2147483648' SECOND(10)")
-        .ok("INTERVAL '-2147483648' SECOND(10)");
-    expr("INTERVAL '1.0000001' SECOND")
-        .ok("INTERVAL '1.0000001' SECOND");
-    expr("INTERVAL '1.0000001' SECOND(2)")
-        .ok("INTERVAL '1.0000001' SECOND(2)");
-    expr("INTERVAL '1.0001' SECOND(2, 3)")
-        .ok("INTERVAL '1.0001' SECOND(2, 3)");
-    expr("INTERVAL '1.000000001' SECOND(2, 9)")
-        .ok("INTERVAL '1.000000001' SECOND(2, 9)");
-
-    // precision > maximum
-    expr("INTERVAL '1' SECOND(11)")
-        .ok("INTERVAL '1' SECOND(11)");
-    expr("INTERVAL '1.1' SECOND(1, 10)")
-        .ok("INTERVAL '1.1' SECOND(1, 10)");
-
-    // precision < minimum allowed)
-    // note: parser will catch negative values, here we
-    // just need to check for 0
-    expr("INTERVAL '0' SECOND(0)")
-        .ok("INTERVAL '0' SECOND(0)");
-    expr("INTERVAL '0' SECOND(1, 0)")
-        .ok("INTERVAL '0' SECOND(1, 0)");
-  }
-
   /**
    * Runs tests for each of the thirteen different main types of INTERVAL
    * qualifiers (YEAR, YEAR TO MONTH, etc.) Tests in this section fall into
@@ -7012,33 +6005,37 @@ public void subTestIntervalSecondFailsValidation() {
    * any changes here should be synchronized there.
    */
   @Test void testIntervalLiterals() {
-    subTestIntervalYearPositive();
-    subTestIntervalYearToMonthPositive();
-    subTestIntervalMonthPositive();
-    subTestIntervalDayPositive();
-    subTestIntervalDayToHourPositive();
-    subTestIntervalDayToMinutePositive();
-    subTestIntervalDayToSecondPositive();
-    subTestIntervalHourPositive();
-    subTestIntervalHourToMinutePositive();
-    subTestIntervalHourToSecondPositive();
-    subTestIntervalMinutePositive();
-    subTestIntervalMinuteToSecondPositive();
-    subTestIntervalSecondPositive();
-
-    subTestIntervalYearFailsValidation();
-    subTestIntervalYearToMonthFailsValidation();
-    subTestIntervalMonthFailsValidation();
-    subTestIntervalDayFailsValidation();
-    subTestIntervalDayToHourFailsValidation();
-    subTestIntervalDayToMinuteFailsValidation();
-    subTestIntervalDayToSecondFailsValidation();
-    subTestIntervalHourFailsValidation();
-    subTestIntervalHourToMinuteFailsValidation();
-    subTestIntervalHourToSecondFailsValidation();
-    subTestIntervalMinuteFailsValidation();
-    subTestIntervalMinuteToSecondFailsValidation();
-    subTestIntervalSecondFailsValidation();
+    final SqlParserFixture f = fixture();
+    final IntervalTest.Fixture intervalFixture = new IntervalTest.Fixture() {
+      @Override public IntervalTest.Fixture2 expr(String sql) {
+        final SqlParserFixture f2 = f.sql(sql).expression(true);
+        return getFixture2(f2, f2.sap.sql);
+      }
+
+      @Override public IntervalTest.Fixture2 wholeExpr(String sql) {
+        return expr(sql);
+      }
+
+      private IntervalTest.Fixture2 getFixture2(SqlParserFixture f2,
+          String expectedSql) {
+        return new IntervalTest.Fixture2() {
+          @Override public void fails(String message) {
+            f2.compare(expectedSql);
+          }
+
+          @Override public void columnType(String expectedType) {
+            f2.compare(expectedSql);
+          }
+
+          @Override public IntervalTest.Fixture2 assertParse(
+              String expectedSql) {
+            return getFixture2(f2, expectedSql);
+          }
+        };
+      }
+    };
+
+    new IntervalTest(intervalFixture).testAll();
   }
 
   @Test void testUnparseableIntervalQualifiers() {
@@ -7054,8 +6051,12 @@ public void subTestIntervalSecondFailsValidation() {
             + "    \"MINUTES\" \\.\\.\\.\n"
             + "    \"MONTH\" \\.\\.\\.\n"
             + "    \"MONTHS\" \\.\\.\\.\n"
+            + "    \"QUARTER\" \\.\\.\\.\n"
+            + "    \"QUARTERS\" \\.\\.\\.\n"
             + "    \"SECOND\" \\.\\.\\.\n"
             + "    \"SECONDS\" \\.\\.\\.\n"
+            + "    \"WEEK\" \\.\\.\\.\n"
+            + "    \"WEEKS\" \\.\\.\\.\n"
             + "    \"YEAR\" \\.\\.\\.\n"
             + "    \"YEARS\" \\.\\.\\.\n"
             + "    ");
@@ -7420,8 +6421,6 @@ public void subTestIntervalSecondFailsValidation() {
         .fails(ANY);
     expr("INTERVAL '10' ^DECADE^")
         .fails(ANY);
-    expr("INTERVAL '4' ^QUARTER^")
-        .fails(ANY);
   }
 
   /** Tests that plural time units are allowed when not in strict mode. */
@@ -7566,6 +6565,47 @@ private static Consumer<List<? extends Throwable>> checkWarnings(
         .fails("(?s)Encountered \"to\".*");
   }
 
+  /** Tests that EXTRACT, FLOOR, CEIL, DATE_TRUNC functions accept abbreviations for
+   * time units (such as "Y" for "YEAR") when configured via
+   * {@link Config#timeUnitCodes()}. */
+  @Test protected void testTimeUnitCodes() {
+    // YEAR is a built-in time frame. When unparsed, it looks like a keyword.
+    // (Note no backticks around YEAR.)
+    expr("floor(d to year)")
+        .ok("FLOOR(`D` TO YEAR)");
+    // Y is an extension time frame. (Or rather, it could be, if you configure
+    // it.) When unparsed, it looks like an identifier (backticks around Y.)
+    expr("floor(d to y)")
+        .ok("FLOOR(`D` TO `Y`)");
+
+    // As for FLOOR, so for CEIL.
+    expr("ceil(d to year)").ok("CEIL(`D` TO YEAR)");
+    expr("ceil(d to y)").ok("CEIL(`D` TO `Y`)");
+
+    // CEILING is a synonym for CEIL.
+    expr("ceiling(d to year)").ok("CEIL(`D` TO YEAR)");
+    expr("ceiling(d to y)").ok("CEIL(`D` TO `Y`)");
+
+    // As for FLOOR, so for EXTRACT.
+    expr("extract(year from d)").ok("EXTRACT(YEAR FROM `D`)");
+    expr("extract(y from d)").ok("EXTRACT(`Y` FROM `D`)");
+
+    // MICROSECOND, NANOSECOND used to be native for EXTRACT but not for FLOOR
+    // or CEIL. Now they are native, and so appear as keywords, without
+    // backticks.
+    expr("floor(d to nanosecond)").ok("FLOOR(`D` TO NANOSECOND)");
+    expr("floor(d to microsecond)").ok("FLOOR(`D` TO MICROSECOND)");
+    expr("ceil(d to nanosecond)").ok("CEIL(`D` TO NANOSECOND)");
+    expr("ceiling(d to microsecond)").ok("CEIL(`D` TO MICROSECOND)");
+    expr("extract(nanosecond from d)").ok("EXTRACT(NANOSECOND FROM `D`)");
+    expr("extract(microsecond from d)").ok("EXTRACT(MICROSECOND FROM `D`)");
+
+    // As for FLOOR, so for DATE_TRUNC.
+    expr("date_trunc(d , year)").ok("DATE_TRUNC(`D`, YEAR)");
+    expr("date_trunc(d , y)").ok("DATE_TRUNC(`D`, `Y`)");
+    expr("date_trunc(d , week(tuesday))").ok("DATE_TRUNC(`D`, `WEEK_TUESDAY`)");
+  }
+
   @Test void testGeometry() {
     expr("cast(null as ^geometry^)")
         .fails("Geo-spatial extensions and the GEOMETRY data type are not enabled");
@@ -7657,58 +6697,85 @@ private static Consumer<List<? extends Throwable>> checkWarnings(
         .ok("CAST(`X` AS VARBINARY)");
   }
 
-  @Test void testTimestampAddAndDiff() {
-    Map<String, List<String>> tsi = ImmutableMap.<String, List<String>>builder()
-        .put("MICROSECOND",
-            Arrays.asList("FRAC_SECOND", "MICROSECOND", "SQL_TSI_MICROSECOND"))
-        .put("NANOSECOND", Arrays.asList("NANOSECOND", "SQL_TSI_FRAC_SECOND"))
-        .put("SECOND", Arrays.asList("SECOND", "SQL_TSI_SECOND"))
-        .put("MINUTE", Arrays.asList("MINUTE", "SQL_TSI_MINUTE"))
-        .put("HOUR", Arrays.asList("HOUR", "SQL_TSI_HOUR"))
-        .put("DAY", Arrays.asList("DAY", "SQL_TSI_DAY"))
-        .put("WEEK", Arrays.asList("WEEK", "SQL_TSI_WEEK"))
-        .put("MONTH", Arrays.asList("MONTH", "SQL_TSI_MONTH"))
-        .put("QUARTER", Arrays.asList("QUARTER", "SQL_TSI_QUARTER"))
-        .put("YEAR", Arrays.asList("YEAR", "SQL_TSI_YEAR"))
-        .build();
-
-    List<String> functions = ImmutableList.<String>builder()
-        .add("timestampadd(%1$s, 12, current_timestamp)")
-        .add("timestampdiff(%1$s, current_timestamp, current_timestamp)")
-        .build();
-
-    for (Map.Entry<String, List<String>> intervalGroup : tsi.entrySet()) {
-      for (String function : functions) {
-        for (String interval : intervalGroup.getValue()) {
-          expr(String.format(Locale.ROOT, function, interval, ""))
-              .ok(String.format(Locale.ROOT, function, intervalGroup.getKey(), "`")
-                  .toUpperCase(Locale.ROOT));
-        }
-      }
-    }
-
-    expr("timestampadd(^incorrect^, 1, current_timestamp)")
-        .fails("(?s).*Was expecting one of.*");
-    expr("timestampdiff(^incorrect^, current_timestamp, current_timestamp)")
-        .fails("(?s).*Was expecting one of.*");
-  }
-
   @Test void testTimestampAdd() {
     final String sql = "select * from t\n"
-        + "where timestampadd(sql_tsi_month, 5, hiredate) < curdate";
+        + "where timestampadd(month, 5, hiredate) < curdate";
     final String expected = "SELECT *\n"
         + "FROM `T`\n"
         + "WHERE (TIMESTAMPADD(MONTH, 5, `HIREDATE`) < `CURDATE`)";
     sql(sql).ok(expected);
+
+    // SQL_TSI_MONTH is treated as a user-defined time frame, hence appears as
+    // an identifier (with backticks) when unparsed. It will be resolved to
+    // MICROSECOND during validation.
+    final String sql2 = "select * from t\n"
+        + "where timestampadd(sql_tsi_month, 5, hiredate) < curdate";
+    final String expected2 = "SELECT *\n"
+        + "FROM `T`\n"
+        + "WHERE (TIMESTAMPADD(`SQL_TSI_MONTH`, 5, `HIREDATE`) < `CURDATE`)";
+    sql(sql2).ok(expected2);
+
+    // Previously a parse error, now an identifier that the validator will find
+    // to be invalid.
+    expr("timestampadd(incorrect, 1, current_timestamp)")
+        .ok("TIMESTAMPADD(`INCORRECT`, 1, CURRENT_TIMESTAMP)");
   }
 
   @Test void testTimestampDiff() {
     final String sql = "select * from t\n"
-        + "where timestampdiff(frac_second, 5, hiredate) < curdate";
+        + "where timestampdiff(microsecond, 5, hiredate) < curdate";
     final String expected = "SELECT *\n"
         + "FROM `T`\n"
         + "WHERE (TIMESTAMPDIFF(MICROSECOND, 5, `HIREDATE`) < `CURDATE`)";
     sql(sql).ok(expected);
+
+    // FRAC_SECOND is treated as a user-defined time frame, hence appears as
+    // an identifier (with backticks) when unparsed. It will be resolved to
+    // MICROSECOND during validation.
+    final String sql2 = "select * from t\n"
+        + "where timestampdiff(frac_second, 5, hiredate) < curdate";
+    final String expected2 = "SELECT *\n"
+        + "FROM `T`\n"
+        + "WHERE (TIMESTAMPDIFF(`FRAC_SECOND`, 5, `HIREDATE`) < `CURDATE`)";
+    sql(sql2).ok(expected2);
+
+    // Previously a parse error, now an identifier that the validator will find
+    // to be invalid.
+    expr("timestampdiff(incorrect, current_timestamp, current_timestamp)")
+        .ok("TIMESTAMPDIFF(`INCORRECT`, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)");
+  }
+
+  @Test void testTimeTrunc() {
+    final String sql = "select time_trunc(TIME '15:30:00', hour) from t";
+    final String expected = "SELECT TIME_TRUNC(TIME '15:30:00', HOUR)\n"
+        + "FROM `T`";
+    sql(sql).ok(expected);
+
+    // Syntactically valid; validator will complain because WEEK is for DATE or
+    // TIMESTAMP but not for TIME.
+    final String sql2 = "select time_trunc(time '15:30:00', week) from t";
+    final String expected2 = "SELECT TIME_TRUNC(TIME '15:30:00', WEEK)\n"
+        + "FROM `T`";
+    sql(sql2).ok(expected2);
+
+    // note backticks
+    final String sql3 = "select time_trunc(time '15:30:00', incorrect) from t";
+    final String expected3 = "SELECT TIME_TRUNC(TIME '15:30:00', `INCORRECT`)\n"
+        + "FROM `T`";
+    sql(sql3).ok(expected3);
+  }
+
+  @Test void testTimestampTrunc() {
+    final String sql = "select timestamp_trunc(timestamp '2008-12-25 15:30:00', week) from t";
+    final String expected = "SELECT TIMESTAMP_TRUNC(TIMESTAMP '2008-12-25 15:30:00', WEEK)\n"
+        + "FROM `T`";
+    sql(sql).ok(expected);
+
+    // note backticks
+    final String sql3 = "select timestamp_trunc(time '15:30:00', incorrect) from t";
+    String expected3 = "SELECT TIMESTAMP_TRUNC(TIME '15:30:00', `INCORRECT`)\n"
+        + "FROM `T`";
+    sql(sql3).ok(expected3);
   }
 
   @Test void testUnnest() {
@@ -7770,28 +6837,226 @@ private static Consumer<List<? extends Throwable>> checkWarnings(
   @Test void testParensInFrom() {
     // UNNEST may not occur within parentheses.
     // FIXME should fail at "unnest"
-    sql("select *from ^(^unnest(x))")
-        .fails("(?s)Encountered \"\\( unnest\" at .*");
+    sql("select *from (^unnest(x)^)")
+        .fails("Expected query or join");
 
     // <table-name> may not occur within parentheses.
+    // TODO: Postgres gives "syntax error at ')'", which might be better
     sql("select * from (^emp^)")
-        .fails("(?s)Non-query expression encountered in illegal context.*");
+        .fails("(?s)Expected query or join.*");
 
     // <table-name> may not occur within parentheses.
-    sql("select * from (^emp^ as x)")
-        .fails("(?s)Non-query expression encountered in illegal context.*");
+    // TODO: Postgres gives "syntax error at ')'", which might be better
+    sql("select * from (^emp as x^)")
+        .fails("Expected query or join");
 
     // <table-name> may not occur within parentheses.
     sql("select * from (^emp^) as x")
-        .fails("(?s)Non-query expression encountered in illegal context.*");
+        .fails("Expected query or join");
 
     // Parentheses around JOINs are OK, and sometimes necessary.
-    if (false) {
-      // todo:
-      sql("select * from (emp join dept using (deptno))").ok("xx");
+    String sql1 = "select *\n"
+        + "from (emp join dept using (deptno))";
+    String expected = "SELECT *\n"
+        + "FROM `EMP`\n"
+        + "INNER JOIN `DEPT` USING (`DEPTNO`)";
+    sql(sql1).ok(expected);
 
-      sql("select * from (emp join dept using (deptno)) join foo using (x)").ok("xx");
-    }
+    String sql2 = "select *\n"
+        + "from (emp join dept using (deptno))\n"
+        + "join foo using (x)";
+    String expected2 = "SELECT *\n"
+        + "FROM `EMP`\n"
+        + "INNER JOIN `DEPT` USING (`DEPTNO`)\n"
+        + "INNER JOIN `FOO` USING (`X`)";
+    sql(sql2).ok(expected2);
+
+    // In Postgres and Standard SQL, you can alias a join:
+    //   "select x.i from (t cross join u) as x"
+    // is syntactically and semantically valid; but
+    //   "select t.i from (t cross join u) as x"
+    // is semantically invalid.
+    // TODO: Support this in Calcite.
+    sql("select * from (t cross ^join^ u) as x")
+        .fails("Join expression encountered in illegal context");
+    sql("select *\n"
+        + "from (t cross ^join^ u)\n"
+        + "  tablesample substitute('medium')")
+        .fails("Join expression encountered in illegal context");
+    sql("select *\n"
+        + "from (t cross ^join^ u)\n"
+        + "PIVOT (sum(sal) AS sal FOR job in ('CLERK' AS c))")
+        .fails("Join expression encountered in illegal context");
+  }
+
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-35">[CALCITE-35]
+   * Support parenthesized sub-clause in JOIN</a>. */
+  @Test void testParenthesizedJoins() {
+    final String sql = "SELECT * FROM "
+        + "(((S.C c INNER JOIN S.N n ON n.id = c.id) "
+        + "INNER JOIN S.A a ON (NOT a.isactive)) "
+        + "INNER JOIN S.T t ON t.id = a.id)";
+    final String expected = "SELECT *\n"
+        + "FROM `S`.`C` AS `C`\n"
+        + "INNER JOIN `S`.`N` AS `N` ON (`N`.`ID` = `C`.`ID`)\n"
+        + "INNER JOIN `S`.`A` AS `A` ON (NOT `A`.`ISACTIVE`)\n"
+        + "INNER JOIN `S`.`T` AS `T` ON (`T`.`ID` = `A`.`ID`)";
+    sql(sql).ok(expected);
+
+    final String sql2 = "select *\n"
+        + "from a\n"
+        + " join (b join c on b.x = c.x)\n"
+        + " on a.y = c.y";
+    final String expected2 = "SELECT *\n"
+        + "FROM `A`\n"
+        + "INNER JOIN (`B` INNER JOIN `C` ON (`B`.`X` = `C`.`X`))"
+        + " ON (`A`.`Y` = `C`.`Y`)";
+    sql(sql2).ok(expected2);
+  }
+
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5194">[CALCITE-5194]
+   * Cannot parse parenthesized UNION in FROM</a>. */
+  @Test void testParenthesizedUnionInFrom() {
+    final String sql = "select *\n"
+        + "from (\n"
+        + "  (select x from a)\n"
+        + "  union\n"
+        + "  (select y from b))";
+    final String expected = "SELECT *\n"
+        + "FROM (SELECT `X`\n"
+        + "FROM `A`\n"
+        + "UNION\n"
+        + "SELECT `Y`\n"
+        + "FROM `B`)";
+    sql(sql).ok(expected);
+  }
+
+  @Test void testParenthesizedUnionAndJoinInFrom() {
+    final String sql = "select *\n"
+        + "from (\n"
+        + "  (select x from a) as a"
+        + "  cross join\n"
+        + "  (select x from a\n"
+        + "  union\n"
+        + "  select y from b) as b)";
+    final String expected = "SELECT *\n"
+        + "FROM (SELECT `X`\n"
+        + "FROM `A`) AS `A`\n"
+        + "CROSS JOIN (SELECT `X`\n"
+        + "FROM `A`\n"
+        + "UNION\n"
+        + "SELECT `Y`\n"
+        + "FROM `B`) AS `B`";
+    sql(sql).ok(expected);
+  }
+
+  /** As {@link #testParenthesizedUnionAndJoinInFrom()}
+   * but the UNION is the first input to the JOIN. */
+  @Test void testParenthesizedUnionAndJoinInFrom2() {
+    final String sql = "select *\n"
+        + "from (\n"
+        + "  (select x from a\n"
+        + "  union\n"
+        + "  select y from b) as b\n"
+        + "  cross join\n"
+        + "  (select x from a) as a)";
+    final String expected = "SELECT *\n"
+        + "FROM (SELECT `X`\n"
+        + "FROM `A`\n"
+        + "UNION\n"
+        + "SELECT `Y`\n"
+        + "FROM `B`) AS `B`\n"
+        + "CROSS JOIN (SELECT `X`\n"
+        + "FROM `A`) AS `A`";
+    sql(sql).ok(expected);
+  }
+
+  /** As {@link #testParenthesizedUnionAndJoinInFrom2()}
+   * but INNER JOIN rather than CROSS JOIN. */
+  @Test void testParenthesizedUnionAndJoinInFrom3() {
+    final String sql = "select *\n"
+        + "from (\n"
+        + "  (select x from a\n"
+        + "  union\n"
+        + "  select y from b) as b\n"
+        + "  join\n"
+        + "  (select x from a) as a on b.x = a.x)";
+    final String expected = "SELECT *\n"
+        + "FROM (SELECT `X`\n"
+        + "FROM `A`\n"
+        + "UNION\n"
+        + "SELECT `Y`\n"
+        + "FROM `B`) AS `B`\n"
+        + "INNER JOIN (SELECT `X`\n"
+        + "FROM `A`) AS `A` ON (`B`.`X` = `A`.`X`)";
+    sql(sql).ok(expected);
+  }
+
+  @Test void testParenthesizedUnion() {
+    final String sql = "(select x from a\n"
+        + "  union\n"
+        + "  select y from b)\n"
+        + "except\n"
+        + "(select z from c)";
+    final String expected = "SELECT `X`\n"
+        + "FROM `A`\n"
+        + "UNION\n"
+        + "SELECT `Y`\n"
+        + "FROM `B`\n"
+        + "EXCEPT\n"
+        + "SELECT `Z`\n"
+        + "FROM `C`";
+    sql(sql).ok(expected);
+  }
+
+  @Test void testFromExpr() {
+    String sql0 = "select * from a cross join b";
+    String sql1 = "select * from (a cross join b)";
+    String expected = "SELECT *\n"
+        + "FROM `A`\n"
+        + "CROSS JOIN `B`";
+    sql(sql0).ok(expected);
+    sql(sql1).ok(expected);
+  }
+
+  /** Tests parsing parenthesized queries. */
+  @Test void testParenthesizedQueries() {
+    final String expected = "SELECT *\n"
+        + "FROM (SELECT *\n"
+        + "FROM `TAB`) AS `X`";
+    final String sql1 = "SELECT *\n"
+        + "FROM (((SELECT * FROM tab))) X";
+    final String sql2 = "SELECT *\n"
+        + "FROM ((((((((((((SELECT * FROM tab)))))))))))) X";
+    sql(sql1).ok(expected);
+    sql(sql2).ok(expected);
+
+    final String sql3 = "SELECT *\n"
+        + "FROM ((((((((((((SELECT * FROM t)))\n"
+        + "  cross join ((table t2)))))))))))";
+    final String expected3 = "SELECT *\n"
+        + "FROM (SELECT *\n"
+        + "FROM `T`)\n"
+        + "CROSS JOIN (TABLE `T2`)";
+    sql(sql3).ok(expected3);
+
+    // Adding an alias to the previous query makes it invalid
+    // (The error message and location could be improved)
+    final String sql4 = "SELECT *\n"
+        + "FROM ((((((((((((SELECT * FROM t)))\n"
+        + "  cross ^join^ ((table t2))))))))))) X";
+    final String sql5 = "SELECT *\n"
+        + "FROM ((((((((((((SELECT * FROM t)))\n"
+        + "  cross ^join^ ((table t2))))))))))) as X";
+    final String sql6 = "SELECT *\n"
+        + "FROM ((((((((((((SELECT * FROM t)))\n"
+        + "  cross ^join^ ((table t2))))))))))) as X (a, b, c)";
+    final String message = "Join expression encountered in illegal context";
+    sql(sql4).fails(message);
+    sql(sql5).fails(message);
+    sql(sql6).fails(message);
   }
 
   @Test void testProcedureCall() {
@@ -8186,6 +7451,18 @@ private static Consumer<List<? extends Throwable>> checkWarnings(
     sql(sql).ok(expected);
   }
 
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-4746">[CALCITE-4746]
+   * Pivots with pivotAgg without alias fail with Babel Parser Implementation</a>.*/
+  @Test void testPivotWithoutAlias() {
+    final String sql = "SELECT * FROM emp\n"
+        + "PIVOT (sum(sal) FOR job in ('CLERK'))";
+    final String expected = "SELECT *\n"
+        + "FROM `EMP` PIVOT (SUM(`SAL`)"
+        + " FOR `JOB` IN ('CLERK'))";
+    sql(sql).ok(expected);
+  }
+
   /** In PIVOT, FOR clause must contain only simple identifiers. */
   @Test void testPivotErrorExpressionInFor() {
     final String sql = "SELECT * FROM emp\n"
@@ -8243,6 +7520,28 @@ private static Consumer<List<? extends Throwable>> checkWarnings(
     sql(sql).ok(expected);
   }
 
+  @Test void testPivotThroughShuttle() {
+    final String sql = ""
+        + "SELECT *\n"
+        + "FROM (SELECT job, deptno FROM \"EMP\")\n"
+        + "PIVOT (COUNT(*) AS \"COUNT\" FOR deptno IN (10, 50, 20))";
+    final String expected = ""
+        + "SELECT *\n"
+        + "FROM (SELECT `JOB`, `DEPTNO`\n"
+        + "FROM `EMP`) PIVOT (COUNT(*) AS `COUNT` FOR `DEPTNO` IN (10, 50, 20))";
+    final SqlNode sqlNode = sql(sql).node();
+
+    final SqlNode shuttled = sqlNode.accept(new SqlShuttle() {
+      @Override public @Nullable SqlNode visit(final SqlCall call) {
+        // Handler always creates a new copy of 'call'
+        CallCopyingArgHandler argHandler = new CallCopyingArgHandler(call, true);
+        call.getOperator().acceptCall(this, call, false, argHandler);
+        return argHandler.result();
+      }
+    });
+    assertThat(toLinux(shuttled.toString()), is(expected));
+  }
+
   @Test void testMatchRecognize1() {
     final String sql = "select *\n"
         + "  from t match_recognize\n"
@@ -8549,7 +7848,7 @@ private static Consumer<List<? extends Throwable>> checkWarnings(
         + "  ) mr";
     final String expected = "SELECT *\n"
         + "FROM `T` MATCH_RECOGNIZE(\n"
-        + "MEASURES (MATCH_NUMBER ()) AS `MATCH_NUM`, "
+        + "MEASURES (MATCH_NUMBER()) AS `MATCH_NUM`, "
         + "(CLASSIFIER()) AS `VAR_MATCH`, "
         + "`STRT`.`TS` AS `START_TS`, "
         + "LAST(`DOWN`.`TS`, 0) AS `BOTTOM_TS`, "
@@ -9510,8 +8809,8 @@ private static Consumer<List<? extends Throwable>> checkWarnings(
         + "select * from emps";
     final String expected = "INSERT INTO `EMPS`\n"
         + "/*+ `PROPERTIES`(`K1` = 'v1', `K2` = 'v2'), `INDEX`(`IDX0`, `IDX1`) */\n"
-        + "(SELECT *\n"
-        + "FROM `EMPS`)";
+        + "SELECT *\n"
+        + "FROM `EMPS`";
     sql(sql).ok(expected);
   }
 
@@ -9558,7 +8857,7 @@ private static Consumer<List<? extends Throwable>> checkWarnings(
         + ", `DEPTNO` = `T`.`DEPTNO`"
         + ", `SALARY` = (`T`.`SALARY` * 0.1)\n"
         + "WHEN NOT MATCHED THEN INSERT (`NAME`, `DEPT`, `SALARY`) "
-        + "(VALUES (ROW(`T`.`NAME`, 10, (`T`.`SALARY` * 0.15))))";
+        + "VALUES (ROW(`T`.`NAME`, 10, (`T`.`SALARY` * 0.15)))";
     sql(sql).ok(expected);
   }
 
@@ -9641,8 +8940,12 @@ private static Consumer<List<? extends Throwable>> checkWarnings(
   protected static String varToStr(Hoist.Variable v) {
     if (v.node instanceof SqlLiteral) {
       SqlLiteral literal = (SqlLiteral) v.node;
+      SqlTypeName typeName = literal.getTypeName();
       return "[" + v.ordinal
-          + ":" + literal.getTypeName()
+          + ":"
+          + (typeName == SqlTypeName.UNKNOWN
+              ? ((SqlUnknownLiteral) literal).tag
+              : typeName.getName())
           + ":" + literal.toValue()
           + "]";
     } else {
@@ -9873,7 +9176,7 @@ static UnaryOperator<SqlWriterConfig> randomize(Random random) {
           .withClauseEndsLine(random.nextBoolean());
     }
 
-    private String toSqlString(SqlNodeList sqlNodeList,
+    static String toSqlString(SqlNodeList sqlNodeList,
         UnaryOperator<SqlWriterConfig> transform) {
       return sqlNodeList.stream()
           .map(node -> node.toSqlString(transform).getSql())
@@ -9889,7 +9192,7 @@ static <E extends Enum<E>> E nextEnum(Random random, Class<E> enumClass) {
       return constants[random.nextInt(constants.length)];
     }
 
-    private void checkList(SqlNodeList sqlNodeList,
+    static void checkList(SqlNodeList sqlNodeList,
         UnaryOperator<String> converter, List<String> expected) {
       assertThat(sqlNodeList.size(), is(expected.size()));
 
diff --git a/testkit/src/main/java/org/apache/calcite/sql/test/AbstractSqlTester.java b/testkit/src/main/java/org/apache/calcite/sql/test/AbstractSqlTester.java
index fc50c9c6dba..d68b381cba1 100644
--- a/testkit/src/main/java/org/apache/calcite/sql/test/AbstractSqlTester.java
+++ b/testkit/src/main/java/org/apache/calcite/sql/test/AbstractSqlTester.java
@@ -119,7 +119,7 @@ protected void checkParseEx(Throwable e, @Nullable String expectedMsgPattern,
       if (expectedMsgPattern == null) {
         throw new RuntimeException("Error while parsing query:" + sap, spe);
       } else if (errMessage == null
-          || !errMessage.matches(expectedMsgPattern)) {
+          || !Util.toLinux(errMessage).matches(expectedMsgPattern)) {
         throw new RuntimeException("Error did not match expected ["
             + expectedMsgPattern + "] while parsing query ["
             + sap + "]", spe);
@@ -325,9 +325,10 @@ public static String buildQueryAgg(String expression) {
    * @return Query that evaluates a scalar expression
    */
   protected String buildQuery2(SqlTestFactory factory, String expression) {
-    if (expression.matches("(?i).*percentile_(cont|disc).*")) {
+    if (expression.matches("(?i).*(percentile_(cont|disc)|convert)\\(.*")) {
       // PERCENTILE_CONT requires its argument to be a literal,
       // so converting its argument to a column will cause false errors.
+      // Similarly, MSSQL-style CONVERT.
       return buildQuery(expression);
     }
     // "values (1 < 5)"
@@ -362,15 +363,18 @@ protected String buildQuery2(SqlTestFactory factory, String expression) {
           @Override public SqlNode visit(SqlCall call) {
             SqlOperator operator = call.getOperator();
             if (operator instanceof SqlUnresolvedFunction) {
-              final SqlUnresolvedFunction unresolvedFunction = (SqlUnresolvedFunction) operator;
-              final SqlOperator lookup = SqlValidatorUtil.lookupSqlFunctionByID(
-                  SqlStdOperatorTable.instance(),
-                  unresolvedFunction.getSqlIdentifier(),
-                  unresolvedFunction.getFunctionType());
+              final SqlUnresolvedFunction unresolvedFunction =
+                  (SqlUnresolvedFunction) operator;
+              final SqlOperator lookup =
+                  SqlValidatorUtil.lookupSqlFunctionByID(
+                      SqlStdOperatorTable.instance(),
+                      unresolvedFunction.getSqlIdentifier(),
+                      unresolvedFunction.getFunctionType());
               if (lookup != null) {
                 operator = lookup;
-                call = operator.createCall(call.getFunctionQuantifier(),
-                    call.getParserPosition(), call.getOperandList());
+                call =
+                    operator.createCall(call.getFunctionQuantifier(),
+                        call.getParserPosition(), call.getOperandList());
               }
             }
             if (operator == SqlStdOperatorTable.CAST
diff --git a/testkit/src/main/java/org/apache/calcite/sql/test/SqlOperatorFixture.java b/testkit/src/main/java/org/apache/calcite/sql/test/SqlOperatorFixture.java
index 2e118f07453..70ae0a89b71 100644
--- a/testkit/src/main/java/org/apache/calcite/sql/test/SqlOperatorFixture.java
+++ b/testkit/src/main/java/org/apache/calcite/sql/test/SqlOperatorFixture.java
@@ -29,6 +29,7 @@
 import org.apache.calcite.sql.test.SqlTester.ResultChecker;
 import org.apache.calcite.sql.test.SqlTester.TypeChecker;
 import org.apache.calcite.sql.validate.SqlConformance;
+import org.apache.calcite.sql.validate.SqlConformanceEnum;
 import org.apache.calcite.sql.validate.SqlValidator;
 import org.apache.calcite.test.CalciteAssert;
 import org.apache.calcite.test.ConnectionFactories;
@@ -38,6 +39,7 @@
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 
+import java.util.function.Consumer;
 import java.util.function.UnaryOperator;
 
 import static org.apache.calcite.rel.type.RelDataTypeImpl.NON_NULLABLE_SUFFIX;
@@ -561,6 +563,30 @@ default SqlOperatorFixture withLibrary(SqlLibrary library) {
                 .with(CalciteConnectionProperty.FUN, library.fun));
   }
 
+  /** Applies this fixture to some code for each of the given libraries. */
+  default void forEachLibrary(Iterable<? extends SqlLibrary> libraries,
+      Consumer<SqlOperatorFixture> consumer) {
+    libraries.forEach(library -> {
+      try {
+        consumer.accept(this.withLibrary(library));
+      } catch (Exception e) {
+        throw new RuntimeException("for library " + library, e);
+      }
+    });
+  }
+
+  /** Applies this fixture to some code for each of the given conformances. */
+  default void forEachConformance(Iterable<? extends SqlConformanceEnum> conformances,
+      Consumer<SqlOperatorFixture> consumer) {
+    conformances.forEach(conformance -> {
+      try {
+        consumer.accept(this.withConformance(conformance));
+      } catch (Exception e) {
+        throw new RuntimeException("for conformance " + conformance, e);
+      }
+    });
+  }
+
   default SqlOperatorFixture forOracle(SqlConformance conformance) {
     return withConformance(conformance)
         .withOperatorTable(
@@ -574,71 +600,78 @@ default SqlOperatorFixture forOracle(SqlConformance conformance) {
   default String getCastString(
       String value,
       String targetType,
-      boolean errorLoc) {
+      boolean errorLoc,
+      boolean safe) {
     if (errorLoc) {
       value = "^" + value + "^";
     }
-    return "cast(" + value + " as " + targetType + ")";
+    String function = safe ? "safe_cast" : "cast";
+    return function + "(" + value + " as " + targetType + ")";
   }
 
   default void checkCastToApproxOkay(String value, String targetType,
-      Object expected) {
-    checkScalarApprox(getCastString(value, targetType, false),
-        targetType + NON_NULLABLE_SUFFIX, expected);
+      Object expected, boolean safe) {
+    checkScalarApprox(getCastString(value, targetType, false, safe),
+        getTargetType(targetType, safe), expected);
   }
 
   default void checkCastToStringOkay(String value, String targetType,
-      String expected) {
-    checkString(getCastString(value, targetType, false), expected,
-        targetType + NON_NULLABLE_SUFFIX);
+      String expected, boolean safe) {
+    final String castString = getCastString(value, targetType, false, safe);
+    checkString(castString, expected, getTargetType(targetType, safe));
   }
 
   default void checkCastToScalarOkay(String value, String targetType,
-      String expected) {
-    checkScalarExact(getCastString(value, targetType, false),
-        targetType + NON_NULLABLE_SUFFIX,
-        expected);
+      String expected, boolean safe) {
+    final String castString = getCastString(value, targetType, false, safe);
+    checkScalarExact(castString, getTargetType(targetType, safe), expected);
   }
 
-  default void checkCastToScalarOkay(String value, String targetType) {
-    checkCastToScalarOkay(value, targetType, value);
+  default String getTargetType(String targetType, boolean safe) {
+    return safe ? targetType : targetType + NON_NULLABLE_SUFFIX;
+  }
+
+  default void checkCastToScalarOkay(String value, String targetType,
+      boolean safe) {
+    checkCastToScalarOkay(value, targetType, value, safe);
   }
 
   default void checkCastFails(String value, String targetType,
-      String expectedError, boolean runtime) {
-    checkFails(getCastString(value, targetType, !runtime), expectedError,
-        runtime);
+      String expectedError, boolean runtime, boolean safe) {
+    final String castString = getCastString(value, targetType, !runtime, safe);
+    checkFails(castString, expectedError, runtime);
   }
 
-  default void checkCastToString(String value, String type,
-      @Nullable String expected) {
+  default void checkCastToString(String value, @Nullable String type,
+      @Nullable String expected, boolean safe) {
     String spaces = "     ";
     if (expected == null) {
       expected = value.trim();
     }
     int len = expected.length();
     if (type != null) {
-      value = getCastString(value, type, false);
+      value = getCastString(value, type, false, safe);
     }
 
     // currently no exception thrown for truncation
     if (Bug.DT239_FIXED) {
       checkCastFails(value,
           "VARCHAR(" + (len - 1) + ")", STRING_TRUNC_MESSAGE,
-          true);
+          true, safe);
     }
 
-    checkCastToStringOkay(value, "VARCHAR(" + len + ")", expected);
-    checkCastToStringOkay(value, "VARCHAR(" + (len + 5) + ")", expected);
+    checkCastToStringOkay(value, "VARCHAR(" + len + ")", expected, safe);
+    checkCastToStringOkay(value, "VARCHAR(" + (len + 5) + ")", expected, safe);
 
     // currently no exception thrown for truncation
     if (Bug.DT239_FIXED) {
       checkCastFails(value,
           "CHAR(" + (len - 1) + ")", STRING_TRUNC_MESSAGE,
-          true);
+          true, safe);
     }
 
-    checkCastToStringOkay(value, "CHAR(" + len + ")", expected);
-    checkCastToStringOkay(value, "CHAR(" + (len + 5) + ")", expected + spaces);
+    checkCastToStringOkay(value, "CHAR(" + len + ")", expected, safe);
+    checkCastToStringOkay(value, "CHAR(" + (len + 5) + ")",
+        expected + spaces, safe);
   }
 }
diff --git a/testkit/src/main/java/org/apache/calcite/sql/test/SqlTestFactory.java b/testkit/src/main/java/org/apache/calcite/sql/test/SqlTestFactory.java
index 2c36fd14b94..238ace00c0a 100644
--- a/testkit/src/main/java/org/apache/calcite/sql/test/SqlTestFactory.java
+++ b/testkit/src/main/java/org/apache/calcite/sql/test/SqlTestFactory.java
@@ -75,12 +75,9 @@ public class SqlTestFactory {
           SqlParser.Config.DEFAULT,
           SqlValidator.Config.DEFAULT,
           SqlToRelConverter.CONFIG,
-          SqlStdOperatorTable.instance())
-      .withOperatorTable(o -> {
-        MockSqlOperatorTable opTab = new MockSqlOperatorTable(o);
-        MockSqlOperatorTable.addRamp(opTab);
-        return opTab;
-      });
+          SqlStdOperatorTable.instance(),
+          UnaryOperator.identity())
+      .withOperatorTable(o -> MockSqlOperatorTable.of(o).extend());
 
   public final ConnectionFactory connectionFactory;
   public final TypeFactoryFactory typeFactoryFactory;
@@ -96,6 +93,7 @@ public class SqlTestFactory {
   private final SqlParser.Config parserConfig;
   public final SqlValidator.Config validatorConfig;
   public final SqlToRelConverter.Config sqlToRelConfig;
+  public final UnaryOperator<RelDataTypeSystem> typeSystemTransform;
 
   protected SqlTestFactory(CatalogReaderFactory catalogReaderFactory,
       TypeFactoryFactory typeFactoryFactory, PlannerFactory plannerFactory,
@@ -103,7 +101,8 @@ protected SqlTestFactory(CatalogReaderFactory catalogReaderFactory,
       ValidatorFactory validatorFactory,
       ConnectionFactory connectionFactory,
       SqlParser.Config parserConfig, SqlValidator.Config validatorConfig,
-      SqlToRelConverter.Config sqlToRelConfig, SqlOperatorTable operatorTable) {
+      SqlToRelConverter.Config sqlToRelConfig, SqlOperatorTable operatorTable,
+      UnaryOperator<RelDataTypeSystem> typeSystemTransform) {
     this.catalogReaderFactory =
         requireNonNull(catalogReaderFactory, "catalogReaderFactory");
     this.typeFactoryFactory =
@@ -118,8 +117,10 @@ protected SqlTestFactory(CatalogReaderFactory catalogReaderFactory,
         requireNonNull(connectionFactory, "connectionFactory");
     this.sqlToRelConfig = requireNonNull(sqlToRelConfig, "sqlToRelConfig");
     this.operatorTable = operatorTable;
+    this.typeSystemTransform = typeSystemTransform;
     this.typeFactorySupplier = Suppliers.memoize(() ->
-        typeFactoryFactory.create(validatorConfig.conformance()))::get;
+        typeFactoryFactory.create(validatorConfig.conformance(),
+            typeSystemTransform.apply(RelDataTypeSystem.DEFAULT)))::get;
     this.catalogReaderSupplier = Suppliers.memoize(() ->
         catalogReaderFactory.create(this.typeFactorySupplier.get(),
             parserConfig.caseSensitive()))::get;
@@ -156,7 +157,18 @@ public SqlTestFactory withTypeFactoryFactory(
     return new SqlTestFactory(catalogReaderFactory, typeFactoryFactory,
         plannerFactory, plannerContext, clusterTransform, validatorFactory,
         connectionFactory, parserConfig, validatorConfig, sqlToRelConfig,
-        operatorTable);
+        operatorTable, typeSystemTransform);
+  }
+
+  public SqlTestFactory withTypeSystem(
+      UnaryOperator<RelDataTypeSystem> typeSystemTransform) {
+    if (typeSystemTransform.equals(this.typeSystemTransform)) {
+      return this;
+    }
+    return new SqlTestFactory(catalogReaderFactory, typeFactoryFactory,
+        plannerFactory, plannerContext, clusterTransform, validatorFactory,
+        connectionFactory, parserConfig, validatorConfig, sqlToRelConfig,
+        operatorTable, typeSystemTransform);
   }
 
   public SqlTestFactory withPlannerFactory(PlannerFactory plannerFactory) {
@@ -166,7 +178,7 @@ public SqlTestFactory withPlannerFactory(PlannerFactory plannerFactory) {
     return new SqlTestFactory(catalogReaderFactory, typeFactoryFactory,
         plannerFactory, plannerContext, clusterTransform, validatorFactory,
         connectionFactory, parserConfig, validatorConfig, sqlToRelConfig,
-        operatorTable);
+        operatorTable, typeSystemTransform);
   }
 
   public SqlTestFactory withPlannerContext(
@@ -178,7 +190,7 @@ public SqlTestFactory withPlannerContext(
     return new SqlTestFactory(catalogReaderFactory, typeFactoryFactory,
         plannerFactory, plannerContext, clusterTransform, validatorFactory,
         connectionFactory, parserConfig, validatorConfig, sqlToRelConfig,
-        operatorTable);
+        operatorTable, typeSystemTransform);
   }
 
   public SqlTestFactory withCluster(UnaryOperator<RelOptCluster> transform) {
@@ -187,7 +199,7 @@ public SqlTestFactory withCluster(UnaryOperator<RelOptCluster> transform) {
     return new SqlTestFactory(catalogReaderFactory, typeFactoryFactory,
         plannerFactory, plannerContext, clusterTransform, validatorFactory,
         connectionFactory, parserConfig, validatorConfig, sqlToRelConfig,
-        operatorTable);
+        operatorTable, typeSystemTransform);
   }
 
   public SqlTestFactory withCatalogReader(
@@ -198,7 +210,7 @@ public SqlTestFactory withCatalogReader(
     return new SqlTestFactory(catalogReaderFactory, typeFactoryFactory,
         plannerFactory, plannerContext, clusterTransform, validatorFactory,
         connectionFactory, parserConfig, validatorConfig, sqlToRelConfig,
-        operatorTable);
+        operatorTable, typeSystemTransform);
   }
 
   public SqlTestFactory withValidator(ValidatorFactory validatorFactory) {
@@ -208,7 +220,7 @@ public SqlTestFactory withValidator(ValidatorFactory validatorFactory) {
     return new SqlTestFactory(catalogReaderFactory, typeFactoryFactory,
         plannerFactory, plannerContext, clusterTransform, validatorFactory,
         connectionFactory, parserConfig, validatorConfig, sqlToRelConfig,
-        operatorTable);
+        operatorTable, typeSystemTransform);
   }
 
   public SqlTestFactory withValidatorConfig(
@@ -221,7 +233,7 @@ public SqlTestFactory withValidatorConfig(
     return new SqlTestFactory(catalogReaderFactory, typeFactoryFactory,
         plannerFactory, plannerContext, clusterTransform, validatorFactory,
         connectionFactory, parserConfig, validatorConfig, sqlToRelConfig,
-        operatorTable);
+        operatorTable, typeSystemTransform);
   }
 
   public SqlTestFactory withSqlToRelConfig(
@@ -234,11 +246,11 @@ public SqlTestFactory withSqlToRelConfig(
     return new SqlTestFactory(catalogReaderFactory, typeFactoryFactory,
         plannerFactory, plannerContext, clusterTransform, validatorFactory,
         connectionFactory, parserConfig, validatorConfig, sqlToRelConfig,
-        operatorTable);
+        operatorTable, typeSystemTransform);
   }
 
-  private static RelDataTypeFactory createTypeFactory(SqlConformance conformance) {
-    RelDataTypeSystem typeSystem = RelDataTypeSystem.DEFAULT;
+  private static RelDataTypeFactory createTypeFactory(SqlConformance conformance,
+      RelDataTypeSystem typeSystem) {
     if (conformance.shouldConvertRaggedUnionTypesToVarying()) {
       typeSystem = new DelegatingTypeSystem(typeSystem) {
         @Override public boolean shouldConvertRaggedUnionTypesToVarying() {
@@ -258,7 +270,7 @@ public SqlTestFactory withParserConfig(
     return new SqlTestFactory(catalogReaderFactory, typeFactoryFactory,
         plannerFactory, plannerContext, clusterTransform, validatorFactory,
         connectionFactory, parserConfig, validatorConfig, sqlToRelConfig,
-        operatorTable);
+        operatorTable, typeSystemTransform);
   }
 
   public SqlTestFactory withConnectionFactory(
@@ -271,7 +283,7 @@ public SqlTestFactory withConnectionFactory(
     return new SqlTestFactory(catalogReaderFactory, typeFactoryFactory,
         plannerFactory, plannerContext, clusterTransform, validatorFactory,
         connectionFactory, parserConfig, validatorConfig, sqlToRelConfig,
-        operatorTable);
+        operatorTable, typeSystemTransform);
   }
 
   public SqlTestFactory withOperatorTable(
@@ -284,7 +296,7 @@ public SqlTestFactory withOperatorTable(
     return new SqlTestFactory(catalogReaderFactory, typeFactoryFactory,
         plannerFactory, plannerContext, clusterTransform, validatorFactory,
         connectionFactory, parserConfig, validatorConfig, sqlToRelConfig,
-        operatorTable);
+        operatorTable, typeSystemTransform);
   }
 
   public SqlParser.Config parserConfig() {
@@ -313,7 +325,8 @@ public SqlToRelConverter createSqlToRelConverter() {
 
   /** Creates a {@link RelDataTypeFactory} for tests. */
   public interface TypeFactoryFactory {
-    RelDataTypeFactory create(SqlConformance conformance);
+    RelDataTypeFactory create(SqlConformance conformance,
+        RelDataTypeSystem typeSystem);
   }
 
   /** Creates a {@link RelOptPlanner} for tests. */
diff --git a/testkit/src/main/java/org/apache/calcite/test/CalciteAssert.java b/testkit/src/main/java/org/apache/calcite/test/CalciteAssert.java
index 473ae6c30aa..b5a0adaf57e 100644
--- a/testkit/src/main/java/org/apache/calcite/test/CalciteAssert.java
+++ b/testkit/src/main/java/org/apache/calcite/test/CalciteAssert.java
@@ -41,9 +41,12 @@
 import org.apache.calcite.rel.type.RelDataTypeFactory;
 import org.apache.calcite.rel.type.RelDataTypeImpl;
 import org.apache.calcite.rel.type.RelProtoDataType;
+import org.apache.calcite.runtime.AccumOperation;
 import org.apache.calcite.runtime.CalciteException;
-import org.apache.calcite.runtime.GeoFunctions;
+import org.apache.calcite.runtime.CollectOperation;
 import org.apache.calcite.runtime.Hook;
+import org.apache.calcite.runtime.SpatialTypeFunctions;
+import org.apache.calcite.runtime.UnionOperation;
 import org.apache.calcite.schema.Schema;
 import org.apache.calcite.schema.SchemaPlus;
 import org.apache.calcite.schema.SchemaVersion;
@@ -53,6 +56,7 @@
 import org.apache.calcite.schema.Wrapper;
 import org.apache.calcite.schema.impl.AbstractSchema;
 import org.apache.calcite.schema.impl.AbstractTable;
+import org.apache.calcite.schema.impl.AggregateFunctionImpl;
 import org.apache.calcite.schema.impl.TableFunctionImpl;
 import org.apache.calcite.schema.impl.ViewTable;
 import org.apache.calcite.schema.impl.ViewTableMacro;
@@ -60,7 +64,7 @@
 import org.apache.calcite.sql.SqlDialect;
 import org.apache.calcite.sql.SqlExplainLevel;
 import org.apache.calcite.sql.SqlNode;
-import org.apache.calcite.sql.fun.SqlGeoFunctions;
+import org.apache.calcite.sql.fun.SqlSpatialTypeFunctions;
 import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.sql.validate.SqlConformanceEnum;
 import org.apache.calcite.sql.validate.SqlValidatorException;
@@ -723,7 +727,7 @@ static Method method(Object o, String methodName, Object[] args) {
     loop:
       for (Method method1 : aClass.getMethods()) {
         if (method1.getName().equals(methodName)
-            && method1.getParameterTypes().length == args.length
+            && method1.getParameterCount() == args.length
             && Modifier.isPublic(method1.getDeclaringClass().getModifiers())) {
           for (Pair<Object, Class> pair
               : Pair.zip(args, (Class[]) method1.getParameterTypes())) {
@@ -773,8 +777,8 @@ static SchemaPlus addSchema_(SchemaPlus rootSchema, SchemaSpec schema) {
           new ReflectiveSchema(new FoodmartSchema()));
     case JDBC_SCOTT:
       cs = DatabaseInstance.HSQLDB.scott;
-      dataSource = JdbcSchema.dataSource(cs.url, cs.driver, cs.username,
-          cs.password);
+      dataSource =
+          JdbcSchema.dataSource(cs.url, cs.driver, cs.username, cs.password);
       return rootSchema.add(schema.schemaName,
           JdbcSchema.create(rootSchema, schema.schemaName, dataSource,
               cs.catalog, cs.schema));
@@ -820,25 +824,29 @@ static SchemaPlus addSchema_(SchemaPlus rootSchema, SchemaSpec schema) {
       return rootSchema.add("foodmart2", new CloneSchema(foodmart));
     case GEO:
       ModelHandler.addFunctions(rootSchema, null, emptyPath,
-          GeoFunctions.class.getName(), "*", true);
+          SpatialTypeFunctions.class.getName(), "*", true);
       ModelHandler.addFunctions(rootSchema, null, emptyPath,
-          SqlGeoFunctions.class.getName(), "*", true);
+          SqlSpatialTypeFunctions.class.getName(), "*", true);
+      rootSchema.add("ST_UNION", AggregateFunctionImpl.create(UnionOperation.class));
+      rootSchema.add("ST_ACCUM", AggregateFunctionImpl.create(AccumOperation.class));
+      rootSchema.add("ST_COLLECT", AggregateFunctionImpl.create(CollectOperation.class));
       final SchemaPlus s =
           rootSchema.add(schema.schemaName, new AbstractSchema());
       ModelHandler.addFunctions(s, "countries", emptyPath,
           CountriesTableFunction.class.getName(), null, false);
       final String sql = "select * from table(\"countries\"(true))";
-      final ViewTableMacro viewMacro = ViewTable.viewMacro(rootSchema, sql,
-          ImmutableList.of("GEO"), emptyPath, false);
+      final ViewTableMacro viewMacro =
+          ViewTable.viewMacro(rootSchema, sql,
+              ImmutableList.of("GEO"), emptyPath, false);
       s.add("countries", viewMacro);
-
       ModelHandler.addFunctions(s, "states", emptyPath,
           StatesTableFunction.class.getName(), "states", false);
       final String sql2 = "select \"name\",\n"
           + " ST_PolyFromText(\"geom\") as \"geom\"\n"
           + "from table(\"states\"(true))";
-      final ViewTableMacro viewMacro2 = ViewTable.viewMacro(rootSchema, sql2,
-          ImmutableList.of("GEO"), emptyPath, false);
+      final ViewTableMacro viewMacro2 =
+          ViewTable.viewMacro(rootSchema, sql2,
+              ImmutableList.of("GEO"), emptyPath, false);
       s.add("states", viewMacro2);
 
       ModelHandler.addFunctions(s, "parks", emptyPath,
@@ -846,8 +854,9 @@ static SchemaPlus addSchema_(SchemaPlus rootSchema, SchemaSpec schema) {
       final String sql3 = "select \"name\",\n"
           + " ST_PolyFromText(\"geom\") as \"geom\"\n"
           + "from table(\"parks\"(true))";
-      final ViewTableMacro viewMacro3 = ViewTable.viewMacro(rootSchema, sql3,
-          ImmutableList.of("GEO"), emptyPath, false);
+      final ViewTableMacro viewMacro3 =
+          ViewTable.viewMacro(rootSchema, sql3,
+              ImmutableList.of("GEO"), emptyPath, false);
       s.add("parks", viewMacro3);
 
       return s;
@@ -1212,9 +1221,10 @@ public final AssertThat withMaterializations(String model,
             + "]"
             + model.substring(endIndex + 1);
       } else if (model.contains("type: ")) {
-        model2 = model.replaceFirst("type: ",
-            java.util.regex.Matcher.quoteReplacement(buf + ",\n"
-            + "type: "));
+        model2 =
+            model.replaceFirst("type: ",
+                java.util.regex.Matcher.quoteReplacement(buf + ",\n"
+                    + "type: "));
       } else {
         throw new AssertionError("do not know where to splice");
       }
diff --git a/testkit/src/main/java/org/apache/calcite/test/ConnectionFactories.java b/testkit/src/main/java/org/apache/calcite/test/ConnectionFactories.java
index cb02df29ebf..2a09b981260 100644
--- a/testkit/src/main/java/org/apache/calcite/test/ConnectionFactories.java
+++ b/testkit/src/main/java/org/apache/calcite/test/ConnectionFactories.java
@@ -18,6 +18,7 @@
 
 import org.apache.calcite.avatica.ConnectionProperty;
 import org.apache.calcite.jdbc.CalciteConnection;
+import org.apache.calcite.rel.type.RelProtoDataType;
 import org.apache.calcite.runtime.FlatLists;
 import org.apache.calcite.schema.Schema;
 import org.apache.calcite.schema.SchemaPlus;
@@ -83,6 +84,12 @@ public static CalciteAssert.ConnectionPostProcessor setDefault(
     return new DefaultSchemaPostProcessor(schema);
   }
 
+  /** Returns a post-processor that adds a type. */
+  public static CalciteAssert.ConnectionPostProcessor addType(String name,
+      RelProtoDataType protoDataType) {
+    return new AddTypePostProcessor(name, protoDataType);
+  }
+
   /** Connection factory that uses a given map of (name, value) pairs and
    * optionally an initial schema. */
   private static class MapConnectionFactory implements ConnectionFactory {
@@ -162,6 +169,25 @@ private static class AddSchemaPostProcessor
     }
   }
 
+  /** Post-processor that adds a type. */
+  private static class AddTypePostProcessor
+      implements CalciteAssert.ConnectionPostProcessor {
+    private final String name;
+    private final RelProtoDataType protoDataType;
+
+    AddTypePostProcessor(String name, RelProtoDataType protoDataType) {
+      this.name = requireNonNull(name, "name");
+      this.protoDataType = requireNonNull(protoDataType, "protoDataType");
+    }
+
+    @Override public Connection apply(Connection connection) throws SQLException {
+      CalciteConnection con = connection.unwrap(CalciteConnection.class);
+      SchemaPlus rootSchema = con.getRootSchema();
+      rootSchema.add(name, protoDataType);
+      return connection;
+    }
+  }
+
   /** Post-processor that sets a default schema name. */
   private static class DefaultSchemaPostProcessor
       implements CalciteAssert.ConnectionPostProcessor {
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 07bd6260cb1..86cbc1b3016 100644
--- a/testkit/src/main/java/org/apache/calcite/test/DiffRepository.java
+++ b/testkit/src/main/java/org/apache/calcite/test/DiffRepository.java
@@ -44,6 +44,7 @@
 
 import java.io.File;
 import java.io.IOException;
+import java.io.InputStream;
 import java.io.Writer;
 import java.net.URL;
 import java.util.AbstractList;
@@ -52,6 +53,7 @@
 import java.util.Objects;
 import java.util.SortedMap;
 import java.util.TreeMap;
+import javax.xml.XMLConstants;
 import javax.xml.parsers.DocumentBuilder;
 import javax.xml.parsers.DocumentBuilderFactory;
 import javax.xml.parsers.ParserConfigurationException;
@@ -108,20 +110,15 @@
  * </code></pre></blockquote>
  *
  * <p>If any of the test cases fails, a log file is generated, called
- * <code>target/surefire/com/acme/test/MyTest.xml</code>, containing the actual
+ * <code>build/resources/test/com/acme/test/MyTest_actual.xml</code>, containing the actual
  * output.</p>
  *
- * <p>(Maven sometimes removes this file; if it is not present, run maven with
- * an extra {@code -X} flag.
- * See <a href="http://jira.codehaus.org/browse/SUREFIRE-846">[SUREFIRE-846]</a>
- * for details.)</p>
- *
  * <p>The log
  * file is otherwise identical to the reference log, so once the log file has
  * been verified, it can simply be copied over to become the new reference
  * log:</p>
  *
- * <blockquote><code>cp target/surefire/com/acme/test/MyTest.xml
+ * <blockquote><code>cp build/resources/test/com/acme/test/MyTest_actual.xml
  * src/test/resources/com/acme/test/MyTest.xml</code></blockquote>
  *
  * <p>If a resource or test case does not exist, <code>DiffRepository</code>
@@ -129,9 +126,9 @@
  * very easy to create new tests and test cases.</p>
  *
  * <p>The {@link #lookup} method ensures that all test cases share the same
- * instance of the repository. This is important more than one one test case
- * fails. The shared instance ensures that the generated
- * <code>target/surefire/com/acme/test/MyTest.xml</code>
+ * instance of the repository. This is important more than one test case fails.
+ * The shared instance ensures that the generated
+ * <code>build/resources/test/com/acme/test/MyTest_actual.xml</code>
  * file contains the actual for <em>both</em> test cases.
  */
 public class DiffRepository {
@@ -174,6 +171,22 @@ public class DiffRepository {
   private static final LoadingCache<Key, DiffRepository> REPOSITORY_CACHE =
       CacheBuilder.newBuilder().build(CacheLoader.from(Key::toRepo));
 
+  private static final ThreadLocal<@Nullable DocumentBuilderFactory> DOCUMENT_BUILDER_FACTORY =
+      ThreadLocal.withInitial(() -> {
+        final DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
+        documentBuilderFactory.setXIncludeAware(false);
+        documentBuilderFactory.setExpandEntityReferences(false);
+        documentBuilderFactory.setNamespaceAware(true);
+        try {
+          documentBuilderFactory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true);
+          documentBuilderFactory
+              .setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
+        } catch (final ParserConfigurationException e) {
+          throw new IllegalStateException("Document Builder configuration failed", e);
+        }
+        return documentBuilderFactory;
+      });
+
   //~ Instance fields --------------------------------------------------------
 
   private final DiffRepository baseRepository;
@@ -207,19 +220,17 @@ private DiffRepository(URL refFile, File logFile,
     this.modCount = 0;
 
     // Load the document.
-    DocumentBuilderFactory fac = DocumentBuilderFactory.newInstance();
     try {
-      DocumentBuilder docBuilder = fac.newDocumentBuilder();
-      try {
+      DocumentBuilder docBuilder =
+          Nullness.castNonNull(DOCUMENT_BUILDER_FACTORY.get()).newDocumentBuilder();
+      try (InputStream inputStream = refFile.openStream()) {
         // Parse the reference file.
-        this.doc = docBuilder.parse(refFile.openStream());
-        // Don't write a log file yet -- as far as we know, it's still
-        // identical.
+        this.doc = docBuilder.parse(inputStream);
+        // Don't write a log file yet -- as far as we know, it's still identical.
       } catch (IOException e) {
         // There's no reference file. Create and write a log file.
         this.doc = docBuilder.newDocument();
-        this.doc.appendChild(
-            doc.createElement(ROOT_TAG));
+        this.doc.appendChild(doc.createElement(ROOT_TAG));
         flushDoc();
       }
       this.root = doc.getDocumentElement();
@@ -231,6 +242,27 @@ private DiffRepository(URL refFile, File logFile,
 
   //~ Methods ----------------------------------------------------------------
 
+  public void checkActualAndReferenceFiles() {
+    if (!logFile.exists()) {
+      return;
+    }
+
+    final String resourceFile =
+        Sources.of(refFile).file().getPath().replace(
+            String.join(File.separator, "build", "resources", "test"),
+            String.join(File.separator, "src", "test", "resources"));
+
+    final String diff = DiffTestCase.diff(new File(resourceFile), logFile);
+
+    if (!diff.isEmpty()) {
+      throw new IllegalArgumentException("Actual and reference files differ. "
+          + "If you are adding new tests, replace the reference file with the "
+          + "current actual file, after checking its content."
+          + "\ndiff " + logFile.getAbsolutePath() + " " + resourceFile + "\n"
+          + diff);
+    }
+  }
+
   private static URL findFile(Class<?> clazz, final String suffix) {
     // The reference file for class "com.foo.Bar" is "com/foo/Bar.xml"
     String rest = "/" + clazz.getName().replace('.', File.separatorChar)
diff --git a/testkit/src/main/java/org/apache/calcite/test/IntervalTest.java b/testkit/src/main/java/org/apache/calcite/test/IntervalTest.java
new file mode 100644
index 00000000000..1c808db3195
--- /dev/null
+++ b/testkit/src/main/java/org/apache/calcite/test/IntervalTest.java
@@ -0,0 +1,1969 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.test;
+
+/** Test cases for intervals.
+ *
+ * <p>Called, with varying implementations of {@link Fixture},
+ * from both parser and validator test.
+ */
+public class IntervalTest {
+  private final Fixture f;
+
+  public IntervalTest(Fixture fixture) {
+    this.f = fixture;
+  }
+
+  /** Runs all tests. */
+  public void testAll() {
+    // Tests that should pass both parser and validator
+    subTestIntervalYearPositive();
+    subTestIntervalYearToMonthPositive();
+    subTestIntervalMonthPositive();
+    subTestIntervalDayPositive();
+    subTestIntervalDayToHourPositive();
+    subTestIntervalDayToMinutePositive();
+    subTestIntervalDayToSecondPositive();
+    subTestIntervalHourPositive();
+    subTestIntervalHourToMinutePositive();
+    subTestIntervalHourToSecondPositive();
+    subTestIntervalMinutePositive();
+    subTestIntervalMinuteToSecondPositive();
+    subTestIntervalSecondPositive();
+    subTestIntervalWeekPositive();
+    subTestIntervalQuarterPositive();
+    subTestIntervalPlural();
+
+    // Tests that should pass parser but fail validator
+    subTestIntervalYearNegative();
+    subTestIntervalYearToMonthNegative();
+    subTestIntervalMonthNegative();
+    subTestIntervalDayNegative();
+    subTestIntervalDayToHourNegative();
+    subTestIntervalDayToMinuteNegative();
+    subTestIntervalDayToSecondNegative();
+    subTestIntervalHourNegative();
+    subTestIntervalHourToMinuteNegative();
+    subTestIntervalHourToSecondNegative();
+    subTestIntervalMinuteNegative();
+    subTestIntervalMinuteToSecondNegative();
+    subTestIntervalSecondNegative();
+
+    subTestMisc();
+  }
+
+  /**
+   * Runs tests for INTERVAL... YEAR that should pass both parser and
+   * validator. A substantially identical set of tests exists in
+   * SqlParserTest, and any changes here should be synchronized there.
+   * Similarly, any changes to tests here should be echoed appropriately to
+   * each of the other 12 subTestIntervalXXXPositive() tests.
+   */
+  public void subTestIntervalYearPositive() {
+    // default precision
+    f.expr("INTERVAL '1' YEAR")
+        .columnType("INTERVAL YEAR NOT NULL");
+    f.expr("INTERVAL '99' YEAR")
+        .columnType("INTERVAL YEAR NOT NULL");
+
+    // explicit precision equal to default
+    f.expr("INTERVAL '1' YEAR(2)")
+        .columnType("INTERVAL YEAR(2) NOT NULL");
+    f.expr("INTERVAL '99' YEAR(2)")
+        .columnType("INTERVAL YEAR(2) NOT NULL");
+
+    // max precision
+    f.expr("INTERVAL '2147483647' YEAR(10)")
+        .columnType("INTERVAL YEAR(10) NOT NULL");
+
+    // min precision
+    f.expr("INTERVAL '0' YEAR(1)")
+        .columnType("INTERVAL YEAR(1) NOT NULL");
+
+    // alternate precision
+    f.expr("INTERVAL '1234' YEAR(4)")
+        .columnType("INTERVAL YEAR(4) NOT NULL");
+
+    // sign
+    f.expr("INTERVAL '+1' YEAR")
+        .columnType("INTERVAL YEAR NOT NULL");
+    f.expr("INTERVAL '-1' YEAR")
+        .columnType("INTERVAL YEAR NOT NULL");
+    f.expr("INTERVAL +'1' YEAR")
+        .assertParse("INTERVAL '1' YEAR")
+        .columnType("INTERVAL YEAR NOT NULL");
+    f.expr("INTERVAL +'+1' YEAR")
+        .assertParse("INTERVAL '+1' YEAR")
+        .columnType("INTERVAL YEAR NOT NULL");
+    f.expr("INTERVAL +'-1' YEAR")
+        .assertParse("INTERVAL '-1' YEAR")
+        .columnType("INTERVAL YEAR NOT NULL");
+    f.expr("INTERVAL -'1' YEAR")
+        .columnType("INTERVAL YEAR NOT NULL");
+    f.expr("INTERVAL -'+1' YEAR")
+        .columnType("INTERVAL YEAR NOT NULL");
+    f.expr("INTERVAL -'-1' YEAR")
+        .columnType("INTERVAL YEAR NOT NULL");
+  }
+
+  /**
+   * Runs tests for INTERVAL... YEAR TO MONTH that should pass both parser and
+   * validator. A substantially identical set of tests exists in
+   * SqlParserTest, and any changes here should be synchronized there.
+   * Similarly, any changes to tests here should be echoed appropriately to
+   * each of the other 12 subTestIntervalXXXPositive() tests.
+   */
+  public void subTestIntervalYearToMonthPositive() {
+    // default precision
+    f.expr("INTERVAL '1-2' YEAR TO MONTH")
+        .columnType("INTERVAL YEAR TO MONTH NOT NULL");
+    f.expr("INTERVAL '99-11' YEAR TO MONTH")
+        .columnType("INTERVAL YEAR TO MONTH NOT NULL");
+    f.expr("INTERVAL '99-0' YEAR TO MONTH")
+        .columnType("INTERVAL YEAR TO MONTH NOT NULL");
+
+    // explicit precision equal to default
+    f.expr("INTERVAL '1-2' YEAR(2) TO MONTH")
+        .columnType("INTERVAL YEAR(2) TO MONTH NOT NULL");
+    f.expr("INTERVAL '99-11' YEAR(2) TO MONTH")
+        .columnType("INTERVAL YEAR(2) TO MONTH NOT NULL");
+    f.expr("INTERVAL '99-0' YEAR(2) TO MONTH")
+        .columnType("INTERVAL YEAR(2) TO MONTH NOT NULL");
+
+    // max precision
+    f.expr("INTERVAL '2147483647-11' YEAR(10) TO MONTH")
+        .columnType("INTERVAL YEAR(10) TO MONTH NOT NULL");
+
+    // min precision
+    f.expr("INTERVAL '0-0' YEAR(1) TO MONTH")
+        .columnType("INTERVAL YEAR(1) TO MONTH NOT NULL");
+
+    // alternate precision
+    f.expr("INTERVAL '2006-2' YEAR(4) TO MONTH")
+        .columnType("INTERVAL YEAR(4) TO MONTH NOT NULL");
+
+    // sign
+    f.expr("INTERVAL '-1-2' YEAR TO MONTH")
+        .columnType("INTERVAL YEAR TO MONTH NOT NULL");
+    f.expr("INTERVAL '+1-2' YEAR TO MONTH")
+        .columnType("INTERVAL YEAR TO MONTH NOT NULL");
+    f.expr("INTERVAL +'1-2' YEAR TO MONTH")
+        .assertParse("INTERVAL '1-2' YEAR TO MONTH")
+        .columnType("INTERVAL YEAR TO MONTH NOT NULL");
+    f.expr("INTERVAL +'-1-2' YEAR TO MONTH")
+        .assertParse("INTERVAL '-1-2' YEAR TO MONTH")
+        .columnType("INTERVAL YEAR TO MONTH NOT NULL");
+    f.expr("INTERVAL +'+1-2' YEAR TO MONTH")
+        .assertParse("INTERVAL '+1-2' YEAR TO MONTH")
+        .columnType("INTERVAL YEAR TO MONTH NOT NULL");
+    f.expr("INTERVAL -'1-2' YEAR TO MONTH")
+        .columnType("INTERVAL YEAR TO MONTH NOT NULL");
+    f.expr("INTERVAL -'-1-2' YEAR TO MONTH")
+        .columnType("INTERVAL YEAR TO MONTH NOT NULL");
+    f.expr("INTERVAL -'+1-2' YEAR TO MONTH")
+        .columnType("INTERVAL YEAR TO MONTH NOT NULL");
+  }
+
+  /**
+   * Runs tests for INTERVAL... MONTH that should pass both parser and
+   * validator. A substantially identical set of tests exists in
+   * SqlParserTest, and any changes here should be synchronized there.
+   * Similarly, any changes to tests here should be echoed appropriately to
+   * each of the other 12 subTestIntervalXXXPositive() tests.
+   */
+  public void subTestIntervalMonthPositive() {
+    // default precision
+    f.expr("INTERVAL '1' MONTH")
+        .columnType("INTERVAL MONTH NOT NULL");
+    f.expr("INTERVAL '99' MONTH")
+        .columnType("INTERVAL MONTH NOT NULL");
+
+    // explicit precision equal to default
+    f.expr("INTERVAL '1' MONTH(2)")
+        .columnType("INTERVAL MONTH(2) NOT NULL");
+    f.expr("INTERVAL '99' MONTH(2)")
+        .columnType("INTERVAL MONTH(2) NOT NULL");
+
+    // max precision
+    f.expr("INTERVAL '2147483647' MONTH(10)")
+        .columnType("INTERVAL MONTH(10) NOT NULL");
+
+    // min precision
+    f.expr("INTERVAL '0' MONTH(1)")
+        .columnType("INTERVAL MONTH(1) NOT NULL");
+
+    // alternate precision
+    f.expr("INTERVAL '1234' MONTH(4)")
+        .columnType("INTERVAL MONTH(4) NOT NULL");
+
+    // sign
+    f.expr("INTERVAL '+1' MONTH")
+        .columnType("INTERVAL MONTH NOT NULL");
+    f.expr("INTERVAL '-1' MONTH")
+        .columnType("INTERVAL MONTH NOT NULL");
+    f.expr("INTERVAL +'1' MONTH")
+        .assertParse("INTERVAL '1' MONTH")
+        .columnType("INTERVAL MONTH NOT NULL");
+    f.expr("INTERVAL +'+1' MONTH")
+        .assertParse("INTERVAL '+1' MONTH")
+        .columnType("INTERVAL MONTH NOT NULL");
+    f.expr("INTERVAL +'-1' MONTH")
+        .assertParse("INTERVAL '-1' MONTH")
+        .columnType("INTERVAL MONTH NOT NULL");
+    f.expr("INTERVAL -'1' MONTH")
+        .columnType("INTERVAL MONTH NOT NULL");
+    f.expr("INTERVAL -'+1' MONTH")
+        .columnType("INTERVAL MONTH NOT NULL");
+    f.expr("INTERVAL -'-1' MONTH")
+        .columnType("INTERVAL MONTH NOT NULL");
+  }
+
+  /**
+   * Runs tests for INTERVAL... DAY that should pass both parser and
+   * validator. A substantially identical set of tests exists in
+   * SqlParserTest, and any changes here should be synchronized there.
+   * Similarly, any changes to tests here should be echoed appropriately to
+   * each of the other 12 subTestIntervalXXXPositive() tests.
+   */
+  public void subTestIntervalDayPositive() {
+    // default precision
+    f.expr("INTERVAL '1' DAY")
+        .columnType("INTERVAL DAY NOT NULL");
+    f.expr("INTERVAL '99' DAY")
+        .columnType("INTERVAL DAY NOT NULL");
+
+    // explicit precision equal to default
+    f.expr("INTERVAL '1' DAY(2)")
+        .columnType("INTERVAL DAY(2) NOT NULL");
+    f.expr("INTERVAL '99' DAY(2)")
+        .columnType("INTERVAL DAY(2) NOT NULL");
+
+    // max precision
+    f.expr("INTERVAL '2147483647' DAY(10)")
+        .columnType("INTERVAL DAY(10) NOT NULL");
+
+    // min precision
+    f.expr("INTERVAL '0' DAY(1)")
+        .columnType("INTERVAL DAY(1) NOT NULL");
+
+    // alternate precision
+    f.expr("INTERVAL '1234' DAY(4)")
+        .columnType("INTERVAL DAY(4) NOT NULL");
+
+    // sign
+    f.expr("INTERVAL '+1' DAY")
+        .columnType("INTERVAL DAY NOT NULL");
+    f.expr("INTERVAL '-1' DAY")
+        .columnType("INTERVAL DAY NOT NULL");
+    f.expr("INTERVAL +'1' DAY")
+        .assertParse("INTERVAL '1' DAY")
+        .columnType("INTERVAL DAY NOT NULL");
+    f.expr("INTERVAL +'+1' DAY")
+        .assertParse("INTERVAL '+1' DAY")
+        .columnType("INTERVAL DAY NOT NULL");
+    f.expr("INTERVAL +'-1' DAY")
+        .assertParse("INTERVAL '-1' DAY")
+        .columnType("INTERVAL DAY NOT NULL");
+    f.expr("INTERVAL -'1' DAY")
+        .columnType("INTERVAL DAY NOT NULL");
+    f.expr("INTERVAL -'+1' DAY")
+        .columnType("INTERVAL DAY NOT NULL");
+    f.expr("INTERVAL -'-1' DAY")
+        .columnType("INTERVAL DAY NOT NULL");
+  }
+
+  public void subTestIntervalDayToHourPositive() {
+    // default precision
+    f.expr("INTERVAL '1 2' DAY TO HOUR")
+        .columnType("INTERVAL DAY TO HOUR NOT NULL");
+    f.expr("INTERVAL '99 23' DAY TO HOUR")
+        .columnType("INTERVAL DAY TO HOUR NOT NULL");
+    f.expr("INTERVAL '99 0' DAY TO HOUR")
+        .columnType("INTERVAL DAY TO HOUR NOT NULL");
+
+    // explicit precision equal to default
+    f.expr("INTERVAL '1 2' DAY(2) TO HOUR")
+        .columnType("INTERVAL DAY(2) TO HOUR NOT NULL");
+    f.expr("INTERVAL '99 23' DAY(2) TO HOUR")
+        .columnType("INTERVAL DAY(2) TO HOUR NOT NULL");
+    f.expr("INTERVAL '99 0' DAY(2) TO HOUR")
+        .columnType("INTERVAL DAY(2) TO HOUR NOT NULL");
+
+    // max precision
+    f.expr("INTERVAL '2147483647 23' DAY(10) TO HOUR")
+        .columnType("INTERVAL DAY(10) TO HOUR NOT NULL");
+
+    // min precision
+    f.expr("INTERVAL '0 0' DAY(1) TO HOUR")
+        .columnType("INTERVAL DAY(1) TO HOUR NOT NULL");
+
+    // alternate precision
+    f.expr("INTERVAL '2345 2' DAY(4) TO HOUR")
+        .columnType("INTERVAL DAY(4) TO HOUR NOT NULL");
+
+    // sign
+    f.expr("INTERVAL '-1 2' DAY TO HOUR")
+        .columnType("INTERVAL DAY TO HOUR NOT NULL");
+    f.expr("INTERVAL '+1 2' DAY TO HOUR")
+        .columnType("INTERVAL DAY TO HOUR NOT NULL");
+    f.expr("INTERVAL +'1 2' DAY TO HOUR")
+        .assertParse("INTERVAL '1 2' DAY TO HOUR")
+        .columnType("INTERVAL DAY TO HOUR NOT NULL");
+    f.expr("INTERVAL +'-1 2' DAY TO HOUR")
+        .assertParse("INTERVAL '-1 2' DAY TO HOUR")
+        .columnType("INTERVAL DAY TO HOUR NOT NULL");
+    f.expr("INTERVAL +'+1 2' DAY TO HOUR")
+        .assertParse("INTERVAL '+1 2' DAY TO HOUR")
+        .columnType("INTERVAL DAY TO HOUR NOT NULL");
+    f.expr("INTERVAL -'1 2' DAY TO HOUR")
+        .columnType("INTERVAL DAY TO HOUR NOT NULL");
+    f.expr("INTERVAL -'-1 2' DAY TO HOUR")
+        .columnType("INTERVAL DAY TO HOUR NOT NULL");
+    f.expr("INTERVAL -'+1 2' DAY TO HOUR")
+        .columnType("INTERVAL DAY TO HOUR NOT NULL");
+  }
+
+  /**
+   * Runs tests for INTERVAL... DAY TO MINUTE that should pass both parser and
+   * validator. A substantially identical set of tests exists in
+   * SqlParserTest, and any changes here should be synchronized there.
+   * Similarly, any changes to tests here should be echoed appropriately to
+   * each of the other 12 subTestIntervalXXXPositive() tests.
+   */
+  public void subTestIntervalDayToMinutePositive() {
+    // default precision
+    f.expr("INTERVAL '1 2:3' DAY TO MINUTE")
+        .columnType("INTERVAL DAY TO MINUTE NOT NULL");
+    f.expr("INTERVAL '99 23:59' DAY TO MINUTE")
+        .columnType("INTERVAL DAY TO MINUTE NOT NULL");
+    f.expr("INTERVAL '99 0:0' DAY TO MINUTE")
+        .columnType("INTERVAL DAY TO MINUTE NOT NULL");
+
+    // explicit precision equal to default
+    f.expr("INTERVAL '1 2:3' DAY(2) TO MINUTE")
+        .columnType("INTERVAL DAY(2) TO MINUTE NOT NULL");
+    f.expr("INTERVAL '99 23:59' DAY(2) TO MINUTE")
+        .columnType("INTERVAL DAY(2) TO MINUTE NOT NULL");
+    f.expr("INTERVAL '99 0:0' DAY(2) TO MINUTE")
+        .columnType("INTERVAL DAY(2) TO MINUTE NOT NULL");
+
+    // max precision
+    f.expr("INTERVAL '2147483647 23:59' DAY(10) TO MINUTE")
+        .columnType("INTERVAL DAY(10) TO MINUTE NOT NULL");
+
+    // min precision
+    f.expr("INTERVAL '0 0:0' DAY(1) TO MINUTE")
+        .columnType("INTERVAL DAY(1) TO MINUTE NOT NULL");
+
+    // alternate precision
+    f.expr("INTERVAL '2345 6:7' DAY(4) TO MINUTE")
+        .columnType("INTERVAL DAY(4) TO MINUTE NOT NULL");
+
+    // sign
+    f.expr("INTERVAL '-1 2:3' DAY TO MINUTE")
+        .columnType("INTERVAL DAY TO MINUTE NOT NULL");
+    f.expr("INTERVAL '+1 2:3' DAY TO MINUTE")
+        .assertParse("INTERVAL '+1 2:3' DAY TO MINUTE")
+        .columnType("INTERVAL DAY TO MINUTE NOT NULL");
+    f.expr("INTERVAL +'1 2:3' DAY TO MINUTE")
+        .assertParse("INTERVAL '1 2:3' DAY TO MINUTE")
+        .columnType("INTERVAL DAY TO MINUTE NOT NULL");
+    f.expr("INTERVAL +'-1 2:3' DAY TO MINUTE")
+        .assertParse("INTERVAL '-1 2:3' DAY TO MINUTE")
+        .columnType("INTERVAL DAY TO MINUTE NOT NULL");
+    f.expr("INTERVAL +'+1 2:3' DAY TO MINUTE")
+        .assertParse("INTERVAL '+1 2:3' DAY TO MINUTE")
+        .columnType("INTERVAL DAY TO MINUTE NOT NULL");
+    f.expr("INTERVAL -'1 2:3' DAY TO MINUTE")
+        .columnType("INTERVAL DAY TO MINUTE NOT NULL");
+    f.expr("INTERVAL -'-1 2:3' DAY TO MINUTE")
+        .columnType("INTERVAL DAY TO MINUTE NOT NULL");
+    f.expr("INTERVAL -'+1 2:3' DAY TO MINUTE")
+        .columnType("INTERVAL DAY TO MINUTE NOT NULL");
+  }
+
+  /**
+   * Runs tests for INTERVAL... DAY TO SECOND that should pass both parser and
+   * validator. A substantially identical set of tests exists in
+   * SqlParserTest, and any changes here should be synchronized there.
+   * Similarly, any changes to tests here should be echoed appropriately to
+   * each of the other 12 subTestIntervalXXXPositive() tests.
+   */
+  public void subTestIntervalDayToSecondPositive() {
+    // default precision
+    f.expr("INTERVAL '1 2:3:4' DAY TO SECOND")
+        .columnType("INTERVAL DAY TO SECOND NOT NULL");
+    f.expr("INTERVAL '99 23:59:59' DAY TO SECOND")
+        .columnType("INTERVAL DAY TO SECOND NOT NULL");
+    f.expr("INTERVAL '99 0:0:0' DAY TO SECOND")
+        .columnType("INTERVAL DAY TO SECOND NOT NULL");
+    f.expr("INTERVAL '99 23:59:59.999999' DAY TO SECOND")
+        .columnType("INTERVAL DAY TO SECOND NOT NULL");
+    f.expr("INTERVAL '99 0:0:0.0' DAY TO SECOND")
+        .columnType("INTERVAL DAY TO SECOND NOT NULL");
+
+    // explicit precision equal to default
+    f.expr("INTERVAL '1 2:3:4' DAY(2) TO SECOND")
+        .columnType("INTERVAL DAY(2) TO SECOND NOT NULL");
+    f.expr("INTERVAL '99 23:59:59' DAY(2) TO SECOND")
+        .columnType("INTERVAL DAY(2) TO SECOND NOT NULL");
+    f.expr("INTERVAL '99 0:0:0' DAY(2) TO SECOND")
+        .columnType("INTERVAL DAY(2) TO SECOND NOT NULL");
+    f.expr("INTERVAL '99 23:59:59.999999' DAY TO SECOND(6)")
+        .columnType("INTERVAL DAY TO SECOND(6) NOT NULL");
+    f.expr("INTERVAL '99 0:0:0.0' DAY TO SECOND(6)")
+        .columnType("INTERVAL DAY TO SECOND(6) NOT NULL");
+
+    // max precision
+    f.expr("INTERVAL '2147483647 23:59:59' DAY(10) TO SECOND")
+        .columnType("INTERVAL DAY(10) TO SECOND NOT NULL");
+    f.expr("INTERVAL '2147483647 23:59:59.999999999' DAY(10) TO SECOND(9)")
+        .columnType("INTERVAL DAY(10) TO SECOND(9) NOT NULL");
+
+    // min precision
+    f.expr("INTERVAL '0 0:0:0' DAY(1) TO SECOND")
+        .columnType("INTERVAL DAY(1) TO SECOND NOT NULL");
+    f.expr("INTERVAL '0 0:0:0.0' DAY(1) TO SECOND(1)")
+        .columnType("INTERVAL DAY(1) TO SECOND(1) NOT NULL");
+
+    // alternate precision
+    f.expr("INTERVAL '2345 6:7:8' DAY(4) TO SECOND")
+        .columnType("INTERVAL DAY(4) TO SECOND NOT NULL");
+    f.expr("INTERVAL '2345 6:7:8.9012' DAY(4) TO SECOND(4)")
+        .columnType("INTERVAL DAY(4) TO SECOND(4) NOT NULL");
+
+    // sign
+    f.expr("INTERVAL '-1 2:3:4' DAY TO SECOND")
+        .columnType("INTERVAL DAY TO SECOND NOT NULL");
+    f.expr("INTERVAL '+1 2:3:4' DAY TO SECOND")
+        .columnType("INTERVAL DAY TO SECOND NOT NULL");
+    f.expr("INTERVAL +'1 2:3:4' DAY TO SECOND")
+        .assertParse("INTERVAL '1 2:3:4' DAY TO SECOND")
+        .columnType("INTERVAL DAY TO SECOND NOT NULL");
+    f.expr("INTERVAL +'-1 2:3:4' DAY TO SECOND")
+        .assertParse("INTERVAL '-1 2:3:4' DAY TO SECOND")
+        .columnType("INTERVAL DAY TO SECOND NOT NULL");
+    f.expr("INTERVAL +'+1 2:3:4' DAY TO SECOND")
+        .assertParse("INTERVAL '+1 2:3:4' DAY TO SECOND")
+        .columnType("INTERVAL DAY TO SECOND NOT NULL");
+    f.expr("INTERVAL -'1 2:3:4' DAY TO SECOND")
+        .columnType("INTERVAL DAY TO SECOND NOT NULL");
+    f.expr("INTERVAL -'-1 2:3:4' DAY TO SECOND")
+        .columnType("INTERVAL DAY TO SECOND NOT NULL");
+    f.expr("INTERVAL -'+1 2:3:4' DAY TO SECOND")
+        .columnType("INTERVAL DAY TO SECOND NOT NULL");
+  }
+
+  /**
+   * Runs tests for INTERVAL... HOUR that should pass both parser and
+   * validator. A substantially identical set of tests exists in
+   * SqlParserTest, and any changes here should be synchronized there.
+   * Similarly, any changes to tests here should be echoed appropriately to
+   * each of the other 12 subTestIntervalXXXPositive() tests.
+   */
+  public void subTestIntervalHourPositive() {
+    // default precision
+    f.expr("INTERVAL '1' HOUR")
+        .columnType("INTERVAL HOUR NOT NULL");
+    f.expr("INTERVAL '99' HOUR")
+        .columnType("INTERVAL HOUR NOT NULL");
+
+    // explicit precision equal to default
+    f.expr("INTERVAL '1' HOUR(2)")
+        .columnType("INTERVAL HOUR(2) NOT NULL");
+    f.expr("INTERVAL '99' HOUR(2)")
+        .columnType("INTERVAL HOUR(2) NOT NULL");
+
+    // max precision
+    f.expr("INTERVAL '2147483647' HOUR(10)")
+        .columnType("INTERVAL HOUR(10) NOT NULL");
+
+    // min precision
+    f.expr("INTERVAL '0' HOUR(1)")
+        .columnType("INTERVAL HOUR(1) NOT NULL");
+
+    // alternate precision
+    f.expr("INTERVAL '1234' HOUR(4)")
+        .columnType("INTERVAL HOUR(4) NOT NULL");
+
+    // sign
+    f.expr("INTERVAL '+1' HOUR")
+        .columnType("INTERVAL HOUR NOT NULL");
+    f.expr("INTERVAL '-1' HOUR")
+        .columnType("INTERVAL HOUR NOT NULL");
+    f.expr("INTERVAL +'1' HOUR")
+        .assertParse("INTERVAL '1' HOUR")
+        .columnType("INTERVAL HOUR NOT NULL");
+    f.expr("INTERVAL +'+1' HOUR")
+        .assertParse("INTERVAL '+1' HOUR")
+        .columnType("INTERVAL HOUR NOT NULL");
+    f.expr("INTERVAL +'-1' HOUR")
+        .assertParse("INTERVAL '-1' HOUR")
+        .columnType("INTERVAL HOUR NOT NULL");
+    f.expr("INTERVAL -'1' HOUR")
+        .columnType("INTERVAL HOUR NOT NULL");
+    f.expr("INTERVAL -'+1' HOUR")
+        .columnType("INTERVAL HOUR NOT NULL");
+    f.expr("INTERVAL -'-1' HOUR")
+        .columnType("INTERVAL HOUR NOT NULL");
+  }
+
+  /**
+   * Runs tests for INTERVAL... HOUR TO MINUTE that should pass both parser
+   * and validator. A substantially identical set of tests exists in
+   * SqlParserTest, and any changes here should be synchronized there.
+   * Similarly, any changes to tests here should be echoed appropriately to
+   * each of the other 12 subTestIntervalXXXPositive() tests.
+   */
+  public void subTestIntervalHourToMinutePositive() {
+    // default precision
+    f.expr("INTERVAL '2:3' HOUR TO MINUTE")
+        .columnType("INTERVAL HOUR TO MINUTE NOT NULL");
+    f.expr("INTERVAL '23:59' HOUR TO MINUTE")
+        .columnType("INTERVAL HOUR TO MINUTE NOT NULL");
+    f.expr("INTERVAL '99:0' HOUR TO MINUTE")
+        .columnType("INTERVAL HOUR TO MINUTE NOT NULL");
+
+    // explicit precision equal to default
+    f.expr("INTERVAL '2:3' HOUR(2) TO MINUTE")
+        .columnType("INTERVAL HOUR(2) TO MINUTE NOT NULL");
+    f.expr("INTERVAL '23:59' HOUR(2) TO MINUTE")
+        .columnType("INTERVAL HOUR(2) TO MINUTE NOT NULL");
+    f.expr("INTERVAL '99:0' HOUR(2) TO MINUTE")
+        .columnType("INTERVAL HOUR(2) TO MINUTE NOT NULL");
+
+    // max precision
+    f.expr("INTERVAL '2147483647:59' HOUR(10) TO MINUTE")
+        .columnType("INTERVAL HOUR(10) TO MINUTE NOT NULL");
+
+    // min precision
+    f.expr("INTERVAL '0:0' HOUR(1) TO MINUTE")
+        .columnType("INTERVAL HOUR(1) TO MINUTE NOT NULL");
+
+    // alternate precision
+    f.expr("INTERVAL '2345:7' HOUR(4) TO MINUTE")
+        .columnType("INTERVAL HOUR(4) TO MINUTE NOT NULL");
+
+    // sign
+    f.expr("INTERVAL '-1:3' HOUR TO MINUTE")
+        .columnType("INTERVAL HOUR TO MINUTE NOT NULL");
+    f.expr("INTERVAL '+1:3' HOUR TO MINUTE")
+        .columnType("INTERVAL HOUR TO MINUTE NOT NULL");
+    f.expr("INTERVAL +'2:3' HOUR TO MINUTE")
+        .assertParse("INTERVAL '2:3' HOUR TO MINUTE")
+        .columnType("INTERVAL HOUR TO MINUTE NOT NULL");
+    f.expr("INTERVAL +'-2:3' HOUR TO MINUTE")
+        .assertParse("INTERVAL '-2:3' HOUR TO MINUTE")
+        .columnType("INTERVAL HOUR TO MINUTE NOT NULL");
+    f.expr("INTERVAL +'+2:3' HOUR TO MINUTE")
+        .assertParse("INTERVAL '+2:3' HOUR TO MINUTE")
+        .columnType("INTERVAL HOUR TO MINUTE NOT NULL");
+    f.expr("INTERVAL -'2:3' HOUR TO MINUTE")
+        .columnType("INTERVAL HOUR TO MINUTE NOT NULL");
+    f.expr("INTERVAL -'-2:3' HOUR TO MINUTE")
+        .columnType("INTERVAL HOUR TO MINUTE NOT NULL");
+    f.expr("INTERVAL -'+2:3' HOUR TO MINUTE")
+        .columnType("INTERVAL HOUR TO MINUTE NOT NULL");
+  }
+
+  /**
+   * Runs tests for INTERVAL... HOUR TO SECOND that should pass both parser
+   * and validator. A substantially identical set of tests exists in
+   * SqlParserTest, and any changes here should be synchronized there.
+   * Similarly, any changes to tests here should be echoed appropriately to
+   * each of the other 12 subTestIntervalXXXPositive() tests.
+   */
+  public void subTestIntervalHourToSecondPositive() {
+    // default precision
+    f.expr("INTERVAL '2:3:4' HOUR TO SECOND")
+        .columnType("INTERVAL HOUR TO SECOND NOT NULL");
+    f.expr("INTERVAL '23:59:59' HOUR TO SECOND")
+        .columnType("INTERVAL HOUR TO SECOND NOT NULL");
+    f.expr("INTERVAL '99:0:0' HOUR TO SECOND")
+        .columnType("INTERVAL HOUR TO SECOND NOT NULL");
+    f.expr("INTERVAL '23:59:59.999999' HOUR TO SECOND")
+        .columnType("INTERVAL HOUR TO SECOND NOT NULL");
+    f.expr("INTERVAL '99:0:0.0' HOUR TO SECOND")
+        .columnType("INTERVAL HOUR TO SECOND NOT NULL");
+
+    // explicit precision equal to default
+    f.expr("INTERVAL '2:3:4' HOUR(2) TO SECOND")
+        .columnType("INTERVAL HOUR(2) TO SECOND NOT NULL");
+    f.expr("INTERVAL '99:59:59' HOUR(2) TO SECOND")
+        .columnType("INTERVAL HOUR(2) TO SECOND NOT NULL");
+    f.expr("INTERVAL '99:0:0' HOUR(2) TO SECOND")
+        .columnType("INTERVAL HOUR(2) TO SECOND NOT NULL");
+    f.expr("INTERVAL '99:59:59.999999' HOUR TO SECOND(6)")
+        .columnType("INTERVAL HOUR TO SECOND(6) NOT NULL");
+    f.expr("INTERVAL '99:0:0.0' HOUR TO SECOND(6)")
+        .columnType("INTERVAL HOUR TO SECOND(6) NOT NULL");
+
+    // max precision
+    f.expr("INTERVAL '2147483647:59:59' HOUR(10) TO SECOND")
+        .columnType("INTERVAL HOUR(10) TO SECOND NOT NULL");
+    f.expr("INTERVAL '2147483647:59:59.999999999' HOUR(10) TO SECOND(9)")
+        .columnType("INTERVAL HOUR(10) TO SECOND(9) NOT NULL");
+
+    // min precision
+    f.expr("INTERVAL '0:0:0' HOUR(1) TO SECOND")
+        .columnType("INTERVAL HOUR(1) TO SECOND NOT NULL");
+    f.expr("INTERVAL '0:0:0.0' HOUR(1) TO SECOND(1)")
+        .columnType("INTERVAL HOUR(1) TO SECOND(1) NOT NULL");
+
+    // alternate precision
+    f.expr("INTERVAL '2345:7:8' HOUR(4) TO SECOND")
+        .columnType("INTERVAL HOUR(4) TO SECOND NOT NULL");
+    f.expr("INTERVAL '2345:7:8.9012' HOUR(4) TO SECOND(4)")
+        .columnType("INTERVAL HOUR(4) TO SECOND(4) NOT NULL");
+
+    // sign
+    f.expr("INTERVAL '-2:3:4' HOUR TO SECOND")
+        .columnType("INTERVAL HOUR TO SECOND NOT NULL");
+    f.expr("INTERVAL '+2:3:4' HOUR TO SECOND")
+        .columnType("INTERVAL HOUR TO SECOND NOT NULL");
+    f.expr("INTERVAL +'2:3:4' HOUR TO SECOND")
+        .assertParse("INTERVAL '2:3:4' HOUR TO SECOND")
+        .columnType("INTERVAL HOUR TO SECOND NOT NULL");
+    f.expr("INTERVAL +'-2:3:4' HOUR TO SECOND")
+        .assertParse("INTERVAL '-2:3:4' HOUR TO SECOND")
+        .columnType("INTERVAL HOUR TO SECOND NOT NULL");
+    f.expr("INTERVAL +'+2:3:4' HOUR TO SECOND")
+        .assertParse("INTERVAL '+2:3:4' HOUR TO SECOND")
+        .columnType("INTERVAL HOUR TO SECOND NOT NULL");
+    f.expr("INTERVAL -'2:3:4' HOUR TO SECOND")
+        .columnType("INTERVAL HOUR TO SECOND NOT NULL");
+    f.expr("INTERVAL -'-2:3:4' HOUR TO SECOND")
+        .columnType("INTERVAL HOUR TO SECOND NOT NULL");
+    f.expr("INTERVAL -'+2:3:4' HOUR TO SECOND")
+        .columnType("INTERVAL HOUR TO SECOND NOT NULL");
+  }
+
+  /**
+   * Runs tests for INTERVAL... MINUTE that should pass both parser and
+   * validator. A substantially identical set of tests exists in
+   * SqlParserTest, and any changes here should be synchronized there.
+   * Similarly, any changes to tests here should be echoed appropriately to
+   * each of the other 12 subTestIntervalXXXPositive() tests.
+   */
+  public void subTestIntervalMinutePositive() {
+    // default precision
+    f.expr("INTERVAL '1' MINUTE")
+        .columnType("INTERVAL MINUTE NOT NULL");
+    f.expr("INTERVAL '99' MINUTE")
+        .columnType("INTERVAL MINUTE NOT NULL");
+
+    // explicit precision equal to default
+    f.expr("INTERVAL '1' MINUTE(2)")
+        .columnType("INTERVAL MINUTE(2) NOT NULL");
+    f.expr("INTERVAL '99' MINUTE(2)")
+        .columnType("INTERVAL MINUTE(2) NOT NULL");
+
+    // max precision
+    f.expr("INTERVAL '2147483647' MINUTE(10)")
+        .columnType("INTERVAL MINUTE(10) NOT NULL");
+
+    // min precision
+    f.expr("INTERVAL '0' MINUTE(1)")
+        .columnType("INTERVAL MINUTE(1) NOT NULL");
+
+    // alternate precision
+    f.expr("INTERVAL '1234' MINUTE(4)")
+        .columnType("INTERVAL MINUTE(4) NOT NULL");
+
+    // sign
+    f.expr("INTERVAL '+1' MINUTE")
+        .columnType("INTERVAL MINUTE NOT NULL");
+    f.expr("INTERVAL '-1' MINUTE")
+        .columnType("INTERVAL MINUTE NOT NULL");
+    f.expr("INTERVAL +'1' MINUTE")
+        .assertParse("INTERVAL '1' MINUTE")
+        .columnType("INTERVAL MINUTE NOT NULL");
+    f.expr("INTERVAL +'+1' MINUTE")
+        .assertParse("INTERVAL '+1' MINUTE")
+        .columnType("INTERVAL MINUTE NOT NULL");
+    f.expr("INTERVAL +'-1' MINUTE")
+        .assertParse("INTERVAL '-1' MINUTE")
+        .columnType("INTERVAL MINUTE NOT NULL");
+    f.expr("INTERVAL -'1' MINUTE")
+        .columnType("INTERVAL MINUTE NOT NULL");
+    f.expr("INTERVAL -'+1' MINUTE")
+        .columnType("INTERVAL MINUTE NOT NULL");
+    f.expr("INTERVAL -'-1' MINUTE")
+        .columnType("INTERVAL MINUTE NOT NULL");
+  }
+
+  /**
+   * Runs tests for INTERVAL... MINUTE TO SECOND that should pass both parser
+   * and validator. A substantially identical set of tests exists in
+   * SqlParserTest, and any changes here should be synchronized there.
+   * Similarly, any changes to tests here should be echoed appropriately to
+   * each of the other 12 subTestIntervalXXXPositive() tests.
+   */
+  public void subTestIntervalMinuteToSecondPositive() {
+    // default precision
+    f.expr("INTERVAL '2:4' MINUTE TO SECOND")
+        .columnType("INTERVAL MINUTE TO SECOND NOT NULL");
+    f.expr("INTERVAL '59:59' MINUTE TO SECOND")
+        .columnType("INTERVAL MINUTE TO SECOND NOT NULL");
+    f.expr("INTERVAL '99:0' MINUTE TO SECOND")
+        .columnType("INTERVAL MINUTE TO SECOND NOT NULL");
+    f.expr("INTERVAL '59:59.999999' MINUTE TO SECOND")
+        .columnType("INTERVAL MINUTE TO SECOND NOT NULL");
+    f.expr("INTERVAL '99:0.0' MINUTE TO SECOND")
+        .columnType("INTERVAL MINUTE TO SECOND NOT NULL");
+
+    // explicit precision equal to default
+    f.expr("INTERVAL '2:4' MINUTE(2) TO SECOND")
+        .columnType("INTERVAL MINUTE(2) TO SECOND NOT NULL");
+    f.expr("INTERVAL '99:59' MINUTE(2) TO SECOND")
+        .columnType("INTERVAL MINUTE(2) TO SECOND NOT NULL");
+    f.expr("INTERVAL '99:0' MINUTE(2) TO SECOND")
+        .columnType("INTERVAL MINUTE(2) TO SECOND NOT NULL");
+    f.expr("INTERVAL '99:59.999999' MINUTE TO SECOND(6)")
+        .columnType("INTERVAL MINUTE TO SECOND(6) NOT NULL");
+    f.expr("INTERVAL '99:0.0' MINUTE TO SECOND(6)")
+        .columnType("INTERVAL MINUTE TO SECOND(6) NOT NULL");
+
+    // max precision
+    f.expr("INTERVAL '2147483647:59' MINUTE(10) TO SECOND")
+        .columnType("INTERVAL MINUTE(10) TO SECOND NOT NULL");
+    f.expr("INTERVAL '2147483647:59.999999999' MINUTE(10) TO SECOND(9)")
+        .columnType("INTERVAL MINUTE(10) TO SECOND(9) NOT NULL");
+
+    // min precision
+    f.expr("INTERVAL '0:0' MINUTE(1) TO SECOND")
+        .columnType("INTERVAL MINUTE(1) TO SECOND NOT NULL");
+    f.expr("INTERVAL '0:0.0' MINUTE(1) TO SECOND(1)")
+        .columnType("INTERVAL MINUTE(1) TO SECOND(1) NOT NULL");
+
+    // alternate precision
+    f.expr("INTERVAL '2345:8' MINUTE(4) TO SECOND")
+        .columnType("INTERVAL MINUTE(4) TO SECOND NOT NULL");
+    f.expr("INTERVAL '2345:7.8901' MINUTE(4) TO SECOND(4)")
+        .columnType("INTERVAL MINUTE(4) TO SECOND(4) NOT NULL");
+
+    // sign
+    f.expr("INTERVAL '-3:4' MINUTE TO SECOND")
+        .columnType("INTERVAL MINUTE TO SECOND NOT NULL");
+    f.expr("INTERVAL '+3:4' MINUTE TO SECOND")
+        .columnType("INTERVAL MINUTE TO SECOND NOT NULL");
+    f.expr("INTERVAL +'3:4' MINUTE TO SECOND")
+        .assertParse("INTERVAL '3:4' MINUTE TO SECOND")
+        .columnType("INTERVAL MINUTE TO SECOND NOT NULL");
+    f.expr("INTERVAL +'-3:4' MINUTE TO SECOND")
+        .assertParse("INTERVAL '-3:4' MINUTE TO SECOND")
+        .columnType("INTERVAL MINUTE TO SECOND NOT NULL");
+    f.expr("INTERVAL +'+3:4' MINUTE TO SECOND")
+        .assertParse("INTERVAL '+3:4' MINUTE TO SECOND")
+        .columnType("INTERVAL MINUTE TO SECOND NOT NULL");
+    f.expr("INTERVAL -'3:4' MINUTE TO SECOND")
+        .columnType("INTERVAL MINUTE TO SECOND NOT NULL");
+    f.expr("INTERVAL -'-3:4' MINUTE TO SECOND")
+        .columnType("INTERVAL MINUTE TO SECOND NOT NULL");
+    f.expr("INTERVAL -'+3:4' MINUTE TO SECOND")
+        .columnType("INTERVAL MINUTE TO SECOND NOT NULL");
+  }
+
+  /**
+   * Runs tests for INTERVAL... SECOND that should pass both parser and
+   * validator. A substantially identical set of tests exists in
+   * SqlParserTest, and any changes here should be synchronized there.
+   * Similarly, any changes to tests here should be echoed appropriately to
+   * each of the other 12 subTestIntervalXXXPositive() tests.
+   */
+  public void subTestIntervalSecondPositive() {
+    // default precision
+    f.expr("INTERVAL '1' SECOND")
+        .columnType("INTERVAL SECOND NOT NULL");
+    f.expr("INTERVAL '99' SECOND")
+        .columnType("INTERVAL SECOND NOT NULL");
+
+    // explicit precision equal to default
+    f.expr("INTERVAL '1' SECOND(2)")
+        .columnType("INTERVAL SECOND(2) NOT NULL");
+    f.expr("INTERVAL '99' SECOND(2)")
+        .columnType("INTERVAL SECOND(2) NOT NULL");
+    f.expr("INTERVAL '1' SECOND(2, 6)")
+        .columnType("INTERVAL SECOND(2, 6) NOT NULL");
+    f.expr("INTERVAL '99' SECOND(2, 6)")
+        .columnType("INTERVAL SECOND(2, 6) NOT NULL");
+
+    // max precision
+    f.expr("INTERVAL '2147483647' SECOND(10)")
+        .columnType("INTERVAL SECOND(10) NOT NULL");
+    f.expr("INTERVAL '2147483647.999999999' SECOND(10, 9)")
+        .columnType("INTERVAL SECOND(10, 9) NOT NULL");
+
+    // min precision
+    f.expr("INTERVAL '0' SECOND(1)")
+        .columnType("INTERVAL SECOND(1) NOT NULL");
+    f.expr("INTERVAL '0.0' SECOND(1, 1)")
+        .columnType("INTERVAL SECOND(1, 1) NOT NULL");
+
+    // alternate precision
+    f.expr("INTERVAL '1234' SECOND(4)")
+        .columnType("INTERVAL SECOND(4) NOT NULL");
+    f.expr("INTERVAL '1234.56789' SECOND(4, 5)")
+        .columnType("INTERVAL SECOND(4, 5) NOT NULL");
+
+    // sign
+    f.expr("INTERVAL '+1' SECOND")
+        .columnType("INTERVAL SECOND NOT NULL");
+    f.expr("INTERVAL '-1' SECOND")
+        .columnType("INTERVAL SECOND NOT NULL");
+    f.expr("INTERVAL +'1' SECOND")
+        .assertParse("INTERVAL '1' SECOND")
+        .columnType("INTERVAL SECOND NOT NULL");
+    f.expr("INTERVAL +'+1' SECOND")
+        .assertParse("INTERVAL '+1' SECOND")
+        .columnType("INTERVAL SECOND NOT NULL");
+    f.expr("INTERVAL +'-1' SECOND")
+        .assertParse("INTERVAL '-1' SECOND")
+        .columnType("INTERVAL SECOND NOT NULL");
+    f.expr("INTERVAL -'1' SECOND")
+        .columnType("INTERVAL SECOND NOT NULL");
+    f.expr("INTERVAL -'+1' SECOND")
+        .columnType("INTERVAL SECOND NOT NULL");
+    f.expr("INTERVAL -'-1' SECOND")
+        .columnType("INTERVAL SECOND NOT NULL");
+  }
+
+  /**
+   * Runs tests for INTERVAL... YEAR that should pass parser but fail
+   * validator. A substantially identical set of tests exists in
+   * SqlParserTest, and any changes here should be synchronized there.
+   * Similarly, any changes to tests here should be echoed appropriately to
+   * each of the other 12 subTestIntervalXXXNegative() tests.
+   */
+  public void subTestIntervalYearNegative() {
+    // Qualifier - field mismatches
+    f.wholeExpr("INTERVAL '-' YEAR")
+        .fails("Illegal interval literal format '-' for INTERVAL YEAR.*");
+    f.wholeExpr("INTERVAL '1-2' YEAR")
+        .fails("Illegal interval literal format '1-2' for INTERVAL YEAR.*");
+    f.wholeExpr("INTERVAL '1.2' YEAR")
+        .fails("Illegal interval literal format '1.2' for INTERVAL YEAR.*");
+    f.wholeExpr("INTERVAL '1 2' YEAR")
+        .fails("Illegal interval literal format '1 2' for INTERVAL YEAR.*");
+    f.wholeExpr("INTERVAL '1-2' YEAR(2)")
+        .fails("Illegal interval literal format '1-2' for INTERVAL YEAR\\(2\\)");
+    f.wholeExpr("INTERVAL 'bogus text' YEAR")
+        .fails("Illegal interval literal format 'bogus text' for INTERVAL YEAR.*");
+
+    // negative field values
+    f.wholeExpr("INTERVAL '--1' YEAR")
+        .fails("Illegal interval literal format '--1' for INTERVAL YEAR.*");
+
+    // Field value out of range
+    //  (default, explicit default, alt, neg alt, max, neg max)
+    f.wholeExpr("INTERVAL '100' YEAR")
+        .fails("Interval field value 100 exceeds precision of YEAR\\(2\\) field.*");
+    f.wholeExpr("INTERVAL '100' YEAR(2)")
+        .fails("Interval field value 100 exceeds precision of YEAR\\(2\\) field.*");
+    f.wholeExpr("INTERVAL '1000' YEAR(3)")
+        .fails("Interval field value 1,000 exceeds precision of YEAR\\(3\\) field.*");
+    f.wholeExpr("INTERVAL '-1000' YEAR(3)")
+        .fails("Interval field value -1,000 exceeds precision of YEAR\\(3\\) field.*");
+    f.wholeExpr("INTERVAL '2147483648' YEAR(10)")
+        .fails("Interval field value 2,147,483,648 exceeds precision of "
+            + "YEAR\\(10\\) field.*");
+    f.wholeExpr("INTERVAL '-2147483648' YEAR(10)")
+        .fails("Interval field value -2,147,483,648 exceeds precision of "
+            + "YEAR\\(10\\) field");
+
+    // precision > maximum
+    f.expr("INTERVAL '1' ^YEAR(11)^")
+        .fails("Interval leading field precision '11' out of range for "
+            + "INTERVAL YEAR\\(11\\)");
+
+    // precision < minimum allowed)
+    // note: parser will catch negative values, here we
+    // just need to check for 0
+    f.expr("INTERVAL '0' ^YEAR(0)^")
+        .fails("Interval leading field precision '0' out of range for "
+            + "INTERVAL YEAR\\(0\\)");
+  }
+
+  /**
+   * Runs tests for INTERVAL... YEAR TO MONTH that should pass parser but fail
+   * validator. A substantially identical set of tests exists in
+   * SqlParserTest, and any changes here should be synchronized there.
+   * Similarly, any changes to tests here should be echoed appropriately to
+   * each of the other 12 subTestIntervalXXXNegative() tests.
+   */
+  public void subTestIntervalYearToMonthNegative() {
+    // Qualifier - field mismatches
+    f.wholeExpr("INTERVAL '-' YEAR TO MONTH")
+        .fails("Illegal interval literal format '-' for INTERVAL YEAR TO MONTH");
+    f.wholeExpr("INTERVAL '1' YEAR TO MONTH")
+        .fails("Illegal interval literal format '1' for INTERVAL YEAR TO MONTH");
+    f.wholeExpr("INTERVAL '1:2' YEAR TO MONTH")
+        .fails("Illegal interval literal format '1:2' for INTERVAL YEAR TO MONTH");
+    f.wholeExpr("INTERVAL '1.2' YEAR TO MONTH")
+        .fails("Illegal interval literal format '1.2' for INTERVAL YEAR TO MONTH");
+    f.wholeExpr("INTERVAL '1 2' YEAR TO MONTH")
+        .fails("Illegal interval literal format '1 2' for INTERVAL YEAR TO MONTH");
+    f.wholeExpr("INTERVAL '1:2' YEAR(2) TO MONTH")
+        .fails("Illegal interval literal format '1:2' for "
+            + "INTERVAL YEAR\\(2\\) TO MONTH");
+    f.wholeExpr("INTERVAL 'bogus text' YEAR TO MONTH")
+        .fails("Illegal interval literal format 'bogus text' for "
+            + "INTERVAL YEAR TO MONTH");
+
+    // negative field values
+    f.wholeExpr("INTERVAL '--1-2' YEAR TO MONTH")
+        .fails("Illegal interval literal format '--1-2' for "
+            + "INTERVAL YEAR TO MONTH");
+    f.wholeExpr("INTERVAL '1--2' YEAR TO MONTH")
+        .fails("Illegal interval literal format '1--2' for "
+            + "INTERVAL YEAR TO MONTH");
+
+    // Field value out of range
+    //  (default, explicit default, alt, neg alt, max, neg max)
+    //  plus >max value for mid/end fields
+    f.wholeExpr("INTERVAL '100-0' YEAR TO MONTH")
+        .fails("Interval field value 100 exceeds precision of YEAR\\(2\\) field.*");
+    f.wholeExpr("INTERVAL '100-0' YEAR(2) TO MONTH")
+        .fails("Interval field value 100 exceeds precision of YEAR\\(2\\) field.*");
+    f.wholeExpr("INTERVAL '1000-0' YEAR(3) TO MONTH")
+        .fails("Interval field value 1,000 exceeds precision of YEAR\\(3\\) field.*");
+    f.wholeExpr("INTERVAL '-1000-0' YEAR(3) TO MONTH")
+        .fails("Interval field value -1,000 exceeds precision of YEAR\\(3\\) field.*");
+    f.wholeExpr("INTERVAL '2147483648-0' YEAR(10) TO MONTH")
+        .fails("Interval field value 2,147,483,648 exceeds precision of YEAR\\(10\\) field.*");
+    f.wholeExpr("INTERVAL '-2147483648-0' YEAR(10) TO MONTH")
+        .fails("Interval field value -2,147,483,648 exceeds precision of YEAR\\(10\\) field.*");
+    f.wholeExpr("INTERVAL '1-12' YEAR TO MONTH")
+        .fails("Illegal interval literal format '1-12' for INTERVAL YEAR TO MONTH.*");
+
+    // precision > maximum
+    f.expr("INTERVAL '1-1' ^YEAR(11) TO MONTH^")
+        .fails("Interval leading field precision '11' out of range for "
+            + "INTERVAL YEAR\\(11\\) TO MONTH");
+
+    // precision < minimum allowed)
+    // note: parser will catch negative values, here we
+    // just need to check for 0
+    f.expr("INTERVAL '0-0' ^YEAR(0) TO MONTH^")
+        .fails("Interval leading field precision '0' out of range for "
+            + "INTERVAL YEAR\\(0\\) TO MONTH");
+  }
+
+  /**
+   * Runs tests for INTERVAL... WEEK that should pass both parser and
+   * validator. A substantially identical set of tests exists in
+   * SqlValidatorTest, and any changes here should be synchronized there.
+   * Similarly, any changes to tests here should be echoed appropriately to
+   * each of the other 12 subTestIntervalXXXPositive() tests.
+   */
+  public void subTestIntervalWeekPositive() {
+    // default precision
+    f.expr("INTERVAL '1' WEEK")
+        .columnType("INTERVAL WEEK NOT NULL");
+    f.expr("INTERVAL '99' WEEK")
+        .columnType("INTERVAL WEEK NOT NULL");
+
+    // explicit precision equal to default
+    f.expr("INTERVAL '1' WEEK(2)")
+        .columnType("INTERVAL WEEK(2) NOT NULL");
+    f.expr("INTERVAL '99' WEEK(2)")
+        .columnType("INTERVAL WEEK(2) NOT NULL");
+
+    // max precision
+    f.expr("INTERVAL '2147483647' WEEK(10)")
+        .columnType("INTERVAL WEEK(10) NOT NULL");
+
+    // min precision
+    f.expr("INTERVAL '0' WEEK(1)")
+        .columnType("INTERVAL WEEK(1) NOT NULL");
+
+    // alternate precision
+    f.expr("INTERVAL '1234' WEEK(4)")
+        .columnType("INTERVAL WEEK(4) NOT NULL");
+
+    // sign
+    f.expr("INTERVAL '+1' WEEK")
+        .columnType("INTERVAL WEEK NOT NULL");
+    f.expr("INTERVAL '-1' WEEK")
+        .columnType("INTERVAL WEEK NOT NULL");
+    f.expr("INTERVAL +'1' WEEK")
+        .assertParse("INTERVAL '1' WEEK")
+        .columnType("INTERVAL WEEK NOT NULL");
+    f.expr("INTERVAL +'+1' WEEK")
+        .assertParse("INTERVAL '+1' WEEK")
+        .columnType("INTERVAL WEEK NOT NULL");
+    f.expr("INTERVAL +'-1' WEEK")
+        .assertParse("INTERVAL '-1' WEEK")
+        .columnType("INTERVAL WEEK NOT NULL");
+    f.expr("INTERVAL -'1' WEEK")
+        .columnType("INTERVAL WEEK NOT NULL");
+    f.expr("INTERVAL -'+1' WEEK")
+        .columnType("INTERVAL WEEK NOT NULL");
+    f.expr("INTERVAL -'-1' WEEK")
+        .columnType("INTERVAL WEEK NOT NULL");
+  }
+
+  /**
+   * Runs tests for INTERVAL... QUARTER that should pass both parser and
+   * validator. A substantially identical set of tests exists in
+   * SqlValidatorTest, and any changes here should be synchronized there.
+   * Similarly, any changes to tests here should be echoed appropriately to
+   * each of the other 12 subTestIntervalXXXPositive() tests.
+   */
+  public void subTestIntervalQuarterPositive() {
+    // default precision
+    f.expr("INTERVAL '1' QUARTER")
+        .columnType("INTERVAL QUARTER NOT NULL");
+    f.expr("INTERVAL '99' QUARTER")
+        .columnType("INTERVAL QUARTER NOT NULL");
+
+    // explicit precision equal to default
+    f.expr("INTERVAL '1' QUARTER(2)")
+        .columnType("INTERVAL QUARTER(2) NOT NULL");
+    f.expr("INTERVAL '99' QUARTER(2)")
+        .columnType("INTERVAL QUARTER(2) NOT NULL");
+
+    // max precision
+    f.expr("INTERVAL '2147483647' QUARTER(10)")
+        .columnType("INTERVAL QUARTER(10) NOT NULL");
+
+    // min precision
+    f.expr("INTERVAL '0' QUARTER(1)")
+        .columnType("INTERVAL QUARTER(1) NOT NULL");
+
+    // alternate precision
+    f.expr("INTERVAL '1234' QUARTER(4)")
+        .columnType("INTERVAL QUARTER(4) NOT NULL");
+
+    // sign
+    f.expr("INTERVAL '+1' QUARTER")
+        .columnType("INTERVAL QUARTER NOT NULL");
+    f.expr("INTERVAL '-1' QUARTER")
+        .columnType("INTERVAL QUARTER NOT NULL");
+    f.expr("INTERVAL +'1' QUARTER")
+        .assertParse("INTERVAL '1' QUARTER")
+        .columnType("INTERVAL QUARTER NOT NULL");
+    f.expr("INTERVAL +'+1' QUARTER")
+        .assertParse("INTERVAL '+1' QUARTER")
+        .columnType("INTERVAL QUARTER NOT NULL");
+    f.expr("INTERVAL +'-1' QUARTER")
+        .assertParse("INTERVAL '-1' QUARTER")
+        .columnType("INTERVAL QUARTER NOT NULL");
+    f.expr("INTERVAL -'1' QUARTER")
+        .columnType("INTERVAL QUARTER NOT NULL");
+    f.expr("INTERVAL -'+1' QUARTER")
+        .columnType("INTERVAL QUARTER NOT NULL");
+    f.expr("INTERVAL -'-1' QUARTER")
+        .columnType("INTERVAL QUARTER NOT NULL");
+  }
+
+  public void subTestIntervalPlural() {
+    f.expr("INTERVAL '+2' SECONDS")
+        .assertParse("INTERVAL '+2' SECOND")
+        .columnType("INTERVAL SECOND NOT NULL");
+    f.expr("INTERVAL '+2' HOURS")
+        .assertParse("INTERVAL '+2' HOUR")
+        .columnType("INTERVAL HOUR NOT NULL");
+    f.expr("INTERVAL '+2' DAYS")
+        .assertParse("INTERVAL '+2' DAY")
+        .columnType("INTERVAL DAY NOT NULL");
+    f.expr("INTERVAL '+2' WEEKS")
+        .assertParse("INTERVAL '+2' WEEK")
+        .columnType("INTERVAL WEEK NOT NULL");
+    f.expr("INTERVAL '+2' QUARTERS")
+        .assertParse("INTERVAL '+2' QUARTER")
+        .columnType("INTERVAL QUARTER NOT NULL");
+    f.expr("INTERVAL '+2' MONTHS")
+        .assertParse("INTERVAL '+2' MONTH")
+        .columnType("INTERVAL MONTH NOT NULL");
+    f.expr("INTERVAL '+2' YEARS")
+        .assertParse("INTERVAL '+2' YEAR")
+        .columnType("INTERVAL YEAR NOT NULL");
+  }
+
+  /**
+   * Runs tests for INTERVAL... MONTH that should pass parser but fail
+   * validator. A substantially identical set of tests exists in
+   * SqlParserTest, and any changes here should be synchronized there.
+   * Similarly, any changes to tests here should be echoed appropriately to
+   * each of the other 12 subTestIntervalXXXNegative() tests.
+   */
+  public void subTestIntervalMonthNegative() {
+    // Qualifier - field mismatches
+    f.wholeExpr("INTERVAL '-' MONTH")
+        .fails("Illegal interval literal format '-' for INTERVAL MONTH.*");
+    f.wholeExpr("INTERVAL '1-2' MONTH")
+        .fails("Illegal interval literal format '1-2' for INTERVAL MONTH.*");
+    f.wholeExpr("INTERVAL '1.2' MONTH")
+        .fails("Illegal interval literal format '1.2' for INTERVAL MONTH.*");
+    f.wholeExpr("INTERVAL '1 2' MONTH")
+        .fails("Illegal interval literal format '1 2' for INTERVAL MONTH.*");
+    f.wholeExpr("INTERVAL '1-2' MONTH(2)")
+        .fails("Illegal interval literal format '1-2' for INTERVAL MONTH\\(2\\)");
+    f.wholeExpr("INTERVAL 'bogus text' MONTH")
+        .fails("Illegal interval literal format 'bogus text' for INTERVAL MONTH.*");
+
+    // negative field values
+    f.wholeExpr("INTERVAL '--1' MONTH")
+        .fails("Illegal interval literal format '--1' for INTERVAL MONTH.*");
+
+    // Field value out of range
+    //  (default, explicit default, alt, neg alt, max, neg max)
+    f.wholeExpr("INTERVAL '100' MONTH")
+        .fails("Interval field value 100 exceeds precision of MONTH\\(2\\) field.*");
+    f.wholeExpr("INTERVAL '100' MONTH(2)")
+        .fails("Interval field value 100 exceeds precision of MONTH\\(2\\) field.*");
+    f.wholeExpr("INTERVAL '1000' MONTH(3)")
+        .fails("Interval field value 1,000 exceeds precision of MONTH\\(3\\) field.*");
+    f.wholeExpr("INTERVAL '-1000' MONTH(3)")
+        .fails("Interval field value -1,000 exceeds precision of MONTH\\(3\\) field.*");
+    f.wholeExpr("INTERVAL '2147483648' MONTH(10)")
+        .fails("Interval field value 2,147,483,648 exceeds precision of MONTH\\(10\\) field.*");
+    f.wholeExpr("INTERVAL '-2147483648' MONTH(10)")
+        .fails("Interval field value -2,147,483,648 exceeds precision of MONTH\\(10\\) field.*");
+
+    // precision > maximum
+    f.expr("INTERVAL '1' ^MONTH(11)^")
+        .fails("Interval leading field precision '11' out of range for "
+            + "INTERVAL MONTH\\(11\\)");
+
+    // precision < minimum allowed)
+    // note: parser will catch negative values, here we
+    // just need to check for 0
+    f.expr("INTERVAL '0' ^MONTH(0)^")
+        .fails("Interval leading field precision '0' out of range for "
+            + "INTERVAL MONTH\\(0\\)");
+  }
+
+  /**
+   * Runs tests for INTERVAL... DAY that should pass parser but fail
+   * validator. A substantially identical set of tests exists in
+   * SqlParserTest, and any changes here should be synchronized there.
+   * Similarly, any changes to tests here should be echoed appropriately to
+   * each of the other 12 subTestIntervalXXXNegative() tests.
+   */
+  public void subTestIntervalDayNegative() {
+    // Qualifier - field mismatches
+    f.wholeExpr("INTERVAL '-' DAY")
+        .fails("Illegal interval literal format '-' for INTERVAL DAY.*");
+    f.wholeExpr("INTERVAL '1-2' DAY")
+        .fails("Illegal interval literal format '1-2' for INTERVAL DAY.*");
+    f.wholeExpr("INTERVAL '1.2' DAY")
+        .fails("Illegal interval literal format '1.2' for INTERVAL DAY.*");
+    f.wholeExpr("INTERVAL '1 2' DAY")
+        .fails("Illegal interval literal format '1 2' for INTERVAL DAY.*");
+    f.wholeExpr("INTERVAL '1:2' DAY")
+        .fails("Illegal interval literal format '1:2' for INTERVAL DAY.*");
+    f.wholeExpr("INTERVAL '1-2' DAY(2)")
+        .fails("Illegal interval literal format '1-2' for INTERVAL DAY\\(2\\)");
+    f.wholeExpr("INTERVAL 'bogus text' DAY")
+        .fails("Illegal interval literal format 'bogus text' for INTERVAL DAY.*");
+
+    // negative field values
+    f.wholeExpr("INTERVAL '--1' DAY")
+        .fails("Illegal interval literal format '--1' for INTERVAL DAY.*");
+
+    // Field value out of range
+    //  (default, explicit default, alt, neg alt, max, neg max)
+    f.wholeExpr("INTERVAL '100' DAY")
+        .fails("Interval field value 100 exceeds precision of DAY\\(2\\) field.*");
+    f.wholeExpr("INTERVAL '100' DAY(2)")
+        .fails("Interval field value 100 exceeds precision of DAY\\(2\\) field.*");
+    f.wholeExpr("INTERVAL '1000' DAY(3)")
+        .fails("Interval field value 1,000 exceeds precision of DAY\\(3\\) field.*");
+    f.wholeExpr("INTERVAL '-1000' DAY(3)")
+        .fails("Interval field value -1,000 exceeds precision of DAY\\(3\\) field.*");
+    f.wholeExpr("INTERVAL '2147483648' DAY(10)")
+        .fails("Interval field value 2,147,483,648 exceeds precision of "
+            + "DAY\\(10\\) field.*");
+    f.wholeExpr("INTERVAL '-2147483648' DAY(10)")
+        .fails("Interval field value -2,147,483,648 exceeds precision of "
+            + "DAY\\(10\\) field.*");
+
+    // precision > maximum
+    f.expr("INTERVAL '1' ^DAY(11)^")
+        .fails("Interval leading field precision '11' out of range for "
+            + "INTERVAL DAY\\(11\\)");
+
+    // precision < minimum allowed)
+    // note: parser will catch negative values, here we
+    // just need to check for 0
+    f.expr("INTERVAL '0' ^DAY(0)^")
+        .fails("Interval leading field precision '0' out of range for "
+            + "INTERVAL DAY\\(0\\)");
+  }
+
+  /**
+   * Runs tests for INTERVAL... DAY TO HOUR that should pass parser but fail
+   * validator. A substantially identical set of tests exists in
+   * SqlParserTest, and any changes here should be synchronized there.
+   * Similarly, any changes to tests here should be echoed appropriately to
+   * each of the other 12 subTestIntervalXXXNegative() tests.
+   */
+  public void subTestIntervalDayToHourNegative() {
+    // Qualifier - field mismatches
+    f.wholeExpr("INTERVAL '-' DAY TO HOUR")
+        .fails("Illegal interval literal format '-' for INTERVAL DAY TO HOUR");
+    f.wholeExpr("INTERVAL '1' DAY TO HOUR")
+        .fails("Illegal interval literal format '1' for INTERVAL DAY TO HOUR");
+    f.wholeExpr("INTERVAL '1:2' DAY TO HOUR")
+        .fails("Illegal interval literal format '1:2' for INTERVAL DAY TO HOUR");
+    f.wholeExpr("INTERVAL '1.2' DAY TO HOUR")
+        .fails("Illegal interval literal format '1.2' for INTERVAL DAY TO HOUR");
+    f.wholeExpr("INTERVAL '1 x' DAY TO HOUR")
+        .fails("Illegal interval literal format '1 x' for INTERVAL DAY TO HOUR");
+    f.wholeExpr("INTERVAL ' ' DAY TO HOUR")
+        .fails("Illegal interval literal format ' ' for INTERVAL DAY TO HOUR");
+    f.wholeExpr("INTERVAL '1:2' DAY(2) TO HOUR")
+        .fails("Illegal interval literal format '1:2' for "
+            + "INTERVAL DAY\\(2\\) TO HOUR");
+    f.wholeExpr("INTERVAL 'bogus text' DAY TO HOUR")
+        .fails("Illegal interval literal format 'bogus text' for "
+            + "INTERVAL DAY TO HOUR");
+
+    // negative field values
+    f.wholeExpr("INTERVAL '--1 1' DAY TO HOUR")
+        .fails("Illegal interval literal format '--1 1' for INTERVAL DAY TO HOUR");
+    f.wholeExpr("INTERVAL '1 -1' DAY TO HOUR")
+        .fails("Illegal interval literal format '1 -1' for INTERVAL DAY TO HOUR");
+
+    // Field value out of range
+    //  (default, explicit default, alt, neg alt, max, neg max)
+    //  plus >max value for mid/end fields
+    f.wholeExpr("INTERVAL '100 0' DAY TO HOUR")
+        .fails("Interval field value 100 exceeds precision of DAY\\(2\\) field.*");
+    f.wholeExpr("INTERVAL '100 0' DAY(2) TO HOUR")
+        .fails("Interval field value 100 exceeds precision of DAY\\(2\\) field.*");
+    f.wholeExpr("INTERVAL '1000 0' DAY(3) TO HOUR")
+        .fails("Interval field value 1,000 exceeds precision of DAY\\(3\\) field.*");
+    f.wholeExpr("INTERVAL '-1000 0' DAY(3) TO HOUR")
+        .fails("Interval field value -1,000 exceeds precision of DAY\\(3\\) field.*");
+    f.wholeExpr("INTERVAL '2147483648 0' DAY(10) TO HOUR")
+        .fails("Interval field value 2,147,483,648 exceeds precision of DAY\\(10\\) field.*");
+    f.wholeExpr("INTERVAL '-2147483648 0' DAY(10) TO HOUR")
+        .fails("Interval field value -2,147,483,648 exceeds precision of "
+            + "DAY\\(10\\) field.*");
+    f.wholeExpr("INTERVAL '1 24' DAY TO HOUR")
+        .fails("Illegal interval literal format '1 24' for INTERVAL DAY TO HOUR.*");
+
+    // precision > maximum
+    f.expr("INTERVAL '1 1' ^DAY(11) TO HOUR^")
+        .fails("Interval leading field precision '11' out of range for "
+            + "INTERVAL DAY\\(11\\) TO HOUR");
+
+    // precision < minimum allowed)
+    // note: parser will catch negative values, here we
+    // just need to check for 0
+    f.expr("INTERVAL '0 0' ^DAY(0) TO HOUR^")
+        .fails("Interval leading field precision '0' out of range for INTERVAL DAY\\(0\\) TO HOUR");
+  }
+
+  /**
+   * Runs tests for INTERVAL... DAY TO MINUTE that should pass parser but fail
+   * validator. A substantially identical set of tests exists in
+   * SqlParserTest, and any changes here should be synchronized there.
+   * Similarly, any changes to tests here should be echoed appropriately to
+   * each of the other 12 subTestIntervalXXXNegative() tests.
+   */
+  public void subTestIntervalDayToMinuteNegative() {
+    // Qualifier - field mismatches
+    f.wholeExpr("INTERVAL ' :' DAY TO MINUTE")
+        .fails("Illegal interval literal format ' :' for INTERVAL DAY TO MINUTE");
+    f.wholeExpr("INTERVAL '1' DAY TO MINUTE")
+        .fails("Illegal interval literal format '1' for INTERVAL DAY TO MINUTE");
+    f.wholeExpr("INTERVAL '1 2' DAY TO MINUTE")
+        .fails("Illegal interval literal format '1 2' for INTERVAL DAY TO MINUTE");
+    f.wholeExpr("INTERVAL '1:2' DAY TO MINUTE")
+        .fails("Illegal interval literal format '1:2' for INTERVAL DAY TO MINUTE");
+    f.wholeExpr("INTERVAL '1.2' DAY TO MINUTE")
+        .fails("Illegal interval literal format '1.2' for INTERVAL DAY TO MINUTE");
+    f.wholeExpr("INTERVAL 'x 1:1' DAY TO MINUTE")
+        .fails("Illegal interval literal format 'x 1:1' for INTERVAL DAY TO MINUTE");
+    f.wholeExpr("INTERVAL '1 x:1' DAY TO MINUTE")
+        .fails("Illegal interval literal format '1 x:1' for INTERVAL DAY TO MINUTE");
+    f.wholeExpr("INTERVAL '1 1:x' DAY TO MINUTE")
+        .fails("Illegal interval literal format '1 1:x' for INTERVAL DAY TO MINUTE");
+    f.wholeExpr("INTERVAL '1 1:2:3' DAY TO MINUTE")
+        .fails("Illegal interval literal format '1 1:2:3' for INTERVAL DAY TO MINUTE");
+    f.wholeExpr("INTERVAL '1 1:1:1.2' DAY TO MINUTE")
+        .fails("Illegal interval literal format '1 1:1:1.2' for INTERVAL DAY TO MINUTE");
+    f.wholeExpr("INTERVAL '1 1:2:3' DAY(2) TO MINUTE")
+        .fails("Illegal interval literal format '1 1:2:3' for "
+            + "INTERVAL DAY\\(2\\) TO MINUTE");
+    f.wholeExpr("INTERVAL '1 1' DAY(2) TO MINUTE")
+        .fails("Illegal interval literal format '1 1' for "
+            + "INTERVAL DAY\\(2\\) TO MINUTE");
+    f.wholeExpr("INTERVAL 'bogus text' DAY TO MINUTE")
+        .fails("Illegal interval literal format 'bogus text' for "
+            + "INTERVAL DAY TO MINUTE");
+
+    // negative field values
+    f.wholeExpr("INTERVAL '--1 1:1' DAY TO MINUTE")
+        .fails("Illegal interval literal format '--1 1:1' for INTERVAL DAY TO MINUTE");
+    f.wholeExpr("INTERVAL '1 -1:1' DAY TO MINUTE")
+        .fails("Illegal interval literal format '1 -1:1' for INTERVAL DAY TO MINUTE");
+    f.wholeExpr("INTERVAL '1 1:-1' DAY TO MINUTE")
+        .fails("Illegal interval literal format '1 1:-1' for INTERVAL DAY TO MINUTE");
+
+    // Field value out of range
+    //  (default, explicit default, alt, neg alt, max, neg max)
+    //  plus >max value for mid/end fields
+    f.wholeExpr("INTERVAL '100 0:0' DAY TO MINUTE")
+        .fails("Interval field value 100 exceeds precision of DAY\\(2\\) field.*");
+    f.wholeExpr("INTERVAL '100 0:0' DAY(2) TO MINUTE")
+        .fails("Interval field value 100 exceeds precision of DAY\\(2\\) field.*");
+    f.wholeExpr("INTERVAL '1000 0:0' DAY(3) TO MINUTE")
+        .fails("Interval field value 1,000 exceeds precision of DAY\\(3\\) field.*");
+    f.wholeExpr("INTERVAL '-1000 0:0' DAY(3) TO MINUTE")
+        .fails("Interval field value -1,000 exceeds precision of DAY\\(3\\) field.*");
+    f.wholeExpr("INTERVAL '2147483648 0:0' DAY(10) TO MINUTE")
+        .fails("Interval field value 2,147,483,648 exceeds precision of "
+            + "DAY\\(10\\) field.*");
+    f.wholeExpr("INTERVAL '-2147483648 0:0' DAY(10) TO MINUTE")
+        .fails("Interval field value -2,147,483,648 exceeds precision of "
+            + "DAY\\(10\\) field.*");
+    f.wholeExpr("INTERVAL '1 24:1' DAY TO MINUTE")
+        .fails("Illegal interval literal format '1 24:1' for "
+            + "INTERVAL DAY TO MINUTE.*");
+    f.wholeExpr("INTERVAL '1 1:60' DAY TO MINUTE")
+        .fails("Illegal interval literal format '1 1:60' for INTERVAL DAY TO MINUTE.*");
+
+    // precision > maximum
+    f.expr("INTERVAL '1 1:1' ^DAY(11) TO MINUTE^")
+        .fails("Interval leading field precision '11' out of range for "
+            + "INTERVAL DAY\\(11\\) TO MINUTE");
+
+    // precision < minimum allowed)
+    // note: parser will catch negative values, here we
+    // just need to check for 0
+    f.expr("INTERVAL '0 0' ^DAY(0) TO MINUTE^")
+        .fails("Interval leading field precision '0' out of range for "
+            + "INTERVAL DAY\\(0\\) TO MINUTE");
+  }
+
+  /**
+   * Runs tests for INTERVAL... DAY TO SECOND that should pass parser but fail
+   * validator. A substantially identical set of tests exists in
+   * SqlParserTest, and any changes here should be synchronized there.
+   * Similarly, any changes to tests here should be echoed appropriately to
+   * each of the other 12 subTestIntervalXXXNegative() tests.
+   */
+  public void subTestIntervalDayToSecondNegative() {
+    // Qualifier - field mismatches
+    f.wholeExpr("INTERVAL ' ::' DAY TO SECOND")
+        .fails("Illegal interval literal format ' ::' for INTERVAL DAY TO SECOND");
+    f.wholeExpr("INTERVAL ' ::.' DAY TO SECOND")
+        .fails("Illegal interval literal format ' ::\\.' for INTERVAL DAY TO SECOND");
+    f.wholeExpr("INTERVAL '1' DAY TO SECOND")
+        .fails("Illegal interval literal format '1' for INTERVAL DAY TO SECOND");
+    f.wholeExpr("INTERVAL '1 2' DAY TO SECOND")
+        .fails("Illegal interval literal format '1 2' for INTERVAL DAY TO SECOND");
+    f.wholeExpr("INTERVAL '1:2' DAY TO SECOND")
+        .fails("Illegal interval literal format '1:2' for "
+            + "INTERVAL DAY TO SECOND");
+    f.wholeExpr("INTERVAL '1.2' DAY TO SECOND")
+        .fails("Illegal interval literal format '1\\.2' for "
+            + "INTERVAL DAY TO SECOND");
+    f.wholeExpr("INTERVAL '1 1:2' DAY TO SECOND")
+        .fails("Illegal interval literal format '1 1:2' for "
+            + "INTERVAL DAY TO SECOND");
+    f.wholeExpr("INTERVAL '1 1:2:x' DAY TO SECOND")
+        .fails("Illegal interval literal format '1 1:2:x' for "
+            + "INTERVAL DAY TO SECOND");
+    f.wholeExpr("INTERVAL '1:2:3' DAY TO SECOND")
+        .fails("Illegal interval literal format '1:2:3' for "
+            + "INTERVAL DAY TO SECOND");
+    f.wholeExpr("INTERVAL '1:1:1.2' DAY TO SECOND")
+        .fails("Illegal interval literal format '1:1:1\\.2' for "
+            + "INTERVAL DAY TO SECOND");
+    f.wholeExpr("INTERVAL '1 1:2' DAY(2) TO SECOND")
+        .fails("Illegal interval literal format '1 1:2' for "
+            + "INTERVAL DAY\\(2\\) TO SECOND");
+    f.wholeExpr("INTERVAL '1 1' DAY(2) TO SECOND")
+        .fails("Illegal interval literal format '1 1' for "
+            + "INTERVAL DAY\\(2\\) TO SECOND");
+    f.wholeExpr("INTERVAL 'bogus text' DAY TO SECOND")
+        .fails("Illegal interval literal format 'bogus text' for "
+            + "INTERVAL DAY TO SECOND");
+    f.wholeExpr("INTERVAL '2345 6:7:8901' DAY TO SECOND(4)")
+        .fails("Illegal interval literal format '2345 6:7:8901' for "
+            + "INTERVAL DAY TO SECOND\\(4\\)");
+
+    // negative field values
+    f.wholeExpr("INTERVAL '--1 1:1:1' DAY TO SECOND")
+        .fails("Illegal interval literal format '--1 1:1:1' for "
+            + "INTERVAL DAY TO SECOND");
+    f.wholeExpr("INTERVAL '1 -1:1:1' DAY TO SECOND")
+        .fails("Illegal interval literal format '1 -1:1:1' for "
+            + "INTERVAL DAY TO SECOND");
+    f.wholeExpr("INTERVAL '1 1:-1:1' DAY TO SECOND")
+        .fails("Illegal interval literal format '1 1:-1:1' for "
+            + "INTERVAL DAY TO SECOND");
+    f.wholeExpr("INTERVAL '1 1:1:-1' DAY TO SECOND")
+        .fails("Illegal interval literal format '1 1:1:-1' for "
+            + "INTERVAL DAY TO SECOND");
+    f.wholeExpr("INTERVAL '1 1:1:1.-1' DAY TO SECOND")
+        .fails("Illegal interval literal format '1 1:1:1.-1' for "
+            + "INTERVAL DAY TO SECOND");
+
+    // Field value out of range
+    //  (default, explicit default, alt, neg alt, max, neg max)
+    //  plus >max value for mid/end fields
+    f.wholeExpr("INTERVAL '100 0' DAY TO SECOND")
+        .fails("Illegal interval literal format '100 0' for "
+            + "INTERVAL DAY TO SECOND.*");
+    f.wholeExpr("INTERVAL '100 0' DAY(2) TO SECOND")
+        .fails("Illegal interval literal format '100 0' for "
+            + "INTERVAL DAY\\(2\\) TO SECOND.*");
+    f.wholeExpr("INTERVAL '1000 0' DAY(3) TO SECOND")
+        .fails("Illegal interval literal format '1000 0' for "
+            + "INTERVAL DAY\\(3\\) TO SECOND.*");
+    f.wholeExpr("INTERVAL '-1000 0' DAY(3) TO SECOND")
+        .fails("Illegal interval literal format '-1000 0' for "
+            + "INTERVAL DAY\\(3\\) TO SECOND.*");
+    f.wholeExpr("INTERVAL '2147483648 1:1:0' DAY(10) TO SECOND")
+        .fails("Interval field value 2,147,483,648 exceeds precision of "
+            + "DAY\\(10\\) field.*");
+    f.wholeExpr("INTERVAL '-2147483648 1:1:0' DAY(10) TO SECOND")
+        .fails("Interval field value -2,147,483,648 exceeds precision of "
+            + "DAY\\(10\\) field.*");
+    f.wholeExpr("INTERVAL '2147483648 0' DAY(10) TO SECOND")
+        .fails("Illegal interval literal format '2147483648 0' for "
+            + "INTERVAL DAY\\(10\\) TO SECOND.*");
+    f.wholeExpr("INTERVAL '-2147483648 0' DAY(10) TO SECOND")
+        .fails("Illegal interval literal format '-2147483648 0' for "
+            + "INTERVAL DAY\\(10\\) TO SECOND.*");
+    f.wholeExpr("INTERVAL '1 24:1:1' DAY TO SECOND")
+        .fails("Illegal interval literal format '1 24:1:1' for "
+            + "INTERVAL DAY TO SECOND.*");
+    f.wholeExpr("INTERVAL '1 1:60:1' DAY TO SECOND")
+        .fails("Illegal interval literal format '1 1:60:1' for "
+            + "INTERVAL DAY TO SECOND.*");
+    f.wholeExpr("INTERVAL '1 1:1:60' DAY TO SECOND")
+        .fails("Illegal interval literal format '1 1:1:60' for "
+            + "INTERVAL DAY TO SECOND.*");
+    f.wholeExpr("INTERVAL '1 1:1:1.0000001' DAY TO SECOND")
+        .fails("Illegal interval literal format '1 1:1:1\\.0000001' for "
+            + "INTERVAL DAY TO SECOND.*");
+    f.wholeExpr("INTERVAL '1 1:1:1.0001' DAY TO SECOND(3)")
+        .fails("Illegal interval literal format '1 1:1:1\\.0001' for "
+            + "INTERVAL DAY TO SECOND\\(3\\).*");
+
+    // precision > maximum
+    f.expr("INTERVAL '1 1' ^DAY(11) TO SECOND^")
+        .fails("Interval leading field precision '11' out of range for "
+            + "INTERVAL DAY\\(11\\) TO SECOND");
+    f.expr("INTERVAL '1 1' ^DAY TO SECOND(10)^")
+        .fails("Interval fractional second precision '10' out of range for "
+            + "INTERVAL DAY TO SECOND\\(10\\)");
+
+    // precision < minimum allowed)
+    // note: parser will catch negative values, here we
+    // just need to check for 0
+    f.expr("INTERVAL '0 0:0:0' ^DAY(0) TO SECOND^")
+        .fails("Interval leading field precision '0' out of range for "
+            + "INTERVAL DAY\\(0\\) TO SECOND");
+    f.expr("INTERVAL '0 0:0:0' ^DAY TO SECOND(0)^")
+        .fails("Interval fractional second precision '0' out of range for "
+            + "INTERVAL DAY TO SECOND\\(0\\)");
+  }
+
+  /**
+   * Runs tests for INTERVAL... HOUR that should pass parser but fail
+   * validator. A substantially identical set of tests exists in
+   * SqlParserTest, and any changes here should be synchronized there.
+   * Similarly, any changes to tests here should be echoed appropriately to
+   * each of the other 12 subTestIntervalXXXNegative() tests.
+   */
+  public void subTestIntervalHourNegative() {
+    // Qualifier - field mismatches
+    f.wholeExpr("INTERVAL '-' HOUR")
+        .fails("Illegal interval literal format '-' for INTERVAL HOUR.*");
+    f.wholeExpr("INTERVAL '1-2' HOUR")
+        .fails("Illegal interval literal format '1-2' for INTERVAL HOUR.*");
+    f.wholeExpr("INTERVAL '1.2' HOUR")
+        .fails("Illegal interval literal format '1.2' for INTERVAL HOUR.*");
+    f.wholeExpr("INTERVAL '1 2' HOUR")
+        .fails("Illegal interval literal format '1 2' for INTERVAL HOUR.*");
+    f.wholeExpr("INTERVAL '1:2' HOUR")
+        .fails("Illegal interval literal format '1:2' for INTERVAL HOUR.*");
+    f.wholeExpr("INTERVAL '1-2' HOUR(2)")
+        .fails("Illegal interval literal format '1-2' for INTERVAL HOUR\\(2\\)");
+    f.wholeExpr("INTERVAL 'bogus text' HOUR")
+        .fails("Illegal interval literal format 'bogus text' for "
+            + "INTERVAL HOUR.*");
+
+    // negative field values
+    f.wholeExpr("INTERVAL '--1' HOUR")
+        .fails("Illegal interval literal format '--1' for INTERVAL HOUR.*");
+
+    // Field value out of range
+    //  (default, explicit default, alt, neg alt, max, neg max)
+    f.wholeExpr("INTERVAL '100' HOUR")
+        .fails("Interval field value 100 exceeds precision of "
+            + "HOUR\\(2\\) field.*");
+    f.wholeExpr("INTERVAL '100' HOUR(2)")
+        .fails("Interval field value 100 exceeds precision of "
+            + "HOUR\\(2\\) field.*");
+    f.wholeExpr("INTERVAL '1000' HOUR(3)")
+        .fails("Interval field value 1,000 exceeds precision of "
+            + "HOUR\\(3\\) field.*");
+    f.wholeExpr("INTERVAL '-1000' HOUR(3)")
+        .fails("Interval field value -1,000 exceeds precision of "
+            + "HOUR\\(3\\) field.*");
+    f.wholeExpr("INTERVAL '2147483648' HOUR(10)")
+        .fails("Interval field value 2,147,483,648 exceeds precision of "
+            + "HOUR\\(10\\) field.*");
+    f.wholeExpr("INTERVAL '-2147483648' HOUR(10)")
+        .fails("Interval field value -2,147,483,648 exceeds precision of "
+            + "HOUR\\(10\\) field.*");
+
+    // precision > maximum
+    f.expr("INTERVAL '1' ^HOUR(11)^")
+        .fails("Interval leading field precision '11' out of range for "
+            + "INTERVAL HOUR\\(11\\)");
+
+    // precision < minimum allowed)
+    // note: parser will catch negative values, here we
+    // just need to check for 0
+    f.expr("INTERVAL '0' ^HOUR(0)^")
+        .fails("Interval leading field precision '0' out of range for "
+            + "INTERVAL HOUR\\(0\\)");
+  }
+
+  /**
+   * Runs tests for INTERVAL... HOUR TO MINUTE that should pass parser but
+   * fail validator. A substantially identical set of tests exists in
+   * SqlParserTest, and any changes here should be synchronized there.
+   * Similarly, any changes to tests here should be echoed appropriately to
+   * each of the other 12 subTestIntervalXXXNegative() tests.
+   */
+  public void subTestIntervalHourToMinuteNegative() {
+    // Qualifier - field mismatches
+    f.wholeExpr("INTERVAL ':' HOUR TO MINUTE")
+        .fails("Illegal interval literal format ':' for INTERVAL HOUR TO MINUTE");
+    f.wholeExpr("INTERVAL '1' HOUR TO MINUTE")
+        .fails("Illegal interval literal format '1' for INTERVAL HOUR TO MINUTE");
+    f.wholeExpr("INTERVAL '1:x' HOUR TO MINUTE")
+        .fails("Illegal interval literal format '1:x' for INTERVAL HOUR TO MINUTE");
+    f.wholeExpr("INTERVAL '1.2' HOUR TO MINUTE")
+        .fails("Illegal interval literal format '1.2' for INTERVAL HOUR TO MINUTE");
+    f.wholeExpr("INTERVAL '1 2' HOUR TO MINUTE")
+        .fails("Illegal interval literal format '1 2' for INTERVAL HOUR TO MINUTE");
+    f.wholeExpr("INTERVAL '1:2:3' HOUR TO MINUTE")
+        .fails("Illegal interval literal format '1:2:3' for INTERVAL HOUR TO MINUTE");
+    f.wholeExpr("INTERVAL '1 2' HOUR(2) TO MINUTE")
+        .fails("Illegal interval literal format '1 2' for "
+            + "INTERVAL HOUR\\(2\\) TO MINUTE");
+    f.wholeExpr("INTERVAL 'bogus text' HOUR TO MINUTE")
+        .fails("Illegal interval literal format 'bogus text' for "
+            + "INTERVAL HOUR TO MINUTE");
+
+    // negative field values
+    f.wholeExpr("INTERVAL '--1:1' HOUR TO MINUTE")
+        .fails("Illegal interval literal format '--1:1' for INTERVAL HOUR TO MINUTE");
+    f.wholeExpr("INTERVAL '1:-1' HOUR TO MINUTE")
+        .fails("Illegal interval literal format '1:-1' for INTERVAL HOUR TO MINUTE");
+
+    // Field value out of range
+    //  (default, explicit default, alt, neg alt, max, neg max)
+    //  plus >max value for mid/end fields
+    f.wholeExpr("INTERVAL '100:0' HOUR TO MINUTE")
+        .fails("Interval field value 100 exceeds precision of HOUR\\(2\\) field.*");
+    f.wholeExpr("INTERVAL '100:0' HOUR(2) TO MINUTE")
+        .fails("Interval field value 100 exceeds precision of HOUR\\(2\\) field.*");
+    f.wholeExpr("INTERVAL '1000:0' HOUR(3) TO MINUTE")
+        .fails("Interval field value 1,000 exceeds precision of HOUR\\(3\\) field.*");
+    f.wholeExpr("INTERVAL '-1000:0' HOUR(3) TO MINUTE")
+        .fails("Interval field value -1,000 exceeds precision of HOUR\\(3\\) field.*");
+    f.wholeExpr("INTERVAL '2147483648:0' HOUR(10) TO MINUTE")
+        .fails("Interval field value 2,147,483,648 exceeds precision of HOUR\\(10\\) field.*");
+    f.wholeExpr("INTERVAL '-2147483648:0' HOUR(10) TO MINUTE")
+        .fails("Interval field value -2,147,483,648 exceeds precision of HOUR\\(10\\) field.*");
+    f.wholeExpr("INTERVAL '1:60' HOUR TO MINUTE")
+        .fails("Illegal interval literal format '1:60' for INTERVAL HOUR TO MINUTE.*");
+
+    // precision > maximum
+    f.expr("INTERVAL '1:1' ^HOUR(11) TO MINUTE^")
+        .fails("Interval leading field precision '11' out of range for "
+            + "INTERVAL HOUR\\(11\\) TO MINUTE");
+
+    // precision < minimum allowed)
+    // note: parser will catch negative values, here we
+    // just need to check for 0
+    f.expr("INTERVAL '0:0' ^HOUR(0) TO MINUTE^")
+        .fails("Interval leading field precision '0' out of range for "
+            + "INTERVAL HOUR\\(0\\) TO MINUTE");
+  }
+
+  /**
+   * Runs tests for INTERVAL... HOUR TO SECOND that should pass parser but
+   * fail validator. A substantially identical set of tests exists in
+   * SqlParserTest, and any changes here should be synchronized there.
+   * Similarly, any changes to tests here should be echoed appropriately to
+   * each of the other 12 subTestIntervalXXXNegative() tests.
+   */
+  public void subTestIntervalHourToSecondNegative() {
+    // Qualifier - field mismatches
+    f.wholeExpr("INTERVAL '::' HOUR TO SECOND")
+        .fails("Illegal interval literal format '::' for INTERVAL HOUR TO SECOND");
+    f.wholeExpr("INTERVAL '::.' HOUR TO SECOND")
+        .fails("Illegal interval literal format '::\\.' for INTERVAL HOUR TO SECOND");
+    f.wholeExpr("INTERVAL '1' HOUR TO SECOND")
+        .fails("Illegal interval literal format '1' for INTERVAL HOUR TO SECOND");
+    f.wholeExpr("INTERVAL '1 2' HOUR TO SECOND")
+        .fails("Illegal interval literal format '1 2' for INTERVAL HOUR TO SECOND");
+    f.wholeExpr("INTERVAL '1:2' HOUR TO SECOND")
+        .fails("Illegal interval literal format '1:2' for INTERVAL HOUR TO SECOND");
+    f.wholeExpr("INTERVAL '1.2' HOUR TO SECOND")
+        .fails("Illegal interval literal format '1\\.2' for INTERVAL HOUR TO SECOND");
+    f.wholeExpr("INTERVAL '1 1:2' HOUR TO SECOND")
+        .fails("Illegal interval literal format '1 1:2' for INTERVAL HOUR TO SECOND");
+    f.wholeExpr("INTERVAL '1:2:x' HOUR TO SECOND")
+        .fails("Illegal interval literal format '1:2:x' for INTERVAL HOUR TO SECOND");
+    f.wholeExpr("INTERVAL '1:x:3' HOUR TO SECOND")
+        .fails("Illegal interval literal format '1:x:3' for INTERVAL HOUR TO SECOND");
+    f.wholeExpr("INTERVAL '1:1:1.x' HOUR TO SECOND")
+        .fails("Illegal interval literal format '1:1:1\\.x' for INTERVAL HOUR TO SECOND");
+    f.wholeExpr("INTERVAL '1 1:2' HOUR(2) TO SECOND")
+        .fails("Illegal interval literal format '1 1:2' for INTERVAL HOUR\\(2\\) TO SECOND");
+    f.wholeExpr("INTERVAL '1 1' HOUR(2) TO SECOND")
+        .fails("Illegal interval literal format '1 1' for INTERVAL HOUR\\(2\\) TO SECOND");
+    f.wholeExpr("INTERVAL 'bogus text' HOUR TO SECOND")
+        .fails("Illegal interval literal format 'bogus text' for INTERVAL HOUR TO SECOND");
+    f.wholeExpr("INTERVAL '6:7:8901' HOUR TO SECOND(4)")
+        .fails("Illegal interval literal format '6:7:8901' for INTERVAL HOUR TO SECOND\\(4\\)");
+
+    // negative field values
+    f.wholeExpr("INTERVAL '--1:1:1' HOUR TO SECOND")
+        .fails("Illegal interval literal format '--1:1:1' for INTERVAL HOUR TO SECOND");
+    f.wholeExpr("INTERVAL '1:-1:1' HOUR TO SECOND")
+        .fails("Illegal interval literal format '1:-1:1' for INTERVAL HOUR TO SECOND");
+    f.wholeExpr("INTERVAL '1:1:-1' HOUR TO SECOND")
+        .fails("Illegal interval literal format '1:1:-1' for INTERVAL HOUR TO SECOND");
+    f.wholeExpr("INTERVAL '1:1:1.-1' HOUR TO SECOND")
+        .fails("Illegal interval literal format '1:1:1\\.-1' for INTERVAL HOUR TO SECOND");
+
+    // Field value out of range
+    //  (default, explicit default, alt, neg alt, max, neg max)
+    //  plus >max value for mid/end fields
+    f.wholeExpr("INTERVAL '100:0:0' HOUR TO SECOND")
+        .fails("Interval field value 100 exceeds precision of "
+            + "HOUR\\(2\\) field.*");
+    f.wholeExpr("INTERVAL '100:0:0' HOUR(2) TO SECOND")
+        .fails("Interval field value 100 exceeds precision of "
+            + "HOUR\\(2\\) field.*");
+    f.wholeExpr("INTERVAL '1000:0:0' HOUR(3) TO SECOND")
+        .fails("Interval field value 1,000 exceeds precision of "
+            + "HOUR\\(3\\) field.*");
+    f.wholeExpr("INTERVAL '-1000:0:0' HOUR(3) TO SECOND")
+        .fails("Interval field value -1,000 exceeds precision of "
+            + "HOUR\\(3\\) field.*");
+    f.wholeExpr("INTERVAL '2147483648:0:0' HOUR(10) TO SECOND")
+        .fails("Interval field value 2,147,483,648 exceeds precision of "
+            + "HOUR\\(10\\) field.*");
+    f.wholeExpr("INTERVAL '-2147483648:0:0' HOUR(10) TO SECOND")
+        .fails("Interval field value -2,147,483,648 exceeds precision of "
+            + "HOUR\\(10\\) field.*");
+    f.wholeExpr("INTERVAL '1:60:1' HOUR TO SECOND")
+        .fails("Illegal interval literal format '1:60:1' for "
+            + "INTERVAL HOUR TO SECOND.*");
+    f.wholeExpr("INTERVAL '1:1:60' HOUR TO SECOND")
+        .fails("Illegal interval literal format '1:1:60' for "
+            + "INTERVAL HOUR TO SECOND.*");
+    f.wholeExpr("INTERVAL '1:1:1.0000001' HOUR TO SECOND")
+        .fails("Illegal interval literal format '1:1:1\\.0000001' for "
+            + "INTERVAL HOUR TO SECOND.*");
+    f.wholeExpr("INTERVAL '1:1:1.0001' HOUR TO SECOND(3)")
+        .fails("Illegal interval literal format '1:1:1\\.0001' for "
+            + "INTERVAL HOUR TO SECOND\\(3\\).*");
+
+    // precision > maximum
+    f.expr("INTERVAL '1:1:1' ^HOUR(11) TO SECOND^")
+        .fails("Interval leading field precision '11' out of range for "
+            + "INTERVAL HOUR\\(11\\) TO SECOND");
+    f.expr("INTERVAL '1:1:1' ^HOUR TO SECOND(10)^")
+        .fails("Interval fractional second precision '10' out of range for "
+            + "INTERVAL HOUR TO SECOND\\(10\\)");
+
+    // precision < minimum allowed)
+    // note: parser will catch negative values, here we
+    // just need to check for 0
+    f.expr("INTERVAL '0:0:0' ^HOUR(0) TO SECOND^")
+        .fails("Interval leading field precision '0' out of range for "
+            + "INTERVAL HOUR\\(0\\) TO SECOND");
+    f.expr("INTERVAL '0:0:0' ^HOUR TO SECOND(0)^")
+        .fails("Interval fractional second precision '0' out of range for "
+            + "INTERVAL HOUR TO SECOND\\(0\\)");
+  }
+
+  /**
+   * Runs tests for INTERVAL... MINUTE that should pass parser but fail
+   * validator. A substantially identical set of tests exists in
+   * SqlParserTest, and any changes here should be synchronized there.
+   * Similarly, any changes to tests here should be echoed appropriately to
+   * each of the other 12 subTestIntervalXXXNegative() tests.
+   */
+  public void subTestIntervalMinuteNegative() {
+    // Qualifier - field mismatches
+    f.wholeExpr("INTERVAL '-' MINUTE")
+        .fails("Illegal interval literal format '-' for INTERVAL MINUTE.*");
+    f.wholeExpr("INTERVAL '1-2' MINUTE")
+        .fails("Illegal interval literal format '1-2' for INTERVAL MINUTE.*");
+    f.wholeExpr("INTERVAL '1.2' MINUTE")
+        .fails("Illegal interval literal format '1.2' for INTERVAL MINUTE.*");
+    f.wholeExpr("INTERVAL '1 2' MINUTE")
+        .fails("Illegal interval literal format '1 2' for INTERVAL MINUTE.*");
+    f.wholeExpr("INTERVAL '1:2' MINUTE")
+        .fails("Illegal interval literal format '1:2' for INTERVAL MINUTE.*");
+    f.wholeExpr("INTERVAL '1-2' MINUTE(2)")
+        .fails("Illegal interval literal format '1-2' for INTERVAL MINUTE\\(2\\)");
+    f.wholeExpr("INTERVAL 'bogus text' MINUTE")
+        .fails("Illegal interval literal format 'bogus text' for INTERVAL MINUTE.*");
+
+    // negative field values
+    f.wholeExpr("INTERVAL '--1' MINUTE")
+        .fails("Illegal interval literal format '--1' for INTERVAL MINUTE.*");
+
+    // Field value out of range
+    //  (default, explicit default, alt, neg alt, max, neg max)
+    f.wholeExpr("INTERVAL '100' MINUTE")
+        .fails("Interval field value 100 exceeds precision of MINUTE\\(2\\) field.*");
+    f.wholeExpr("INTERVAL '100' MINUTE(2)")
+        .fails("Interval field value 100 exceeds precision of MINUTE\\(2\\) field.*");
+    f.wholeExpr("INTERVAL '1000' MINUTE(3)")
+        .fails("Interval field value 1,000 exceeds precision of MINUTE\\(3\\) field.*");
+    f.wholeExpr("INTERVAL '-1000' MINUTE(3)")
+        .fails("Interval field value -1,000 exceeds precision of MINUTE\\(3\\) field.*");
+    f.wholeExpr("INTERVAL '2147483648' MINUTE(10)")
+        .fails("Interval field value 2,147,483,648 exceeds precision of MINUTE\\(10\\) field.*");
+    f.wholeExpr("INTERVAL '-2147483648' MINUTE(10)")
+        .fails("Interval field value -2,147,483,648 exceeds precision of MINUTE\\(10\\) field.*");
+
+    // precision > maximum
+    f.expr("INTERVAL '1' ^MINUTE(11)^")
+        .fails("Interval leading field precision '11' out of range for "
+            + "INTERVAL MINUTE\\(11\\)");
+
+    // precision < minimum allowed)
+    // note: parser will catch negative values, here we
+    // just need to check for 0
+    f.expr("INTERVAL '0' ^MINUTE(0)^")
+        .fails("Interval leading field precision '0' out of range for "
+            + "INTERVAL MINUTE\\(0\\)");
+  }
+
+  /**
+   * Runs tests for INTERVAL... MINUTE TO SECOND that should pass parser but
+   * fail validator. A substantially identical set of tests exists in
+   * SqlParserTest, and any changes here should be synchronized there.
+   * Similarly, any changes to tests here should be echoed appropriately to
+   * each of the other 12 subTestIntervalXXXNegative() tests.
+   */
+  public void subTestIntervalMinuteToSecondNegative() {
+    // Qualifier - field mismatches
+    f.wholeExpr("INTERVAL ':' MINUTE TO SECOND")
+        .fails("Illegal interval literal format ':' for INTERVAL MINUTE TO SECOND");
+    f.wholeExpr("INTERVAL ':.' MINUTE TO SECOND")
+        .fails("Illegal interval literal format ':\\.' for INTERVAL MINUTE TO SECOND");
+    f.wholeExpr("INTERVAL '1' MINUTE TO SECOND")
+        .fails("Illegal interval literal format '1' for INTERVAL MINUTE TO SECOND");
+    f.wholeExpr("INTERVAL '1 2' MINUTE TO SECOND")
+        .fails("Illegal interval literal format '1 2' for INTERVAL MINUTE TO SECOND");
+    f.wholeExpr("INTERVAL '1.2' MINUTE TO SECOND")
+        .fails("Illegal interval literal format '1\\.2' for INTERVAL MINUTE TO SECOND");
+    f.wholeExpr("INTERVAL '1 1:2' MINUTE TO SECOND")
+        .fails("Illegal interval literal format '1 1:2' for INTERVAL MINUTE TO SECOND");
+    f.wholeExpr("INTERVAL '1:x' MINUTE TO SECOND")
+        .fails("Illegal interval literal format '1:x' for INTERVAL MINUTE TO SECOND");
+    f.wholeExpr("INTERVAL 'x:3' MINUTE TO SECOND")
+        .fails("Illegal interval literal format 'x:3' for INTERVAL MINUTE TO SECOND");
+    f.wholeExpr("INTERVAL '1:1.x' MINUTE TO SECOND")
+        .fails("Illegal interval literal format '1:1\\.x' for INTERVAL MINUTE TO SECOND");
+    f.wholeExpr("INTERVAL '1 1:2' MINUTE(2) TO SECOND")
+        .fails("Illegal interval literal format '1 1:2' for INTERVAL MINUTE\\(2\\) TO SECOND");
+    f.wholeExpr("INTERVAL '1 1' MINUTE(2) TO SECOND")
+        .fails("Illegal interval literal format '1 1' for INTERVAL MINUTE\\(2\\) TO SECOND");
+    f.wholeExpr("INTERVAL 'bogus text' MINUTE TO SECOND")
+        .fails("Illegal interval literal format 'bogus text' for INTERVAL MINUTE TO SECOND");
+    f.wholeExpr("INTERVAL '7:8901' MINUTE TO SECOND(4)")
+        .fails("Illegal interval literal format '7:8901' for INTERVAL MINUTE TO SECOND\\(4\\)");
+
+    // negative field values
+    f.wholeExpr("INTERVAL '--1:1' MINUTE TO SECOND")
+        .fails("Illegal interval literal format '--1:1' for INTERVAL MINUTE TO SECOND");
+    f.wholeExpr("INTERVAL '1:-1' MINUTE TO SECOND")
+        .fails("Illegal interval literal format '1:-1' for INTERVAL MINUTE TO SECOND");
+    f.wholeExpr("INTERVAL '1:1.-1' MINUTE TO SECOND")
+        .fails("Illegal interval literal format '1:1.-1' for INTERVAL MINUTE TO SECOND");
+
+    // Field value out of range
+    //  (default, explicit default, alt, neg alt, max, neg max)
+    //  plus >max value for mid/end fields
+    f.wholeExpr("INTERVAL '100:0' MINUTE TO SECOND")
+        .fails("Interval field value 100 exceeds precision of MINUTE\\(2\\) field.*");
+    f.wholeExpr("INTERVAL '100:0' MINUTE(2) TO SECOND")
+        .fails("Interval field value 100 exceeds precision of MINUTE\\(2\\) field.*");
+    f.wholeExpr("INTERVAL '1000:0' MINUTE(3) TO SECOND")
+        .fails("Interval field value 1,000 exceeds precision of MINUTE\\(3\\) field.*");
+    f.wholeExpr("INTERVAL '-1000:0' MINUTE(3) TO SECOND")
+        .fails("Interval field value -1,000 exceeds precision of MINUTE\\(3\\) field.*");
+    f.wholeExpr("INTERVAL '2147483648:0' MINUTE(10) TO SECOND")
+        .fails("Interval field value 2,147,483,648 exceeds precision of MINUTE\\(10\\) field.*");
+    f.wholeExpr("INTERVAL '-2147483648:0' MINUTE(10) TO SECOND")
+        .fails("Interval field value -2,147,483,648 exceeds precision of MINUTE\\(10\\) field.*");
+    f.wholeExpr("INTERVAL '1:60' MINUTE TO SECOND")
+        .fails("Illegal interval literal format '1:60' for"
+            + " INTERVAL MINUTE TO SECOND.*");
+    f.wholeExpr("INTERVAL '1:1.0000001' MINUTE TO SECOND")
+        .fails("Illegal interval literal format '1:1\\.0000001' for"
+            + " INTERVAL MINUTE TO SECOND.*");
+    f.wholeExpr("INTERVAL '1:1:1.0001' MINUTE TO SECOND(3)")
+        .fails("Illegal interval literal format '1:1:1\\.0001' for"
+            + " INTERVAL MINUTE TO SECOND\\(3\\).*");
+
+    // precision > maximum
+    f.expr("INTERVAL '1:1' ^MINUTE(11) TO SECOND^")
+        .fails("Interval leading field precision '11' out of range for"
+            + " INTERVAL MINUTE\\(11\\) TO SECOND");
+    f.expr("INTERVAL '1:1' ^MINUTE TO SECOND(10)^")
+        .fails("Interval fractional second precision '10' out of range for"
+            + " INTERVAL MINUTE TO SECOND\\(10\\)");
+
+    // precision < minimum allowed)
+    // note: parser will catch negative values, here we
+    // just need to check for 0
+    f.expr("INTERVAL '0:0' ^MINUTE(0) TO SECOND^")
+        .fails("Interval leading field precision '0' out of range for"
+            + " INTERVAL MINUTE\\(0\\) TO SECOND");
+    f.expr("INTERVAL '0:0' ^MINUTE TO SECOND(0)^")
+        .fails("Interval fractional second precision '0' out of range for"
+            + " INTERVAL MINUTE TO SECOND\\(0\\)");
+  }
+
+  /**
+   * Runs tests for INTERVAL... SECOND that should pass parser but fail
+   * validator. A substantially identical set of tests exists in
+   * SqlParserTest, and any changes here should be synchronized there.
+   * Similarly, any changes to tests here should be echoed appropriately to
+   * each of the other 12 subTestIntervalXXXNegative() tests.
+   */
+  public void subTestIntervalSecondNegative() {
+    // Qualifier - field mismatches
+    f.wholeExpr("INTERVAL ':' SECOND")
+        .fails("Illegal interval literal format ':' for INTERVAL SECOND.*");
+    f.wholeExpr("INTERVAL '.' SECOND")
+        .fails("Illegal interval literal format '\\.' for INTERVAL SECOND.*");
+    f.wholeExpr("INTERVAL '1-2' SECOND")
+        .fails("Illegal interval literal format '1-2' for INTERVAL SECOND.*");
+    f.wholeExpr("INTERVAL '1.x' SECOND")
+        .fails("Illegal interval literal format '1\\.x' for INTERVAL SECOND.*");
+    f.wholeExpr("INTERVAL 'x.1' SECOND")
+        .fails("Illegal interval literal format 'x\\.1' for INTERVAL SECOND.*");
+    f.wholeExpr("INTERVAL '1 2' SECOND")
+        .fails("Illegal interval literal format '1 2' for INTERVAL SECOND.*");
+    f.wholeExpr("INTERVAL '1:2' SECOND")
+        .fails("Illegal interval literal format '1:2' for INTERVAL SECOND.*");
+    f.wholeExpr("INTERVAL '1-2' SECOND(2)")
+        .fails("Illegal interval literal format '1-2' for INTERVAL SECOND\\(2\\)");
+    f.wholeExpr("INTERVAL 'bogus text' SECOND")
+        .fails("Illegal interval literal format 'bogus text' for INTERVAL SECOND.*");
+
+    // negative field values
+    f.wholeExpr("INTERVAL '--1' SECOND")
+        .fails("Illegal interval literal format '--1' for INTERVAL SECOND.*");
+    f.wholeExpr("INTERVAL '1.-1' SECOND")
+        .fails("Illegal interval literal format '1.-1' for INTERVAL SECOND.*");
+
+    // Field value out of range
+    //  (default, explicit default, alt, neg alt, max, neg max)
+    f.wholeExpr("INTERVAL '100' SECOND")
+        .fails("Interval field value 100 exceeds precision of SECOND\\(2\\) field.*");
+    f.wholeExpr("INTERVAL '100' SECOND(2)")
+        .fails("Interval field value 100 exceeds precision of SECOND\\(2\\) field.*");
+    f.wholeExpr("INTERVAL '1000' SECOND(3)")
+        .fails("Interval field value 1,000 exceeds precision of SECOND\\(3\\) field.*");
+    f.wholeExpr("INTERVAL '-1000' SECOND(3)")
+        .fails("Interval field value -1,000 exceeds precision of SECOND\\(3\\) field.*");
+    f.wholeExpr("INTERVAL '2147483648' SECOND(10)")
+        .fails("Interval field value 2,147,483,648 exceeds precision of SECOND\\(10\\) field.*");
+    f.wholeExpr("INTERVAL '-2147483648' SECOND(10)")
+        .fails("Interval field value -2,147,483,648 exceeds precision of SECOND\\(10\\) field.*");
+    f.wholeExpr("INTERVAL '1.0000001' SECOND")
+        .fails("Illegal interval literal format '1\\.0000001' for INTERVAL SECOND.*");
+    f.wholeExpr("INTERVAL '1.0000001' SECOND(2)")
+        .fails("Illegal interval literal format '1\\.0000001' for INTERVAL SECOND\\(2\\).*");
+    f.wholeExpr("INTERVAL '1.0001' SECOND(2, 3)")
+        .fails("Illegal interval literal format '1\\.0001' for INTERVAL SECOND\\(2, 3\\).*");
+    f.wholeExpr("INTERVAL '1.0000000001' SECOND(2, 9)")
+        .fails("Illegal interval literal format '1\\.0000000001' for"
+            + " INTERVAL SECOND\\(2, 9\\).*");
+
+    // precision > maximum
+    f.expr("INTERVAL '1' ^SECOND(11)^")
+        .fails("Interval leading field precision '11' out of range for"
+            + " INTERVAL SECOND\\(11\\)");
+    f.expr("INTERVAL '1.1' ^SECOND(1, 10)^")
+        .fails("Interval fractional second precision '10' out of range for"
+            + " INTERVAL SECOND\\(1, 10\\)");
+
+    // precision < minimum allowed)
+    // note: parser will catch negative values, here we
+    // just need to check for 0
+    f.expr("INTERVAL '0' ^SECOND(0)^")
+        .fails("Interval leading field precision '0' out of range for"
+            + " INTERVAL SECOND\\(0\\)");
+    f.expr("INTERVAL '0' ^SECOND(1, 0)^")
+        .fails("Interval fractional second precision '0' out of range for"
+            + " INTERVAL SECOND\\(1, 0\\)");
+  }
+
+  public void subTestMisc() {
+    // Miscellaneous
+    // fractional value is not OK, even if it is 0
+    f.wholeExpr("INTERVAL '1.0' HOUR")
+        .fails("Illegal interval literal format '1.0' for INTERVAL HOUR");
+    // only seconds are allowed to have a fractional part
+    f.expr("INTERVAL '1.0' SECOND")
+        .columnType("INTERVAL SECOND NOT NULL");
+    // leading zeros do not cause precision to be exceeded
+    f.expr("INTERVAL '0999' MONTH(3)")
+        .columnType("INTERVAL MONTH(3) NOT NULL");
+  }
+
+  /** Fluent interface for binding an expression to create a fixture that can
+   * be used to validate, check AST, or check type. */
+  public interface Fixture {
+    Fixture2 expr(String s);
+    Fixture2 wholeExpr(String s);
+  }
+
+  /** Fluent interface to validate an expression. */
+  public interface Fixture2 {
+    /** Checks that the expression is valid in the parser
+     * but invalid (with the given error message) in the validator. */
+    void fails(String expected);
+
+    /** Checks that the expression is valid in the parser and validator
+     * and has the given column type. */
+    void columnType(String expectedType);
+
+    /** Checks that the expression parses successfully and produces the given
+     * SQL when unparsed. */
+    Fixture2 assertParse(String expectedAst);
+  }
+}
diff --git a/testkit/src/main/java/org/apache/calcite/test/MockDdlExecutor.java b/testkit/src/main/java/org/apache/calcite/test/MockDdlExecutor.java
new file mode 100644
index 00000000000..f3aa437b13e
--- /dev/null
+++ b/testkit/src/main/java/org/apache/calcite/test/MockDdlExecutor.java
@@ -0,0 +1,292 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.test;
+
+import org.apache.calcite.adapter.java.JavaTypeFactory;
+import org.apache.calcite.jdbc.CalcitePrepare;
+import org.apache.calcite.jdbc.CalciteSchema;
+import org.apache.calcite.jdbc.ContextSqlValidator;
+import org.apache.calcite.linq4j.Enumerator;
+import org.apache.calcite.linq4j.Linq4j;
+import org.apache.calcite.linq4j.QueryProvider;
+import org.apache.calcite.linq4j.Queryable;
+import org.apache.calcite.linq4j.tree.Expression;
+import org.apache.calcite.rel.RelRoot;
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.rel.type.RelDataTypeFactory;
+import org.apache.calcite.rel.type.RelDataTypeImpl;
+import org.apache.calcite.rel.type.RelProtoDataType;
+import org.apache.calcite.schema.Function;
+import org.apache.calcite.schema.SchemaPlus;
+import org.apache.calcite.schema.Schemas;
+import org.apache.calcite.schema.TranslatableTable;
+import org.apache.calcite.schema.impl.AbstractTableQueryable;
+import org.apache.calcite.schema.impl.ViewTable;
+import org.apache.calcite.schema.impl.ViewTableMacro;
+import org.apache.calcite.server.DdlExecutorImpl;
+import org.apache.calcite.sql.SqlCall;
+import org.apache.calcite.sql.SqlDataTypeSpec;
+import org.apache.calcite.sql.SqlIdentifier;
+import org.apache.calcite.sql.SqlNode;
+import org.apache.calcite.sql.SqlNodeList;
+import org.apache.calcite.sql.SqlSelect;
+import org.apache.calcite.sql.SqlUtil;
+import org.apache.calcite.sql.ddl.SqlColumnDeclaration;
+import org.apache.calcite.sql.ddl.SqlCreateTable;
+import org.apache.calcite.sql.ddl.SqlCreateView;
+import org.apache.calcite.sql.dialect.CalciteSqlDialect;
+import org.apache.calcite.sql.fun.SqlStdOperatorTable;
+import org.apache.calcite.sql.parser.SqlParseException;
+import org.apache.calcite.sql.parser.SqlParserPos;
+import org.apache.calcite.sql.pretty.SqlPrettyWriter;
+import org.apache.calcite.sql.validate.SqlValidator;
+import org.apache.calcite.tools.FrameworkConfig;
+import org.apache.calcite.tools.Frameworks;
+import org.apache.calcite.tools.Planner;
+import org.apache.calcite.tools.RelConversionException;
+import org.apache.calcite.tools.ValidationException;
+import org.apache.calcite.util.Pair;
+import org.apache.calcite.util.Util;
+
+import com.google.common.collect.ImmutableList;
+
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+import java.lang.reflect.Type;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.function.BiConsumer;
+
+import static org.apache.calcite.util.Static.RESOURCE;
+
+import static java.util.Objects.requireNonNull;
+
+/** Executes the few DDL commands. */
+public class MockDdlExecutor extends DdlExecutorImpl {
+
+  /** Returns the schema in which to create an object. */
+  static Pair<CalciteSchema, String> schema(CalcitePrepare.Context context,
+      boolean mutable, SqlIdentifier id) {
+    final String name;
+    final List<String> path;
+    if (id.isSimple()) {
+      path = context.getDefaultSchemaPath();
+      name = id.getSimple();
+    } else {
+      path = Util.skipLast(id.names);
+      name = Util.last(id.names);
+    }
+    CalciteSchema schema = mutable ? context.getMutableRootSchema()
+        : context.getRootSchema();
+    for (String p : path) {
+      schema = requireNonNull(schema.getSubSchema(p, true));
+    }
+    return Pair.of(schema, name);
+  }
+
+  /** Wraps a query to rename its columns. Used by CREATE VIEW and CREATE
+   * MATERIALIZED VIEW. */
+  static SqlNode renameColumns(@Nullable SqlNodeList columnList,
+      SqlNode query) {
+    if (columnList == null) {
+      return query;
+    }
+    final SqlParserPos p = query.getParserPosition();
+    final SqlNodeList selectList = SqlNodeList.SINGLETON_STAR;
+    final SqlCall from =
+        SqlStdOperatorTable.AS.createCall(p,
+            ImmutableList.<SqlNode>builder()
+                .add(query)
+                .add(new SqlIdentifier("_", p))
+                .addAll(columnList)
+                .build());
+    return new SqlSelect(p, null, selectList, from, null, null, null, null,
+        null, null, null, null, null);
+  }
+
+  /** Executes a {@code CREATE TABLE} command. Called via reflection. */
+  public void execute(SqlCreateTable create, CalcitePrepare.Context context) {
+    final CalciteSchema schema =
+        Schemas.subSchema(context.getRootSchema(),
+            context.getDefaultSchemaPath());
+    final JavaTypeFactory typeFactory = context.getTypeFactory();
+    final RelDataType queryRowType;
+    if (create.query != null) {
+      // A bit of a hack: pretend it's a view, to get its row type
+      final String sql =
+          create.query.toSqlString(CalciteSqlDialect.DEFAULT).getSql();
+      final ViewTableMacro viewTableMacro =
+          ViewTable.viewMacro(schema.plus(), sql, schema.path(null),
+              context.getObjectPath(), false);
+      final TranslatableTable x = viewTableMacro.apply(ImmutableList.of());
+      queryRowType = x.getRowType(typeFactory);
+
+      if (create.columnList != null
+          && queryRowType.getFieldCount() != create.columnList.size()) {
+        throw SqlUtil.newContextException(create.columnList.getParserPosition(),
+            RESOURCE.columnCountMismatch());
+      }
+    } else {
+      queryRowType = null;
+    }
+    final RelDataTypeFactory.Builder builder = typeFactory.builder();
+    if (create.columnList != null) {
+      final SqlValidator validator = new ContextSqlValidator(context, false);
+      forEachNameType(create, (name, typeSpec) ->
+          builder.add(name.getSimple(), typeSpec.deriveType(validator, true)));
+    } else {
+      if (queryRowType == null) {
+        // "CREATE TABLE t" is invalid; because there is no "AS query" we need
+        // a list of column names and types, "CREATE TABLE t (INT c)".
+        throw SqlUtil.newContextException(create.name.getParserPosition(),
+            RESOURCE.createTableRequiresColumnList());
+      }
+      builder.addAll(queryRowType.getFieldList());
+    }
+    final RelDataType rowType = builder.build();
+    schema.add(create.name.getSimple(),
+        new MutableArrayTable(create.name.getSimple(),
+            RelDataTypeImpl.proto(rowType)));
+    if (create.query != null) {
+      populate(create.name, create.query, context);
+    }
+  }
+
+  /** Executes a {@code CREATE VIEW} command. */
+  public void execute(SqlCreateView create,
+      CalcitePrepare.Context context) {
+    final Pair<CalciteSchema, String> pair =
+        schema(context, true, create.name);
+    final SchemaPlus schemaPlus = pair.left.plus();
+    for (Function function : schemaPlus.getFunctions(pair.right)) {
+      if (function.getParameters().isEmpty()) {
+        if (!create.getReplace()) {
+          throw SqlUtil.newContextException(create.name.getParserPosition(),
+              RESOURCE.viewExists(pair.right));
+        }
+        pair.left.removeFunction(pair.right);
+      }
+    }
+    final SqlNode q = renameColumns(create.columnList, create.query);
+    final String sql = q.toSqlString(CalciteSqlDialect.DEFAULT).getSql();
+    final ViewTableMacro viewTableMacro =
+        ViewTable.viewMacro(schemaPlus, sql, pair.left.path(null),
+            context.getObjectPath(), false);
+    final TranslatableTable x = viewTableMacro.apply(ImmutableList.of());
+    Util.discard(x);
+    schemaPlus.add(pair.right, viewTableMacro);
+  }
+
+  /** Populates the table called {@code name} by executing {@code query}. */
+  protected static void populate(SqlIdentifier name, SqlNode query,
+      CalcitePrepare.Context context) {
+    // Generate, prepare and execute an "INSERT INTO table query" statement.
+    // (It's a bit inefficient that we convert from SqlNode to SQL and back
+    // again.)
+    final FrameworkConfig config = Frameworks.newConfigBuilder()
+        .defaultSchema(
+            requireNonNull(
+                Schemas.subSchema(context.getRootSchema(),
+                    context.getDefaultSchemaPath())).plus())
+        .build();
+    final Planner planner = Frameworks.getPlanner(config);
+    try {
+      final StringBuilder buf = new StringBuilder();
+      final SqlPrettyWriter w =
+          new SqlPrettyWriter(
+              SqlPrettyWriter.config()
+                  .withDialect(CalciteSqlDialect.DEFAULT)
+                  .withAlwaysUseParentheses(false),
+              buf);
+      buf.append("INSERT INTO ");
+      name.unparse(w, 0, 0);
+      buf.append(" ");
+      query.unparse(w, 0, 0);
+      final String sql = buf.toString();
+      final SqlNode query1 = planner.parse(sql);
+      final SqlNode query2 = planner.validate(query1);
+      final RelRoot r = planner.rel(query2);
+      final PreparedStatement prepare =
+          context.getRelRunner().prepareStatement(r.rel);
+      int rowCount = prepare.executeUpdate();
+      Util.discard(rowCount);
+      prepare.close();
+    } catch (SqlParseException | ValidationException
+             | RelConversionException | SQLException e) {
+      throw Util.throwAsRuntime(e);
+    }
+  }
+
+  /** Calls an action for each (name, type) pair from {@code SqlCreateTable::columnList}, in which
+   * they alternate. */
+  @SuppressWarnings({"unchecked", "rawtypes"})
+  protected void forEachNameType(SqlCreateTable createTable,
+      BiConsumer<SqlIdentifier, SqlDataTypeSpec> consumer) {
+    createTable.columnList.forEach(sqlNode -> {
+      if (sqlNode instanceof SqlColumnDeclaration) {
+        final SqlColumnDeclaration d = (SqlColumnDeclaration) sqlNode;
+        consumer.accept(d.name, d.dataType);
+      } else {
+        throw new AssertionError(sqlNode.getClass());
+      }
+    });
+  }
+
+  /** Table backed by a Java list. */
+  private static class MutableArrayTable
+      extends AbstractModifiableTable {
+    final List list = new ArrayList();
+    private final RelProtoDataType protoRowType;
+
+    MutableArrayTable(String name, RelProtoDataType protoRowType) {
+      super(name);
+      this.protoRowType = protoRowType;
+    }
+
+    @Override public Collection getModifiableCollection() {
+      return list;
+    }
+
+    @Override public <T> Queryable<T> asQueryable(QueryProvider queryProvider,
+        SchemaPlus schema, String tableName) {
+      return new AbstractTableQueryable<T>(queryProvider, schema, this,
+          tableName) {
+        @Override public Enumerator<T> enumerator() {
+          //noinspection unchecked
+          return (Enumerator<T>) Linq4j.enumerator(list);
+        }
+      };
+    }
+
+    @Override public Type getElementType() {
+      return Object[].class;
+    }
+
+    @Override public Expression getExpression(SchemaPlus schema, String tableName,
+        Class clazz) {
+      return Schemas.tableExpression(schema, getElementType(),
+          tableName, clazz);
+    }
+
+    @Override public RelDataType getRowType(RelDataTypeFactory typeFactory) {
+      return protoRowType.apply(typeFactory);
+    }
+  }
+}
diff --git a/testkit/src/main/java/org/apache/calcite/test/MockSqlOperatorTable.java b/testkit/src/main/java/org/apache/calcite/test/MockSqlOperatorTable.java
index ced92d9b961..60e9e2559e6 100644
--- a/testkit/src/main/java/org/apache/calcite/test/MockSqlOperatorTable.java
+++ b/testkit/src/main/java/org/apache/calcite/test/MockSqlOperatorTable.java
@@ -19,58 +19,94 @@
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeFactory;
 import org.apache.calcite.sql.SqlAggFunction;
+import org.apache.calcite.sql.SqlCallBinding;
 import org.apache.calcite.sql.SqlFunction;
 import org.apache.calcite.sql.SqlFunctionCategory;
 import org.apache.calcite.sql.SqlIdentifier;
 import org.apache.calcite.sql.SqlKind;
+import org.apache.calcite.sql.SqlNode;
+import org.apache.calcite.sql.SqlOperandCountRange;
 import org.apache.calcite.sql.SqlOperator;
 import org.apache.calcite.sql.SqlOperatorBinding;
 import org.apache.calcite.sql.SqlOperatorTable;
 import org.apache.calcite.sql.SqlTableFunction;
+import org.apache.calcite.sql.TableCharacteristic;
+import org.apache.calcite.sql.fun.SqlLibrary;
+import org.apache.calcite.sql.fun.SqlLibraryOperatorTableFactory;
+import org.apache.calcite.sql.fun.SqlStdOperatorTable;
 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.SqlOperandCountRanges;
+import org.apache.calcite.sql.type.SqlOperandMetadata;
 import org.apache.calcite.sql.type.SqlReturnTypeInference;
 import org.apache.calcite.sql.type.SqlTypeFamily;
 import org.apache.calcite.sql.type.SqlTypeName;
+import org.apache.calcite.sql.type.SqlTypeUtil;
 import org.apache.calcite.sql.util.ChainedSqlOperatorTable;
-import org.apache.calcite.sql.util.ListSqlOperatorTable;
+import org.apache.calcite.sql.util.SqlOperatorTables;
+import org.apache.calcite.sql.validate.SqlValidator;
 import org.apache.calcite.util.Optionality;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Iterables;
+
+import java.util.List;
+import java.util.Map;
 
 /**
  * Mock operator table for testing purposes. Contains the standard SQL operator
  * table, plus a list of operators.
  */
 public class MockSqlOperatorTable extends ChainedSqlOperatorTable {
-  private final ListSqlOperatorTable listOpTab;
+  /** Internal constructor; call {@link #standard()},
+   * {@link #of(SqlOperatorTable)},
+   * {@link #plus(Iterable)}, or
+   * {@link #extend()}. */
+  private MockSqlOperatorTable(SqlOperatorTable parentTable) {
+    super(ImmutableList.of(parentTable));
+  }
 
-  public MockSqlOperatorTable(SqlOperatorTable parentTable) {
-    super(ImmutableList.of(parentTable, new ListSqlOperatorTable()));
-    listOpTab = (ListSqlOperatorTable) tableList.get(1);
+  /** Returns the operator table that contains only the standard operators. */
+  public static MockSqlOperatorTable standard() {
+    return of(SqlStdOperatorTable.instance());
   }
 
-  /**
-   * Adds an operator to this table.
-   */
-  public void addOperator(SqlOperator op) {
-    listOpTab.add(op);
+  /** Returns a mock operator table based on the given operator table. */
+  public static MockSqlOperatorTable of(SqlOperatorTable operatorTable) {
+    return new MockSqlOperatorTable(operatorTable);
   }
 
-  public static void addRamp(MockSqlOperatorTable opTab) {
+  /** Returns this table with a few mock operators added. */
+  public MockSqlOperatorTable extend() {
     // Don't use anonymous inner classes. They can't be instantiated
     // using reflection when we are deserializing from JSON.
-    opTab.addOperator(new RampFunction());
-    opTab.addOperator(new DedupFunction());
-    opTab.addOperator(new MyFunction());
-    opTab.addOperator(new MyAvgAggFunction());
-    opTab.addOperator(new RowFunction());
-    opTab.addOperator(new NotATableFunction());
-    opTab.addOperator(new BadTableFunction());
-    opTab.addOperator(new StructuredFunction());
-    opTab.addOperator(new CompositeFunction());
+    final SqlOperatorTable parentTable = Iterables.getOnlyElement(tableList);
+    return new MockSqlOperatorTable(
+        SqlOperatorTables.chain(parentTable,
+            SqlOperatorTables.of(new RampFunction(),
+                new DedupFunction(),
+                new MyFunction(),
+                new MyAvgAggFunction(),
+                new RowFunction(),
+                new NotATableFunction(),
+                new BadTableFunction(),
+                new StructuredFunction(),
+                new CompositeFunction(),
+                new ScoreTableFunction(),
+                new TopNTableFunction(),
+                new SimilarlityTableFunction(),
+                new InvalidTableFunction())));
+  }
+
+  /** Adds a library set. */
+  public MockSqlOperatorTable plus(Iterable<SqlLibrary> librarySet) {
+    final SqlOperatorTable parentTable = Iterables.getOnlyElement(tableList);
+    return new MockSqlOperatorTable(
+        SqlOperatorTables.chain(parentTable,
+            SqlLibraryOperatorTableFactory.INSTANCE
+                .getOperatorTable(librarySet)));
   }
 
   /** "RAMP" user-defined table function. */
@@ -168,6 +204,274 @@ public DedupFunction() {
     }
   }
 
+  /** "Score" user-defined table function. First parameter is input table
+   * with row semantics. */
+  public static class ScoreTableFunction extends SqlFunction
+      implements SqlTableFunction {
+
+    private final Map<Integer, TableCharacteristic> tableParams =
+        ImmutableMap.of(
+            0,
+            TableCharacteristic
+                .builder(TableCharacteristic.Semantics.ROW)
+                .passColumnsThrough().build());
+
+    public ScoreTableFunction() {
+      super("SCORE",
+          SqlKind.OTHER_FUNCTION,
+          ReturnTypes.CURSOR,
+          null,
+          new OperandMetadataImpl(),
+          SqlFunctionCategory.USER_DEFINED_TABLE_FUNCTION);
+    }
+
+    private static RelDataType inferRowType(SqlOperatorBinding opBinding) {
+      final RelDataTypeFactory typeFactory = opBinding.getTypeFactory();
+      final RelDataType inputRowType = opBinding.getOperandType(0);
+      final RelDataType bigintType =
+          typeFactory.createSqlType(SqlTypeName.BIGINT);
+      return typeFactory.builder()
+          .kind(inputRowType.getStructKind())
+          .addAll(inputRowType.getFieldList())
+          .add("SCORE_VALUE", bigintType).nullable(true)
+          .build();
+    }
+
+    @Override public SqlReturnTypeInference getRowTypeInference() {
+      return ScoreTableFunction::inferRowType;
+    }
+
+    @Override public TableCharacteristic tableCharacteristic(int ordinal) {
+      return tableParams.get(ordinal);
+    }
+
+    @Override public boolean argumentMustBeScalar(int ordinal) {
+      return !tableParams.containsKey(ordinal);
+    }
+
+    /** Operand type checker for {@link ScoreTableFunction}. */
+    private static class OperandMetadataImpl implements SqlOperandMetadata {
+
+      @Override public List<RelDataType> paramTypes(RelDataTypeFactory typeFactory) {
+        return ImmutableList.of(typeFactory.createSqlType(SqlTypeName.ANY));
+      }
+
+      @Override public List<String> paramNames() {
+        return ImmutableList.of("DATA");
+      }
+
+      @Override public boolean checkOperandTypes(
+          SqlCallBinding callBinding, boolean throwOnFailure) {
+        return true;
+      }
+
+      @Override public SqlOperandCountRange getOperandCountRange() {
+        return SqlOperandCountRanges.of(1);
+      }
+
+      @Override public String getAllowedSignatures(SqlOperator op, String opName) {
+        return "Score(TABLE table_name)";
+      };
+    }
+  }
+
+  /** "TopN" user-defined table function. First parameter is input table
+   * with set semantics. */
+  public static class TopNTableFunction extends SqlFunction
+      implements SqlTableFunction {
+
+    private final Map<Integer, TableCharacteristic> tableParams =
+        ImmutableMap.of(
+            0,
+            TableCharacteristic
+                .builder(TableCharacteristic.Semantics.SET)
+                .passColumnsThrough()
+                .pruneIfEmpty()
+                .build());
+
+    public TopNTableFunction() {
+      super("TOPN",
+          SqlKind.OTHER_FUNCTION,
+          ReturnTypes.CURSOR,
+          null,
+          new OperandMetadataImpl(),
+          SqlFunctionCategory.USER_DEFINED_TABLE_FUNCTION);
+    }
+
+    private static RelDataType inferRowType(SqlOperatorBinding opBinding) {
+      final RelDataTypeFactory typeFactory = opBinding.getTypeFactory();
+      final RelDataType inputRowType = opBinding.getOperandType(0);
+      final RelDataType bigintType =
+          typeFactory.createSqlType(SqlTypeName.BIGINT);
+      return typeFactory.builder()
+          .kind(inputRowType.getStructKind())
+          .addAll(inputRowType.getFieldList())
+          .add("RANK_NUMBER", bigintType).nullable(true)
+          .build();
+    }
+
+    @Override public SqlReturnTypeInference getRowTypeInference() {
+      return TopNTableFunction::inferRowType;
+    }
+
+    @Override public TableCharacteristic tableCharacteristic(int ordinal) {
+      return tableParams.get(ordinal);
+    }
+
+    @Override public boolean argumentMustBeScalar(int ordinal) {
+      return !tableParams.containsKey(ordinal);
+    }
+
+    /** Operand type checker for {@link TopNTableFunction}. */
+    private static class OperandMetadataImpl implements SqlOperandMetadata {
+
+      @Override public List<RelDataType> paramTypes(RelDataTypeFactory typeFactory) {
+        return ImmutableList.of(
+            typeFactory.createSqlType(SqlTypeName.ANY),
+            typeFactory.createSqlType(SqlTypeName.INTEGER));
+      }
+
+      @Override public List<String> paramNames() {
+        return ImmutableList.of("DATA", "COL");
+      }
+
+      @Override public boolean checkOperandTypes(
+          SqlCallBinding callBinding, boolean throwOnFailure) {
+        final SqlNode operand1 = callBinding.operand(1);
+        final SqlValidator validator = callBinding.getValidator();
+        final RelDataType type = validator.getValidatedNodeType(operand1);
+        if (!SqlTypeUtil.isIntType(type)) {
+          if (throwOnFailure) {
+            throw callBinding.newValidationSignatureError();
+          } else {
+            return false;
+          }
+        } else {
+          return true;
+        }
+      }
+
+      @Override public SqlOperandCountRange getOperandCountRange() {
+        return SqlOperandCountRanges.of(2);
+      }
+
+      @Override public String getAllowedSignatures(SqlOperator op, String opName) {
+        return "TopN(TABLE table_name, BIGINT rows)";
+      }
+    }
+  }
+
+  /** Similarity performs an analysis on two data sets, which are both tables
+   * of two columns, treated as the x and y axes of a graph. It has two input
+   * tables with set semantics. */
+  public static class SimilarlityTableFunction extends SqlFunction
+      implements SqlTableFunction {
+
+    private final Map<Integer, TableCharacteristic> tableParams =
+        ImmutableMap.of(
+            0,
+            TableCharacteristic
+                .builder(TableCharacteristic.Semantics.SET)
+                .build(),
+            1,
+            TableCharacteristic
+                .builder(TableCharacteristic.Semantics.SET)
+                .build());
+
+    public SimilarlityTableFunction() {
+      super("SIMILARLITY",
+          SqlKind.OTHER_FUNCTION,
+          ReturnTypes.CURSOR,
+          null,
+          new OperandMetadataImpl(),
+          SqlFunctionCategory.USER_DEFINED_TABLE_FUNCTION);
+    }
+
+    @Override public SqlReturnTypeInference getRowTypeInference() {
+      return opBinding -> opBinding.getTypeFactory().builder()
+          .add("VAL", SqlTypeName.DECIMAL, 5, 2)
+          .build();
+    }
+
+    @Override public TableCharacteristic tableCharacteristic(int ordinal) {
+      return tableParams.get(ordinal);
+    }
+
+    @Override public boolean argumentMustBeScalar(int ordinal) {
+      return !tableParams.containsKey(ordinal);
+    }
+
+
+    /** Operand type checker for {@link TopNTableFunction}. */
+    private static class OperandMetadataImpl implements SqlOperandMetadata {
+
+      @Override public List<RelDataType> paramTypes(RelDataTypeFactory typeFactory) {
+        return ImmutableList.of(
+            typeFactory.createSqlType(SqlTypeName.ANY),
+            typeFactory.createSqlType(SqlTypeName.ANY));
+      }
+
+      @Override public List<String> paramNames() {
+        return ImmutableList.of("LTABLE", "RTABLE");
+      }
+
+      @Override public boolean checkOperandTypes(
+          SqlCallBinding callBinding, boolean throwOnFailure) {
+        return true;
+      }
+
+      @Override public SqlOperandCountRange getOperandCountRange() {
+        return SqlOperandCountRanges.of(2);
+      }
+
+      @Override public String getAllowedSignatures(SqlOperator op, String opName) {
+        return "SIMILARITY(TABLE table_name, TABLE table_name)";
+      }
+    }
+  }
+
+  /** Invalid user-defined table function with multiple input tables with
+   * row semantics. */
+  public static class InvalidTableFunction extends SqlFunction
+      implements SqlTableFunction {
+
+    private final Map<Integer, TableCharacteristic> tableParams =
+        ImmutableMap.of(
+            0,
+            TableCharacteristic
+                .builder(TableCharacteristic.Semantics.ROW)
+                .passColumnsThrough()
+                .build(),
+            1,
+            TableCharacteristic
+                .builder(TableCharacteristic.Semantics.ROW)
+                .passColumnsThrough()
+                .build());
+
+    public InvalidTableFunction() {
+      super("INVALID",
+          SqlKind.OTHER_FUNCTION,
+          ReturnTypes.CURSOR,
+          null,
+          OperandTypes.VARIADIC,
+          SqlFunctionCategory.USER_DEFINED_TABLE_FUNCTION);
+    }
+
+    @Override public SqlReturnTypeInference getRowTypeInference() {
+      return opBinding -> opBinding.getTypeFactory().builder()
+          .add("NAME", SqlTypeName.VARCHAR, 1024)
+          .build();
+    }
+
+    @Override public TableCharacteristic tableCharacteristic(int ordinal) {
+      return tableParams.get(ordinal);
+    }
+
+    @Override public boolean argumentMustBeScalar(int ordinal) {
+      return !tableParams.containsKey(ordinal);
+    }
+  }
+
   /** "MYFUN" user-defined scalar function. */
   public static class MyFunction extends SqlFunction {
     public MyFunction() {
@@ -308,9 +612,8 @@ public CompositeFunction() {
           SqlKind.OTHER_FUNCTION,
           null,
           null,
-          OperandTypes.or(
-              OperandTypes.variadic(SqlOperandCountRanges.from(1)),
-              OperandTypes.variadic(SqlOperandCountRanges.from(2))),
+          OperandTypes.variadic(SqlOperandCountRanges.from(1))
+              .or(OperandTypes.variadic(SqlOperandCountRanges.from(2))),
           SqlFunctionCategory.USER_DEFINED_FUNCTION);
     }
 
diff --git a/testkit/src/main/java/org/apache/calcite/test/QuidemTest.java b/testkit/src/main/java/org/apache/calcite/test/QuidemTest.java
index 6c88920428f..224f7a5e3f7 100644
--- a/testkit/src/main/java/org/apache/calcite/test/QuidemTest.java
+++ b/testkit/src/main/java/org/apache/calcite/test/QuidemTest.java
@@ -39,6 +39,7 @@
 import net.hydromatic.quidem.CommandHandler;
 import net.hydromatic.quidem.Quidem;
 
+import org.junit.jupiter.api.TestInstance;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.MethodSource;
 
@@ -63,6 +64,7 @@
 /**
  * Test that runs every Quidem file as a test.
  */
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
 public abstract class QuidemTest {
 
   private static final Pattern PATTERN = Pattern.compile("\\.iq$");
@@ -112,7 +114,7 @@ private Method findMethod(String path) {
   }
 
   @SuppressWarnings("BetaApi")
-  protected static Collection<Object[]> data(String first) {
+  protected static Collection<String> data(String first) {
     // inUrl = "file:/home/fred/calcite/core/target/test-classes/sql/agg.iq"
     final URL inUrl = QuidemTest.class.getResource("/" + n2u(first));
     final File firstFile = Sources.of(inUrl).file();
@@ -123,7 +125,7 @@ protected static Collection<Object[]> data(String first) {
     for (File f : Util.first(dir.listFiles(filter), new File[0])) {
       paths.add(f.getAbsolutePath().substring(commonPrefixLength));
     }
-    return Util.transform(paths, path -> new Object[] {path});
+    return paths;
   }
 
   protected void checkRun(String path) throws Exception {
@@ -202,7 +204,7 @@ private static String n2u(String s) {
   }
 
   @ParameterizedTest
-  @MethodSource("data")
+  @MethodSource("getPath")
   public void test(String path) throws Exception {
     final Method method = findMethod(path);
     if (method != null) {
@@ -223,6 +225,9 @@ public void test(String path) throws Exception {
     }
   }
 
+  /** Factory method for {@link QuidemTest#test(String)} parameters. */
+  protected abstract Collection<String> getPath();
+
   /** Quidem connection factory for Calcite's built-in test schemas. */
   protected static class QuidemConnectionFactory
       implements Quidem.ConnectionFactory {
@@ -286,8 +291,14 @@ public Connection connect(String name) throws Exception {
             .with(CalciteConnectionProperty.FUN, "oracle")
             .with(CalciteAssert.Config.REGULAR)
             .connect();
+      case "mssqlfunc":
+        return CalciteAssert.that()
+            .with(CalciteConnectionProperty.FUN, "mssql")
+            .with(CalciteAssert.Config.REGULAR)
+            .connect();
       case "catchall":
         return CalciteAssert.that()
+            .with(CalciteConnectionProperty.TIME_ZONE, "UTC")
             .withSchema("s",
                 new ReflectiveSchema(
                     new CatchallSchema()))
diff --git a/testkit/src/main/java/org/apache/calcite/test/RelMetadataFixture.java b/testkit/src/main/java/org/apache/calcite/test/RelMetadataFixture.java
index 090816cced0..04c9e97bae0 100644
--- a/testkit/src/main/java/org/apache/calcite/test/RelMetadataFixture.java
+++ b/testkit/src/main/java/org/apache/calcite/test/RelMetadataFixture.java
@@ -41,6 +41,7 @@
 import org.apache.calcite.tools.RelBuilder;
 import org.apache.calcite.util.ImmutableBitSet;
 
+import com.google.common.base.Preconditions;
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.ImmutableSortedSet;
 import com.google.common.collect.Iterables;
@@ -195,12 +196,14 @@ public RelNode toRel() {
     metadataConfig.applyMetadata(rel.getCluster());
     if (convertAsCalc) {
       Project project = (Project) rel;
-      RexProgram program = RexProgram.create(
-          project.getInput().getRowType(),
-          project.getProjects(),
-          null,
-          project.getRowType(),
-          project.getCluster().getRexBuilder());
+      Preconditions.checkArgument(project.getVariablesSet().isEmpty(),
+          "Calc does not allow variables");
+      RexProgram program =
+          RexProgram.create(project.getInput().getRowType(),
+              project.getProjects(),
+              null,
+              project.getRowType(),
+              project.getCluster().getRexBuilder());
       return LogicalCalc.create(project.getInput(), program);
     }
     return relTransform.apply(rel);
diff --git a/testkit/src/main/java/org/apache/calcite/test/RelOptFixture.java b/testkit/src/main/java/org/apache/calcite/test/RelOptFixture.java
index ecb474a9ec0..7045d274354 100644
--- a/testkit/src/main/java/org/apache/calcite/test/RelOptFixture.java
+++ b/testkit/src/main/java/org/apache/calcite/test/RelOptFixture.java
@@ -77,14 +77,14 @@
  * set up (for example, the same SQL expression and set of planner rules), it is
  * safe to use the same fixture object as a starting point for both tests.
  */
-class RelOptFixture {
+public class RelOptFixture {
   static final RelOptFixture DEFAULT =
       new RelOptFixture(SqlToRelFixture.TESTER, SqlTestFactory.INSTANCE,
           null, RelSupplier.NONE, null, null,
           ImmutableMap.of(), (f, r) -> r, (f, r) -> r, false, false)
           .withFactory(f ->
-              f.withValidatorConfig(c ->
-                  c.withIdentifierExpansion(true)))
+              f.withValidatorConfig(c -> c.withIdentifierExpansion(true))
+                  .withSqlToRelConfig(c -> c.withExpand(false)))
           .withRelBuilderConfig(b -> b.withPruneInputOfAggregate(false));
 
   /**
@@ -369,8 +369,9 @@ private void checkPlanning(boolean unchanged) {
 
     final RelNode r2;
     if (planner instanceof VolcanoPlanner) {
-      r2 = planner.changeTraits(relBefore,
-          relBefore.getTraitSet().replace(EnumerableConvention.INSTANCE));
+      r2 =
+          planner.changeTraits(relBefore,
+              relBefore.getTraitSet().replace(EnumerableConvention.INSTANCE));
     } else {
       r2 = relBefore;
     }
diff --git a/testkit/src/main/java/org/apache/calcite/test/RelOptTestBase.java b/testkit/src/main/java/org/apache/calcite/test/RelOptTestBase.java
index 13d8cca98db..0a0ac79b9d6 100644
--- a/testkit/src/main/java/org/apache/calcite/test/RelOptTestBase.java
+++ b/testkit/src/main/java/org/apache/calcite/test/RelOptTestBase.java
@@ -34,7 +34,10 @@ RelOptFixture fixture() {
     return RelOptFixture.DEFAULT;
   }
 
-  /** Creates a fixture and sets its SQL statement. */
+  /**
+   * Creates a test context with a SQL query.
+   * Default catalog: {@link org.apache.calcite.test.catalog.MockCatalogReaderSimple#init()}.
+   */
   protected final RelOptFixture sql(String sql) {
     return fixture().sql(sql);
   }
diff --git a/testkit/src/main/java/org/apache/calcite/test/RelSupplier.java b/testkit/src/main/java/org/apache/calcite/test/RelSupplier.java
index 6b50fe88c95..44a82f54df9 100644
--- a/testkit/src/main/java/org/apache/calcite/test/RelSupplier.java
+++ b/testkit/src/main/java/org/apache/calcite/test/RelSupplier.java
@@ -97,7 +97,7 @@ private SqlRelSupplier(String sql) {
       return fixture.tester
           .convertSqlToRel(fixture.factory, sql2, fixture.decorrelate,
               fixture.factory.sqlToRelConfig.isTrimUnusedFields())
-          .rel;
+          .project();
     }
 
     @Override public RelNode apply2(RelMetadataFixture metadataFixture) {
diff --git a/testkit/src/main/java/org/apache/calcite/test/RexImplicationCheckerFixtures.java b/testkit/src/main/java/org/apache/calcite/test/RexImplicationCheckerFixtures.java
index 26db5c6b097..ed6d468a398 100644
--- a/testkit/src/main/java/org/apache/calcite/test/RexImplicationCheckerFixtures.java
+++ b/testkit/src/main/java/org/apache/calcite/test/RexImplicationCheckerFixtures.java
@@ -133,8 +133,8 @@ public Fixture() {
           .add("string", stringDataType)
           .build();
 
-      executor = Frameworks.withPrepare(
-          (cluster, relOptSchema, rootSchema, statement) ->
+      executor =
+          Frameworks.withPrepare((cluster, relOptSchema, rootSchema, statement) ->
               new RexExecutorImpl(
                   DataContexts.of(statement.getConnection(), rootSchema)));
       simplify =
@@ -230,7 +230,7 @@ public RexNode timeLiteral(TimeString t) {
     }
 
     public RexNode cast(RelDataType type, RexNode exp) {
-      return rexBuilder.makeCast(type, exp, true);
+      return rexBuilder.makeCast(type, exp, true, false);
     }
 
     void checkImplies(RexNode node1, RexNode node2) {
diff --git a/testkit/src/main/java/org/apache/calcite/test/SqlOperatorFixtures.java b/testkit/src/main/java/org/apache/calcite/test/SqlOperatorFixtures.java
new file mode 100644
index 00000000000..1d91c97759d
--- /dev/null
+++ b/testkit/src/main/java/org/apache/calcite/test/SqlOperatorFixtures.java
@@ -0,0 +1,116 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.test;
+
+import org.apache.calcite.sql.test.SqlOperatorFixture;
+import org.apache.calcite.util.DelegatingInvocationHandler;
+
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+import java.lang.reflect.Proxy;
+import java.util.regex.Pattern;
+
+/** Utilities for {@link SqlOperatorFixture}. */
+class SqlOperatorFixtures {
+  private SqlOperatorFixtures() {
+  }
+
+  /** Returns a fixture that converts each CAST test into a test for
+   * SAFE_CAST. */
+  static SqlOperatorFixture safeCastWrapper(SqlOperatorFixture fixture) {
+    return (SqlOperatorFixture) Proxy.newProxyInstance(
+        SqlOperatorTest.class.getClassLoader(),
+        new Class[]{SqlOperatorFixture.class},
+        new SqlOperatorFixtureInvocationHandler(fixture));
+  }
+
+  /** A helper for {@link #safeCastWrapper(SqlOperatorFixture)} that provides
+   * alternative implementations of methods in {@link SqlOperatorFixture}.
+   *
+   * <p>Must be public, so that its methods can be seen via reflection. */
+  @SuppressWarnings("unused")
+  public static class SqlOperatorFixtureInvocationHandler
+      extends DelegatingInvocationHandler {
+    static final Pattern CAST_PATTERN = Pattern.compile("(?i)\\bCAST\\(");
+    static final Pattern NOT_NULL_PATTERN = Pattern.compile(" NOT NULL");
+
+    final SqlOperatorFixture f;
+
+    SqlOperatorFixtureInvocationHandler(SqlOperatorFixture f) {
+      this.f = f;
+    }
+
+    @Override protected Object getTarget() {
+      return f;
+    }
+
+    String addSafe(String sql) {
+      return CAST_PATTERN.matcher(sql).replaceAll("SAFE_CAST(");
+    }
+
+    String removeNotNull(String type) {
+      return NOT_NULL_PATTERN.matcher(type).replaceAll("");
+    }
+
+    /** Proxy for
+     * {@link SqlOperatorFixture#checkCastToString(String, String, String, boolean)}. */
+    public void checkCastToString(String value, @Nullable String type,
+        @Nullable String expected, boolean safe) {
+      f.checkCastToString(addSafe(value),
+          type == null ? null : removeNotNull(type), expected, safe);
+    }
+
+    /** Proxy for {@link SqlOperatorFixture#checkBoolean(String, Boolean)}. */
+    public void checkFails(String expression, @Nullable Boolean result) {
+      f.checkBoolean(addSafe(expression), result);
+    }
+
+    /** Proxy for {@link SqlOperatorFixture#checkNull(String)}. */
+    public void checkNull(String expression) {
+      f.checkNull(addSafe(expression));
+    }
+
+    /** Proxy for
+     * {@link SqlOperatorFixture#checkFails(String, String, boolean)}. */
+    public void checkFails(String expression, String expectedError, boolean runtime) {
+      f.checkFails(addSafe(expression), expectedError, runtime);
+    }
+
+    /** Proxy for
+     * {@link SqlOperatorFixture#checkScalar(String, Object, String)}. */
+    public void checkScalar(String expression, Object result, String resultType) {
+      f.checkScalar(addSafe(expression), result, removeNotNull(resultType));
+    }
+
+    /** Proxy for {@link SqlOperatorFixture#checkScalarExact(String, int)}. */
+    public void checkScalarExact(String expression, int result) {
+      f.checkScalarExact(addSafe(expression), result);
+    }
+
+    /** Proxy for
+     * {@link SqlOperatorFixture#checkScalarExact(String, String, String)}. */
+    public void checkScalarExact(String expression, String expectedType, String result) {
+      f.checkScalarExact(addSafe(expression), removeNotNull(expectedType), result);
+    }
+
+    /** Proxy for
+     * {@link SqlOperatorFixture#checkString(String, String, String)}. */
+    public void checkString(String expression, String result, String resultType) {
+      f.checkString(addSafe(expression), result, removeNotNull(resultType));
+    }
+  }
+}
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 26919dfb9a5..a586c264f7d 100644
--- a/testkit/src/main/java/org/apache/calcite/test/SqlOperatorTest.java
+++ b/testkit/src/main/java/org/apache/calcite/test/SqlOperatorTest.java
@@ -19,9 +19,15 @@
 import org.apache.calcite.avatica.util.DateTimeUtils;
 import org.apache.calcite.config.CalciteConnectionProperty;
 import org.apache.calcite.linq4j.Linq4j;
+import org.apache.calcite.linq4j.function.Function1;
+import org.apache.calcite.linq4j.function.Function2;
+import org.apache.calcite.linq4j.tree.Types;
 import org.apache.calcite.plan.Strong;
+import org.apache.calcite.rel.type.DelegatingTypeSystem;
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeFactory;
+import org.apache.calcite.rel.type.RelDataTypeSystem;
+import org.apache.calcite.rel.type.TimeFrameSet;
 import org.apache.calcite.runtime.CalciteContextException;
 import org.apache.calcite.runtime.CalciteException;
 import org.apache.calcite.runtime.Hook;
@@ -64,17 +70,24 @@
 import org.apache.calcite.util.Pair;
 import org.apache.calcite.util.TestUtil;
 import org.apache.calcite.util.TimestampString;
+import org.apache.calcite.util.TryThreadLocal;
 import org.apache.calcite.util.Util;
 import org.apache.calcite.util.trace.CalciteTrace;
 
 import com.google.common.base.Throwables;
+import com.google.common.collect.ImmutableList;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.ValueSource;
 import org.slf4j.Logger;
 
+import java.lang.reflect.Field;
 import java.math.BigDecimal;
 import java.sql.Connection;
 import java.sql.ResultSet;
@@ -82,6 +95,7 @@
 import java.sql.Statement;
 import java.text.SimpleDateFormat;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Calendar;
 import java.util.Collections;
 import java.util.HashSet;
@@ -94,8 +108,10 @@
 import java.util.regex.Pattern;
 import java.util.stream.Stream;
 
+import static org.apache.calcite.linq4j.tree.Expressions.list;
 import static org.apache.calcite.rel.type.RelDataTypeImpl.NON_NULLABLE_SUFFIX;
 import static org.apache.calcite.sql.fun.SqlStdOperatorTable.PI;
+import static org.apache.calcite.sql.fun.SqlStdOperatorTable.QUANTIFY_OPERATORS;
 import static org.apache.calcite.sql.test.ResultCheckers.isExactly;
 import static org.apache.calcite.sql.test.ResultCheckers.isNullValue;
 import static org.apache.calcite.sql.test.ResultCheckers.isSet;
@@ -109,7 +125,6 @@
 import static org.apache.calcite.sql.test.SqlOperatorFixture.INVALID_EXTRACT_UNIT_VALIDATION_ERROR;
 import static org.apache.calcite.sql.test.SqlOperatorFixture.LITERAL_OUT_OF_RANGE_MESSAGE;
 import static org.apache.calcite.sql.test.SqlOperatorFixture.OUT_OF_RANGE_MESSAGE;
-import static org.apache.calcite.sql.test.SqlOperatorFixture.STRING_TRUNC_MESSAGE;
 import static org.apache.calcite.util.DateTimeStringUtils.getDateFormatter;
 
 import static org.hamcrest.CoreMatchers.equalTo;
@@ -173,6 +188,7 @@
  * null arguments or null results.</li>
  * </ul>
  */
+@SuppressWarnings("MethodCanBeStatic")
 public class SqlOperatorTest {
   //~ Static fields/initializers ---------------------------------------------
 
@@ -205,6 +221,27 @@ public class SqlOperatorTest {
       Pattern.compile(
           "[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]");
 
+  public static final List<String> MICROSECOND_VARIANTS =
+      Arrays.asList("FRAC_SECOND", "MICROSECOND", "SQL_TSI_MICROSECOND");
+  public static final List<String> NANOSECOND_VARIANTS =
+      Arrays.asList("NANOSECOND", "SQL_TSI_FRAC_SECOND");
+  public static final List<String> SECOND_VARIANTS =
+      Arrays.asList("SECOND", "SQL_TSI_SECOND");
+  public static final List<String> MINUTE_VARIANTS =
+      Arrays.asList("MINUTE", "SQL_TSI_MINUTE");
+  public static final List<String> HOUR_VARIANTS =
+      Arrays.asList("HOUR", "SQL_TSI_HOUR");
+  public static final List<String> DAY_VARIANTS =
+      Arrays.asList("DAY", "SQL_TSI_DAY");
+  public static final List<String> WEEK_VARIANTS =
+      Arrays.asList("WEEK", "SQL_TSI_WEEK");
+  public static final List<String> MONTH_VARIANTS =
+      Arrays.asList("MONTH", "SQL_TSI_MONTH");
+  public static final List<String> QUARTER_VARIANTS =
+      Arrays.asList("QUARTER", "SQL_TSI_QUARTER");
+  public static final List<String> YEAR_VARIANTS =
+      Arrays.asList("YEAR", "SQL_TSI_YEAR");
+
   /** Minimum and maximum values for each exact and approximate numeric
    * type. */
   enum Numeric {
@@ -293,11 +330,12 @@ static void forEach(Consumer<Numeric> consumer) {
   // time zone for the CURRENT{DATE,TIME,TIMESTAMP} functions
   protected static final TimeZone CURRENT_TZ = LOCAL_TZ;
 
-  private static final Pattern INVALID_ARG_FOR_POWER = Pattern.compile(
-      "(?s).*Invalid argument\\(s\\) for 'POWER' function.*");
+  private static final Pattern INVALID_ARG_FOR_POWER =
+      Pattern.compile("(?s).*Invalid argument\\(s\\) for 'POWER' function.*");
 
-  private static final Pattern CODE_2201F = Pattern.compile(
-      "(?s).*could not calculate results for the following row.*PC=5 Code=2201F.*");
+  private static final Pattern CODE_2201F =
+      Pattern.compile("(?s).*could not calculate results for the following "
+          + "row.*PC=5 Code=2201F.*");
 
   /**
    * Whether DECIMAL type is implemented.
@@ -393,27 +431,52 @@ protected SqlOperatorFixture fixture() {
         true);
   }
 
-  @Test void testCastToString() {
-    final SqlOperatorFixture f = fixture();
+  /** Tests that CAST and SAFE_CAST are basically equivalent but SAFE_CAST is
+   * only available in BigQuery library. */
+  @Test void testCastVsSafeCast() {
+    // SAFE_CAST is available in BigQuery library but not by default
+    final SqlOperatorFixture f0 = fixture();
+    f0.checkScalar("cast(12 + 3 as varchar(10))", "15", "VARCHAR(10) NOT NULL");
+    f0.checkFails("^safe_cast(12 + 3 as varchar(10))^",
+        "No match found for function signature SAFE_CAST\\(<NUMERIC>, <CHARACTER>\\)",
+        false);
+
+    final SqlOperatorFixture f = f0.withLibrary(SqlLibrary.BIG_QUERY);
+    f.checkScalar("cast(12 + 3 as varchar(10))", "15", "VARCHAR(10) NOT NULL");
+    f.checkScalar("safe_cast(12 + 3 as varchar(10))", "15", "VARCHAR(10)");
+  }
+
+  /** Generates parameters to test both regular and safe cast. */
+  static Stream<Arguments> safeParameters() {
+    SqlOperatorFixture f = SqlOperatorFixtureImpl.DEFAULT;
+    SqlOperatorFixture f2 = f.withLibrary(SqlLibrary.BIG_QUERY);
+    SqlOperatorFixture f3 = SqlOperatorFixtures.safeCastWrapper(f2);
+    return Stream.of(
+        () -> new Object[] {false, f},
+        () -> new Object[] {true, f3});
+  }
+
+  @ParameterizedTest
+  @MethodSource("safeParameters")
+  void testCastToString(boolean safe, SqlOperatorFixture f) {
     f.setFor(SqlStdOperatorTable.CAST, VmName.EXPAND);
     f.checkCastToString("cast(cast('abc' as char(4)) as varchar(6))", null,
-        "abc ");
+        "abc ", safe);
 
     // integer
-    f.checkCastToString("123", "CHAR(3)", "123");
-    f.checkCastToString("0", "CHAR", "0");
-    f.checkCastToString("-123", "CHAR(4)", "-123");
+    f.checkCastToString("123", "CHAR(3)", "123", safe);
+
+    f.checkCastToString("0", "CHAR", "0", safe);
+    f.checkCastToString("-123", "CHAR(4)", "-123", safe);
 
     // decimal
-    f.checkCastToString("123.4", "CHAR(5)", "123.4");
-    f.checkCastToString("-0.0", "CHAR(2)", ".0");
-    f.checkCastToString("-123.4", "CHAR(6)", "-123.4");
+    f.checkCastToString("123.4", "CHAR(5)", "123.4", safe);
+    f.checkCastToString("-0.0", "CHAR(2)", ".0", safe);
+    f.checkCastToString("-123.4", "CHAR(6)", "-123.4", safe);
 
     f.checkString("cast(1.29 as varchar(10))", "1.29", "VARCHAR(10) NOT NULL");
     f.checkString("cast(.48 as varchar(10))", ".48", "VARCHAR(10) NOT NULL");
-    if (Bug.CALCITE_2539_FIXED) {
-      f.checkFails("cast(2.523 as char(2))", STRING_TRUNC_MESSAGE, true);
-    }
+    f.checkString("cast(2.523 as char(2))", "2.", "CHAR(2) NOT NULL");
 
     f.checkString("cast(-0.29 as varchar(10))",
         "-.29", "VARCHAR(10) NOT NULL");
@@ -421,36 +484,33 @@ protected SqlOperatorFixture fixture() {
         "-1.29", "VARCHAR(10) NOT NULL");
 
     // approximate
-    f.checkCastToString("1.23E45", "CHAR(7)", "1.23E45");
-    f.checkCastToString("CAST(0 AS DOUBLE)", "CHAR(3)", "0E0");
-    f.checkCastToString("-1.20e-07", "CHAR(7)", "-1.2E-7");
-    f.checkCastToString("cast(0e0 as varchar(5))", "CHAR(3)", "0E0");
+    f.checkCastToString("1.23E45", "CHAR(7)", "1.23E45", safe);
+    f.checkCastToString("CAST(0 AS DOUBLE)", "CHAR(3)", "0E0", safe);
+    f.checkCastToString("-1.20e-07", "CHAR(7)", "-1.2E-7", safe);
+    f.checkCastToString("cast(0e0 as varchar(5))", "CHAR(3)", "0E0", safe);
     if (TODO) {
       f.checkCastToString("cast(-45e-2 as varchar(17))", "CHAR(7)",
-          "-4.5E-1");
+          "-4.5E-1", safe);
     }
     if (TODO) {
       f.checkCastToString("cast(4683442.3432498375e0 as varchar(20))",
           "CHAR(19)",
-          "4.683442343249838E6");
+          "4.683442343249838E6", safe);
     }
     if (TODO) {
-      f.checkCastToString("cast(-0.1 as real)", "CHAR(5)", "-1E-1");
-    }
-    if (Bug.CALCITE_2539_FIXED) {
-      f.checkFails("cast(1.3243232e0 as varchar(4))", STRING_TRUNC_MESSAGE,
-          true);
-      f.checkFails("cast(1.9e5 as char(4))", STRING_TRUNC_MESSAGE,
-          true);
+      f.checkCastToString("cast(-0.1 as real)", "CHAR(5)", "-1E-1", safe);
     }
+    f.checkString("cast(1.3243232e0 as varchar(4))", "1.32",
+        "VARCHAR(4) NOT NULL");
+    f.checkString("cast(1.9e5 as char(4))", "1.9E", "CHAR(4) NOT NULL");
 
     // string
-    f.checkCastToString("'abc'", "CHAR(1)", "a");
-    f.checkCastToString("'abc'", "CHAR(3)", "abc");
-    f.checkCastToString("cast('abc' as varchar(6))", "CHAR(3)", "abc");
-    f.checkCastToString("cast(' abc  ' as varchar(10))", null, " abc  ");
+    f.checkCastToString("'abc'", "CHAR(1)", "a", safe);
+    f.checkCastToString("'abc'", "CHAR(3)", "abc", safe);
+    f.checkCastToString("cast('abc' as varchar(6))", "CHAR(3)", "abc", safe);
+    f.checkCastToString("cast(' abc  ' as varchar(10))", null, " abc  ", safe);
     f.checkCastToString("cast(cast('abc' as char(4)) as varchar(6))", null,
-        "abc ");
+        "abc ", safe);
     f.checkString("cast(cast('a' as char(2)) as varchar(3)) || 'x' ",
         "a x", "VARCHAR(4) NOT NULL");
     f.checkString("cast(cast('a' as char(3)) as varchar(5)) || 'x' ",
@@ -470,37 +530,36 @@ protected SqlOperatorFixture fixture() {
         "INTEGER NOT NULL");
 
     // date & time
-    f.checkCastToString("date '2008-01-01'", "CHAR(10)", "2008-01-01");
-    f.checkCastToString("time '1:2:3'", "CHAR(8)", "01:02:03");
+    f.checkCastToString("date '2008-01-01'", "CHAR(10)", "2008-01-01", safe);
+    f.checkCastToString("time '1:2:3'", "CHAR(8)", "01:02:03", safe);
     f.checkCastToString("timestamp '2008-1-1 1:2:3'", "CHAR(19)",
-        "2008-01-01 01:02:03");
+        "2008-01-01 01:02:03", safe);
     f.checkCastToString("timestamp '2008-1-1 1:2:3'", "VARCHAR(30)",
-        "2008-01-01 01:02:03");
+        "2008-01-01 01:02:03", safe);
 
-    f.checkCastToString("interval '3-2' year to month", "CHAR(5)", "+3-02");
-    f.checkCastToString("interval '32' month", "CHAR(3)", "+32");
+    f.checkCastToString("interval '3-2' year to month", "CHAR(5)", "+3-02", safe);
+    f.checkCastToString("interval '32' month", "CHAR(3)", "+32", safe);
     f.checkCastToString("interval '1 2:3:4' day to second", "CHAR(11)",
-        "+1 02:03:04");
+        "+1 02:03:04", safe);
     f.checkCastToString("interval '1234.56' second(4,2)", "CHAR(8)",
-        "+1234.56");
-    f.checkCastToString("interval '60' day", "CHAR(8)", "+60     ");
+        "+1234.56", safe);
+    f.checkCastToString("interval '60' day", "CHAR(8)", "+60     ", safe);
 
     // boolean
-    f.checkCastToString("True", "CHAR(4)", "TRUE");
-    f.checkCastToString("True", "CHAR(6)", "TRUE  ");
-    f.checkCastToString("True", "VARCHAR(6)", "TRUE");
-    f.checkCastToString("False", "CHAR(5)", "FALSE");
+    f.checkCastToString("True", "CHAR(4)", "TRUE", safe);
+    f.checkCastToString("True", "CHAR(6)", "TRUE  ", safe);
+    f.checkCastToString("True", "VARCHAR(6)", "TRUE", safe);
+    f.checkCastToString("False", "CHAR(5)", "FALSE", safe);
 
-    if (Bug.CALCITE_2539_FIXED) {
-      f.checkFails("cast(true as char(3))", INVALID_CHAR_MESSAGE, true);
-      f.checkFails("cast(false as char(4))", INVALID_CHAR_MESSAGE, true);
-      f.checkFails("cast(true as varchar(3))", INVALID_CHAR_MESSAGE, true);
-      f.checkFails("cast(false as varchar(4))", INVALID_CHAR_MESSAGE, true);
-    }
+    f.checkString("cast(true as char(3))", "TRU", "CHAR(3) NOT NULL");
+    f.checkString("cast(false as char(4))", "FALS", "CHAR(4) NOT NULL");
+    f.checkString("cast(true as varchar(3))", "TRU", "VARCHAR(3) NOT NULL");
+    f.checkString("cast(false as varchar(4))", "FALS", "VARCHAR(4) NOT NULL");
   }
 
-  @Test void testCastExactNumericLimits() {
-    final SqlOperatorFixture f = fixture();
+  @ParameterizedTest
+  @MethodSource("safeParameters")
+  void testCastExactNumericLimits(boolean safe, SqlOperatorFixture f) {
     f.setFor(SqlStdOperatorTable.CAST, VmName.EXPAND);
 
     // Test casting for min,max, out of range for exact numeric types
@@ -517,72 +576,74 @@ protected SqlOperatorFixture fixture() {
       }
 
       // Convert from literal to type
-      f.checkCastToScalarOkay(numeric.maxNumericString, type);
-      f.checkCastToScalarOkay(numeric.minNumericString, type);
+      f.checkCastToScalarOkay(numeric.maxNumericString, type, safe);
+      f.checkCastToScalarOkay(numeric.minNumericString, type, safe);
 
       // Overflow test
       if (numeric == Numeric.BIGINT) {
         // Literal of range
         f.checkCastFails(numeric.maxOverflowNumericString,
-            type, LITERAL_OUT_OF_RANGE_MESSAGE, false);
+            type, LITERAL_OUT_OF_RANGE_MESSAGE, false, safe);
         f.checkCastFails(numeric.minOverflowNumericString,
-            type, LITERAL_OUT_OF_RANGE_MESSAGE, false);
+            type, LITERAL_OUT_OF_RANGE_MESSAGE, false, safe);
       } else {
         if (Bug.CALCITE_2539_FIXED) {
           f.checkCastFails(numeric.maxOverflowNumericString,
-              type, OUT_OF_RANGE_MESSAGE, true);
+              type, OUT_OF_RANGE_MESSAGE, true, safe);
           f.checkCastFails(numeric.minOverflowNumericString,
-              type, OUT_OF_RANGE_MESSAGE, true);
+              type, OUT_OF_RANGE_MESSAGE, true, safe);
         }
       }
 
       // Convert from string to type
       f.checkCastToScalarOkay("'" + numeric.maxNumericString + "'",
-          type, numeric.maxNumericString);
+          type, numeric.maxNumericString, safe);
       f.checkCastToScalarOkay("'" + numeric.minNumericString + "'",
-          type, numeric.minNumericString);
+          type, numeric.minNumericString, safe);
 
       if (Bug.CALCITE_2539_FIXED) {
         f.checkCastFails("'" + numeric.maxOverflowNumericString + "'",
-            type, OUT_OF_RANGE_MESSAGE, true);
+            type, OUT_OF_RANGE_MESSAGE, true, safe);
         f.checkCastFails("'" + numeric.minOverflowNumericString + "'",
-            type, OUT_OF_RANGE_MESSAGE, true);
+            type, OUT_OF_RANGE_MESSAGE, true, safe);
       }
 
       // Convert from type to string
-      f.checkCastToString(numeric.maxNumericString, null, null);
-      f.checkCastToString(numeric.maxNumericString, type, null);
+      f.checkCastToString(numeric.maxNumericString, null, null, safe);
+      f.checkCastToString(numeric.maxNumericString, type, null, safe);
 
-      f.checkCastToString(numeric.minNumericString, null, null);
-      f.checkCastToString(numeric.minNumericString, type, null);
+      f.checkCastToString(numeric.minNumericString, null, null, safe);
+      f.checkCastToString(numeric.minNumericString, type, null, safe);
 
       if (Bug.CALCITE_2539_FIXED) {
-        f.checkCastFails("'notnumeric'", type, INVALID_CHAR_MESSAGE, true);
+        f.checkCastFails("'notnumeric'", type, INVALID_CHAR_MESSAGE, true,
+            safe);
       }
     });
   }
 
-  @Test void testCastToExactNumeric() {
-    final SqlOperatorFixture f = fixture();
+  @ParameterizedTest
+  @MethodSource("safeParameters")
+  void testCastToExactNumeric(boolean safe, SqlOperatorFixture f) {
     f.setFor(SqlStdOperatorTable.CAST, VmName.EXPAND);
 
-    f.checkCastToScalarOkay("1", "BIGINT");
-    f.checkCastToScalarOkay("1", "INTEGER");
-    f.checkCastToScalarOkay("1", "SMALLINT");
-    f.checkCastToScalarOkay("1", "TINYINT");
-    f.checkCastToScalarOkay("1", "DECIMAL(4, 0)");
-    f.checkCastToScalarOkay("-1", "BIGINT");
-    f.checkCastToScalarOkay("-1", "INTEGER");
-    f.checkCastToScalarOkay("-1", "SMALLINT");
-    f.checkCastToScalarOkay("-1", "TINYINT");
-    f.checkCastToScalarOkay("-1", "DECIMAL(4, 0)");
-
-    f.checkCastToScalarOkay("1.234E3", "INTEGER", "1234");
-    f.checkCastToScalarOkay("-9.99E2", "INTEGER", "-999");
-    f.checkCastToScalarOkay("'1'", "INTEGER", "1");
-    f.checkCastToScalarOkay("' 01 '", "INTEGER", "1");
-    f.checkCastToScalarOkay("'-1'", "INTEGER", "-1");
-    f.checkCastToScalarOkay("' -00 '", "INTEGER", "0");
+    f.checkCastToScalarOkay("1", "BIGINT", safe);
+    f.checkCastToScalarOkay("1", "INTEGER", safe);
+    f.checkCastToScalarOkay("1", "SMALLINT", safe);
+    f.checkCastToScalarOkay("1", "TINYINT", safe);
+    f.checkCastToScalarOkay("1", "DECIMAL(4, 0)", safe);
+    f.checkCastToScalarOkay("-1", "BIGINT", safe);
+    f.checkCastToScalarOkay("-1", "INTEGER", safe);
+    f.checkCastToScalarOkay("-1", "SMALLINT", safe);
+    f.checkCastToScalarOkay("-1", "TINYINT", safe);
+    f.checkCastToScalarOkay("-1", "DECIMAL(4, 0)", safe);
+
+    f.checkCastToScalarOkay("1.234E3", "INTEGER", "1234", safe);
+    f.checkCastToScalarOkay("-9.99E2", "INTEGER", "-999", safe);
+    f.checkCastToScalarOkay("'1'", "INTEGER", "1", safe);
+    f.checkCastToScalarOkay("' 01 '", "INTEGER", "1", safe);
+    f.checkCastToScalarOkay("'-1'", "INTEGER", "-1", safe);
+    f.checkCastToScalarOkay("' -00 '", "INTEGER", "0", safe);
 
     // string to integer
     f.checkScalarExact("cast('6543' as integer)", 6543);
@@ -592,8 +653,9 @@ protected SqlOperatorFixture fixture() {
         "654342432412312");
   }
 
-  @Test void testCastStringToDecimal() {
-    final SqlOperatorFixture f = fixture();
+  @ParameterizedTest
+  @MethodSource("safeParameters")
+  void testCastStringToDecimal(boolean safe, SqlOperatorFixture f) {
     f.setFor(SqlStdOperatorTable.CAST, VmName.EXPAND);
     if (!DECIMAL) {
       return;
@@ -621,8 +683,9 @@ protected SqlOperatorFixture fixture() {
         true);
   }
 
-  @Test void testCastIntervalToNumeric() {
-    final SqlOperatorFixture f = fixture();
+  @ParameterizedTest
+  @MethodSource("safeParameters")
+  void testCastIntervalToNumeric(boolean safe, SqlOperatorFixture f) {
     f.setFor(SqlStdOperatorTable.CAST, VmName.EXPAND);
 
     // interval to decimal
@@ -728,8 +791,9 @@ protected SqlOperatorFixture fixture() {
         "-1");
   }
 
-  @Test void testCastToInterval() {
-    final SqlOperatorFixture f = fixture();
+  @ParameterizedTest
+  @MethodSource("safeParameters")
+  void testCastToInterval(boolean safe, SqlOperatorFixture f) {
     f.setFor(SqlStdOperatorTable.CAST, VmName.EXPAND);
     f.checkScalar(
         "cast(5 as interval second)",
@@ -782,8 +846,9 @@ protected SqlOperatorFixture fixture() {
         "INTERVAL MINUTE(4) NOT NULL");
   }
 
-  @Test void testCastIntervalToInterval() {
-    final SqlOperatorFixture f = fixture();
+  @ParameterizedTest
+  @MethodSource("safeParameters")
+  void testCastIntervalToInterval(boolean safe, SqlOperatorFixture f) {
     f.checkScalar("cast(interval '2 5' day to hour as interval hour to minute)",
         "+53:00",
         "INTERVAL HOUR TO MINUTE NOT NULL");
@@ -801,8 +866,9 @@ protected SqlOperatorFixture fixture() {
         "INTERVAL DAY TO HOUR NOT NULL");
   }
 
-  @Test void testCastWithRoundingToScalar() {
-    final SqlOperatorFixture f = fixture();
+  @ParameterizedTest
+  @MethodSource("safeParameters")
+  void testCastWithRoundingToScalar(boolean safe, SqlOperatorFixture f) {
     f.setFor(SqlStdOperatorTable.CAST, VmName.EXPAND);
 
     f.checkFails("cast(1.25 as int)", "INTEGER", true);
@@ -841,8 +907,9 @@ protected SqlOperatorFixture fixture() {
         true);
   }
 
-  @Test void testCastDecimalToDoubleToInteger() {
-    final SqlOperatorFixture f = fixture();
+  @ParameterizedTest
+  @MethodSource("safeParameters")
+  void testCastDecimalToDoubleToInteger(boolean safe, SqlOperatorFixture f) {
     f.setFor(SqlStdOperatorTable.CAST, VmName.EXPAND);
 
     f.checkFails("cast( cast(1.25 as double) as integer)", OUT_OF_RANGE_MESSAGE, true);
@@ -856,8 +923,9 @@ protected SqlOperatorFixture fixture() {
     f.checkFails("cast( cast(-1.5 as double) as integer)", OUT_OF_RANGE_MESSAGE, true);
   }
 
-  @Test void testCastApproxNumericLimits() {
-    final SqlOperatorFixture f = fixture();
+  @ParameterizedTest
+  @MethodSource("safeParameters")
+  void testCastApproxNumericLimits(boolean safe, SqlOperatorFixture f) {
     f.setFor(SqlStdOperatorTable.CAST, VmName.EXPAND);
 
     // Test casting for min, max, out of range for approx numeric types
@@ -886,43 +954,43 @@ protected SqlOperatorFixture fixture() {
       f.checkCastToApproxOkay(numeric.maxNumericString, type,
           isFloat
               ? isWithin(numeric.maxNumericAsDouble(), 1E32)
-              : isExactly(numeric.maxNumericAsDouble()));
+              : isExactly(numeric.maxNumericAsDouble()), safe);
       f.checkCastToApproxOkay(numeric.minNumericString, type,
-          isExactly(numeric.minNumericString));
+          isExactly(numeric.minNumericString), safe);
 
       if (isFloat) {
         f.checkCastFails(numeric.maxOverflowNumericString, type,
-            OUT_OF_RANGE_MESSAGE, true);
+            OUT_OF_RANGE_MESSAGE, true, safe);
       } else {
         // Double: Literal out of range
         f.checkCastFails(numeric.maxOverflowNumericString, type,
-            LITERAL_OUT_OF_RANGE_MESSAGE, false);
+            LITERAL_OUT_OF_RANGE_MESSAGE, false, safe);
       }
 
       // Underflow: goes to 0
       f.checkCastToApproxOkay(numeric.minOverflowNumericString, type,
-          isExactly(0));
+          isExactly(0), safe);
 
       // Convert from string to type
       f.checkCastToApproxOkay("'" + numeric.maxNumericString + "'", type,
           isFloat
               ? isWithin(numeric.maxNumericAsDouble(), 1E32)
-              : isExactly(numeric.maxNumericAsDouble()));
+              : isExactly(numeric.maxNumericAsDouble()), safe);
       f.checkCastToApproxOkay("'" + numeric.minNumericString + "'", type,
-          isExactly(numeric.minNumericAsDouble()));
+          isExactly(numeric.minNumericAsDouble()), safe);
 
       f.checkCastFails("'" + numeric.maxOverflowNumericString + "'", type,
-          OUT_OF_RANGE_MESSAGE, true);
+          OUT_OF_RANGE_MESSAGE, true, safe);
 
       // Underflow: goes to 0
       f.checkCastToApproxOkay("'" + numeric.minOverflowNumericString + "'",
-          type, isExactly(0));
+          type, isExactly(0), safe);
 
       // Convert from type to string
 
       // Treated as DOUBLE
       f.checkCastToString(numeric.maxNumericString, null,
-          isFloat ? null : "1.79769313486231E308");
+          isFloat ? null : "1.79769313486231E308", safe);
 
       // TODO: The following tests are slightly different depending on
       // whether the java or fennel calc are used.
@@ -930,42 +998,45 @@ protected SqlOperatorFixture fixture() {
       if (false /* fennel calc*/) { // Treated as FLOAT or DOUBLE
         f.checkCastToString(numeric.maxNumericString, type,
             // Treated as DOUBLE
-            isFloat ? "3.402824E38" : "1.797693134862316E308");
+            isFloat ? "3.402824E38" : "1.797693134862316E308", safe);
         f.checkCastToString(numeric.minNumericString, null,
             // Treated as FLOAT or DOUBLE
-            isFloat ? null : "4.940656458412465E-324");
+            isFloat ? null : "4.940656458412465E-324", safe);
         f.checkCastToString(numeric.minNumericString, type,
-            isFloat ? "1.401299E-45" : "4.940656458412465E-324");
+            isFloat ? "1.401299E-45" : "4.940656458412465E-324", safe);
       } else if (false /* JavaCalc */) {
         // Treated as FLOAT or DOUBLE
         f.checkCastToString(numeric.maxNumericString, type,
             // Treated as DOUBLE
-            isFloat ? "3.402823E38" : "1.797693134862316E308");
+            isFloat ? "3.402823E38" : "1.797693134862316E308", safe);
         f.checkCastToString(numeric.minNumericString, null,
-            isFloat ? null : null); // Treated as FLOAT or DOUBLE
+            isFloat ? null : null, safe); // Treated as FLOAT or DOUBLE
         f.checkCastToString(numeric.minNumericString, type,
-            isFloat ? "1.401298E-45" : null);
+            isFloat ? "1.401298E-45" : null, safe);
       }
 
-      f.checkCastFails("'notnumeric'", type, INVALID_CHAR_MESSAGE, true);
+      f.checkCastFails("'notnumeric'", type, INVALID_CHAR_MESSAGE, true, safe);
     });
   }
 
-  @Test void testCastToApproxNumeric() {
-    final SqlOperatorFixture f = fixture();
+  @ParameterizedTest
+  @MethodSource("safeParameters")
+  void testCastToApproxNumeric(boolean safe, SqlOperatorFixture f) {
     f.setFor(SqlStdOperatorTable.CAST, VmName.EXPAND);
 
-    f.checkCastToApproxOkay("1", "DOUBLE", isExactly(1));
-    f.checkCastToApproxOkay("1.0", "DOUBLE", isExactly(1));
-    f.checkCastToApproxOkay("-2.3", "FLOAT", isWithin(-2.3, 0.000001));
-    f.checkCastToApproxOkay("'1'", "DOUBLE", isExactly(1));
-    f.checkCastToApproxOkay("'  -1e-37  '", "DOUBLE", isExactly("-1.0E-37"));
-    f.checkCastToApproxOkay("1e0", "DOUBLE", isExactly(1));
-    f.checkCastToApproxOkay("0e0", "REAL", isExactly(0));
+    f.checkCastToApproxOkay("1", "DOUBLE", isExactly(1), safe);
+    f.checkCastToApproxOkay("1.0", "DOUBLE", isExactly(1), safe);
+    f.checkCastToApproxOkay("-2.3", "FLOAT", isWithin(-2.3, 0.000001), safe);
+    f.checkCastToApproxOkay("'1'", "DOUBLE", isExactly(1), safe);
+    f.checkCastToApproxOkay("'  -1e-37  '", "DOUBLE", isExactly("-1.0E-37"),
+        safe);
+    f.checkCastToApproxOkay("1e0", "DOUBLE", isExactly(1), safe);
+    f.checkCastToApproxOkay("0e0", "REAL", isExactly(0), safe);
   }
 
-  @Test void testCastNull() {
-    final SqlOperatorFixture f = fixture();
+  @ParameterizedTest
+  @MethodSource("safeParameters")
+  void testCastNull(boolean safe, SqlOperatorFixture f) {
     f.setFor(SqlStdOperatorTable.CAST, VmName.EXPAND);
 
     // null
@@ -982,16 +1053,28 @@ protected SqlOperatorFixture fixture() {
     f.checkNull("cast(null as interval year to month)");
     f.checkNull("cast(null as interval day to second(3))");
     f.checkNull("cast(null as boolean)");
+
+    if (safe) {
+      // In the following, 'cast' becomes 'safe_cast'
+      f.checkNull("cast('a' as time)");
+      f.checkNull("cast('a' as int)");
+      f.checkNull("cast('2023-03-17a' as date)");
+      f.checkNull("cast('12:12:11a' as time)");
+      f.checkNull("cast('a' as interval year)");
+      f.checkNull("cast('a' as interval minute to second)");
+      f.checkNull("cast('True' as bigint)");
+    }
   }
 
   /** Test case for
    * <a href="https://issues.apache.org/jira/browse/CALCITE-1439">[CALCITE-1439]
    * Handling errors during constant reduction</a>. */
-  @Test void testCastInvalid() {
+  @ParameterizedTest
+  @MethodSource("safeParameters")
+  void testCastInvalid(boolean safe, SqlOperatorFixture f) {
     // Before CALCITE-1439 was fixed, constant reduction would kick in and
     // generate Java constants that throw when the class is loaded, thus
     // ExceptionInInitializerError.
-    final SqlOperatorFixture f = fixture();
     f.checkScalarExact("cast('15' as integer)", "INTEGER NOT NULL", "15");
     if (Bug.CALCITE_2539_FIXED) {
       f.checkFails("cast('15.4' as integer)", "xxx", true);
@@ -1005,9 +1088,10 @@ protected SqlOperatorFixture fixture() {
     }
   }
 
-  @Test void testCastDateTime() {
-    // Test cast for date/time/timestamp
-    final SqlOperatorFixture f = fixture();
+  /** Test cast for DATE, TIME, TIMESTAMP types. */
+  @ParameterizedTest
+  @MethodSource("safeParameters")
+  void testCastDateTime(boolean safe, SqlOperatorFixture f) {
     f.setFor(SqlStdOperatorTable.CAST, VmName.EXPAND);
 
     f.checkScalar("cast(TIMESTAMP '1945-02-24 12:42:25.34' as TIMESTAMP)",
@@ -1036,17 +1120,17 @@ protected SqlOperatorFixture fixture() {
         "12:42:25", "TIME(0) NOT NULL");
 
     // time <-> string
-    f.checkCastToString("TIME '12:42:25'", null, "12:42:25");
+    f.checkCastToString("TIME '12:42:25'", null, "12:42:25", safe);
     if (TODO) {
-      f.checkCastToString("TIME '12:42:25.34'", null, "12:42:25.34");
+      f.checkCastToString("TIME '12:42:25.34'", null, "12:42:25.34", safe);
     }
 
     // Generate the current date as a string, e.g. "2007-04-18". The value
     // is guaranteed to be good for at least 2 minutes, which should give
     // us time to run the rest of the tests.
     final String today =
-        new SimpleDateFormat("yyyy-MM-dd", Locale.ROOT).format(
-            getCalendarNotTooNear(Calendar.DAY_OF_MONTH).getTime());
+        new SimpleDateFormat("yyyy-MM-dd", Locale.ROOT)
+            .format(getCalendarNotTooNear(Calendar.DAY_OF_MONTH).getTime());
 
     f.checkScalar("cast(DATE '1945-02-24' as TIMESTAMP)",
         "1945-02-24 00:00:00", "TIMESTAMP(0) NOT NULL");
@@ -1071,8 +1155,9 @@ protected SqlOperatorFixture fixture() {
         "1945-02-24 00:00:00", "TIMESTAMP(0) NOT NULL");
   }
 
-  @Test void testCastStringToDateTime() {
-    final SqlOperatorFixture f = fixture();
+  @ParameterizedTest
+  @MethodSource("safeParameters")
+  void testCastStringToDateTime(boolean safe, SqlOperatorFixture f) {
     f.checkScalar("cast('12:42:25' as TIME)",
         "12:42:25", "TIME(0) NOT NULL");
     f.checkScalar("cast('1:42:25' as TIME)",
@@ -1090,22 +1175,20 @@ protected SqlOperatorFixture fixture() {
     }
 
     f.checkFails("cast('nottime' as TIME)", BAD_DATETIME_MESSAGE, true);
-    if (Bug.CALCITE_2539_FIXED) {
-      f.checkFails("cast('1241241' as TIME)", BAD_DATETIME_MESSAGE, true);
-      f.checkFails("cast('12:54:78' as TIME)", BAD_DATETIME_MESSAGE, true);
-      f.checkFails("cast('12:34:5' as TIME)", BAD_DATETIME_MESSAGE, true);
-      f.checkFails("cast('12:3:45' as TIME)", BAD_DATETIME_MESSAGE, true);
-      f.checkFails("cast('1:23:45' as TIME)", BAD_DATETIME_MESSAGE, true);
-    }
+    f.checkScalar("cast('1241241' as TIME)", "72:40:12", "TIME(0) NOT NULL");
+    f.checkScalar("cast('12:54:78' as TIME)", "12:55:18", "TIME(0) NOT NULL");
+    f.checkScalar("cast('12:34:5' as TIME)", "12:34:05", "TIME(0) NOT NULL");
+    f.checkScalar("cast('12:3:45' as TIME)", "12:03:45", "TIME(0) NOT NULL");
+    f.checkScalar("cast('1:23:45' as TIME)", "01:23:45", "TIME(0) NOT NULL");
 
     // timestamp <-> string
     f.checkCastToString("TIMESTAMP '1945-02-24 12:42:25'", null,
-        "1945-02-24 12:42:25");
+        "1945-02-24 12:42:25", safe);
 
     if (TODO) {
       // TODO: casting allows one to discard precision without error
       f.checkCastToString("TIMESTAMP '1945-02-24 12:42:25.34'",
-          null, "1945-02-24 12:42:25.34");
+          null, "1945-02-24 12:42:25.34", safe);
     }
 
     f.checkScalar("cast('1945-02-24 12:42:25' as TIMESTAMP)",
@@ -1126,21 +1209,18 @@ protected SqlOperatorFixture fixture() {
           "1945-02-24 12:42:25.34", "TIMESTAMP(2) NOT NULL");
     }
     f.checkFails("cast('nottime' as TIMESTAMP)", BAD_DATETIME_MESSAGE, true);
-
-    if (Bug.CALCITE_2539_FIXED) {
-      f.checkFails("cast('1241241' as TIMESTAMP)",
-          BAD_DATETIME_MESSAGE, true);
-      f.checkFails("cast('1945-20-24 12:42:25.34' as TIMESTAMP)",
-          BAD_DATETIME_MESSAGE, true);
-      f.checkFails("cast('1945-01-24 25:42:25.34' as TIMESTAMP)",
-          BAD_DATETIME_MESSAGE, true);
-      f.checkFails("cast('1945-1-24 12:23:34.454' as TIMESTAMP)",
-          BAD_DATETIME_MESSAGE, true);
-    }
+    f.checkScalar("cast('1241241' as TIMESTAMP)",
+        "1241-01-01 00:00:00", "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("cast('1945-20-24 12:42:25.34' as TIMESTAMP)",
+        "1946-08-26 12:42:25", "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("cast('1945-01-24 25:42:25.34' as TIMESTAMP)",
+        "1945-01-25 01:42:25", "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("cast('1945-1-24 12:23:34.454' as TIMESTAMP)",
+        "1945-01-24 12:23:34", "TIMESTAMP(0) NOT NULL");
 
     // date <-> string
-    f.checkCastToString("DATE '1945-02-24'", null, "1945-02-24");
-    f.checkCastToString("DATE '1945-2-24'", null, "1945-02-24");
+    f.checkCastToString("DATE '1945-02-24'", null, "1945-02-24", safe);
+    f.checkCastToString("DATE '1945-2-24'", null, "1945-02-24", safe);
 
     f.checkScalar("cast('1945-02-24' as DATE)", "1945-02-24", "DATE NOT NULL");
     f.checkScalar("cast(' 1945-2-4 ' as DATE)", "1945-02-04", "DATE NOT NULL");
@@ -1148,10 +1228,8 @@ protected SqlOperatorFixture fixture() {
         "1945-02-24", "DATE NOT NULL");
     f.checkFails("cast('notdate' as DATE)", BAD_DATETIME_MESSAGE, true);
 
-    if (Bug.CALCITE_2539_FIXED) {
-      f.checkFails("cast('52534253' as DATE)", BAD_DATETIME_MESSAGE, true);
-      f.checkFails("cast('1945-30-24' as DATE)", BAD_DATETIME_MESSAGE, true);
-    }
+    f.checkScalar("cast('52534253' as DATE)", "7368-10-13", "DATE NOT NULL");
+    f.checkScalar("cast('1945-30-24' as DATE)", "1947-06-26", "DATE NOT NULL");
 
     // cast null
     f.checkNull("cast(null as date)");
@@ -1166,6 +1244,34 @@ protected SqlOperatorFixture fixture() {
     f.checkNull("cast(cast(null as timestamp) as time)");
   }
 
+  @Test void testMssqlConvert() {
+    final SqlOperatorFixture f = fixture();
+    f.setFor(SqlLibraryOperators.MSSQL_CONVERT, VmName.EXPAND);
+    // happy-paths (no need to test all, proper functionality is tested by CAST already
+    // just need to make sure it works at all
+    f.checkScalar("convert(INTEGER, 45.4)", "45", "INTEGER NOT NULL");
+    f.checkScalar("convert(DATE, '2000-01-01')", "2000-01-01", "DATE NOT NULL");
+
+    // null-values
+    f.checkNull("convert(DATE, NULL)");
+  }
+
+  @Test void testMssqlConvertWithStyle() {
+    final SqlOperatorFixture f = fixture();
+    f.setFor(SqlLibraryOperators.MSSQL_CONVERT, VmName.EXPAND);
+    // ensure 'style' argument is ignored
+    // 3rd argument 'style' is a literal. However,
+    // AbstractSqlTester converts values to a single value in a column.
+    // see AbstractSqlTester.buildQuery2
+    // But CONVERT 'style' is supposed to be a literal.
+    // So for now, they are put in a @Disabled test
+    f.checkScalar("convert(INTEGER, 45.4, 999)", "45", "INTEGER NOT NULL");
+    f.checkScalar("convert(DATE, '2000-01-01', 999)", "2000-01-01", "DATE NOT NULL");
+    // including 'NULL' style argument
+    f.checkScalar("convert(DATE, '2000-01-01', NULL)", "2000-01-01", "DATE NOT NULL");
+
+  }
+
   private static Calendar getFixedCalendar() {
     Calendar calendar = Util.calendar();
     calendar.set(Calendar.YEAR, 2014);
@@ -1219,8 +1325,9 @@ protected static Calendar getCalendarNotTooNear(int timeUnit) {
     }
   }
 
-  @Test void testCastToBoolean() {
-    final SqlOperatorFixture f = fixture();
+  @ParameterizedTest
+  @MethodSource("safeParameters")
+  void testCastToBoolean(boolean safe, SqlOperatorFixture f) {
     f.setFor(SqlStdOperatorTable.CAST, VmName.EXPAND);
 
     // string to boolean
@@ -1290,8 +1397,8 @@ protected static Calendar getCalendarNotTooNear(int timeUnit) {
     // so nulls do not match.
     // (Unlike Oracle's 'decode(null, null, ...)', by the way.)
     f.checkString("case cast(null as int)\n"
-        + "when cast(null as int) then 'nulls match'\n"
-        + "else 'nulls do not match' end",
+            + "when cast(null as int) then 'nulls match'\n"
+            + "else 'nulls do not match' end",
         "nulls do not match",
         "CHAR(18) NOT NULL");
 
@@ -1492,9 +1599,8 @@ protected static Calendar getCalendarNotTooNear(int timeUnit) {
     f.checkScalar("{fn ASCII('ABC')}", "65", "INTEGER NOT NULL");
     f.checkNull("{fn ASCII(cast(null as varchar(1)))}");
 
-    if (false) {
-      f.checkScalar("{fn CHAR(code)}", null, "");
-    }
+    f.checkScalar("{fn CHAR(97)}", "a", "CHAR(1)");
+
     f.checkScalar("{fn CONCAT('foo', 'bar')}", "foobar", "CHAR(6) NOT NULL");
 
     f.checkScalar("{fn DIFFERENCE('Miller', 'miller')}", "4",
@@ -1574,14 +1680,9 @@ protected static Calendar getCalendarNotTooNear(int timeUnit) {
         "VARCHAR(2000) NOT NULL");
     f.checkScalar("{fn DAYOFMONTH(DATE '2014-12-10')}", 10,
         "BIGINT NOT NULL");
-    if (Bug.CALCITE_2539_FIXED) {
-      f.checkFails("{fn DAYOFWEEK(DATE '2014-12-10')}",
-          "cannot translate call EXTRACT.*",
-          true);
-      f.checkFails("{fn DAYOFYEAR(DATE '2014-12-10')}",
-          "cannot translate call EXTRACT.*",
-          true);
-    }
+    f.checkScalar("{fn DAYOFWEEK(DATE '2014-12-10')}", "4", "BIGINT NOT NULL");
+    f.checkScalar("{fn DAYOFYEAR(DATE '2014-12-10')}", "344",
+        "BIGINT NOT NULL");
     f.checkScalar("{fn HOUR(TIMESTAMP '2014-12-10 12:34:56')}", 12,
         "BIGINT NOT NULL");
     f.checkScalar("{fn MINUTE(TIMESTAMP '2014-12-10 12:34:56')}", 34,
@@ -1606,11 +1707,7 @@ protected static Calendar getCalendarNotTooNear(int timeUnit) {
         + " TIMESTAMP '2019-09-01 00:00:00',"
         + " TIMESTAMP '2020-03-01 00:00:00')}", "6", "INTEGER NOT NULL");
 
-    if (Bug.CALCITE_2539_FIXED) {
-      f.checkFails("{fn WEEK(DATE '2014-12-10')}",
-          "cannot translate call EXTRACT.*",
-          true);
-    }
+    f.checkScalar("{fn WEEK(DATE '2014-12-10')}", "50", "BIGINT NOT NULL");
     f.checkScalar("{fn YEAR(DATE '2014-12-10')}", 2014, "BIGINT NOT NULL");
 
     // System Functions
@@ -1630,15 +1727,36 @@ protected static Calendar getCalendarNotTooNear(int timeUnit) {
 
   }
 
+  @Test void testChar() {
+    final SqlOperatorFixture f0 = fixture()
+        .setFor(SqlLibraryOperators.CHR, VM_FENNEL, VM_JAVA);
+    f0.checkFails("^char(97)^",
+        "No match found for function signature CHAR\\(<NUMERIC>\\)", false);
+    final SqlOperatorFixture f = f0.withLibrary(SqlLibrary.MYSQL);
+    f.checkScalar("char(null)", isNullValue(), "CHAR(1)");
+    f.checkScalar("char(-1)", isNullValue(), "CHAR(1)");
+    f.checkScalar("char(97)", "a", "CHAR(1)");
+    f.checkScalar("char(48)", "0", "CHAR(1)");
+    f.checkScalar("char(0)", String.valueOf('\u0000'), "CHAR(1)");
+    f.checkFails("^char(97.1)^",
+        "Cannot apply 'CHAR' to arguments of type 'CHAR\\(<DECIMAL\\(3, 1\\)>\\)'\\. "
+            + "Supported form\\(s\\): 'CHAR\\(<INTEGER>\\)'",
+        false);
+  }
+
   @Test void testChr() {
     final SqlOperatorFixture f0 = fixture()
         .setFor(SqlLibraryOperators.CHR, VM_FENNEL, VM_JAVA);
-    final SqlOperatorFixture f = f0.withLibrary(SqlLibrary.ORACLE);
-    f.checkScalar("chr(97)", "a", "CHAR(1) NOT NULL");
-    f.checkScalar("chr(48)", "0", "CHAR(1) NOT NULL");
-    f.checkScalar("chr(0)", String.valueOf('\u0000'), "CHAR(1) NOT NULL");
     f0.checkFails("^chr(97.1)^",
         "No match found for function signature CHR\\(<NUMERIC>\\)", false);
+    final Consumer<SqlOperatorFixture> consumer = f -> {
+      f.checkScalar("chr(97)", "a", "CHAR(1) NOT NULL");
+      f.checkScalar("chr(48)", "0", "CHAR(1) NOT NULL");
+      f.checkScalar("chr(0)", String.valueOf('\u0000'), "CHAR(1) NOT NULL");
+      f.checkNull("chr(null)");
+    };
+    f0.forEachLibrary(list(SqlLibrary.BIG_QUERY, SqlLibrary.ORACLE, SqlLibrary.POSTGRESQL),
+        consumer);
   }
 
   @Test void testSelect() {
@@ -1791,6 +1909,7 @@ protected static Calendar getCalendarNotTooNear(int timeUnit) {
     final SqlOperatorFixture f = fixture();
     checkConcatFunc(f.withLibrary(SqlLibrary.MYSQL));
     checkConcatFunc(f.withLibrary(SqlLibrary.POSTGRESQL));
+    checkConcatFunc(f.withLibrary(SqlLibrary.BIG_QUERY));
     checkConcat2Func(f.withLibrary(SqlLibrary.ORACLE));
   }
 
@@ -1823,10 +1942,18 @@ private static void checkConcat2Func(SqlOperatorFixture f) {
   }
 
   @Test void testModOperator() {
-    // "%" is allowed under MYSQL_5 SQL conformance level
-    final SqlOperatorFixture f0 = fixture();
-    final SqlOperatorFixture f = f0.withConformance(SqlConformanceEnum.MYSQL_5);
-    f.setFor(SqlStdOperatorTable.PERCENT_REMAINDER);
+    // "%" is allowed under BIG_QUERY, MYSQL_5 SQL conformance levels
+    final SqlOperatorFixture f0 = fixture()
+        .setFor(SqlStdOperatorTable.PERCENT_REMAINDER);
+    final List<SqlConformanceEnum> conformances =
+        list(SqlConformanceEnum.BIG_QUERY, SqlConformanceEnum.MYSQL_5);
+    f0.forEachConformance(conformances, this::checkModOperator);
+    f0.forEachConformance(conformances, this::checkModPrecedence);
+    f0.forEachConformance(conformances, this::checkModOperatorNull);
+    f0.forEachConformance(conformances, this::checkModOperatorDivByZero);
+  }
+
+  void checkModOperator(SqlOperatorFixture f) {
     f.checkScalarExact("4%2", 0);
     f.checkScalarExact("8%5", 3);
     f.checkScalarExact("-12%7", -5);
@@ -1845,19 +1972,12 @@ private static void checkConcat2Func(SqlOperatorFixture f) {
         "DECIMAL(1, 0) NOT NULL", "-2");
   }
 
-  @Test void testModPrecedence() {
-    // "%" is allowed under MYSQL_5 SQL conformance level
-    final SqlOperatorFixture f0 = fixture();
-    final SqlOperatorFixture f = f0.withConformance(SqlConformanceEnum.MYSQL_5);
-    f.setFor(SqlStdOperatorTable.PERCENT_REMAINDER);
+  void checkModPrecedence(SqlOperatorFixture f) {
     f.checkScalarExact("1 + 5 % 3 % 4 * 14 % 17", 12);
     f.checkScalarExact("(1 + 5 % 3) % 4 + 14 % 17", 17);
   }
 
-  @Test void testModOperatorNull() {
-    // "%" is allowed under MYSQL_5 SQL conformance level
-    final SqlOperatorFixture f0 = fixture();
-    final SqlOperatorFixture f = f0.withConformance(SqlConformanceEnum.MYSQL_5);
+  void checkModOperatorNull(SqlOperatorFixture f) {
     f.checkNull("cast(null as integer) % 2");
     f.checkNull("4 % cast(null as tinyint)");
     if (!DECIMAL) {
@@ -1866,13 +1986,10 @@ private static void checkConcat2Func(SqlOperatorFixture f) {
     f.checkNull("4 % cast(null as decimal(12,0))");
   }
 
-  @Test void testModOperatorDivByZero() {
-    // "%" is allowed under MYSQL_5 SQL conformance level
-    final SqlOperatorFixture f0 = fixture();
-    final SqlOperatorFixture f = f0.withConformance(SqlConformanceEnum.MYSQL_5);
+  void checkModOperatorDivByZero(SqlOperatorFixture f) {
     // The extra CASE expression is to fool Janino.  It does constant
     // reduction and will throw the divide by zero exception while
-    // compiling the expression.  The test frame work would then issue
+    // compiling the expression.  The test framework would then issue
     // unexpected exception occurred during "validation".  You cannot
     // submit as non-runtime because the janino exception does not have
     // error position information and the framework is unhappy with that.
@@ -1902,10 +2019,8 @@ private static void checkConcat2Func(SqlOperatorFixture f) {
     }
     f.checkNull("1e1 / cast(null as float)");
 
-    if (Bug.CALCITE_2539_FIXED) {
-      f.checkFails("100.1 / 0.00000000000000001", OUT_OF_RANGE_MESSAGE,
-          true);
-    }
+    f.checkScalarExact("100.1 / 0.00000000000000001", "DECIMAL(19, 0) NOT NULL",
+        "1.001E+19");
   }
 
   @Test void testDivideOperatorIntervals() {
@@ -2641,7 +2756,7 @@ static void checkOverlaps(OverlapChecker c) {
     checkNullOperand(f1, "<>");
   }
 
-  private void checkNullOperand(SqlOperatorFixture f, String op) {
+  private static void checkNullOperand(SqlOperatorFixture f, String op) {
     f.checkBoolean("1 " + op + " null", null);
     f.checkBoolean("null " + op + " -3", null);
     f.checkBoolean("null " + op + " null", null);
@@ -2661,12 +2776,17 @@ private void checkNullOperand(SqlOperatorFixture f, String op) {
         "Bang equal '!=' is not allowed under the current SQL conformance level",
         false);
 
-    // "!=" is allowed under ORACLE_10 SQL conformance level
-    final SqlOperatorFixture f1 =
-        f.withConformance(SqlConformanceEnum.ORACLE_10);
-    f1.checkBoolean("1 <> 1", false);
-    f1.checkBoolean("1 != 1", false);
-    f1.checkBoolean("1 != null", null);
+    final Consumer<SqlOperatorFixture> consumer = f1 -> {
+      f1.checkBoolean("1 <> 1", false);
+      f1.checkBoolean("1 != 1", false);
+      f1.checkBoolean("2 != 1", true);
+      f1.checkBoolean("1 != null", null);
+    };
+
+    // "!=" is allowed under BigQuery, ORACLE_10 SQL conformance levels
+    final List<SqlConformanceEnum> conformances =
+        list(SqlConformanceEnum.BIG_QUERY, SqlConformanceEnum.ORACLE_10);
+    f.forEachConformance(conformances, consumer);
   }
 
   @Test void testNotEqualsOperatorIntervals() {
@@ -3082,7 +3202,7 @@ private void checkNullOperand(SqlOperatorFixture f, String op) {
     checkRlikeFails(f.withLibrary(SqlLibrary.ORACLE));
   }
 
-  void checkRlike(SqlOperatorFixture f) {
+  static void checkRlike(SqlOperatorFixture f) {
     f.checkBoolean("'Merrisa@gmail.com' rlike '.+@*\\.com'", true);
     f.checkBoolean("'Merrisa@gmail.com' rlike '.com$'", true);
     f.checkBoolean("'acbd' rlike '^ac+'", true);
@@ -3099,7 +3219,7 @@ void checkRlike(SqlOperatorFixture f) {
     f.checkBoolean("'Merrisa@gmail.com' not rlike 'Merrisa_'", true);
   }
 
-  void checkRlikeFails(SqlOperatorFixture f) {
+  static void checkRlikeFails(SqlOperatorFixture f) {
     final String noRlike = "(?s).*No match found for function signature RLIKE";
     f.checkFails("^'Merrisa@gmail.com' rlike '.+@*\\.com'^", noRlike, false);
     f.checkFails("^'acb' rlike 'acb|efg'^", noRlike, false);
@@ -3395,7 +3515,6 @@ void checkRlikeFails(SqlOperatorFixture f) {
                 + "                    \\^";
     f.checkFails("'yd3223' similar to '[:LOWER:]{2}[:DIGIT:]{,5}'",
         expectedError, true);
-
     if (Bug.CALCITE_2539_FIXED) {
       f.checkFails("'cd' similar to '[(a-e)]d' ",
           "Invalid regular expression: \\[\\(a-e\\)\\]d at 1",
@@ -3457,22 +3576,31 @@ void checkRlikeFails(SqlOperatorFixture f) {
   }
 
   @Test void testTranslate3Func() {
-    final SqlOperatorFixture f = fixture()
-        .setFor(SqlLibraryOperators.TRANSLATE3)
-        .withLibrary(SqlLibrary.ORACLE);
-    f.checkString("translate('aabbcc', 'ab', '+-')",
-        "++--cc", "VARCHAR(6) NOT NULL");
-    f.checkString("translate('aabbcc', 'ab', 'ba')",
-        "bbaacc", "VARCHAR(6) NOT NULL");
-    f.checkString("translate('aabbcc', 'ab', '')",
-        "cc", "VARCHAR(6) NOT NULL");
-    f.checkString("translate('aabbcc', '', '+-')",
-        "aabbcc", "VARCHAR(6) NOT NULL");
-    f.checkString("translate(cast('aabbcc' as varchar(10)), 'ab', '+-')",
-        "++--cc", "VARCHAR(10) NOT NULL");
-    f.checkNull("translate(cast(null as varchar(7)), 'ab', '+-')");
-    f.checkNull("translate('aabbcc', cast(null as varchar(2)), '+-')");
-    f.checkNull("translate('aabbcc', 'ab', cast(null as varchar(2)))");
+    final SqlOperatorFixture f0 = fixture()
+        .setFor(SqlLibraryOperators.TRANSLATE3);
+    f0.checkFails("^translate('aabbcc', 'ab', '+-')^",
+        "No match found for function signature "
+            + "TRANSLATE3\\(<CHARACTER>, <CHARACTER>, <CHARACTER>\\)",
+        false);
+    final Consumer<SqlOperatorFixture> consumer = f -> {
+      f.checkString("translate('aabbcc', 'ab', '+-')",
+          "++--cc", "VARCHAR(6) NOT NULL");
+      f.checkString("translate('aabbcc', 'ab', 'ba')",
+          "bbaacc", "VARCHAR(6) NOT NULL");
+      f.checkString("translate('aabbcc', 'ab', '')",
+          "cc", "VARCHAR(6) NOT NULL");
+      f.checkString("translate('aabbcc', '', '+-')",
+          "aabbcc", "VARCHAR(6) NOT NULL");
+      f.checkString("translate(cast('aabbcc' as varchar(10)), 'ab', '+-')",
+          "++--cc", "VARCHAR(10) NOT NULL");
+      f.checkNull("translate(cast(null as varchar(7)), 'ab', '+-')");
+      f.checkNull("translate('aabbcc', cast(null as varchar(2)), '+-')");
+      f.checkNull("translate('aabbcc', 'ab', cast(null as varchar(2)))");
+    };
+    final List<SqlLibrary> libraries =
+        ImmutableList.of(SqlLibrary.BIG_QUERY, SqlLibrary.ORACLE,
+            SqlLibrary.POSTGRESQL);
+    f0.forEachLibrary(libraries, consumer);
   }
 
   @Test void testOverlayFunc() {
@@ -3575,6 +3703,23 @@ void checkRlikeFails(SqlOperatorFixture f) {
     f.checkNull("CHARACTER_LENGTH(cast(null as varchar(1)))");
   }
 
+  @Test void testLengthFunc() {
+    final SqlOperatorFixture f0 = fixture().setFor(SqlLibraryOperators.LENGTH);
+    f0.checkFails("^length('hello')^",
+        "No match found for function signature LENGTH\\(<CHARACTER>\\)",
+        false);
+
+    final Consumer<SqlOperatorFixture> consumer = f -> {
+      f.checkScalar("length('hello')", "5", "INTEGER NOT NULL");
+      f.checkScalar("length('')", "0", "INTEGER NOT NULL");
+      f.checkScalar("length(CAST('x' as CHAR(3)))", "3", "INTEGER NOT NULL");
+      f.checkScalar("length(CAST('x' as VARCHAR(4)))", "1", "INTEGER NOT NULL");
+      f.checkNull("length(CAST(NULL as CHAR(5)))");
+    };
+
+    f0.forEachLibrary(list(SqlLibrary.BIG_QUERY), consumer);
+  }
+
   @Test void testOctetLengthFunc() {
     final SqlOperatorFixture f = fixture();
     f.setFor(SqlStdOperatorTable.OCTET_LENGTH, VmName.EXPAND);
@@ -3651,74 +3796,97 @@ void checkRlikeFails(SqlOperatorFixture f) {
   }
 
   @Test void testFromBase64() {
-    final SqlOperatorFixture f = fixture()
-        .setFor(SqlLibraryOperators.FROM_BASE64)
-        .withLibrary(SqlLibrary.MYSQL);
-    f.checkString("from_base64('VGhpcyBpcyBhIHRlc3QgU3RyaW5nLg==')",
-        "546869732069732061207465737420537472696e672e",
-        "VARBINARY NOT NULL");
-    f.checkString("from_base64('VGhpcyBpcyBhIHRlc\t3QgU3RyaW5nLg==')",
-        "546869732069732061207465737420537472696e672e",
-        "VARBINARY NOT NULL");
-    f.checkString("from_base64('VGhpcyBpcyBhIHRlc\t3QgU3\nRyaW5nLg==')",
-        "546869732069732061207465737420537472696e672e",
-        "VARBINARY NOT NULL");
-    f.checkString("from_base64('VGhpcyB  pcyBhIHRlc3Qg\tU3Ry\naW5nLg==')",
-        "546869732069732061207465737420537472696e672e",
-        "VARBINARY NOT NULL");
-    f.checkNull("from_base64('-1')");
-    f.checkNull("from_base64('-100')");
+    final SqlOperatorFixture f0 = fixture()
+        .setFor(SqlLibraryOperators.FROM_BASE64);
+    f0.checkFails("^from_base64('2fjoeiwjfoj==')^",
+        "No match found for function signature FROM_BASE64\\(<CHARACTER>\\)",
+        false);
+    final Consumer<SqlOperatorFixture> consumer = f -> {
+      f.checkString("from_base64('VGhpcyBpcyBhIHRlc3QgU3RyaW5nLg==')",
+          "546869732069732061207465737420537472696e672e",
+          "VARBINARY NOT NULL");
+      f.checkString("from_base64('VGhpcyBpcyBhIHRlc\t3QgU3RyaW5nLg==')",
+          "546869732069732061207465737420537472696e672e",
+          "VARBINARY NOT NULL");
+      f.checkString("from_base64('VGhpcyBpcyBhIHRlc\t3QgU3\nRyaW5nLg==')",
+          "546869732069732061207465737420537472696e672e",
+          "VARBINARY NOT NULL");
+      f.checkString("from_base64('VGhpcyB  pcyBhIHRlc3Qg\tU3Ry\naW5nLg==')",
+          "546869732069732061207465737420537472696e672e",
+          "VARBINARY NOT NULL");
+      f.checkNull("from_base64('-1')");
+      f.checkNull("from_base64('-100')");
+    };
+    f0.forEachLibrary(list(SqlLibrary.BIG_QUERY, SqlLibrary.MYSQL), consumer);
   }
 
   @Test void testMd5() {
-    final SqlOperatorFixture f = fixture()
-        .setFor(SqlLibraryOperators.MD5)
-        .withLibrary(SqlLibrary.MYSQL);
-    f.checkString("md5(x'')",
-        "d41d8cd98f00b204e9800998ecf8427e",
-        "VARCHAR NOT NULL");
-    f.checkString("md5('')",
-        "d41d8cd98f00b204e9800998ecf8427e",
-        "VARCHAR NOT NULL");
-    f.checkString("md5('ABC')",
-        "902fbdd2b1df0c4f70b4a5d23525e932",
-        "VARCHAR NOT NULL");
-    f.checkString("md5(x'414243')",
-        "902fbdd2b1df0c4f70b4a5d23525e932",
-        "VARCHAR NOT NULL");
+    final SqlOperatorFixture f0 = fixture().setFor(SqlLibraryOperators.MD5);
+    f0.checkFails("^md5(x'')^",
+        "No match found for function signature MD5\\(<BINARY>\\)",
+        false);
+    final List<SqlLibrary> libraries =
+        ImmutableList.of(SqlLibrary.BIG_QUERY, SqlLibrary.MYSQL,
+            SqlLibrary.POSTGRESQL);
+    final Consumer<SqlOperatorFixture> consumer = f -> {
+      f.checkString("md5(x'')",
+          "d41d8cd98f00b204e9800998ecf8427e",
+          "VARCHAR NOT NULL");
+      f.checkString("md5('')",
+          "d41d8cd98f00b204e9800998ecf8427e",
+          "VARCHAR NOT NULL");
+      f.checkString("md5('ABC')",
+          "902fbdd2b1df0c4f70b4a5d23525e932",
+          "VARCHAR NOT NULL");
+      f.checkString("md5(x'414243')",
+          "902fbdd2b1df0c4f70b4a5d23525e932",
+          "VARCHAR NOT NULL");
+    };
+    f0.forEachLibrary(libraries, consumer);
   }
 
   @Test void testSha1() {
-    final SqlOperatorFixture f = fixture()
-        .setFor(SqlLibraryOperators.SHA1)
-        .withLibrary(SqlLibrary.MYSQL);
-    f.checkString("sha1(x'')",
-        "da39a3ee5e6b4b0d3255bfef95601890afd80709",
-        "VARCHAR NOT NULL");
-    f.checkString("sha1('')",
-        "da39a3ee5e6b4b0d3255bfef95601890afd80709",
-        "VARCHAR NOT NULL");
-    f.checkString("sha1('ABC')",
-        "3c01bdbb26f358bab27f267924aa2c9a03fcfdb8",
-        "VARCHAR NOT NULL");
-    f.checkString("sha1(x'414243')",
-        "3c01bdbb26f358bab27f267924aa2c9a03fcfdb8",
-        "VARCHAR NOT NULL");
+    final SqlOperatorFixture f0 = fixture().setFor(SqlLibraryOperators.SHA1);
+    f0.checkFails("^sha1(x'')^",
+        "No match found for function signature SHA1\\(<BINARY>\\)",
+        false);
+    final List<SqlLibrary> libraries =
+        ImmutableList.of(SqlLibrary.BIG_QUERY, SqlLibrary.MYSQL,
+            SqlLibrary.POSTGRESQL);
+    final Consumer<SqlOperatorFixture> consumer = f -> {
+      f.checkString("sha1(x'')",
+          "da39a3ee5e6b4b0d3255bfef95601890afd80709",
+          "VARCHAR NOT NULL");
+      f.checkString("sha1('')",
+          "da39a3ee5e6b4b0d3255bfef95601890afd80709",
+          "VARCHAR NOT NULL");
+      f.checkString("sha1('ABC')",
+          "3c01bdbb26f358bab27f267924aa2c9a03fcfdb8",
+          "VARCHAR NOT NULL");
+      f.checkString("sha1(x'414243')",
+          "3c01bdbb26f358bab27f267924aa2c9a03fcfdb8",
+          "VARCHAR NOT NULL");
+    };
+    f0.forEachLibrary(libraries, consumer);
   }
 
   @Test void testRepeatFunc() {
-    final SqlOperatorFixture f = fixture()
-        .setFor(SqlLibraryOperators.REPEAT)
-        .withLibrary(SqlLibrary.MYSQL);
-    f.checkString("REPEAT('a', -100)", "", "VARCHAR(1) NOT NULL");
-    f.checkString("REPEAT('a', -1)", "", "VARCHAR(1) NOT NULL");
-    f.checkString("REPEAT('a', 0)", "", "VARCHAR(1) NOT NULL");
-    f.checkString("REPEAT('a', 2)", "aa", "VARCHAR(1) NOT NULL");
-    f.checkString("REPEAT('abc', 3)", "abcabcabc", "VARCHAR(3) NOT NULL");
-    f.checkNull("REPEAT(cast(null as varchar(1)), -1)");
-    f.checkNull("REPEAT(cast(null as varchar(1)), 2)");
-    f.checkNull("REPEAT('abc', cast(null as integer))");
-    f.checkNull("REPEAT(cast(null as varchar(1)), cast(null as integer))");
+    final SqlOperatorFixture f0 = fixture().setFor(SqlLibraryOperators.REPEAT);
+    f0.checkFails("^repeat('a', -100)^",
+        "No match found for function signature REPEAT\\(<CHARACTER>, <NUMERIC>\\)",
+        false);
+    final Consumer<SqlOperatorFixture> consumer = f -> {
+      f.checkString("REPEAT('a', -100)", "", "VARCHAR(1) NOT NULL");
+      f.checkString("REPEAT('a', -1)", "", "VARCHAR(1) NOT NULL");
+      f.checkString("REPEAT('a', 0)", "", "VARCHAR(1) NOT NULL");
+      f.checkString("REPEAT('a', 2)", "aa", "VARCHAR(1) NOT NULL");
+      f.checkString("REPEAT('abc', 3)", "abcabcabc", "VARCHAR(3) NOT NULL");
+      f.checkNull("REPEAT(cast(null as varchar(1)), -1)");
+      f.checkNull("REPEAT(cast(null as varchar(1)), 2)");
+      f.checkNull("REPEAT('abc', cast(null as integer))");
+      f.checkNull("REPEAT(cast(null as varchar(1)), cast(null as integer))");
+    };
+    f0.forEachLibrary(list(SqlLibrary.BIG_QUERY, SqlLibrary.MYSQL), consumer);
   }
 
   @Test void testSpaceFunc() {
@@ -3745,19 +3913,26 @@ void checkRlikeFails(SqlOperatorFixture f) {
   }
 
   @Test void testSoundexFunc() {
-    final SqlOperatorFixture f = fixture()
-        .setFor(SqlLibraryOperators.SOUNDEX)
-        .withLibrary(SqlLibrary.ORACLE);
-    f.checkString("SOUNDEX('TECH ON THE NET')", "T253", "VARCHAR(4) NOT NULL");
-    f.checkString("SOUNDEX('Miller')", "M460", "VARCHAR(4) NOT NULL");
-    f.checkString("SOUNDEX('miler')", "M460", "VARCHAR(4) NOT NULL");
-    f.checkString("SOUNDEX('myller')", "M460", "VARCHAR(4) NOT NULL");
-    f.checkString("SOUNDEX('muller')", "M460", "VARCHAR(4) NOT NULL");
-    f.checkString("SOUNDEX('m')", "M000", "VARCHAR(4) NOT NULL");
-    f.checkString("SOUNDEX('mu')", "M000", "VARCHAR(4) NOT NULL");
-    f.checkString("SOUNDEX('mile')", "M400", "VARCHAR(4) NOT NULL");
-    f.checkNull("SOUNDEX(cast(null as varchar(1)))");
-    f.checkFails("SOUNDEX(_UTF8'\u5B57\u5B57')", "The character is not mapped.*", true);
+    final SqlOperatorFixture f0 = fixture().setFor(SqlLibraryOperators.SOUNDEX);
+    f0.checkFails("^soundex('tech on the net')^",
+        "No match found for function signature SOUNDEX\\(<CHARACTER>\\)",
+        false);
+    final List<SqlLibrary> libraries =
+        ImmutableList.of(SqlLibrary.BIG_QUERY, SqlLibrary.MYSQL,
+            SqlLibrary.ORACLE, SqlLibrary.POSTGRESQL);
+    final Consumer<SqlOperatorFixture> consumer = f -> {
+      f.checkString("SOUNDEX('TECH ON THE NET')", "T253", "VARCHAR(4) NOT NULL");
+      f.checkString("SOUNDEX('Miller')", "M460", "VARCHAR(4) NOT NULL");
+      f.checkString("SOUNDEX('miler')", "M460", "VARCHAR(4) NOT NULL");
+      f.checkString("SOUNDEX('myller')", "M460", "VARCHAR(4) NOT NULL");
+      f.checkString("SOUNDEX('muller')", "M460", "VARCHAR(4) NOT NULL");
+      f.checkString("SOUNDEX('m')", "M000", "VARCHAR(4) NOT NULL");
+      f.checkString("SOUNDEX('mu')", "M000", "VARCHAR(4) NOT NULL");
+      f.checkString("SOUNDEX('mile')", "M400", "VARCHAR(4) NOT NULL");
+      f.checkNull("SOUNDEX(cast(null as varchar(1)))");
+      f.checkFails("SOUNDEX(_UTF8'\u5B57\u5B57')", "The character is not mapped.*", true);
+    };
+    f0.forEachLibrary(libraries, consumer);
   }
 
   @Test void testDifferenceFunc() {
@@ -3777,18 +3952,22 @@ void checkRlikeFails(SqlOperatorFixture f) {
   }
 
   @Test void testReverseFunc() {
-    final SqlOperatorFixture f = fixture()
-        .setFor(SqlLibraryOperators.REVERSE)
-        .withLibrary(SqlLibrary.MYSQL);
-    f.checkString("reverse('')", "", "VARCHAR(0) NOT NULL");
-    f.checkString("reverse('123')", "321", "VARCHAR(3) NOT NULL");
-    f.checkString("reverse('abc')", "cba", "VARCHAR(3) NOT NULL");
-    f.checkString("reverse('ABC')", "CBA", "VARCHAR(3) NOT NULL");
-    f.checkString("reverse('Hello World')", "dlroW olleH",
-        "VARCHAR(11) NOT NULL");
-    f.checkString("reverse(_UTF8'\u4F60\u597D')", "\u597D\u4F60",
-        "VARCHAR(2) NOT NULL");
-    f.checkNull("reverse(cast(null as varchar(1)))");
+    final SqlOperatorFixture f0 = fixture().setFor(SqlLibraryOperators.REVERSE);
+    f0.checkFails("^reverse('abc')^",
+        "No match found for function signature REVERSE\\(<CHARACTER>\\)",
+        false);
+    final Consumer<SqlOperatorFixture> consumer = f -> {
+      f.checkString("reverse('')", "", "VARCHAR(0) NOT NULL");
+      f.checkString("reverse('123')", "321", "VARCHAR(3) NOT NULL");
+      f.checkString("reverse('abc')", "cba", "VARCHAR(3) NOT NULL");
+      f.checkString("reverse('ABC')", "CBA", "VARCHAR(3) NOT NULL");
+      f.checkString("reverse('Hello World')", "dlroW olleH",
+          "VARCHAR(11) NOT NULL");
+      f.checkString("reverse(_UTF8'\u4F60\u597D')", "\u597D\u4F60",
+          "VARCHAR(2) NOT NULL");
+      f.checkNull("reverse(cast(null as varchar(1)))");
+    };
+    f0.forEachLibrary(list(SqlLibrary.BIG_QUERY, SqlLibrary.MYSQL), consumer);
   }
 
   @Test void testIfFunc() {
@@ -3798,7 +3977,7 @@ void checkRlikeFails(SqlOperatorFixture f) {
     checkIf(f.withLibrary(SqlLibrary.SPARK));
   }
 
-  private void checkIf(SqlOperatorFixture f) {
+  private static void checkIf(SqlOperatorFixture f) {
     f.setFor(SqlLibraryOperators.IF);
     f.checkString("if(1 = 2, 1, 2)", "2", "INTEGER NOT NULL");
     f.checkString("if('abc'='xyz', 'abc', 'xyz')", "xyz",
@@ -3824,91 +4003,89 @@ private void checkIf(SqlOperatorFixture f) {
   }
 
   @Test void testLeftFunc() {
-    final SqlOperatorFixture f = fixture();
-    Stream.of(SqlLibrary.MYSQL, SqlLibrary.POSTGRESQL)
-        .map(f::withLibrary)
-        .forEach(t -> {
-          t.setFor(SqlLibraryOperators.LEFT);
-          t.checkString("left('abcd', 3)", "abc", "VARCHAR(4) NOT NULL");
-          t.checkString("left('abcd', 0)", "", "VARCHAR(4) NOT NULL");
-          t.checkString("left('abcd', 5)", "abcd", "VARCHAR(4) NOT NULL");
-          t.checkString("left('abcd', -2)", "", "VARCHAR(4) NOT NULL");
-          t.checkNull("left(cast(null as varchar(1)), -2)");
-          t.checkNull("left('abcd', cast(null as Integer))");
-
-          // test for ByteString
-          t.checkString("left(x'ABCdef', 1)", "ab", "VARBINARY(3) NOT NULL");
-          t.checkString("left(x'ABCdef', 0)", "", "VARBINARY(3) NOT NULL");
-          t.checkString("left(x'ABCdef', 4)", "abcdef",
-              "VARBINARY(3) NOT NULL");
-          t.checkString("left(x'ABCdef', -2)", "", "VARBINARY(3) NOT NULL");
-          t.checkNull("left(cast(null as binary(1)), -2)");
-          t.checkNull("left(x'ABCdef', cast(null as Integer))");
-        });
+    final SqlOperatorFixture f0 = fixture();
+    final Consumer<SqlOperatorFixture> consumer = f -> {
+      f.setFor(SqlLibraryOperators.LEFT);
+      f.checkString("left('abcd', 3)", "abc", "VARCHAR(4) NOT NULL");
+      f.checkString("left('abcd', 0)", "", "VARCHAR(4) NOT NULL");
+      f.checkString("left('abcd', 5)", "abcd", "VARCHAR(4) NOT NULL");
+      f.checkString("left('abcd', -2)", "", "VARCHAR(4) NOT NULL");
+      f.checkNull("left(cast(null as varchar(1)), -2)");
+      f.checkNull("left('abcd', cast(null as Integer))");
+
+      // test for ByteString
+      f.checkString("left(x'ABCdef', 1)", "ab", "VARBINARY(3) NOT NULL");
+      f.checkString("left(x'ABCdef', 0)", "", "VARBINARY(3) NOT NULL");
+      f.checkString("left(x'ABCdef', 4)", "abcdef",
+          "VARBINARY(3) NOT NULL");
+      f.checkString("left(x'ABCdef', -2)", "", "VARBINARY(3) NOT NULL");
+      f.checkNull("left(cast(null as binary(1)), -2)");
+      f.checkNull("left(x'ABCdef', cast(null as Integer))");
+    };
+    f0.forEachLibrary(list(SqlLibrary.MYSQL, SqlLibrary.POSTGRESQL), consumer);
   }
 
   @Test void testRightFunc() {
-    final SqlOperatorFixture f = fixture();
-    Stream.of(SqlLibrary.MYSQL, SqlLibrary.POSTGRESQL)
-        .map(f::withLibrary)
-        .forEach(t -> {
-          t.setFor(SqlLibraryOperators.RIGHT);
-          t.checkString("right('abcd', 3)", "bcd", "VARCHAR(4) NOT NULL");
-          t.checkString("right('abcd', 0)", "", "VARCHAR(4) NOT NULL");
-          t.checkString("right('abcd', 5)", "abcd", "VARCHAR(4) NOT NULL");
-          t.checkString("right('abcd', -2)", "", "VARCHAR(4) NOT NULL");
-          t.checkNull("right(cast(null as varchar(1)), -2)");
-          t.checkNull("right('abcd', cast(null as Integer))");
-
-          // test for ByteString
-          t.checkString("right(x'ABCdef', 1)", "ef", "VARBINARY(3) NOT NULL");
-          t.checkString("right(x'ABCdef', 0)", "", "VARBINARY(3) NOT NULL");
-          t.checkString("right(x'ABCdef', 4)", "abcdef",
-              "VARBINARY(3) NOT NULL");
-          t.checkString("right(x'ABCdef', -2)", "", "VARBINARY(3) NOT NULL");
-          t.checkNull("right(cast(null as binary(1)), -2)");
-          t.checkNull("right(x'ABCdef', cast(null as Integer))");
-        });
+    final SqlOperatorFixture f0 = fixture();
+    final Consumer<SqlOperatorFixture> consumer = f -> {
+      f.setFor(SqlLibraryOperators.RIGHT);
+      f.checkString("right('abcd', 3)", "bcd", "VARCHAR(4) NOT NULL");
+      f.checkString("right('abcd', 0)", "", "VARCHAR(4) NOT NULL");
+      f.checkString("right('abcd', 5)", "abcd", "VARCHAR(4) NOT NULL");
+      f.checkString("right('abcd', -2)", "", "VARCHAR(4) NOT NULL");
+      f.checkNull("right(cast(null as varchar(1)), -2)");
+      f.checkNull("right('abcd', cast(null as Integer))");
+
+      // test for ByteString
+      f.checkString("right(x'ABCdef', 1)", "ef", "VARBINARY(3) NOT NULL");
+      f.checkString("right(x'ABCdef', 0)", "", "VARBINARY(3) NOT NULL");
+      f.checkString("right(x'ABCdef', 4)", "abcdef",
+          "VARBINARY(3) NOT NULL");
+      f.checkString("right(x'ABCdef', -2)", "", "VARBINARY(3) NOT NULL");
+      f.checkNull("right(cast(null as binary(1)), -2)");
+      f.checkNull("right(x'ABCdef', cast(null as Integer))");
+    };
+
+    f0.forEachLibrary(list(SqlLibrary.MYSQL, SqlLibrary.POSTGRESQL), consumer);
   }
 
   @Test void testRegexpReplaceFunc() {
-    final SqlOperatorFixture f = fixture();
-    Stream.of(SqlLibrary.MYSQL, SqlLibrary.ORACLE)
-        .map(f::withLibrary)
-        .forEach(t -> {
-          t.setFor(SqlLibraryOperators.REGEXP_REPLACE);
-          t.checkString("regexp_replace('a b c', 'b', 'X')", "a X c",
-              "VARCHAR NOT NULL");
-          t.checkString("regexp_replace('abc def ghi', '[a-z]+', 'X')", "X X X",
-              "VARCHAR NOT NULL");
-          t.checkString("regexp_replace('100-200', '(\\d+)', 'num')", "num-num",
-              "VARCHAR NOT NULL");
-          t.checkString("regexp_replace('100-200', '(-)', '###')", "100###200",
-              "VARCHAR NOT NULL");
-          t.checkNull("regexp_replace(cast(null as varchar), '(-)', '###')");
-          t.checkNull("regexp_replace('100-200', cast(null as varchar), '###')");
-          t.checkNull("regexp_replace('100-200', '(-)', cast(null as varchar))");
-          t.checkString("regexp_replace('abc def ghi', '[a-z]+', 'X', 2)", "aX X X",
-              "VARCHAR NOT NULL");
-          t.checkString("regexp_replace('abc def ghi', '[a-z]+', 'X', 1, 3)", "abc def X",
-              "VARCHAR NOT NULL");
-          t.checkString("regexp_replace('abc def GHI', '[a-z]+', 'X', 1, 3, 'c')", "abc def GHI",
-              "VARCHAR NOT NULL");
-          t.checkString("regexp_replace('abc def GHI', '[a-z]+', 'X', 1, 3, 'i')", "abc def X",
-              "VARCHAR NOT NULL");
-          t.checkString("regexp_replace('abc def GHI', '[a-z]+', 'X', 1, 3, 'i')", "abc def X",
-              "VARCHAR NOT NULL");
-          t.checkString("regexp_replace('abc\t\ndef\t\nghi', '\t', '+')", "abc+\ndef+\nghi",
-              "VARCHAR NOT NULL");
-          t.checkString("regexp_replace('abc\t\ndef\t\nghi', '\t\n', '+')", "abc+def+ghi",
-              "VARCHAR NOT NULL");
-          t.checkString("regexp_replace('abc\t\ndef\t\nghi', '\\w+', '+')", "+\t\n+\t\n+",
-              "VARCHAR NOT NULL");
-          t.checkQuery("select regexp_replace('a b c', 'b', 'X')");
-          t.checkQuery("select regexp_replace('a b c', 'b', 'X', 1)");
-          t.checkQuery("select regexp_replace('a b c', 'b', 'X', 1, 3)");
-          t.checkQuery("select regexp_replace('a b c', 'b', 'X', 1, 3, 'i')");
-        });
+    final SqlOperatorFixture f0 = fixture();
+    final Consumer<SqlOperatorFixture> consumer = f -> {
+      f.setFor(SqlLibraryOperators.REGEXP_REPLACE);
+      f.checkString("regexp_replace('a b c', 'b', 'X')", "a X c",
+          "VARCHAR NOT NULL");
+      f.checkString("regexp_replace('abc def ghi', '[a-z]+', 'X')", "X X X",
+          "VARCHAR NOT NULL");
+      f.checkString("regexp_replace('100-200', '(\\d+)', 'num')", "num-num",
+          "VARCHAR NOT NULL");
+      f.checkString("regexp_replace('100-200', '(-)', '###')", "100###200",
+          "VARCHAR NOT NULL");
+      f.checkNull("regexp_replace(cast(null as varchar), '(-)', '###')");
+      f.checkNull("regexp_replace('100-200', cast(null as varchar), '###')");
+      f.checkNull("regexp_replace('100-200', '(-)', cast(null as varchar))");
+      f.checkString("regexp_replace('abc def ghi', '[a-z]+', 'X', 2)", "aX X X",
+          "VARCHAR NOT NULL");
+      f.checkString("regexp_replace('abc def ghi', '[a-z]+', 'X', 1, 3)", "abc def X",
+          "VARCHAR NOT NULL");
+      f.checkString("regexp_replace('abc def GHI', '[a-z]+', 'X', 1, 3, 'c')", "abc def GHI",
+          "VARCHAR NOT NULL");
+      f.checkString("regexp_replace('abc def GHI', '[a-z]+', 'X', 1, 3, 'i')", "abc def X",
+          "VARCHAR NOT NULL");
+      f.checkString("regexp_replace('abc def GHI', '[a-z]+', 'X', 1, 3, 'i')", "abc def X",
+          "VARCHAR NOT NULL");
+      f.checkString("regexp_replace('abc\t\ndef\t\nghi', '\t', '+')", "abc+\ndef+\nghi",
+          "VARCHAR NOT NULL");
+      f.checkString("regexp_replace('abc\t\ndef\t\nghi', '\t\n', '+')", "abc+def+ghi",
+          "VARCHAR NOT NULL");
+      f.checkString("regexp_replace('abc\t\ndef\t\nghi', '\\w+', '+')", "+\t\n+\t\n+",
+          "VARCHAR NOT NULL");
+      f.checkQuery("select regexp_replace('a b c', 'b', 'X')");
+      f.checkQuery("select regexp_replace('a b c', 'b', 'X', 1)");
+      f.checkQuery("select regexp_replace('a b c', 'b', 'X', 1, 3)");
+      f.checkQuery("select regexp_replace('a b c', 'b', 'X', 1, 3, 'i')");
+    };
+    f0.forEachLibrary(list(SqlLibrary.MYSQL, SqlLibrary.ORACLE), consumer);
   }
 
   @Test void testJsonExists() {
@@ -3963,6 +4140,60 @@ private void checkIf(SqlOperatorFixture f) {
 
   }
 
+  @Test public void testJsonInsert() {
+    final SqlOperatorFixture f = fixture().withLibrary(SqlLibrary.MYSQL);
+    f.checkString("json_insert('10', '$.a', 10, '$.c', '[true]')",
+        "10", "VARCHAR(2000)");
+    f.checkString("json_insert('{ \"a\": 1, \"b\": [2]}', '$.a', 10, '$.c', '[true]')",
+        "{\"a\":1,\"b\":[2],\"c\":\"[true]\"}", "VARCHAR(2000)");
+    f.checkString("json_insert('{ \"a\": 1, \"b\": [2]}', '$', 10, '$', '[true]')",
+        "{\"a\":1,\"b\":[2]}", "VARCHAR(2000)");
+    f.checkString("json_insert('{ \"a\": 1, \"b\": [2]}', '$.b[1]', 10)",
+        "{\"a\":1,\"b\":[2,10]}", "VARCHAR(2000)");
+    f.checkString("json_insert('{\"a\": 1, \"b\": [2, 3, [true]]}', '$.b[3]', 'false')",
+        "{\"a\":1,\"b\":[2,3,[true],\"false\"]}", "VARCHAR(2000)");
+    f.checkFails("json_insert('{\"a\": 1, \"b\": [2, 3, [true]]}', 'a', 'false')",
+        "(?s).*Invalid input for.*", true);
+    // nulls
+    f.checkNull("json_insert(cast(null as varchar), '$', 10)");
+  }
+
+  @Test public void testJsonReplace() {
+    final SqlOperatorFixture f = fixture().withLibrary(SqlLibrary.MYSQL);
+    f.checkString("json_replace('10', '$.a', 10, '$.c', '[true]')",
+        "10", "VARCHAR(2000)");
+    f.checkString("json_replace('{ \"a\": 1, \"b\": [2]}', '$.a', 10, '$.c', '[true]')",
+        "{\"a\":10,\"b\":[2]}", "VARCHAR(2000)");
+    f.checkString("json_replace('{ \"a\": 1, \"b\": [2]}', '$', 10, '$.c', '[true]')",
+        "10", "VARCHAR(2000)");
+    f.checkString("json_replace('{ \"a\": 1, \"b\": [2]}', '$.b', 10, '$.c', '[true]')",
+        "{\"a\":1,\"b\":10}", "VARCHAR(2000)");
+    f.checkString("json_replace('{ \"a\": 1, \"b\": [2, 3]}', '$.b[1]', 10)",
+        "{\"a\":1,\"b\":[2,10]}", "VARCHAR(2000)");
+    f.checkFails("json_replace('{\"a\": 1, \"b\": [2, 3, [true]]}', 'a', 'false')",
+        "(?s).*Invalid input for.*", true);
+
+    // nulls
+    f.checkNull("json_replace(cast(null as varchar), '$', 10)");
+  }
+
+  @Test public void testJsonSet() {
+    final SqlOperatorFixture f = fixture().withLibrary(SqlLibrary.MYSQL);
+    f.checkString("json_set('10', '$.a', 10, '$.c', '[true]')",
+        "10", "VARCHAR(2000)");
+    f.checkString("json_set('{ \"a\": 1, \"b\": [2]}', '$.a', 10, '$.c', '[true]')",
+        "{\"a\":10,\"b\":[2],\"c\":\"[true]\"}", "VARCHAR(2000)");
+    f.checkString("json_set('{ \"a\": 1, \"b\": [2]}', '$', 10, '$.c', '[true]')",
+        "10", "VARCHAR(2000)");
+    f.checkString("json_set('{ \"a\": 1, \"b\": [2, 3]}', '$.b[1]', 10, '$.c', '[true]')",
+        "{\"a\":1,\"b\":[2,10],\"c\":\"[true]\"}", "VARCHAR(2000)");
+    f.checkFails("json_set('{\"a\": 1, \"b\": [2, 3, [true]]}', 'a', 'false')",
+        "(?s).*Invalid input for.*", true);
+
+    // nulls
+    f.checkNull("json_set(cast(null as varchar), '$', 10)");
+  }
+
   @Test void testJsonValue() {
     final SqlOperatorFixture f = fixture();
     if (false) {
@@ -4726,7 +4957,7 @@ private void checkIf(SqlOperatorFixture f) {
             "Cannot apply 'INITCAP' to arguments of type "
                 + "'INITCAP\\(<DATE>\\)'\\. Supported form\\(s\\): "
                 + "'INITCAP\\(<CHARACTER>\\)'",
-        false);
+            false);
     f.checkType("initcap(cast(null as date))", "VARCHAR");
   }
 
@@ -4830,7 +5061,7 @@ private void checkIf(SqlOperatorFixture f) {
     f.checkNull("ln(cast(null as tinyint))");
   }
 
-  @Test void testLogFunc() {
+  @Test void testLog10Func() {
     final SqlOperatorFixture f = fixture();
     f.setFor(SqlStdOperatorTable.LOG10, VmName.EXPAND);
     f.checkScalarApprox("log10(10)", "DOUBLE NOT NULL",
@@ -4846,6 +5077,32 @@ private void checkIf(SqlOperatorFixture f) {
     f.checkNull("log10(cast(null as real))");
   }
 
+  @Test void testLogFunc() {
+    final SqlOperatorFixture f0 = fixture()
+        .setFor(SqlLibraryOperators.LOG, VmName.EXPAND);
+    f0.checkFails("^log(100, 10)^",
+        "No match found for function signature LOG\\(<NUMERIC>, <NUMERIC>\\)", false);
+    final SqlOperatorFixture f = f0.withLibrary(SqlLibrary.BIG_QUERY);
+    f.checkScalarApprox("log(10, 10)", "DOUBLE NOT NULL",
+        isWithin(1.0, 0.000001));
+    f.checkScalarApprox("log(64, 8)", "DOUBLE NOT NULL",
+        isWithin(2.0, 0.000001));
+    f.checkScalarApprox("log(27,3)", "DOUBLE NOT NULL",
+        isWithin(3.0, 0.000001));
+    f.checkScalarApprox("log(100, 10)", "DOUBLE NOT NULL",
+        isWithin(2.0, 0.000001));
+    f.checkScalarApprox("log(10, 100)", "DOUBLE NOT NULL",
+        isWithin(0.5, 0.000001));
+    f.checkScalarApprox("log(cast(10e6 as double), 10)", "DOUBLE NOT NULL",
+        isWithin(7.0, 0.000001));
+    f.checkScalarApprox("log(cast(10e8 as float), 10)", "DOUBLE NOT NULL",
+        isWithin(9.0, 0.000001));
+    f.checkScalarApprox("log(cast(10e-3 as real), 10)", "DOUBLE NOT NULL",
+        isWithin(-2.0, 0.000001));
+    f.checkNull("log(cast(null as real), 10)");
+    f.checkNull("log(10, cast(null as real))");
+  }
+
   @Test void testRandFunc() {
     final SqlOperatorFixture f = fixture();
     f.setFor(SqlStdOperatorTable.RAND, VmName.EXPAND);
@@ -4938,10 +5195,10 @@ private void checkIf(SqlOperatorFixture f) {
     f.checkNull("timestamp_micros(cast(null as bigint))");
     f.checkScalar("date_from_unix_date(0)", "1970-01-01", "DATE NOT NULL");
 
-    // Have to quote the "DATE" function because we're not using the Babel
-    // parser. In the regular parser, DATE is a reserved keyword.
-    f.checkNull("\"DATE\"(null)");
-    f.checkScalar("\"DATE\"('1985-12-06')", "1985-12-06", "DATE NOT NULL");
+    // DATE is a reserved keyword, but the parser has special treatment to
+    // allow it as a function.
+    f.checkNull("DATE(null)");
+    f.checkScalar("DATE('1985-12-06')", "1985-12-06", "DATE NOT NULL");
     f.checkType("CURRENT_DATETIME()", "TIMESTAMP(0) NOT NULL");
     f.checkType("CURRENT_DATETIME('America/Los_Angeles')", "TIMESTAMP(0) NOT NULL");
     f.checkType("CURRENT_DATETIME(CAST(NULL AS VARCHAR(20)))", "TIMESTAMP(0)");
@@ -4987,7 +5244,7 @@ private void checkIf(SqlOperatorFixture f) {
             "Cannot apply 'ACOS' to arguments of type "
                 + "'ACOS\\(<CHAR\\(3\\)>\\)'\\. Supported form\\(s\\): "
                 + "'ACOS\\(<NUMERIC>\\)'",
-        false);
+            false);
     f.checkType("acos('abc')", "DOUBLE NOT NULL");
     f.checkScalarApprox("acos(0.5)", "DOUBLE NOT NULL",
         isWithin(1.0472d, 0.0001d));
@@ -5008,7 +5265,7 @@ private void checkIf(SqlOperatorFixture f) {
             "Cannot apply 'ASIN' to arguments of type "
                 + "'ASIN\\(<CHAR\\(3\\)>\\)'\\. Supported form\\(s\\): "
                 + "'ASIN\\(<NUMERIC>\\)'",
-        false);
+            false);
     f.checkType("asin('abc')", "DOUBLE NOT NULL");
     f.checkScalarApprox("asin(0.5)", "DOUBLE NOT NULL",
         isWithin(0.5236d, 0.0001d));
@@ -5029,7 +5286,7 @@ private void checkIf(SqlOperatorFixture f) {
             "Cannot apply 'ATAN' to arguments of type "
                 + "'ATAN\\(<CHAR\\(3\\)>\\)'\\. Supported form\\(s\\): "
                 + "'ATAN\\(<NUMERIC>\\)'",
-        false);
+            false);
     f.checkType("atan('abc')", "DOUBLE NOT NULL");
     f.checkScalarApprox("atan(2)", "DOUBLE NOT NULL",
         isWithin(1.1071d, 0.0001d));
@@ -5052,7 +5309,7 @@ private void checkIf(SqlOperatorFixture f) {
             "Cannot apply 'ATAN2' to arguments of type "
                 + "'ATAN2\\(<CHAR\\(3\\)>, <CHAR\\(3\\)>\\)'\\. "
                 + "Supported form\\(s\\): 'ATAN2\\(<NUMERIC>, <NUMERIC>\\)'",
-        false);
+            false);
     f.checkType("atan2('abc', 'def')", "DOUBLE NOT NULL");
     f.checkScalarApprox("atan2(0.5, -0.5)", "DOUBLE NOT NULL",
         isWithin(2.3562d, 0.0001d));
@@ -5074,7 +5331,7 @@ private void checkIf(SqlOperatorFixture f) {
             "Cannot apply 'CBRT' to arguments of type "
                 + "'CBRT\\(<CHAR\\(3\\)>\\)'\\. Supported form\\(s\\): "
                 + "'CBRT\\(<NUMERIC>\\)'",
-        false);
+            false);
     f.checkType("cbrt('abc')", "DOUBLE NOT NULL");
     f.checkScalar("cbrt(8)", "2.0", "DOUBLE NOT NULL");
     f.checkScalar("cbrt(-8)", "-2.0", "DOUBLE NOT NULL");
@@ -5095,7 +5352,7 @@ private void checkIf(SqlOperatorFixture f) {
             "Cannot apply 'COS' to arguments of type "
                 + "'COS\\(<CHAR\\(3\\)>\\)'\\. Supported form\\(s\\): "
                 + "'COS\\(<NUMERIC>\\)'",
-        false);
+            false);
     f.checkType("cos('abc')", "DOUBLE NOT NULL");
     f.checkScalarApprox("cos(1)", "DOUBLE NOT NULL",
         isWithin(0.5403d, 0.0001d));
@@ -5106,22 +5363,23 @@ private void checkIf(SqlOperatorFixture f) {
   }
 
   @Test void testCoshFunc() {
-    final SqlOperatorFixture f0 = fixture();
-    final SqlOperatorFixture f = f0.withLibrary(SqlLibrary.ORACLE);
-    f.checkType("cosh(1)", "DOUBLE NOT NULL");
-    f.checkType("cosh(cast(1 as float))", "DOUBLE NOT NULL");
-    f.checkType("cosh(case when false then 1 else null end)", "DOUBLE");
-    f0.enableTypeCoercion(false)
-        .checkFails("^cosh('abc')^",
-            "No match found for function signature COSH\\(<CHARACTER>\\)",
-            false);
-    f.checkType("cosh('abc')", "DOUBLE NOT NULL");
-    f.checkScalarApprox("cosh(1)", "DOUBLE NOT NULL",
-        isWithin(1.5430d, 0.0001d));
-    f.checkScalarApprox("cosh(cast(1 as decimal(1, 0)))", "DOUBLE NOT NULL",
-        isWithin(1.5430d, 0.0001d));
-    f.checkNull("cosh(cast(null as integer))");
-    f.checkNull("cosh(cast(null as double))");
+    final SqlOperatorFixture f0 = fixture().setFor(SqlLibraryOperators.COSH);
+    f0.checkFails("^cosh(1)^",
+        "No match found for function signature COSH\\(<NUMERIC>\\)",
+        false);
+    final Consumer<SqlOperatorFixture> consumer = f -> {
+      f.checkType("cosh(1)", "DOUBLE NOT NULL");
+      f.checkType("cosh(cast(1 as float))", "DOUBLE NOT NULL");
+      f.checkType("cosh(case when false then 1 else null end)", "DOUBLE");
+      f.checkType("cosh('abc')", "DOUBLE NOT NULL");
+      f.checkScalarApprox("cosh(1)", "DOUBLE NOT NULL",
+          isWithin(1.5430d, 0.0001d));
+      f.checkScalarApprox("cosh(cast(1 as decimal(1, 0)))", "DOUBLE NOT NULL",
+          isWithin(1.5430d, 0.0001d));
+      f.checkNull("cosh(cast(null as integer))");
+      f.checkNull("cosh(cast(null as double))");
+    };
+    f0.forEachLibrary(list(SqlLibrary.BIG_QUERY, SqlLibrary.ORACLE), consumer);
   }
 
   @Test void testCotFunc() {
@@ -5155,7 +5413,7 @@ private void checkIf(SqlOperatorFixture f) {
             "Cannot apply 'DEGREES' to arguments of type "
                 + "'DEGREES\\(<CHAR\\(3\\)>\\)'\\. Supported form\\(s\\): "
                 + "'DEGREES\\(<NUMERIC>\\)'",
-        false);
+            false);
     f.checkType("degrees('abc')", "DOUBLE NOT NULL");
     f.checkScalarApprox("degrees(1)", "DOUBLE NOT NULL",
         isWithin(57.2958d, 0.0001d));
@@ -5198,6 +5456,14 @@ private void checkIf(SqlOperatorFixture f) {
     f.checkNull("radians(cast(null as double))");
   }
 
+  @Test void testPowFunc() {
+    final SqlOperatorFixture f = fixture()
+        .setFor(SqlLibraryOperators.POW)
+        .withLibrary(SqlLibrary.BIG_QUERY);
+    f.checkScalarApprox("pow(2,3)", "DOUBLE NOT NULL", isExactly("8.0"));
+    f.checkNull("pow(2, cast(null as integer))");
+    f.checkNull("pow(cast(null as integer), 2)");
+  }
 
   @Test void testRoundFunc() {
     final SqlOperatorFixture f = fixture();
@@ -5275,22 +5541,23 @@ private void checkIf(SqlOperatorFixture f) {
   }
 
   @Test void testSinhFunc() {
-    final SqlOperatorFixture f0 = fixture();
-    final SqlOperatorFixture f = f0.withLibrary(SqlLibrary.ORACLE);
-    f.checkType("sinh(1)", "DOUBLE NOT NULL");
-    f.checkType("sinh(cast(1 as float))", "DOUBLE NOT NULL");
-    f.checkType("sinh(case when false then 1 else null end)", "DOUBLE");
-    f0.enableTypeCoercion(false)
-        .checkFails("^sinh('abc')^",
-            "No match found for function signature SINH\\(<CHARACTER>\\)",
-            false);
-    f.checkType("sinh('abc')", "DOUBLE NOT NULL");
-    f.checkScalarApprox("sinh(1)", "DOUBLE NOT NULL",
-        isWithin(1.1752d, 0.0001d));
-    f.checkScalarApprox("sinh(cast(1 as decimal(1, 0)))", "DOUBLE NOT NULL",
-        isWithin(1.1752d, 0.0001d));
-    f.checkNull("sinh(cast(null as integer))");
-    f.checkNull("sinh(cast(null as double))");
+    final SqlOperatorFixture f0 = fixture().setFor(SqlLibraryOperators.SINH);
+    f0.checkFails("^sinh(1)^",
+        "No match found for function signature SINH\\(<NUMERIC>\\)",
+        false);
+    final Consumer<SqlOperatorFixture> consumer = f -> {
+      f.checkType("sinh(1)", "DOUBLE NOT NULL");
+      f.checkType("sinh(cast(1 as float))", "DOUBLE NOT NULL");
+      f.checkType("sinh(case when false then 1 else null end)", "DOUBLE");
+      f.checkType("sinh('abc')", "DOUBLE NOT NULL");
+      f.checkScalarApprox("sinh(1)", "DOUBLE NOT NULL",
+          isWithin(1.1752d, 0.0001d));
+      f.checkScalarApprox("sinh(cast(1 as decimal(1, 0)))", "DOUBLE NOT NULL",
+          isWithin(1.1752d, 0.0001d));
+      f.checkNull("sinh(cast(null as integer))");
+      f.checkNull("sinh(cast(null as double))");
+    };
+    f0.forEachLibrary(list(SqlLibrary.BIG_QUERY, SqlLibrary.ORACLE), consumer);
   }
 
   @Test void testTanFunc() {
@@ -5315,22 +5582,58 @@ private void checkIf(SqlOperatorFixture f) {
   }
 
   @Test void testTanhFunc() {
-    SqlOperatorFixture f0 = fixture();
-    final SqlOperatorFixture f = f0.withLibrary(SqlLibrary.ORACLE);
-    f.checkType("tanh(1)", "DOUBLE NOT NULL");
-    f.checkType("tanh(cast(1 as float))", "DOUBLE NOT NULL");
-    f.checkType("tanh(case when false then 1 else null end)", "DOUBLE");
-    f0.enableTypeCoercion(false)
-        .checkFails("^tanh('abc')^",
-            "No match found for function signature TANH\\(<CHARACTER>\\)",
+    SqlOperatorFixture f0 = fixture().setFor(SqlLibraryOperators.TANH);
+    f0.checkFails("^tanh(1)^",
+        "No match found for function signature TANH\\(<NUMERIC>\\)",
+        false);
+    final Consumer<SqlOperatorFixture> consumer = f -> {
+      f.checkType("tanh(1)", "DOUBLE NOT NULL");
+      f.checkType("tanh(cast(1 as float))", "DOUBLE NOT NULL");
+      f.checkType("tanh(case when false then 1 else null end)", "DOUBLE");
+      f.checkType("tanh('abc')", "DOUBLE NOT NULL");
+      f.checkScalarApprox("tanh(1)", "DOUBLE NOT NULL",
+          isWithin(0.7615d, 0.0001d));
+      f.checkScalarApprox("tanh(cast(1 as decimal(1, 0)))", "DOUBLE NOT NULL",
+          isWithin(0.7615d, 0.0001d));
+      f.checkNull("tanh(cast(null as integer))");
+      f.checkNull("tanh(cast(null as double))");
+    };
+    f0.forEachLibrary(list(SqlLibrary.BIG_QUERY, SqlLibrary.ORACLE), consumer);
+  }
+
+  @Test void testTruncFunc() {
+    final SqlOperatorFixture f = fixture()
+        .setFor(SqlLibraryOperators.TRUNC)
+        .withLibrary(SqlLibrary.BIG_QUERY);
+    f.checkType("trunc(42, -1)", "INTEGER NOT NULL");
+    f.checkType("trunc(cast(42 as float), 1)", "FLOAT NOT NULL");
+    f.checkType("trunc(case when false then 42 else null end, -1)",
+        "INTEGER");
+    f.enableTypeCoercion(false)
+        .checkFails("^trunc('abc', 'def')^",
+            "Cannot apply 'TRUNC' to arguments of type "
+                + "'TRUNC\\(<CHAR\\(3\\)>, <CHAR\\(3\\)>\\)'\\. Supported "
+                + "form\\(s\\): 'TRUNC\\(<NUMERIC>, <INTEGER>\\)'",
             false);
-    f.checkType("tanh('abc')", "DOUBLE NOT NULL");
-    f.checkScalarApprox("tanh(1)", "DOUBLE NOT NULL",
-        isWithin(0.7615d, 0.0001d));
-    f.checkScalarApprox("tanh(cast(1 as decimal(1, 0)))", "DOUBLE NOT NULL",
-        isWithin(0.7615d, 0.0001d));
-    f.checkNull("tanh(cast(null as integer))");
-    f.checkNull("tanh(cast(null as double))");
+    f.checkType("trunc('abc', 'def')", "DECIMAL(19, 9) NOT NULL");
+    f.checkScalar("trunc(42, -1)", 40, "INTEGER NOT NULL");
+    f.checkScalar("trunc(cast(42.345 as decimal(2, 3)), 2)",
+        BigDecimal.valueOf(4234, 2), "DECIMAL(2, 3) NOT NULL");
+    f.checkScalar("trunc(cast(-42.345 as decimal(2, 3)), 2)",
+        BigDecimal.valueOf(-4234, 2), "DECIMAL(2, 3) NOT NULL");
+    f.checkNull("trunc(cast(null as integer), 1)");
+    f.checkNull("trunc(cast(null as double), 1)");
+    f.checkNull("trunc(43.21, cast(null as integer))");
+
+    f.checkScalar("trunc(42)", 42, "INTEGER NOT NULL");
+    f.checkScalar("trunc(42.324)",
+        BigDecimal.valueOf(42, 0), "DECIMAL(5, 3) NOT NULL");
+    f.checkScalar("trunc(cast(42.324 as float))", 42F,
+        "FLOAT NOT NULL");
+    f.checkScalar("trunc(cast(42.345 as decimal(2, 3)))",
+        BigDecimal.valueOf(42, 0), "DECIMAL(2, 3) NOT NULL");
+    f.checkNull("trunc(cast(null as integer))");
+    f.checkNull("trunc(cast(null as double))");
   }
 
   @Test void testTruncateFunc() {
@@ -5609,8 +5912,8 @@ protected static Pair<String, Hook.Closeable> currentTimeString(TimeZone tz) {
   private static Pair<String, Hook.Closeable> fixedTimeString(TimeZone tz) {
     final Calendar calendar = getFixedCalendar();
     final long timeInMillis = calendar.getTimeInMillis();
-    final Hook.Closeable closeable = Hook.CURRENT_TIME.addThread(
-        (Consumer<Holder<Long>>) o -> o.set(timeInMillis));
+    final Consumer<Holder<Long>> consumer = o -> o.set(timeInMillis);
+    final Hook.Closeable closeable = Hook.CURRENT_TIME.addThread(consumer);
     return Pair.of(toTimeString(tz, calendar), closeable);
   }
 
@@ -5758,6 +6061,164 @@ private void testCurrentDateFunc(Pair<String, Hook.Closeable> pair) {
     f.checkNull("last_day(cast(null as timestamp))");
   }
 
+  @Test void testLpadFunction() {
+    final SqlOperatorFixture f = fixture().withLibrary(SqlLibrary.BIG_QUERY);
+    f.setFor(SqlLibraryOperators.LPAD);
+    f.check("select lpad('12345', 8, 'a')", "VARCHAR(5) NOT NULL", "aaa12345");
+    f.checkString("lpad('12345', 8)", "   12345", "VARCHAR(5) NOT NULL");
+    f.checkString("lpad('12345', 8, 'ab')", "aba12345", "VARCHAR(5) NOT NULL");
+    f.checkString("lpad('12345', 3, 'a')", "123", "VARCHAR(5) NOT NULL");
+    f.checkFails("lpad('12345', -3, 'a')",
+        "Second argument for LPAD/RPAD must not be negative", true);
+    f.checkFails("lpad('12345', -3)",
+        "Second argument for LPAD/RPAD must not be negative", true);
+    f.checkFails("lpad('12345', 3, '')",
+        "Third argument (pad pattern) for LPAD/RPAD must not be empty", true);
+    f.checkString("lpad(x'aa', 4, x'bb')", "bbbbbbaa", "VARBINARY(1) NOT NULL");
+    f.checkString("lpad(x'aa', 4)", "202020aa", "VARBINARY(1) NOT NULL");
+    f.checkString("lpad(x'aaaaaa', 2)", "aaaa", "VARBINARY(3) NOT NULL");
+    f.checkString("lpad(x'aaaaaa', 2, x'bb')", "aaaa", "VARBINARY(3) NOT NULL");
+    f.checkFails("lpad(x'aa', -3, x'bb')",
+        "Second argument for LPAD/RPAD must not be negative", true);
+    f.checkFails("lpad(x'aa', -3)",
+        "Second argument for LPAD/RPAD must not be negative", true);
+    f.checkFails("lpad(x'aa', 3, x'')",
+        "Third argument (pad pattern) for LPAD/RPAD must not be empty", true);
+  }
+
+  @Test void testRpadFunction() {
+    final SqlOperatorFixture f = fixture().withLibrary(SqlLibrary.BIG_QUERY);
+    f.setFor(SqlLibraryOperators.RPAD);
+    f.check("select rpad('12345', 8, 'a')", "VARCHAR(5) NOT NULL", "12345aaa");
+    f.checkString("rpad('12345', 8)", "12345   ", "VARCHAR(5) NOT NULL");
+    f.checkString("rpad('12345', 8, 'ab')", "12345aba", "VARCHAR(5) NOT NULL");
+    f.checkString("rpad('12345', 3, 'a')", "123", "VARCHAR(5) NOT NULL");
+    f.checkFails("rpad('12345', -3, 'a')",
+        "Second argument for LPAD/RPAD must not be negative", true);
+    f.checkFails("rpad('12345', -3)",
+        "Second argument for LPAD/RPAD must not be negative", true);
+    f.checkFails("rpad('12345', 3, '')",
+        "Third argument (pad pattern) for LPAD/RPAD must not be empty", true);
+
+    f.checkString("rpad(x'aa', 4, x'bb')", "aabbbbbb", "VARBINARY(1) NOT NULL");
+    f.checkString("rpad(x'aa', 4)", "aa202020", "VARBINARY(1) NOT NULL");
+    f.checkString("rpad(x'aaaaaa', 2)", "aaaa", "VARBINARY(3) NOT NULL");
+    f.checkString("rpad(x'aaaaaa', 2, x'bb')", "aaaa", "VARBINARY(3) NOT NULL");
+    f.checkFails("rpad(x'aa', -3, x'bb')",
+        "Second argument for LPAD/RPAD must not be negative", true);
+    f.checkFails("rpad(x'aa', -3)",
+        "Second argument for LPAD/RPAD must not be negative", true);
+    f.checkFails("rpad(x'aa', 3, x'')",
+        "Third argument (pad pattern) for LPAD/RPAD must not be empty", true);
+  }
+
+  @Test void testStrposFunction() {
+    final SqlOperatorFixture f0 = fixture().setFor(SqlLibraryOperators.STRPOS);
+    f0.checkFails("^strpos('abc', 'a')^",
+        "No match found for function signature STRPOS\\(<CHARACTER>, <CHARACTER>\\)",
+        false);
+    final SqlOperatorFixture f = f0.withLibrary(SqlLibrary.BIG_QUERY);
+    f.checkScalar("STRPOS('abc', 'a')", "1", "INTEGER NOT NULL");
+    f.checkScalar("STRPOS('abcabc', 'bc')", "2", "INTEGER NOT NULL");
+    f.checkScalar("STRPOS('abcabc', 'd')", "0", "INTEGER NOT NULL");
+    f.checkScalar("STRPOS('abc', '')", "1", "INTEGER NOT NULL");
+    f.checkScalar("STRPOS('', 'a')", "0", "INTEGER NOT NULL");
+    f.checkNull("STRPOS(null, 'a')");
+    f.checkNull("STRPOS('a', null)");
+
+    // test for BINARY
+    f.checkScalar("STRPOS(x'2212', x'12')", "2", "INTEGER NOT NULL");
+    f.checkScalar("STRPOS(x'2122', x'12')", "0", "INTEGER NOT NULL");
+    f.checkScalar("STRPOS(x'1222', x'12')", "1", "INTEGER NOT NULL");
+    f.checkScalar("STRPOS(x'1111', x'22')", "0", "INTEGER NOT NULL");
+    f.checkScalar("STRPOS(x'2122', x'')", "1", "INTEGER NOT NULL");
+    f.checkScalar("STRPOS(x'', x'12')", "0", "INTEGER NOT NULL");
+    f.checkNull("STRPOS(null, x'')");
+    f.checkNull("STRPOS(x'', null)");
+  }
+
+  @Test void testStartsWithFunction() {
+    final SqlOperatorFixture f = fixture().withLibrary(SqlLibrary.BIG_QUERY);
+    f.setFor(SqlLibraryOperators.STARTS_WITH);
+    f.checkBoolean("starts_with('12345', '123')", true);
+    f.checkBoolean("starts_with('12345', '1243')", false);
+    f.checkBoolean("starts_with(x'11', x'11')", true);
+    f.checkBoolean("starts_with(x'112211', x'33')", false);
+    f.checkFails("^starts_with('aabbcc', x'aa')^",
+        "Cannot apply 'STARTS_WITH' to arguments of type "
+            + "'STARTS_WITH\\(<CHAR\\(6\\)>, <BINARY\\(1\\)>\\)'\\. Supported "
+            + "form\\(s\\): 'STARTS_WITH\\(<STRING>, <STRING>\\)'",
+        false);
+    f.checkNull("starts_with(null, null)");
+    f.checkNull("starts_with('12345', null)");
+    f.checkNull("starts_with(null, '123')");
+    f.checkBoolean("starts_with('', '123')", false);
+    f.checkBoolean("starts_with('', '')", true);
+    f.checkNull("starts_with(x'aa', null)");
+    f.checkNull("starts_with(null, x'aa')");
+    f.checkBoolean("starts_with(x'1234', x'')", true);
+    f.checkBoolean("starts_with(x'', x'123456')", false);
+    f.checkBoolean("starts_with(x'', x'')", true);
+  }
+
+  @Test void testEndsWithFunction() {
+    final SqlOperatorFixture f = fixture().withLibrary(SqlLibrary.BIG_QUERY);
+    f.setFor(SqlLibraryOperators.ENDS_WITH);
+    f.checkBoolean("ends_with('12345', '345')", true);
+    f.checkBoolean("ends_with('12345', '123')", false);
+    f.checkBoolean("ends_with(x'11', x'11')", true);
+    f.checkBoolean("ends_with(x'112211', x'33')", false);
+    f.checkFails("^ends_with('aabbcc', x'aa')^",
+        "Cannot apply 'ENDS_WITH' to arguments of type "
+            + "'ENDS_WITH\\(<CHAR\\(6\\)>, <BINARY\\(1\\)>\\)'\\. Supported "
+            + "form\\(s\\): 'ENDS_WITH\\(<STRING>, <STRING>\\)'",
+        false);
+    f.checkNull("ends_with(null, null)");
+    f.checkNull("ends_with('12345', null)");
+    f.checkNull("ends_with(null, '123')");
+    f.checkBoolean("ends_with('', '123')", false);
+    f.checkBoolean("ends_with('', '')", true);
+    f.checkNull("ends_with(x'aa', null)");
+    f.checkNull("ends_with(null, x'aa')");
+    f.checkBoolean("ends_with(x'1234', x'')", true);
+    f.checkBoolean("ends_with(x'', x'123456')", false);
+    f.checkBoolean("ends_with(x'', x'')", true);
+  }
+
+  /** Tests the {@code SPLIT} operator. */
+  @Test void testSplitFunction() {
+    final SqlOperatorFixture f0 = fixture().setFor(SqlLibraryOperators.SPLIT);
+    f0.checkFails("^split('hello')^",
+        "No match found for function signature SPLIT\\(<CHARACTER>\\)",
+        false);
+    final SqlOperatorFixture f = f0.withLibrary(SqlLibrary.BIG_QUERY);
+    f.checkScalar("SPLIT('h,e,l,l,o')", "[h, e, l, l, o]",
+        "CHAR(9) NOT NULL ARRAY NOT NULL");
+    f.checkScalar("SPLIT('h-e-l-l-o', '-')", "[h, e, l, l, o]",
+        "CHAR(9) NOT NULL ARRAY NOT NULL");
+    f.checkScalar("SPLIT('hello', '-')", "[hello]",
+        "CHAR(5) NOT NULL ARRAY NOT NULL");
+    f.checkScalar("SPLIT('')", "[]",
+        "CHAR(0) NOT NULL ARRAY NOT NULL");
+    f.checkScalar("SPLIT('', '-')", "[]",
+        "CHAR(0) NOT NULL ARRAY NOT NULL");
+    f.checkNull("SPLIT(null)");
+    f.checkNull("SPLIT('hello', null)");
+
+    // In ASCII, x'41' = 'A', x'42' = 'B', x'43' = 'C'
+    f.checkScalar("SPLIT(x'414243', x'ff')", "[ABC]",
+        "BINARY(3) NOT NULL ARRAY NOT NULL");
+    f.checkScalar("SPLIT(x'414243', x'41')", "[, BC]",
+        "BINARY(3) NOT NULL ARRAY NOT NULL");
+    f.checkScalar("SPLIT(x'414243', x'42')", "[A, C]",
+        "BINARY(3) NOT NULL ARRAY NOT NULL");
+    f.checkScalar("SPLIT(x'414243', x'43')", "[AB, ]",
+        "BINARY(3) NOT NULL ARRAY NOT NULL");
+    f.checkFails("^SPLIT(x'aabbcc')^",
+        "Call to function 'SPLIT' with argument of type 'BINARY\\(3\\)' "
+            + "requires extra delimiter argument", false);
+  }
+
   /** Tests the {@code SUBSTRING} operator. Many test cases that used to be
    * have been moved to {@link SubFunChecker#assertSubFunReturns}, and are
    * called for both {@code SUBSTRING} and {@code SUBSTR}. */
@@ -5767,7 +6228,7 @@ private void testCurrentDateFunc(Pair<String, Hook.Closeable> pair) {
     checkSubstringFunction(f.withConformance(SqlConformanceEnum.BIG_QUERY));
   }
 
-  void checkSubstringFunction(SqlOperatorFixture f) {
+  private static void checkSubstringFunction(SqlOperatorFixture f) {
     f.setFor(SqlStdOperatorTable.SUBSTRING);
     f.checkString("substring('abc' from 1 for 2)",
         "ab", "VARCHAR(3) NOT NULL");
@@ -6082,53 +6543,73 @@ void assertSubFunReturns(boolean binary, String s, int start,
   }
 
   @Test void testRtrimFunc() {
-    final SqlOperatorFixture f = fixture()
-        .setFor(SqlLibraryOperators.RTRIM, VmName.EXPAND)
-        .withLibrary(SqlLibrary.ORACLE);
-    f.checkString("rtrim(' aAa  ')", " aAa", "VARCHAR(6) NOT NULL");
-    f.checkNull("rtrim(CAST(NULL AS VARCHAR(6)))");
+    final SqlOperatorFixture f0 = fixture()
+        .setFor(SqlLibraryOperators.RTRIM, VmName.EXPAND);
+    f0.checkFails("^rtrim(' aaa')^",
+        "No match found for function signature RTRIM\\(<CHARACTER>\\)",
+        false);
+    final Consumer<SqlOperatorFixture> consumer = f -> {
+      f.checkString("rtrim(' aAa  ')", " aAa", "VARCHAR(6) NOT NULL");
+      f.checkNull("rtrim(CAST(NULL AS VARCHAR(6)))");
+    };
+    f0.forEachLibrary(list(SqlLibrary.BIG_QUERY, SqlLibrary.ORACLE), consumer);
   }
 
   @Test void testLtrimFunc() {
-    final SqlOperatorFixture f = fixture()
-        .setFor(SqlLibraryOperators.LTRIM, VmName.EXPAND)
-        .withLibrary(SqlLibrary.ORACLE);
-    f.checkString("ltrim(' aAa  ')", "aAa  ", "VARCHAR(6) NOT NULL");
-    f.checkNull("ltrim(CAST(NULL AS VARCHAR(6)))");
+    final SqlOperatorFixture f0 = fixture()
+        .setFor(SqlLibraryOperators.LTRIM, VmName.EXPAND);
+    f0.checkFails("^ltrim('  aa')^",
+        "No match found for function signature LTRIM\\(<CHARACTER>\\)",
+        false);
+    final Consumer<SqlOperatorFixture> consumer = f -> {
+      f.checkString("ltrim(' aAa  ')", "aAa  ", "VARCHAR(6) NOT NULL");
+      f.checkNull("ltrim(CAST(NULL AS VARCHAR(6)))");
+    };
+    f0.forEachLibrary(list(SqlLibrary.BIG_QUERY, SqlLibrary.ORACLE), consumer);
   }
 
   @Test void testGreatestFunc() {
-    final SqlOperatorFixture f = fixture()
-        .setFor(SqlLibraryOperators.GREATEST, VmName.EXPAND)
-        .withLibrary(SqlLibrary.ORACLE);
-    f.checkString("greatest('on', 'earth')", "on   ", "CHAR(5) NOT NULL");
-    f.checkString("greatest('show', 'on', 'earth')", "show ",
-        "CHAR(5) NOT NULL");
-    f.checkScalar("greatest(12, CAST(NULL AS INTEGER), 3)", isNullValue(),
-        "INTEGER");
-    f.checkScalar("greatest(false, true)", true, "BOOLEAN NOT NULL");
-
-    final SqlOperatorFixture f12 = f.forOracle(SqlConformanceEnum.ORACLE_12);
-    f12.checkString("greatest('on', 'earth')", "on", "VARCHAR(5) NOT NULL");
-    f12.checkString("greatest('show', 'on', 'earth')", "show",
-        "VARCHAR(5) NOT NULL");
+    final SqlOperatorFixture f0 =
+        fixture().setFor(SqlLibraryOperators.GREATEST, VmName.EXPAND);
+    f0.checkFails("^greatest('on', 'earth')^",
+        "No match found for function signature GREATEST\\(<CHARACTER>, <CHARACTER>\\)",
+        false);
+    final Consumer<SqlOperatorFixture> consumer = f -> {
+      f.checkString("greatest('on', 'earth')", "on   ", "CHAR(5) NOT NULL");
+      f.checkString("greatest('show', 'on', 'earth')", "show ",
+          "CHAR(5) NOT NULL");
+      f.checkScalar("greatest(12, CAST(NULL AS INTEGER), 3)", isNullValue(),
+          "INTEGER");
+      f.checkScalar("greatest(false, true)", true, "BOOLEAN NOT NULL");
+
+      final SqlOperatorFixture f12 = f.forOracle(SqlConformanceEnum.ORACLE_12);
+      f12.checkString("greatest('on', 'earth')", "on", "VARCHAR(5) NOT NULL");
+      f12.checkString("greatest('show', 'on', 'earth')", "show",
+          "VARCHAR(5) NOT NULL");
+    };
+    f0.forEachLibrary(list(SqlLibrary.BIG_QUERY, SqlLibrary.ORACLE), consumer);
   }
 
   @Test void testLeastFunc() {
-    final SqlOperatorFixture f = fixture()
-        .setFor(SqlLibraryOperators.LEAST, VmName.EXPAND)
-        .withLibrary(SqlLibrary.ORACLE);
-    f.checkString("least('on', 'earth')", "earth", "CHAR(5) NOT NULL");
-    f.checkString("least('show', 'on', 'earth')", "earth",
-        "CHAR(5) NOT NULL");
-    f.checkScalar("least(12, CAST(NULL AS INTEGER), 3)", isNullValue(),
-        "INTEGER");
-    f.checkScalar("least(false, true)", false, "BOOLEAN NOT NULL");
-
-    final SqlOperatorFixture f12 = f.forOracle(SqlConformanceEnum.ORACLE_12);
-    f12.checkString("least('on', 'earth')", "earth", "VARCHAR(5) NOT NULL");
-    f12.checkString("least('show', 'on', 'earth')", "earth",
-        "VARCHAR(5) NOT NULL");
+    final SqlOperatorFixture f0 = fixture()
+        .setFor(SqlLibraryOperators.LEAST, VmName.EXPAND);
+    f0.checkFails("^least('on', 'earth')^",
+        "No match found for function signature LEAST\\(<CHARACTER>, <CHARACTER>\\)",
+        false);
+    final Consumer<SqlOperatorFixture> consumer = f -> {
+      f.checkString("least('on', 'earth')", "earth", "CHAR(5) NOT NULL");
+      f.checkString("least('show', 'on', 'earth')", "earth",
+          "CHAR(5) NOT NULL");
+      f.checkScalar("least(12, CAST(NULL AS INTEGER), 3)", isNullValue(),
+          "INTEGER");
+      f.checkScalar("least(false, true)", false, "BOOLEAN NOT NULL");
+
+      final SqlOperatorFixture f12 = f0.forOracle(SqlConformanceEnum.ORACLE_12);
+      f12.checkString("least('on', 'earth')", "earth", "VARCHAR(5) NOT NULL");
+      f12.checkString("least('show', 'on', 'earth')", "earth",
+          "VARCHAR(5) NOT NULL");
+    };
+    f0.forEachLibrary(list(SqlLibrary.BIG_QUERY, SqlLibrary.ORACLE), consumer);
   }
 
   @Test void testNvlFunc() {
@@ -6158,15 +6639,40 @@ void assertSubFunReturns(boolean binary, String s, int start,
     f12.checkNull("nvl(CAST(NULL AS VARCHAR(6)), cast(NULL AS VARCHAR(4)))");
   }
 
-  @Test void testDecodeFunc() {
-    checkDecodeFunc(fixture().withLibrary(SqlLibrary.ORACLE));
-  }
+  /** Tests {@code IFNULL}, which is a synonym for {@code NVL}, and is related to
+   * {@code COALESCE} but requires precisely two arguments. */
+  @Test void testIfnullFunc() {
+    final SqlOperatorFixture f = fixture()
+        .withLibrary(SqlLibrary.BIG_QUERY)
+        .setFor(SqlLibraryOperators.IFNULL, VM_EXPAND);
 
-  void checkDecodeFunc(SqlOperatorFixture f) {
-    f.setFor(SqlLibraryOperators.DECODE, VmName.EXPAND);
-    f.checkScalar("decode(0, 0, 'a', 1, 'b', 2, 'c')", "a", "CHAR(1)");
-    f.checkScalar("decode(1, 0, 'a', 1, 'b', 2, 'c')", "b", "CHAR(1)");
-    // if there are duplicates, take the first match
+    f.checkString("ifnull('a','b')", "a", "CHAR(1) NOT NULL");
+    f.checkString("ifnull(null,'b')", "b", "CHAR(1) NOT NULL");
+    f.checkScalar("ifnull(4,3)", 4, "INTEGER NOT NULL");
+    f.checkScalar("ifnull(null, 4)", 4, "INTEGER NOT NULL");
+    f.enableTypeCoercion(false)
+        .checkFails("1 + ifnull('a', 1) + 2",
+            "Cannot infer return type for IFNULL; operand types: \\[CHAR\\(1\\), INTEGER\\]",
+            false);
+    f.checkType("1 + ifnull(1, null) + 2",
+        "INTEGER NOT NULL");
+    f.checkFails("^ifnull(1,2,3)^",
+        "Invalid number of arguments to function 'IFNULL'. Was expecting 2 arguments",
+        false);
+    f.checkFails("^ifnull(1)^",
+        "Invalid number of arguments to function 'IFNULL'. Was expecting 2 arguments",
+        false);
+  }
+
+  @Test void testDecodeFunc() {
+    checkDecodeFunc(fixture().withLibrary(SqlLibrary.ORACLE));
+  }
+
+  private static void checkDecodeFunc(SqlOperatorFixture f) {
+    f.setFor(SqlLibraryOperators.DECODE, VmName.EXPAND);
+    f.checkScalar("decode(0, 0, 'a', 1, 'b', 2, 'c')", "a", "CHAR(1)");
+    f.checkScalar("decode(1, 0, 'a', 1, 'b', 2, 'c')", "b", "CHAR(1)");
+    // if there are duplicates, take the first match
     f.checkScalar("decode(1, 0, 'a', 1, 'b', 1, 'z', 2, 'c')", "b",
         "CHAR(1)");
     // if there's no match, and no "else", return null
@@ -6179,7 +6685,7 @@ void checkDecodeFunc(SqlOperatorFixture f) {
         "CHAR(1) NOT NULL");
     // nulls match
     f.checkScalar("decode(cast(null as integer), 0, 'a',\n"
-        + " cast(null as integer), 'b', 2, 'c', 'd')", "b",
+            + " cast(null as integer), 'b', 2, 'c', 'd')", "b",
         "CHAR(1) NOT NULL");
   }
 
@@ -6220,7 +6726,7 @@ void checkDecodeFunc(SqlOperatorFixture f) {
     f.checkBoolean("1 member of multiset[1]", true);
     f.checkBoolean("'2' member of multiset['1']", false);
     f.checkBoolean("cast(null as double) member of"
-            + " multiset[cast(null as double)]", true);
+        + " multiset[cast(null as double)]", true);
     f.checkBoolean("cast(null as double) member of multiset[1.1]", false);
     f.checkBoolean("1.1 member of multiset[cast(null as double)]", false);
   }
@@ -6230,7 +6736,7 @@ void checkDecodeFunc(SqlOperatorFixture f) {
     f.setFor(SqlStdOperatorTable.MULTISET_UNION_DISTINCT,
         VM_FENNEL, VM_JAVA);
     f.checkBoolean("multiset[1,2] submultiset of "
-            + "(multiset[2] multiset union multiset[1])", true);
+        + "(multiset[2] multiset union multiset[1])", true);
     f.checkScalar("cardinality(multiset[1, 2, 3, 4, 2] "
             + "multiset union distinct multiset[1, 4, 5, 7, 8])",
         "7",
@@ -6337,7 +6843,7 @@ void checkDecodeFunc(SqlOperatorFixture f) {
     f.checkBoolean("multiset['a', 'b'] not submultiset of "
         + "multiset['c', 'd', 's', 'a']", true);
     f.checkBoolean("multiset['a', 'd'] not submultiset of "
-            + "multiset['c', 's', 'a', 'w', 'd']", false);
+        + "multiset['c', 's', 'a', 'w', 'd']", false);
     f.checkBoolean("multiset['q', 'a'] not submultiset of "
         + "multiset['a', 'q']", false);
   }
@@ -6376,11 +6882,11 @@ void checkDecodeFunc(SqlOperatorFixture f) {
     f.checkAggType("listagg(12)", "VARCHAR NOT NULL");
     f.enableTypeCoercion(false)
         .checkFails("^listagg(12)^",
-        "Cannot apply 'LISTAGG' to arguments of type .*'\n.*'", false);
+            "Cannot apply 'LISTAGG' to arguments of type .*'\n.*'", false);
     f.checkAggType("listagg(cast(12 as double))", "VARCHAR NOT NULL");
     f.enableTypeCoercion(false)
         .checkFails("^listagg(cast(12 as double))^",
-        "Cannot apply 'LISTAGG' to arguments of type .*'\n.*'", false);
+            "Cannot apply 'LISTAGG' to arguments of type .*'\n.*'", false);
     f.checkFails("^listagg()^",
         "Invalid number of arguments to function 'LISTAGG'. Was expecting 1 arguments",
         false);
@@ -6402,7 +6908,7 @@ void checkDecodeFunc(SqlOperatorFixture f) {
     checkStringAggFuncFails(f.withLibrary(SqlLibrary.MYSQL));
   }
 
-  private void checkStringAggFunc(SqlOperatorFixture f) {
+  private static void checkStringAggFunc(SqlOperatorFixture f) {
     final String[] values = {"'x'", "null", "'yz'"};
     f.checkAgg("string_agg(x)", values, isSingle("x,yz"));
     f.checkAgg("string_agg(x,':')", values, isSingle("x:yz"));
@@ -6416,7 +6922,7 @@ private void checkStringAggFunc(SqlOperatorFixture f) {
         false);
   }
 
-  private void checkStringAggFuncFails(SqlOperatorFixture f) {
+  private static void checkStringAggFuncFails(SqlOperatorFixture f) {
     final String[] values = {"'x'", "'y'"};
     f.checkAggFails("^string_agg(x)^", values,
         "No match found for function signature STRING_AGG\\(<CHARACTER>\\)",
@@ -6438,7 +6944,7 @@ private void checkStringAggFuncFails(SqlOperatorFixture f) {
     checkGroupConcatFuncFails(f.withLibrary(SqlLibrary.POSTGRESQL));
   }
 
-  private void checkGroupConcatFunc(SqlOperatorFixture f) {
+  private static void checkGroupConcatFunc(SqlOperatorFixture f) {
     final String[] values = {"'x'", "null", "'yz'"};
     f.checkAgg("group_concat(x)", values, isSingle("x,yz"));
     f.checkAgg("group_concat(x,':')", values, isSingle("x:yz"));
@@ -6455,7 +6961,7 @@ private void checkGroupConcatFunc(SqlOperatorFixture f) {
         false);
   }
 
-  private void checkGroupConcatFuncFails(SqlOperatorFixture t) {
+  private static void checkGroupConcatFuncFails(SqlOperatorFixture t) {
     final String[] values = {"'x'", "'y'"};
     t.checkAggFails("^group_concat(x)^", values,
         "No match found for function signature GROUP_CONCAT\\(<CHARACTER>\\)",
@@ -6477,7 +6983,7 @@ private void checkGroupConcatFuncFails(SqlOperatorFixture t) {
     checkArrayAggFuncFails(f.withLibrary(SqlLibrary.MYSQL));
   }
 
-  private void checkArrayAggFunc(SqlOperatorFixture f) {
+  private static void checkArrayAggFunc(SqlOperatorFixture f) {
     f.setFor(SqlLibraryOperators.ARRAY_CONCAT_AGG, VM_FENNEL, VM_JAVA);
     final String[] values = {"'x'", "null", "'yz'"};
     f.checkAgg("array_agg(x)", values, isSingle("[x, yz]"));
@@ -6492,7 +6998,7 @@ private void checkArrayAggFunc(SqlOperatorFixture f) {
         isSingle("[yz, x]"));
   }
 
-  private void checkArrayAggFuncFails(SqlOperatorFixture t) {
+  private static void checkArrayAggFuncFails(SqlOperatorFixture t) {
     t.setFor(SqlLibraryOperators.ARRAY_CONCAT_AGG, VM_FENNEL, VM_JAVA);
     final String[] values = {"'x'", "'y'"};
     final String expectedError = "No match found for function signature "
@@ -6512,7 +7018,7 @@ private void checkArrayAggFuncFails(SqlOperatorFixture t) {
     checkArrayConcatAggFuncFails(f.withLibrary(SqlLibrary.MYSQL));
   }
 
-  void checkArrayConcatAggFunc(SqlOperatorFixture t) {
+  private static void checkArrayConcatAggFunc(SqlOperatorFixture t) {
     t.setFor(SqlLibraryOperators.ARRAY_CONCAT_AGG, VM_FENNEL, VM_JAVA);
     t.checkFails("array_concat_agg(^*^)",
         "(?s)Encountered \"\\*\" at .*", false);
@@ -6536,7 +7042,7 @@ void checkArrayConcatAggFunc(SqlOperatorFixture t) {
     t.checkAgg("array_concat_agg(x)", values2, isSingle("[0, 1, 1, 2]"));
   }
 
-  void checkArrayConcatAggFuncFails(SqlOperatorFixture t) {
+  private static void checkArrayConcatAggFuncFails(SqlOperatorFixture t) {
     t.setFor(SqlLibraryOperators.ARRAY_CONCAT_AGG, VM_FENNEL, VM_JAVA);
     final String[] values = {"'x'", "'y'"};
     final String expectedError = "No match found for function signature "
@@ -6653,51 +7159,29 @@ void checkArrayConcatAggFuncFails(SqlOperatorFixture t) {
   @Test void testWeek() {
     final SqlOperatorFixture f = fixture();
     f.setFor(SqlStdOperatorTable.WEEK, VM_FENNEL, VM_JAVA);
-    if (Bug.CALCITE_2539_FIXED) {
-      // TODO: Not implemented in operator test execution code
-      f.checkFails("week(date '2008-1-23')",
-          "cannot translate call EXTRACT.*",
-          true);
-      f.checkFails("week(cast(null as date))",
-          "cannot translate call EXTRACT.*",
-          true);
-    }
+    f.checkScalar("week(date '2008-1-23')", "4", "BIGINT NOT NULL");
+    f.checkNull("week(cast(null as date))");
   }
 
   @Test void testDayOfYear() {
     final SqlOperatorFixture f = fixture();
     f.setFor(SqlStdOperatorTable.DAYOFYEAR, VM_FENNEL, VM_JAVA);
-    if (Bug.CALCITE_2539_FIXED) {
-      // TODO: Not implemented in operator test execution code
-      f.checkFails("dayofyear(date '2008-1-23')",
-          "cannot translate call EXTRACT.*",
-          true);
-      f.checkFails("dayofyear(cast(null as date))",
-          "cannot translate call EXTRACT.*",
-          true);
-    }
+    f.checkScalar("dayofyear(date '2008-01-23')", "23", "BIGINT NOT NULL");
+    f.checkNull("dayofyear(cast(null as date))");
   }
 
   @Test void testDayOfMonth() {
     final SqlOperatorFixture f = fixture();
     f.setFor(SqlStdOperatorTable.DAYOFMONTH, VM_FENNEL, VM_JAVA);
-    f.checkScalar("dayofmonth(date '2008-1-23')", "23",
-        "BIGINT NOT NULL");
+    f.checkScalar("dayofmonth(date '2008-1-23')", "23", "BIGINT NOT NULL");
     f.checkNull("dayofmonth(cast(null as date))");
   }
 
   @Test void testDayOfWeek() {
     final SqlOperatorFixture f = fixture();
     f.setFor(SqlStdOperatorTable.DAYOFWEEK, VM_FENNEL, VM_JAVA);
-    if (Bug.CALCITE_2539_FIXED) {
-      // TODO: Not implemented in operator test execution code
-      f.checkFails("dayofweek(date '2008-1-23')",
-          "cannot translate call EXTRACT.*",
-          true);
-      f.checkFails("dayofweek(cast(null as date))",
-          "cannot translate call EXTRACT.*",
-          true);
-    }
+    f.checkScalar("dayofweek(date '2008-1-23')", "4", "BIGINT NOT NULL");
+    f.checkNull("dayofweek(cast(null as date))");
   }
 
   @Test void testHour() {
@@ -6744,13 +7228,13 @@ void checkArrayConcatAggFuncFails(SqlOperatorFixture t) {
           "0", "BIGINT NOT NULL");
 
       f.checkScalar("extract(millisecond from "
-              + "interval '4-2' year to month)", "0", "BIGINT NOT NULL");
+          + "interval '4-2' year to month)", "0", "BIGINT NOT NULL");
 
       f.checkScalar("extract(microsecond "
-              + "from interval '4-2' year to month)", "0", "BIGINT NOT NULL");
+          + "from interval '4-2' year to month)", "0", "BIGINT NOT NULL");
 
       f.checkScalar("extract(nanosecond from "
-              + "interval '4-2' year to month)", "0", "BIGINT NOT NULL");
+          + "interval '4-2' year to month)", "0", "BIGINT NOT NULL");
 
       f.checkScalar("extract(minute from interval '4-2' year to month)",
           "0", "BIGINT NOT NULL");
@@ -6764,14 +7248,16 @@ void checkArrayConcatAggFuncFails(SqlOperatorFixture t) {
 
     // Postgres doesn't support DOW, ISODOW, DOY and WEEK on INTERVAL YEAR MONTH type.
     // SQL standard doesn't have extract units for DOW, ISODOW, DOY and WEEK.
-    f.checkFails("^extract(doy from interval '4-2' year to month)^",
-        INVALID_EXTRACT_UNIT_VALIDATION_ERROR, false);
-    f.checkFails("^extract(dow from interval '4-2' year to month)^",
-        INVALID_EXTRACT_UNIT_VALIDATION_ERROR, false);
-    f.checkFails("^extract(week from interval '4-2' year to month)^",
-        INVALID_EXTRACT_UNIT_VALIDATION_ERROR, false);
-    f.checkFails("^extract(isodow from interval '4-2' year to month)^",
-        INVALID_EXTRACT_UNIT_VALIDATION_ERROR, false);
+    if (Bug.CALCITE_2539_FIXED) {
+      f.checkFails("extract(doy from interval '4-2' year to month)",
+          INVALID_EXTRACT_UNIT_VALIDATION_ERROR, false);
+      f.checkFails("^extract(dow from interval '4-2' year to month)^",
+          INVALID_EXTRACT_UNIT_VALIDATION_ERROR, false);
+      f.checkFails("^extract(week from interval '4-2' year to month)^",
+          INVALID_EXTRACT_UNIT_VALIDATION_ERROR, false);
+      f.checkFails("^extract(isodow from interval '4-2' year to month)^",
+          INVALID_EXTRACT_UNIT_VALIDATION_ERROR, false);
+    }
 
     f.checkScalar("extract(month from interval '4-2' year to month)",
         "2", "BIGINT NOT NULL");
@@ -6843,16 +7329,14 @@ void checkArrayConcatAggFuncFails(SqlOperatorFixture t) {
 
     // Postgres doesn't support DOW, ISODOW, DOY and WEEK on INTERVAL DAY TIME type.
     // SQL standard doesn't have extract units for DOW, ISODOW, DOY and WEEK.
-    if (Bug.CALCITE_2539_FIXED) {
-      f.checkFails("extract(doy from interval '2 3:4:5.678' day to second)",
-          INVALID_EXTRACT_UNIT_CONVERTLET_ERROR, true);
-      f.checkFails("extract(dow from interval '2 3:4:5.678' day to second)",
-          INVALID_EXTRACT_UNIT_CONVERTLET_ERROR, true);
-      f.checkFails("extract(week from interval '2 3:4:5.678' day to second)",
-          INVALID_EXTRACT_UNIT_CONVERTLET_ERROR, true);
-      f.checkFails("extract(isodow from interval '2 3:4:5.678' day to second)",
-          INVALID_EXTRACT_UNIT_CONVERTLET_ERROR, true);
-    }
+    f.checkFails("extract(doy from interval '2 3:4:5.678' day to second)",
+        INVALID_EXTRACT_UNIT_CONVERTLET_ERROR, true);
+    f.checkFails("extract(dow from interval '2 3:4:5.678' day to second)",
+        INVALID_EXTRACT_UNIT_CONVERTLET_ERROR, true);
+    f.checkFails("extract(week from interval '2 3:4:5.678' day to second)",
+        INVALID_EXTRACT_UNIT_CONVERTLET_ERROR, true);
+    f.checkFails("extract(isodow from interval '2 3:4:5.678' day to second)",
+        INVALID_EXTRACT_UNIT_CONVERTLET_ERROR, true);
 
     f.checkFails("^extract(month from interval '2 3:4:5.678' day to second)^",
         "(?s)Cannot apply 'EXTRACT' to arguments of type 'EXTRACT\\(<INTERVAL "
@@ -6889,6 +7373,8 @@ void checkArrayConcatAggFuncFails(SqlOperatorFixture t) {
     final SqlOperatorFixture f = fixture();
     f.setFor(SqlStdOperatorTable.EXTRACT, VM_FENNEL, VM_JAVA);
 
+    f.checkFails("extract(^a^ from date '2008-2-23')",
+        "'A' is not a valid time frame", false);
     f.checkScalar("extract(epoch from date '2008-2-23')",
         "1203724800", // number of seconds elapsed since timestamp
         // '1970-01-01 00:00:00' for given date
@@ -6923,11 +7409,14 @@ void checkArrayConcatAggFuncFails(SqlOperatorFixture t) {
 
     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(dow from date '2008-2-24')",
         "1", "BIGINT NOT NULL");
+    f.checkScalar("extract(dayofweek from date '2008-2-23')",
+        "7", "BIGINT NOT NULL");
     f.checkScalar("extract(isodow from date '2008-2-23')",
         "6", "BIGINT NOT NULL");
     f.checkScalar("extract(isodow from date '2008-2-24')",
@@ -6967,6 +7456,8 @@ void checkArrayConcatAggFuncFails(SqlOperatorFixture t) {
     final SqlOperatorFixture f = fixture();
     f.setFor(SqlStdOperatorTable.EXTRACT, VM_FENNEL, VM_JAVA);
 
+    f.checkFails("extract(^a^ from timestamp '2008-2-23 12:34:56')",
+        "'A' is not a valid time frame", false);
     f.checkScalar("extract(epoch from timestamp '2008-2-23 12:34:56')",
         "1203770096", // number of seconds elapsed since timestamp
         // '1970-01-01 00:00:00' for given date
@@ -6994,21 +7485,12 @@ void checkArrayConcatAggFuncFails(SqlOperatorFixture t) {
         "2008", "BIGINT NOT NULL");
     f.checkScalar("extract(isoyear from timestamp '2008-2-23 12:34:56')",
         "2008", "BIGINT NOT NULL");
-
-    if (Bug.CALCITE_2539_FIXED) {
-      // TODO: Not implemented in operator test execution code
-      f.checkFails("extract(doy from timestamp '2008-2-23 12:34:56')",
-          "cannot translate call EXTRACT.*", true);
-
-      // TODO: Not implemented in operator test execution code
-      f.checkFails("extract(dow from timestamp '2008-2-23 12:34:56')",
-          "cannot translate call EXTRACT.*", true);
-
-      // TODO: Not implemented in operator test execution code
-      f.checkFails("extract(week from timestamp '2008-2-23 12:34:56')",
-          "cannot translate call EXTRACT.*", true);
-    }
-
+    f.checkScalar("extract(doy from timestamp '2008-2-23 12:34:56')",
+        "54", "BIGINT NOT NULL");
+    f.checkScalar("extract(dow from timestamp '2008-2-23 12:34:56')",
+        "7", "BIGINT NOT NULL");
+    f.checkScalar("extract(week from timestamp '2008-2-23 12:34:56')",
+        "8", "BIGINT NOT NULL");
     f.checkScalar("extract(decade from timestamp '2008-2-23 12:34:56')",
         "200", "BIGINT NOT NULL");
     f.checkScalar("extract(century from timestamp '2008-2-23 12:34:56')",
@@ -7023,9 +7505,12 @@ void checkArrayConcatAggFuncFails(SqlOperatorFixture t) {
         "2", "BIGINT NOT NULL");
   }
 
-  @Test void testExtractFunc() {
+  @Test void testExtractInterval() {
     final SqlOperatorFixture f = fixture();
     f.setFor(SqlStdOperatorTable.EXTRACT, VM_FENNEL, VM_JAVA);
+
+    f.checkFails("extract(^a^ from interval '2 3:4:5.678' day to second)",
+        "'A' is not a valid time frame", false);
     f.checkScalar("extract(day from interval '2 3:4:5.678' day to second)",
         "2", "BIGINT NOT NULL");
     f.checkScalar("extract(day from interval '23456 3:4:5.678' day(5) to second)",
@@ -7125,6 +7610,37 @@ void checkArrayConcatAggFuncFails(SqlOperatorFixture t) {
     f.checkFails("^Array[]^", "Require at least 1 argument", false);
   }
 
+  /**
+   * Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-4999">[CALCITE-4999]
+   * ARRAY, MULTISET functions should return an collection of scalars
+   * if a sub-query returns 1 column</a>.
+   */
+  @Test void testArrayQueryConstructor() {
+    final SqlOperatorFixture f = fixture();
+    f.setFor(SqlStdOperatorTable.ARRAY_QUERY, SqlOperatorFixture.VmName.EXPAND);
+    f.checkScalar("array(select 1)", "[1]",
+        "INTEGER NOT NULL ARRAY NOT NULL");
+    f.check("select array(select ROW(1,2))",
+        "RecordType(INTEGER NOT NULL EXPR$0, INTEGER NOT NULL EXPR$1) NOT NULL ARRAY NOT NULL",
+        "[{1, 2}]");
+  }
+
+  /**
+   * Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-4999">[CALCITE-4999]
+   * ARRAY, MULTISET functions should return an collection of scalars
+   * if a sub-query returns 1 column</a>.
+   */
+  @Test void testMultisetQueryConstructor() {
+    final SqlOperatorFixture f = fixture();
+    f.setFor(SqlStdOperatorTable.MULTISET_QUERY, SqlOperatorFixture.VmName.EXPAND);
+    f.checkScalar("multiset(select 1)", "[1]", "INTEGER NOT NULL MULTISET NOT NULL");
+    f.check("select multiset(select ROW(1,2))",
+        "RecordType(INTEGER NOT NULL EXPR$0, INTEGER NOT NULL EXPR$1) NOT NULL MULTISET NOT NULL",
+        "[{1, 2}]");
+  }
+
   @Test void testItemOp() {
     final SqlOperatorFixture f = fixture();
     f.setFor(SqlStdOperatorTable.ITEM, VmName.EXPAND);
@@ -7167,7 +7683,7 @@ void checkArrayConcatAggFuncFails(SqlOperatorFixture t) {
             + "from (VALUES (ROW(ROW(3, CAST(NULL AS INTEGER)), ROW(4, 8)))) as T(x, y)",
         SqlTests.ANY_TYPE_CHECKER, isNullValue());
     f.checkFails("select \"T\".\"X\"[1 + CAST(NULL AS INTEGER)] "
-        + "from (VALUES (ROW(ROW(3, CAST(NULL AS INTEGER)), ROW(4, 8)))) as T(x, y)",
+            + "from (VALUES (ROW(ROW(3, CAST(NULL AS INTEGER)), ROW(4, 8)))) as T(x, y)",
         "Cannot infer type of field at position null within ROW type: "
             + "RecordType\\(INTEGER EXPR\\$0, INTEGER EXPR\\$1\\)", false);
   }
@@ -7253,14 +7769,16 @@ void checkArrayConcatAggFuncFails(SqlOperatorFixture t) {
         "(?s)Cannot apply 'FLOOR' to arguments .*", false);
     f.checkFails("^floor('abcde' to minute)^",
         "(?s)Cannot apply 'FLOOR' to arguments .*", false);
-    f.checkFails("floor(timestamp '2015-02-19 12:34:56.78' to ^microsecond^)",
-        "(?s)Encountered \"microsecond\" at .*", false);
-    f.checkFails("floor(timestamp '2015-02-19 12:34:56.78' to ^nanosecond^)",
-        "(?s)Encountered \"nanosecond\" at .*", false);
     f.checkScalar("floor(time '12:34:56' to minute)",
         "12:34:00", "TIME(0) NOT NULL");
     f.checkScalar("floor(timestamp '2015-02-19 12:34:56.78' to second)",
         "2015-02-19 12:34:56", "TIMESTAMP(2) NOT NULL");
+    f.checkScalar("floor(timestamp '2015-02-19 12:34:56.78' to millisecond)",
+        "2015-02-19 12:34:56", "TIMESTAMP(2) NOT NULL");
+    f.checkScalar("floor(timestamp '2015-02-19 12:34:56.78' to microsecond)",
+        "2015-02-19 12:34:56", "TIMESTAMP(2) NOT NULL");
+    f.checkScalar("floor(timestamp '2015-02-19 12:34:56.78' to nanosecond)",
+        "2015-02-19 12:34:56", "TIMESTAMP(2) NOT NULL");
     f.checkScalar("floor(timestamp '2015-02-19 12:34:56' to minute)",
         "2015-02-19 12:34:00", "TIMESTAMP(0) NOT NULL");
     f.checkScalar("floor(timestamp '2015-02-19 12:34:56' to year)",
@@ -7286,7 +7804,7 @@ void checkArrayConcatAggFuncFails(SqlOperatorFixture t) {
                 + "'CEIL\\(<DATE> TO <TIME_UNIT>\\)'\n"
                 + "'CEIL\\(<TIME> TO <TIME_UNIT>\\)'\n"
                 + "'CEIL\\(<TIMESTAMP> TO <TIME_UNIT>\\)'",
-        false);
+            false);
     f.checkType("ceil('12:34:56')", "DECIMAL(19, 0) NOT NULL");
     f.checkFails("^ceil(time '12:34:56')^",
         "(?s)Cannot apply 'CEIL' to arguments .*", false);
@@ -7294,16 +7812,18 @@ void checkArrayConcatAggFuncFails(SqlOperatorFixture t) {
         "(?s)Cannot apply 'CEIL' to arguments .*", false);
     f.checkFails("^ceil('abcde' to minute)^",
         "(?s)Cannot apply 'CEIL' to arguments .*", false);
-    f.checkFails("ceil(timestamp '2015-02-19 12:34:56.78' to ^microsecond^)",
-        "(?s)Encountered \"microsecond\" at .*", false);
-    f.checkFails("ceil(timestamp '2015-02-19 12:34:56.78' to ^nanosecond^)",
-        "(?s)Encountered \"nanosecond\" at .*", false);
     f.checkScalar("ceil(time '12:34:56' to minute)",
         "12:35:00", "TIME(0) NOT NULL");
     f.checkScalar("ceil(time '12:59:56' to minute)",
         "13:00:00", "TIME(0) NOT NULL");
     f.checkScalar("ceil(timestamp '2015-02-19 12:34:56.78' to second)",
         "2015-02-19 12:34:57", "TIMESTAMP(2) NOT NULL");
+    f.checkScalar("ceil(timestamp '2015-02-19 12:34:56.78' to millisecond)",
+        "2015-02-19 12:34:56", "TIMESTAMP(2) NOT NULL");
+    f.checkScalar("ceil(timestamp '2015-02-19 12:34:56.78' to microsecond)",
+        "2015-02-19 12:34:56", "TIMESTAMP(2) NOT NULL");
+    f.checkScalar("ceil(timestamp '2015-02-19 12:34:56.78' to nanosecond)",
+        "2015-02-19 12:34:56", "TIMESTAMP(2) NOT NULL");
     f.checkScalar("ceil(timestamp '2015-02-19 12:34:56.00' to second)",
         "2015-02-19 12:34:56", "TIMESTAMP(2) NOT NULL");
     f.checkScalar("ceil(timestamp '2015-02-19 12:34:56' to minute)",
@@ -7327,6 +7847,81 @@ void checkArrayConcatAggFuncFails(SqlOperatorFixture t) {
     f.checkNull("ceiling(cast(null as timestamp) to month)");
   }
 
+  /** Tests {@code FLOOR}, {@code CEIL}, {@code TIMESTAMPADD},
+   * {@code TIMESTAMPDIFF} functions with custom time frames. */
+  @Test void testCustomTimeFrame() {
+    final SqlOperatorFixture f = fixture()
+        .withFactory(tf ->
+            tf.withTypeSystem(typeSystem ->
+                new DelegatingTypeSystem(typeSystem) {
+                  @Override public TimeFrameSet deriveTimeFrameSet(
+                      TimeFrameSet frameSet) {
+                    return TimeFrameSet.builder()
+                        .addAll(frameSet)
+                        .addDivision("minute15", 4, "HOUR")
+                        .addMultiple("month4", 4, "MONTH")
+                        .build();
+                  }
+                }));
+    f.checkScalar("floor(timestamp '2020-06-27 12:34:56' to \"minute15\")",
+        "2020-06-27 12:30:00", "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("floor(timestamp '2020-06-27 12:34:56' to \"month4\")",
+        "2020-05-01 00:00:00", "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("floor(date '2020-06-27' to \"month4\")",
+        "2020-05-01", "DATE NOT NULL");
+
+    f.checkScalar("ceil(timestamp '2020-06-27 12:34:56' to \"minute15\")",
+        "2020-06-27 12:45:00", "TIMESTAMP(0) NOT NULL");
+    f.checkFails("ceil(timestamp '2020-06-27 12:34:56' to ^\"minute25\"^)",
+        "'minute25' is not a valid time frame", false);
+
+    f.checkScalar(
+        "timestampadd(\"minute15\", 7, timestamp '2016-02-24 12:42:25')",
+        "2016-02-24 14:27:25", "TIMESTAMP(0) NOT NULL");
+    f.checkScalar(
+        "timestampadd(\"month4\", 7, timestamp '2016-02-24 12:42:25')",
+        "2018-06-24 12:42:25", "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("timestampadd(\"month4\", 7, date '2016-02-24')",
+        "2018-06-24", "DATE NOT NULL");
+
+    f.checkScalar("timestampdiff(\"minute15\", "
+            + "timestamp '2016-02-24 12:42:25', "
+            + "timestamp '2016-02-24 15:42:25')",
+        "12", "INTEGER NOT NULL");
+    f.checkScalar("timestampdiff(\"month4\", "
+            + "timestamp '2016-02-24 12:42:25', "
+            + "timestamp '2016-02-24 15:42:25')",
+        "0", "INTEGER NOT NULL");
+    f.checkScalar("timestampdiff(\"month4\", "
+            + "timestamp '2016-02-24 12:42:25', "
+            + "timestamp '2018-02-24 15:42:25')",
+        "6", "INTEGER NOT NULL");
+    f.checkScalar("timestampdiff(\"month4\", "
+            + "timestamp '2016-02-24 12:42:25', "
+            + "timestamp '2018-02-23 15:42:25')",
+        "5", "INTEGER NOT NULL");
+    f.checkScalar("timestampdiff(\"month4\", date '2016-02-24', "
+            + "date '2020-03-24')",
+        "12", "INTEGER NOT NULL");
+    f.checkScalar("timestampdiff(\"month4\", date '2016-02-24', "
+            + "date '2016-06-23')",
+        "0", "INTEGER NOT NULL");
+    f.checkScalar("timestampdiff(\"month4\", date '2016-02-24', "
+            + "date '2016-06-24')",
+        "1", "INTEGER NOT NULL");
+    f.checkScalar("timestampdiff(\"month4\", date '2016-02-24', "
+            + "date '2015-10-24')",
+        "-1", "INTEGER NOT NULL");
+    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");
+  }
+
   @Test void testFloorFuncInterval() {
     final SqlOperatorFixture f = fixture();
     if (!f.brokenTestsEnabled()) {
@@ -7363,99 +7958,139 @@ void checkArrayConcatAggFuncFails(SqlOperatorFixture t) {
   @Test void testTimestampAdd() {
     final SqlOperatorFixture f = fixture();
     f.setFor(SqlStdOperatorTable.TIMESTAMP_ADD, VmName.EXPAND);
-    f.checkScalar(
-        "timestampadd(MICROSECOND, 2000000, timestamp '2016-02-24 12:42:25')",
-        "2016-02-24 12:42:27",
-        "TIMESTAMP(3) NOT NULL");
-    f.checkScalar(
-        "timestampadd(SQL_TSI_SECOND, 2, timestamp '2016-02-24 12:42:25')",
-        "2016-02-24 12:42:27",
-        "TIMESTAMP(0) NOT NULL");
-    f.checkScalar(
-        "timestampadd(NANOSECOND, 3000000000, timestamp '2016-02-24 12:42:25')",
-        "2016-02-24 12:42:28",
-        "TIMESTAMP(0) NOT NULL");
-    f.checkScalar(
-        "timestampadd(SQL_TSI_FRAC_SECOND, 2000000000, timestamp '2016-02-24 12:42:25')",
-        "2016-02-24 12:42:27",
-        "TIMESTAMP(0) NOT NULL");
-    f.checkScalar(
-        "timestampadd(MINUTE, 2, timestamp '2016-02-24 12:42:25')",
-        "2016-02-24 12:44:25",
-        "TIMESTAMP(0) NOT NULL");
-    f.checkScalar("timestampadd(HOUR, -2000, timestamp '2016-02-24 12:42:25')",
-        "2015-12-03 04:42:25",
-        "TIMESTAMP(0) NOT NULL");
-    f.checkNull("timestampadd(HOUR, CAST(NULL AS INTEGER),"
-        + " timestamp '2016-02-24 12:42:25')");
-    f.checkNull("timestampadd(HOUR, -200, CAST(NULL AS TIMESTAMP))");
-    f.checkScalar("timestampadd(MONTH, 3, timestamp '2016-02-24 12:42:25')",
-        "2016-05-24 12:42:25", "TIMESTAMP(0) NOT NULL");
-    f.checkScalar("timestampadd(MONTH, 3, cast(null as timestamp))",
-        isNullValue(), "TIMESTAMP(0)");
+    MICROSECOND_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s
+                + ", 2000000, timestamp '2016-02-24 12:42:25')",
+            "2016-02-24 12:42:27",
+            "TIMESTAMP(3) NOT NULL"));
+    SECOND_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s
+                + ", 2, timestamp '2016-02-24 12:42:25')",
+            "2016-02-24 12:42:27",
+            "TIMESTAMP(0) NOT NULL"));
+    NANOSECOND_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s
+                + ", 3000000000, timestamp '2016-02-24 12:42:25')",
+            "2016-02-24 12:42:28",
+            "TIMESTAMP(0) NOT NULL"));
+    NANOSECOND_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s
+                + ", 2000000000, timestamp '2016-02-24 12:42:25')",
+            "2016-02-24 12:42:27",
+            "TIMESTAMP(0) NOT NULL"));
+    MINUTE_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s
+                + ", 2, timestamp '2016-02-24 12:42:25')",
+            "2016-02-24 12:44:25",
+            "TIMESTAMP(0) NOT NULL"));
+    HOUR_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s
+                + ", -2000, timestamp '2016-02-24 12:42:25')",
+            "2015-12-03 04:42:25",
+            "TIMESTAMP(0) NOT NULL"));
+    HOUR_VARIANTS.forEach(s ->
+        f.checkNull("timestampadd(" + s + ", CAST(NULL AS INTEGER),"
+            + " timestamp '2016-02-24 12:42:25')"));
+    HOUR_VARIANTS.forEach(s ->
+        f.checkNull("timestampadd(" + s + ", -200, CAST(NULL AS TIMESTAMP))"));
+    MONTH_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s
+                + ", 3, timestamp '2016-02-24 12:42:25')",
+            "2016-05-24 12:42:25", "TIMESTAMP(0) NOT NULL"));
+    MONTH_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s + ", 3, cast(null as timestamp))",
+            isNullValue(), "TIMESTAMP(0)"));
 
     // TIMESTAMPADD with DATE; returns a TIMESTAMP value for sub-day intervals.
-    f.checkScalar("timestampadd(MONTH, 1, date '2016-06-15')",
-        "2016-07-15", "DATE NOT NULL");
-    f.checkScalar("timestampadd(DAY, 1, date '2016-06-15')",
-        "2016-06-16", "DATE NOT NULL");
-    f.checkScalar("timestampadd(HOUR, -1, date '2016-06-15')",
-        "2016-06-14 23:00:00", "TIMESTAMP(0) NOT NULL");
-    f.checkScalar("timestampadd(MINUTE, 1, date '2016-06-15')",
-        "2016-06-15 00:01:00", "TIMESTAMP(0) NOT NULL");
-    f.checkScalar("timestampadd(SQL_TSI_SECOND, -1, date '2016-06-15')",
-        "2016-06-14 23:59:59", "TIMESTAMP(0) NOT NULL");
-    f.checkScalar("timestampadd(SECOND, 1, date '2016-06-15')",
-        "2016-06-15 00:00:01", "TIMESTAMP(0) NOT NULL");
-    f.checkScalar("timestampadd(SECOND, 1, cast(null as date))",
-        isNullValue(), "TIMESTAMP(0)");
-    f.checkScalar("timestampadd(DAY, 1, cast(null as date))",
-        isNullValue(), "DATE");
+    MONTH_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s + ", 1, date '2016-06-15')",
+            "2016-07-15", "DATE NOT NULL"));
+    DAY_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s + ", 1, date '2016-06-15')",
+            "2016-06-16", "DATE NOT NULL"));
+    HOUR_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s + ", -1, date '2016-06-15')",
+            "2016-06-14 23:00:00", "TIMESTAMP(0) NOT NULL"));
+    MINUTE_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s + ", 1, date '2016-06-15')",
+            "2016-06-15 00:01:00", "TIMESTAMP(0) NOT NULL"));
+    SECOND_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s + ", -1, date '2016-06-15')",
+            "2016-06-14 23:59:59", "TIMESTAMP(0) NOT NULL"));
+    SECOND_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s + ", 1, date '2016-06-15')",
+            "2016-06-15 00:00:01", "TIMESTAMP(0) NOT NULL"));
+    SECOND_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s + ", 1, cast(null as date))",
+            isNullValue(), "TIMESTAMP(0)"));
+    DAY_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s + ", 1, cast(null as date))",
+            isNullValue(), "DATE"));
 
     // Round to the last day of previous month
-    f.checkScalar("timestampadd(MONTH, 1, date '2016-05-31')",
-        "2016-06-30", "DATE NOT NULL");
-    f.checkScalar("timestampadd(MONTH, 5, date '2016-01-31')",
-        "2016-06-30", "DATE NOT NULL");
-    f.checkScalar("timestampadd(MONTH, -1, date '2016-03-31')",
-        "2016-02-29", "DATE NOT NULL");
+    MONTH_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s + ", 1, date '2016-05-31')",
+            "2016-06-30", "DATE NOT NULL"));
+    MONTH_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s + ", 5, date '2016-01-31')",
+            "2016-06-30", "DATE NOT NULL"));
+    MONTH_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s + ", -1, date '2016-03-31')",
+            "2016-02-29", "DATE NOT NULL"));
 
     // TIMESTAMPADD with time; returns a time value.The interval is positive.
-    f.checkScalar("timestampadd(SECOND, 1, time '23:59:59')",
-        "00:00:00", "TIME(0) NOT NULL");
-    f.checkScalar("timestampadd(MINUTE, 1, time '00:00:00')",
-        "00:01:00", "TIME(0) NOT NULL");
-    f.checkScalar("timestampadd(MINUTE, 1, time '23:59:59')",
-        "00:00:59", "TIME(0) NOT NULL");
-    f.checkScalar("timestampadd(HOUR, 1, time '23:59:59')",
-        "00:59:59", "TIME(0) NOT NULL");
-    f.checkScalar("timestampadd(DAY, 15, time '23:59:59')",
-        "23:59:59", "TIME(0) NOT NULL");
-    f.checkScalar("timestampadd(WEEK, 3, time '23:59:59')",
-        "23:59:59", "TIME(0) NOT NULL");
-    f.checkScalar("timestampadd(MONTH, 6, time '23:59:59')",
-        "23:59:59", "TIME(0) NOT NULL");
-    f.checkScalar("timestampadd(QUARTER, 1, time '23:59:59')",
-        "23:59:59", "TIME(0) NOT NULL");
-    f.checkScalar("timestampadd(YEAR, 10, time '23:59:59')",
-        "23:59:59", "TIME(0) NOT NULL");
+    SECOND_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s + ", 1, time '23:59:59')",
+            "00:00:00", "TIME(0) NOT NULL"));
+    MINUTE_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s + ", 1, time '00:00:00')",
+            "00:01:00", "TIME(0) NOT NULL"));
+    MINUTE_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s + ", 1, time '23:59:59')",
+            "00:00:59", "TIME(0) NOT NULL"));
+    HOUR_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s + ", 1, time '23:59:59')",
+            "00:59:59", "TIME(0) NOT NULL"));
+    DAY_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s + ", 15, time '23:59:59')",
+            "23:59:59", "TIME(0) NOT NULL"));
+    WEEK_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s + ", 3, time '23:59:59')",
+            "23:59:59", "TIME(0) NOT NULL"));
+    MONTH_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s + ", 6, time '23:59:59')",
+            "23:59:59", "TIME(0) NOT NULL"));
+    QUARTER_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s + ", 1, time '23:59:59')",
+            "23:59:59", "TIME(0) NOT NULL"));
+    YEAR_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s + ", 10, time '23:59:59')",
+            "23:59:59", "TIME(0) NOT NULL"));
     // TIMESTAMPADD with time; returns a time value .The interval is negative.
-    f.checkScalar("timestampadd(SECOND, -1, time '00:00:00')",
-        "23:59:59", "TIME(0) NOT NULL");
-    f.checkScalar("timestampadd(MINUTE, -1, time '00:00:00')",
-        "23:59:00", "TIME(0) NOT NULL");
-    f.checkScalar("timestampadd(HOUR, -1, time '00:00:00')",
-        "23:00:00", "TIME(0) NOT NULL");
-    f.checkScalar("timestampadd(DAY, -1, time '23:59:59')",
-        "23:59:59", "TIME(0) NOT NULL");
-    f.checkScalar("timestampadd(WEEK, -1, time '23:59:59')",
-        "23:59:59", "TIME(0) NOT NULL");
-    f.checkScalar("timestampadd(MONTH, -1, time '23:59:59')",
-        "23:59:59", "TIME(0) NOT NULL");
-    f.checkScalar("timestampadd(QUARTER, -1, time '23:59:59')",
-        "23:59:59", "TIME(0) NOT NULL");
-    f.checkScalar("timestampadd(YEAR, -1, time '23:59:59')",
-        "23:59:59", "TIME(0) NOT NULL");
+    SECOND_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s + ", -1, time '00:00:00')",
+            "23:59:59", "TIME(0) NOT NULL"));
+    MINUTE_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s + ", -1, time '00:00:00')",
+            "23:59:00", "TIME(0) NOT NULL"));
+    HOUR_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s + ", -1, time '00:00:00')",
+            "23:00:00", "TIME(0) NOT NULL"));
+    DAY_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s + ", -1, time '23:59:59')",
+            "23:59:59", "TIME(0) NOT NULL"));
+    WEEK_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s + ", -1, time '23:59:59')",
+            "23:59:59", "TIME(0) NOT NULL"));
+    MONTH_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s + ", -1, time '23:59:59')",
+            "23:59:59", "TIME(0) NOT NULL"));
+    QUARTER_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s + ", -1, time '23:59:59')",
+            "23:59:59", "TIME(0) NOT NULL"));
+    YEAR_VARIANTS.forEach(s ->
+        f.checkScalar("timestampadd(" + s + ", -1, time '23:59:59')",
+            "23:59:59", "TIME(0) NOT NULL"));
   }
 
   @Test void testTimestampAddFractionalSeconds() {
@@ -7476,83 +8111,933 @@ void checkArrayConcatAggFuncFails(SqlOperatorFixture t) {
         "TIMESTAMP(3) NOT NULL");
   }
 
-  @Test void testTimestampDiff() {
-    final SqlOperatorFixture f = fixture();
+  /** Tests {@code TIMESTAMP_ADD}, BigQuery's 2-argument variant of the
+   * 3-argument {@code TIMESTAMPADD} function. */
+  @Test void testTimestampAdd2() {
+    final SqlOperatorFixture f0 = fixture()
+        .setFor(SqlLibraryOperators.TIMESTAMP_ADD2);
+    f0.checkFails("^timestamp_add(timestamp '2008-12-25 15:30:00', "
+            + "interval 5 minute)^",
+        "No match found for function signature "
+            + "TIMESTAMP_ADD\\(<TIMESTAMP>, <INTERVAL_DAY_TIME>\\)", false);
+
+    final SqlOperatorFixture f = f0.withLibrary(SqlLibrary.BIG_QUERY);
+    if (Bug.CALCITE_5422_FIXED) {
+      f.checkScalar("timestamp_add(timestamp '2008-12-25 15:30:00', "
+              + "interval 100000000000 microsecond)",
+          "2008-12-26 19:16:40",
+          "TIMESTAMP(3) NOT NULL");
+      f.checkScalar("timestamp_add(timestamp '2008-12-25 15:30:00', "
+              + "interval 100000000 millisecond)",
+          "2008-12-26 19:16:40",
+          "TIMESTAMP(3) NOT NULL");
+    }
+
+    f.checkScalar("timestamp_add(timestamp '2016-02-24 12:42:25', interval 2 second)",
+        "2016-02-24 12:42:27",
+        "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("timestamp_add(timestamp '2016-02-24 12:42:25', interval 2 minute)",
+        "2016-02-24 12:44:25",
+        "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("timestamp_add(timestamp '2016-02-24 12:42:25', interval -2000 hour)",
+        "2015-12-03 04:42:25",
+        "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("timestamp_add(timestamp '2016-02-24 12:42:25', interval 1 day)",
+        "2016-02-25 12:42:25",
+        "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("timestamp_add(timestamp '2016-02-24 12:42:25', interval 1 month)",
+        "2016-03-24 12:42:25",
+        "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("timestamp_add(timestamp '2016-02-24 12:42:25', interval 1 year)",
+        "2017-02-24 12:42:25",
+        "TIMESTAMP(0) NOT NULL");
+    f.checkNull("timestamp_add(CAST(NULL AS TIMESTAMP), interval 5 minute)");
+  }
+
+  /** Tests BigQuery's {@code DATETIME_ADD(timestamp, interval)} function.
+   * When Calcite runs in BigQuery mode, {@code DATETIME} is a type alias for
+   * {@code TIMESTAMP} and this function follows the same behavior as
+   * {@code TIMESTAMP_ADD(timestamp, interval)}. The tests below use
+   * {@code TIMESTAMP} values rather than the {@code DATETIME} alias because the
+   * operator fixture does not currently support type aliases. */
+  @Test void testDatetimeAdd() {
+    final SqlOperatorFixture f0 = fixture()
+        .setFor(SqlLibraryOperators.DATETIME_ADD);
+    f0.checkFails("^datetime_add(timestamp '2008-12-25 15:30:00', "
+            + "interval 5 minute)^",
+        "No match found for function signature "
+            + "DATETIME_ADD\\(<TIMESTAMP>, <INTERVAL_DAY_TIME>\\)", false);
+
+    final SqlOperatorFixture f = f0.withLibrary(SqlLibrary.BIG_QUERY);
+    if (Bug.CALCITE_5422_FIXED) {
+      f.checkScalar("datetime_add(timestamp '2008-12-25 15:30:00', "
+              + "interval 100000000000 microsecond)",
+          "2008-12-26 19:16:40",
+          "TIMESTAMP(3) NOT NULL");
+      f.checkScalar("datetime_add(timestamp '2008-12-25 15:30:00', "
+              + "interval 100000000 millisecond)",
+          "2008-12-26 19:16:40",
+          "TIMESTAMP(3) NOT NULL");
+    }
+
+    f.checkScalar("datetime_add(timestamp '2016-02-24 12:42:25', interval 2 second)",
+        "2016-02-24 12:42:27",
+        "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("datetime_add(timestamp '2016-02-24 12:42:25', interval 2 minute)",
+        "2016-02-24 12:44:25",
+        "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("datetime_add(timestamp '2016-02-24 12:42:25', interval -2000 hour)",
+        "2015-12-03 04:42:25",
+        "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("datetime_add(timestamp '2016-02-24 12:42:25', interval 1 day)",
+        "2016-02-25 12:42:25",
+        "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("datetime_add(timestamp '2016-02-24 12:42:25', interval 1 month)",
+        "2016-03-24 12:42:25",
+        "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("datetime_add(timestamp '2016-02-24 12:42:25', interval 1 year)",
+        "2017-02-24 12:42:25",
+        "TIMESTAMP(0) NOT NULL");
+    f.checkNull("datetime_add(CAST(NULL AS TIMESTAMP), interval 5 minute)");
+  }
+
+  /** Tests {@code TIMESTAMP_DIFF}, BigQuery's variant of the
+   * {@code TIMESTAMPDIFF} function, which differs in the ordering
+   * of the parameters and the ordering of the subtraction between
+   * the two timestamps. In {@code TIMESTAMPDIFF} it is (t2 - t1)
+   * while for {@code TIMESTAMP_DIFF} is is (t1 - t2). */
+  @Test void testTimestampDiff3() {
+    final SqlOperatorFixture f0 = fixture()
+        .setFor(SqlLibraryOperators.TIMESTAMP_DIFF3);
+    f0.checkFails("^timestamp_diff(timestamp '2008-12-25 15:30:00', "
+            + "timestamp '2008-12-25 16:30:00', "
+            + "minute)^",
+        "No match found for function signature "
+            + "TIMESTAMP_DIFF\\(<TIMESTAMP>, <TIMESTAMP>, <INTERVAL_DAY_TIME>\\)", false);
+
+    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"));
+  }
+
+  /** Tests BigQuery's {@code DATETIME_DIFF(timestamp, timestamp2, timeUnit)}
+   * function. When Calcite runs in BigQuery mode, {@code DATETIME} is a type
+   * alias for {@code TIMESTAMP} and this function follows the same behavior as
+   * {@code TIMESTAMP_DIFF(timestamp, timestamp2, timeUnit)}. The tests below
+   * use {@code TIMESTAMP} values rather than the {@code DATETIME} alias because
+   * the operator fixture does not currently support type aliases. */
+  @Test void testDatetimeDiff() {
+    final SqlOperatorFixture f0 = fixture()
+        .setFor(SqlLibraryOperators.DATETIME_DIFF);
+    f0.checkFails("^datetime_diff(timestamp '2008-12-25 15:30:00', "
+            + "timestamp '2008-12-25 16:30:00', "
+            + "minute)^",
+        "No match found for function signature "
+            + "DATETIME_DIFF\\(<TIMESTAMP>, <TIMESTAMP>, <INTERVAL_DAY_TIME>\\)", false);
+
+    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"));
+  }
+
+  @ValueSource(booleans = {true, false})
+  @ParameterizedTest(name = "CoercionEnabled: {0}")
+  void testTimestampDiff(boolean coercionEnabled) {
+    final SqlOperatorFixture f = fixture()
+        .withValidatorConfig(c -> c.withTypeCoercionEnabled(coercionEnabled));
     f.setFor(SqlStdOperatorTable.TIMESTAMP_DIFF, VmName.EXPAND);
-    f.checkScalar("timestampdiff(HOUR, "
-        + "timestamp '2016-02-24 12:42:25', "
-        + "timestamp '2016-02-24 15:42:25')",
-        "3", "INTEGER NOT NULL");
-    f.checkScalar("timestampdiff(MICROSECOND, "
-        + "timestamp '2016-02-24 12:42:25', "
-        + "timestamp '2016-02-24 12:42:20')",
-        "-5000000", "INTEGER NOT NULL");
-    f.checkScalar("timestampdiff(SQL_TSI_FRAC_SECOND, "
-        + "timestamp '2016-02-24 12:42:25', "
-        + "timestamp '2016-02-24 12:42:20')",
-        "-5000000000", "BIGINT NOT NULL");
-    f.checkScalar("timestampdiff(NANOSECOND, "
-        + "timestamp '2016-02-24 12:42:25', "
-        + "timestamp '2016-02-24 12:42:20')",
-        "-5000000000", "BIGINT NOT NULL");
-    f.checkScalar("timestampdiff(YEAR, "
-        + "timestamp '2014-02-24 12:42:25', "
-        + "timestamp '2016-02-24 12:42:25')",
-        "2", "INTEGER NOT NULL");
-    f.checkScalar("timestampdiff(WEEK, "
-        + "timestamp '2014-02-24 12:42:25', "
-        + "timestamp '2016-02-24 12:42:25')",
-        "104", "INTEGER NOT NULL");
-    f.checkScalar("timestampdiff(WEEK, "
-        + "timestamp '2014-02-19 12:42:25', "
-        + "timestamp '2016-02-24 12:42:25')",
-        "105", "INTEGER NOT NULL");
-    f.checkScalar("timestampdiff(MONTH, "
-        + "timestamp '2014-02-24 12:42:25', "
-        + "timestamp '2016-02-24 12:42:25')",
-        "24", "INTEGER NOT NULL");
-    f.checkScalar("timestampdiff(MONTH, "
-        + "timestamp '2019-09-01 00:00:00', "
-        + "timestamp '2020-03-01 00:00:00')",
+    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");
-    f.checkScalar("timestampdiff(MONTH, "
-        + "timestamp '2019-09-01 00:00:00', "
-        + "timestamp '2016-08-01 00:00:00')",
-        "-37", "INTEGER NOT NULL");
-    f.checkScalar("timestampdiff(QUARTER, "
-        + "timestamp '2014-02-24 12:42:25', "
-        + "timestamp '2016-02-24 12:42:25')",
-        "8", "INTEGER NOT NULL");
-    f.checkFails("timestampdiff(^CENTURY^, "
-        + "timestamp '2014-02-24 12:42:25', "
-        + "timestamp '2614-02-24 12:42:25')",
-        "(?s)Encountered \"CENTURY\" at .*", false);
-    f.checkScalar("timestampdiff(QUARTER, "
-        + "timestamp '2014-02-24 12:42:25', "
-        + "cast(null as timestamp))",
-        isNullValue(), "INTEGER");
-    f.checkScalar("timestampdiff(QUARTER, "
-        + "cast(null as timestamp), "
-        + "timestamp '2014-02-24 12:42:25')",
-        isNullValue(), "INTEGER");
+    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
-    f.checkScalar("timestampdiff(MONTH, date '2016-03-15', date '2016-06-14')",
-        "2", "INTEGER NOT NULL");
-    f.checkScalar("timestampdiff(MONTH, date '2019-09-01', date '2020-03-01')",
-        "6", "INTEGER NOT NULL");
-    f.checkScalar("timestampdiff(MONTH, date '2019-09-01', date '2016-08-01')",
-        "-37", "INTEGER NOT NULL");
-    f.checkScalar("timestampdiff(DAY, date '2016-06-15', date '2016-06-14')",
-        "-1", "INTEGER NOT NULL");
-    f.checkScalar("timestampdiff(HOUR, date '2016-06-15', date '2016-06-14')",
-        "-24", "INTEGER NOT NULL");
-    f.checkScalar("timestampdiff(MINUTE, date '2016-06-15',  date '2016-06-15')",
-        "0", "INTEGER NOT NULL");
-    f.checkScalar("timestampdiff(SECOND, cast(null as date), date '2016-06-15')",
-        isNullValue(), "INTEGER");
-    f.checkScalar("timestampdiff(DAY, date '2016-06-15', cast(null as date))",
-        isNullValue(), "INTEGER");
+    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() {
+    final SqlOperatorFixture f0 = fixture()
+        .setFor(SqlLibraryOperators.TIMESTAMP_SUB);
+    f0.checkFails("^timestamp_sub(timestamp '2008-12-25 15:30:00', "
+            + "interval 5 minute)^",
+        "No match found for function signature "
+            + "TIMESTAMP_SUB\\(<TIMESTAMP>, <INTERVAL_DAY_TIME>\\)", false);
+
+    final SqlOperatorFixture f = f0.withLibrary(SqlLibrary.BIG_QUERY);
+    if (Bug.CALCITE_5422_FIXED) {
+      f.checkScalar("timestamp_sub(timestamp '2008-12-25 15:30:00', "
+              + "interval 100000000000 microsecond)",
+          "2008-12-24 11:44:20",
+          "TIMESTAMP(3) NOT NULL");
+      f.checkScalar("timestamp_sub(timestamp '2008-12-25 15:30:00', "
+              + "interval 100000000 millisecond)",
+          "2008-12-24 11:44:20",
+          "TIMESTAMP(3) NOT NULL");
+    }
+
+    f.checkScalar("timestamp_sub(timestamp '2016-02-24 12:42:25', interval 2 second)",
+        "2016-02-24 12:42:23",
+        "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("timestamp_sub(timestamp '2016-02-24 12:42:25', interval 2 minute)",
+        "2016-02-24 12:40:25",
+        "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("timestamp_sub(timestamp '2016-02-24 12:42:25', interval 2000 hour)",
+        "2015-12-03 04:42:25",
+        "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("timestamp_sub(timestamp '2016-02-24 12:42:25', interval 1 day)",
+        "2016-02-23 12:42:25",
+        "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("timestamp_sub(timestamp '2016-02-24 12:42:25', interval 2 week)",
+        "2016-02-10 12:42:25",
+        "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("timestamp_sub(timestamp '2016-02-24 12:42:25', interval 2 weeks)",
+        "2016-02-10 12:42:25",
+        "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("timestamp_sub(timestamp '2016-02-24 12:42:25', interval 1 month)",
+        "2016-01-24 12:42:25",
+        "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("timestamp_sub(timestamp '2016-02-24 12:42:25', interval 1 quarter)",
+        "2015-11-24 12:42:25",
+        "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("timestamp_sub(timestamp '2016-02-24 12:42:25', interval 1 quarters)",
+        "2015-11-24 12:42:25",
+        "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("timestamp_sub(timestamp '2016-02-24 12:42:25', interval 1 year)",
+        "2015-02-24 12:42:25",
+        "TIMESTAMP(0) NOT NULL");
+    f.checkNull("timestamp_sub(CAST(NULL AS TIMESTAMP), interval 5 minute)");
+  }
+
+  @Test void testTimeSub() {
+    final SqlOperatorFixture f0 = fixture()
+        .setFor(SqlLibraryOperators.TIME_SUB);
+    f0.checkFails("^time_sub(time '15:30:00', "
+            + "interval 5 minute)^",
+        "No match found for function signature "
+            + "TIME_SUB\\(<TIME>, <INTERVAL_DAY_TIME>\\)", false);
+
+    final SqlOperatorFixture f = f0.withLibrary(SqlLibrary.BIG_QUERY);
+    if (Bug.CALCITE_5422_FIXED) {
+      f.checkScalar("time_sub(time '15:30:00', "
+              + "interval 100000000000 microsecond)",
+          "11:44:20",
+          "TIME(3) NOT NULL");
+      f.checkScalar("time_sub(time '15:30:00', "
+              + "interval 100000000 millisecond)",
+          "11:44:20",
+          "TIME(3) NOT NULL");
+    }
+
+    f.checkScalar("time_sub(time '12:42:25', interval 2 second)",
+        "12:42:23",
+        "TIME(0) NOT NULL");
+    f.checkScalar("time_sub(time '12:42:25', interval 2 minute)",
+        "12:40:25",
+        "TIME(0) NOT NULL");
+    f.checkScalar("time_sub(time '12:42:25', interval 0 minute)",
+        "12:42:25",
+        "TIME(0) NOT NULL");
+    f.checkScalar("time_sub(time '12:42:25', interval 20 hour)",
+        "16:42:25",
+        "TIME(0) NOT NULL");
+    f.checkScalar("time_sub(time '12:34:45', interval -5 second)",
+        "12:34:50",
+        "TIME(0) NOT NULL");
+    f.checkNull("time_sub(CAST(NULL AS TIME), interval 5 minute)");
+  }
+
+  @Test void testDateSub() {
+    final SqlOperatorFixture f0 = fixture()
+        .setFor(SqlLibraryOperators.DATE_SUB);
+    f0.checkFails("^date_sub(date '2008-12-25', "
+            + "interval 5 day)^",
+        "No match found for function signature "
+            + "DATE_SUB\\(<DATE>, <INTERVAL_DAY_TIME>\\)", false);
+
+    final SqlOperatorFixture f = f0.withLibrary(SqlLibrary.BIG_QUERY);
+    f.checkScalar("date_sub(date '2016-02-24', interval 2 day)",
+        "2016-02-22",
+        "DATE NOT NULL");
+    f.checkScalar("date_sub(date '2016-02-24', interval 1 week)",
+        "2016-02-17",
+        "DATE NOT NULL");
+    f.checkScalar("date_sub(date '2016-02-24', interval 2 weeks)",
+        "2016-02-10",
+        "DATE NOT NULL");
+    f.checkScalar("date_sub(date '2020-10-17', interval 0 week)",
+        "2020-10-17",
+        "DATE NOT NULL");
+    f.checkScalar("date_sub(date '2016-02-24', interval 3 month)",
+        "2015-11-24",
+        "DATE NOT NULL");
+    f.checkScalar("date_sub(date '2016-02-24', interval 1 quarter)",
+        "2015-11-24",
+        "DATE NOT NULL");
+    f.checkScalar("date_sub(date '2016-02-24', interval 2 quarters)",
+        "2015-08-24",
+        "DATE NOT NULL");
+    f.checkScalar("date_sub(date '2016-02-24', interval 5 year)",
+        "2011-02-24",
+        "DATE NOT NULL");
+    f.checkNull("date_sub(CAST(NULL AS DATE), interval 5 day)");
+  }
+
+  /** Tests for BigQuery's DATETIME_SUB() function. Because the operator
+   * fixture does not currently support type aliases, TIMESTAMPs are used
+   * in place of DATETIMEs (a Calcite alias of TIMESTAMP) for the function's
+   * first argument. */
+  @Test void testDatetimeSub() {
+    final SqlOperatorFixture f0 = fixture()
+        .setFor(SqlLibraryOperators.DATETIME_SUB);
+    f0.checkFails("^datetime_sub(timestamp '2008-12-25 15:30:00', "
+            + "interval 5 minute)^",
+        "No match found for function signature "
+            + "DATETIME_SUB\\(<TIMESTAMP>, <INTERVAL_DAY_TIME>\\)", false);
+
+    final SqlOperatorFixture f = f0.withLibrary(SqlLibrary.BIG_QUERY);
+    if (Bug.CALCITE_5422_FIXED) {
+      f.checkScalar("datetime_sub(timestamp '2008-12-25 15:30:00', "
+              + "interval 100000000000 microsecond)",
+          "2008-12-24 11:44:20",
+          "TIMESTAMP(3) NOT NULL");
+      f.checkScalar("datetime_sub(timestamp '2008-12-25 15:30:00', "
+              + "interval 100000000 millisecond)",
+          "2008-12-24 11:44:20",
+          "TIMESTAMP(3) NOT NULL");
+    }
+
+    f.checkScalar("datetime_sub(timestamp '2016-02-24 12:42:25', interval 2 second)",
+        "2016-02-24 12:42:23",
+        "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("datetime_sub(timestamp '2016-02-24 12:42:25', interval 2 minute)",
+        "2016-02-24 12:40:25",
+        "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("datetime_sub(timestamp '2016-02-24 12:42:25', interval 2000 hour)",
+        "2015-12-03 04:42:25",
+        "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("datetime_sub(timestamp '2016-02-24 12:42:25', interval 1 day)",
+        "2016-02-23 12:42:25",
+        "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("datetime_sub(timestamp '2016-02-24 12:42:25', interval 1 month)",
+        "2016-01-24 12:42:25",
+        "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("datetime_sub(timestamp '2016-02-24 12:42:25', interval 1 year)",
+        "2015-02-24 12:42:25",
+        "TIMESTAMP(0) NOT NULL");
+    f.checkNull("datetime_sub(CAST(NULL AS TIMESTAMP), interval 5 minute)");
+  }
+
+  /** The {@code DATEDIFF} function is implemented in the Babel parser but not
+   * the Core parser, and therefore gives validation errors. */
+  @Test void testDateDiff() {
+    final SqlOperatorFixture f = fixture()
+        .setFor(SqlLibraryOperators.DATEDIFF);
+    f.checkFails("datediff(^\"MONTH\"^, '2019-09-14',  '2019-09-15')",
+        "(?s)Column 'MONTH' not found in any table",
+        false);
+  }
+
+  /** Tests BigQuery's {@code TIME_ADD}, which adds an interval to a time
+   * expression. */
+  @Test void testTimeAdd() {
+    final SqlOperatorFixture f0 = fixture()
+        .setFor(SqlLibraryOperators.TIME_ADD);
+    f0.checkFails("^time_add(time '15:30:00', interval 5 minute)^",
+        "No match found for function signature TIME_ADD\\(<TIME>, <INTERVAL_DAY_TIME>\\)", false);
+
+    final SqlOperatorFixture f = f0.withLibrary(SqlLibrary.BIG_QUERY);
+    if (Bug.CALCITE_5422_FIXED) {
+      f.checkScalar("time_add(time '15:30:00', interval 5000000 millisecond)",
+          "15:30:05", "TIME(3) NOT NULL");
+      f.checkScalar("time_add(time '15:30:00', interval 5000000000 microsecond)",
+          "15:30:05", "TIME(3) NOT NULL");
+    }
+    f.checkScalar("time_add(time '23:59:59', interval 2 second)",
+        "00:00:01", "TIME(0) NOT NULL");
+    f.checkScalar("time_add(time '23:59:59', interval 86402 second)",
+        "00:00:01", "TIME(0) NOT NULL");
+    f.checkScalar("time_add(time '15:30:00', interval 5 minute)",
+        "15:35:00", "TIME(0) NOT NULL");
+    f.checkScalar("time_add(time '15:30:00', interval 1445 minute)",
+        "15:35:00", "TIME(0) NOT NULL");
+    f.checkScalar("time_add(time '15:30:00', interval 3 hour)",
+        "18:30:00", "TIME(0) NOT NULL");
+    f.checkScalar("time_add(time '15:30:00', interval 27 hour)",
+        "18:30:00", "TIME(0) NOT NULL");
+    f.checkNull("time_add(cast(null as time), interval 5 minute)");
+  }
+
+  @Test void testTimeDiff() {
+    final SqlOperatorFixture f0 = fixture()
+        .setFor(SqlLibraryOperators.TIME_DIFF);
+    f0.checkFails("^time_diff(time '15:30:00', "
+            + "time '16:30:00', "
+            + "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"));
+  }
+
+  @Test void testTimeTrunc() {
+    SqlOperatorFixture nonBigQuery = fixture()
+        .setFor(SqlLibraryOperators.TIME_TRUNC);
+    nonBigQuery.checkFails("^time_trunc(time '15:30:00', hour)^",
+        "No match found for function signature "
+            + "TIME_TRUNC\\(<TIME>, <INTERVAL_DAY_TIME>\\)",
+        false);
+
+    final SqlOperatorFixture f = fixture()
+        .withLibrary(SqlLibrary.BIG_QUERY)
+        .setFor(SqlLibraryOperators.TIME_TRUNC);
+    f.checkFails("time_trunc(time '12:34:56', ^year^)",
+        "'YEAR' is not a valid time frame", false);
+    f.checkFails("^time_trunc(123.45, minute)^",
+        "Cannot apply 'TIME_TRUNC' to arguments of type "
+            + "'TIME_TRUNC\\(<DECIMAL\\(5, 2\\)>, <INTERVAL MINUTE>\\)'\\. "
+            + "Supported form\\(s\\): 'TIME_TRUNC\\(<TIME>, <DATETIME_INTERVAL>\\)'", false);
+    f.checkScalar("time_trunc(time '12:34:56', second)",
+        "12:34:56", "TIME(0) NOT NULL");
+    f.checkScalar("time_trunc(time '12:34:56', minute)",
+        "12:34:00", "TIME(0) NOT NULL");
+    f.checkScalar("time_trunc(time '12:34:56', hour)",
+        "12:00:00", "TIME(0) NOT NULL");
+    f.checkNull("time_trunc(cast(null as time), second)");
+  }
+
+  @Test void testTimestampTrunc() {
+    SqlOperatorFixture nonBigQuery = fixture()
+        .setFor(SqlLibraryOperators.TIMESTAMP_TRUNC);
+    nonBigQuery.checkFails("^timestamp_trunc(timestamp '2012-05-02 15:30:00', hour)^",
+        "No match found for function signature "
+            + "TIMESTAMP_TRUNC\\(<TIMESTAMP>, <INTERVAL_DAY_TIME>\\)",
+        false);
+
+    final SqlOperatorFixture f = fixture()
+        .withLibrary(SqlLibrary.BIG_QUERY)
+        .setFor(SqlLibraryOperators.TIMESTAMP_TRUNC);
+    f.checkFails("^timestamp_trunc(100, hour)^",
+        "Cannot apply 'TIMESTAMP_TRUNC' to arguments of type "
+            + "'TIMESTAMP_TRUNC\\(<INTEGER>, <INTERVAL HOUR>\\)'\\. "
+            + "Supported form\\(s\\): 'TIMESTAMP_TRUNC\\(<TIMESTAMP>, <DATETIME_INTERVAL>\\)'",
+        false);
+    f.checkFails("^timestamp_trunc(100, foo)^",
+        "Cannot apply 'TIMESTAMP_TRUNC' to arguments of type "
+            + "'TIMESTAMP_TRUNC\\(<INTEGER>, <INTERVAL `FOO`>\\)'\\. "
+            + "Supported form\\(s\\): 'TIMESTAMP_TRUNC\\(<TIMESTAMP>, <DATETIME_INTERVAL>\\)'",
+        false);
+
+    f.checkFails("timestamp_trunc(timestamp '2015-02-19 12:34:56.78', ^microsecond^)",
+        "'MICROSECOND' is not a valid time frame", false);
+    f.checkFails("timestamp_trunc(timestamp '2015-02-19 12:34:56.78', ^nanosecond^)",
+        "'NANOSECOND' is not a valid time frame", false);
+    f.checkFails("timestamp_trunc(timestamp '2015-02-19 12:34:56.78', ^millisecond^)",
+        "'MILLISECOND' is not a valid time frame", false);
+    f.checkScalar("timestamp_trunc(timestamp '2015-02-19 12:34:56.78', second)",
+        "2015-02-19 12:34:56", "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("timestamp_trunc(timestamp '2015-02-19 12:34:56', minute)",
+        "2015-02-19 12:34:00", "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("timestamp_trunc(timestamp '2015-02-19 12:34:56', hour)",
+        "2015-02-19 12:00:00", "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("timestamp_trunc(timestamp '2015-02-19 12:34:56', day)",
+        "2015-02-19 00:00:00", "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("timestamp_trunc(timestamp '2015-02-19 12:34:56', week)",
+        "2015-02-15 00:00:00", "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("timestamp_trunc(timestamp '2015-02-19 12:34:56', month)",
+        "2015-02-01 00:00:00", "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("timestamp_trunc(timestamp '2015-02-19 12:34:56', year)",
+        "2015-01-01 00:00:00", "TIMESTAMP(0) NOT NULL");
+  }
+
+  @Test void testDatetimeTrunc() {
+    SqlOperatorFixture nonBigQuery = fixture()
+        .setFor(SqlLibraryOperators.DATETIME_TRUNC);
+    nonBigQuery.checkFails("^datetime_trunc(timestamp '2012-05-02 15:30:00', hour)^",
+        "No match found for function signature "
+            + "DATETIME_TRUNC\\(<TIMESTAMP>, <INTERVAL_DAY_TIME>\\)",
+        false);
+
+    final SqlOperatorFixture f = fixture()
+        .withLibrary(SqlLibrary.BIG_QUERY)
+        .setFor(SqlLibraryOperators.DATETIME_TRUNC);
+    f.checkFails("^datetime_trunc(100, hour)^",
+        "Cannot apply 'DATETIME_TRUNC' to arguments of type "
+            + "'DATETIME_TRUNC\\(<INTEGER>, <INTERVAL HOUR>\\)'\\. "
+            + "Supported form\\(s\\): 'DATETIME_TRUNC\\(<TIMESTAMP>, <DATETIME_INTERVAL>\\)'",
+        false);
+    f.checkFails("^datetime_trunc(100, foo)^",
+        "Cannot apply 'DATETIME_TRUNC' to arguments of type "
+            + "'DATETIME_TRUNC\\(<INTEGER>, <INTERVAL `FOO`>\\)'\\. "
+            + "Supported form\\(s\\): 'DATETIME_TRUNC\\(<TIMESTAMP>, <DATETIME_INTERVAL>\\)'",
+        false);
+
+    f.checkScalar("datetime_trunc(timestamp '2015-02-19 12:34:56.78', second)",
+        "2015-02-19 12:34:56", "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("datetime_trunc(timestamp '2015-02-19 12:34:56', minute)",
+        "2015-02-19 12:34:00", "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("datetime_trunc(timestamp '2015-02-19 12:34:56', hour)",
+        "2015-02-19 12:00:00", "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("datetime_trunc(timestamp '2015-02-19 12:34:56', day)",
+        "2015-02-19 00:00:00", "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("datetime_trunc(timestamp '2015-02-19 12:34:56', week)",
+        "2015-02-15 00:00:00", "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("datetime_trunc(timestamp '2015-02-19 12:34:56', month)",
+        "2015-02-01 00:00:00", "TIMESTAMP(0) NOT NULL");
+    f.checkScalar("datetime_trunc(timestamp '2015-02-19 12:34:56', year)",
+        "2015-01-01 00:00:00", "TIMESTAMP(0) NOT NULL");
+  }
+
+  @Test void testDateTrunc() {
+    final SqlOperatorFixture f = fixture()
+        .withLibrary(SqlLibrary.BIG_QUERY)
+        .setFor(SqlLibraryOperators.DATE_TRUNC);
+    f.checkFails("date_trunc(date '2015-02-19', ^foo^)",
+        "Column 'FOO' not found in any table", false);
+    f.checkScalar("date_trunc(date '2015-02-19', day)",
+        "2015-02-19", "DATE NOT NULL");
+    f.checkScalar("date_trunc(date '2015-02-19', week)",
+        "2015-02-15", "DATE NOT NULL");
+    f.checkScalar("date_trunc(date '2015-02-19', isoweek)",
+        "2015-02-16", "DATE NOT NULL");
+    f.checkScalar("date_trunc(date '2015-02-19', week(sunday))",
+        "2015-02-15", "DATE NOT NULL");
+    f.checkScalar("date_trunc(date '2015-02-19', week(monday))",
+        "2015-02-16", "DATE NOT NULL");
+    f.checkScalar("date_trunc(date '2015-02-19', week(tuesday))",
+        "2015-02-17", "DATE NOT NULL");
+    f.checkScalar("date_trunc(date '2015-02-19', week(wednesday))",
+        "2015-02-18", "DATE NOT NULL");
+    f.checkScalar("date_trunc(date '2015-02-19', week(thursday))",
+        "2015-02-19", "DATE NOT NULL");
+    f.checkScalar("date_trunc(date '2015-02-19', week(friday))",
+        "2015-02-13", "DATE NOT NULL");
+    f.checkScalar("date_trunc(date '2015-02-19', week(saturday))",
+        "2015-02-14", "DATE NOT NULL");
+    f.checkScalar("date_trunc(date '2015-02-19', month)",
+        "2015-02-01", "DATE NOT NULL");
+    f.checkScalar("date_trunc(date '2015-02-19', quarter)",
+        "2015-01-01", "DATE NOT NULL");
+    f.checkScalar("date_trunc(date '2015-02-19', year)",
+        "2015-01-01", "DATE NOT NULL");
+    f.checkScalar("date_trunc(date '2015-02-19', isoyear)",
+        "2014-12-29", "DATE NOT NULL");
+  }
+
+  @Test void testFormatTime() {
+    final SqlOperatorFixture f = fixture()
+        .withLibrary(SqlLibrary.BIG_QUERY)
+        .setFor(SqlLibraryOperators.FORMAT_TIME);
+    f.checkFails("^FORMAT_TIME('%x', timestamp '2008-12-25 15:30:00')^",
+        "Cannot apply 'FORMAT_TIME' to arguments of type "
+            + "'FORMAT_TIME\\(<CHAR\\(2\\)>, <TIMESTAMP\\(0\\)>\\)'\\. "
+            + "Supported form\\(s\\): "
+            + "'FORMAT_TIME\\(<CHARACTER>, <TIME>\\)'",
+        false);
+    f.checkScalar("FORMAT_TIME('%H', TIME '12:34:33')",
+        "12",
+        "VARCHAR(2000) NOT NULL");
+    f.checkScalar("FORMAT_TIME('%R', TIME '12:34:33')",
+        "12:34",
+        "VARCHAR(2000) NOT NULL");
+    f.checkScalar("FORMAT_TIME('The time is %M-%S', TIME '12:34:33')",
+        "The time is 34-33",
+        "VARCHAR(2000) NOT NULL");
+  }
+
+  @Test void testFormatDate() {
+    final SqlOperatorFixture f = fixture()
+        .withLibrary(SqlLibrary.BIG_QUERY)
+        .setFor(SqlLibraryOperators.FORMAT_DATE);
+    f.checkFails("^FORMAT_DATE('%x', 123)^",
+        "Cannot apply 'FORMAT_DATE' to arguments of type "
+            + "'FORMAT_DATE\\(<CHAR\\(2\\)>, <INTEGER>\\)'\\. "
+            + "Supported form\\(s\\): "
+            + "'FORMAT_DATE\\(<CHARACTER>, <DATE>\\)'",
+        false);
+    // Can implicitly cast TIMESTAMP to DATE
+    f.checkScalar("FORMAT_DATE('%x', timestamp '2008-12-25 15:30:00')",
+        "12/25/08",
+        "VARCHAR(2000) NOT NULL");
+    f.checkScalar("FORMAT_DATE('%b-%d-%Y', DATE '2008-12-25')",
+        "Dec-25-2008",
+        "VARCHAR(2000) NOT NULL");
+    f.checkScalar("FORMAT_DATE('%b %Y', DATE '2008-12-25')",
+        "Dec 2008",
+        "VARCHAR(2000) NOT NULL");
+    f.checkScalar("FORMAT_DATE('%x', DATE '2008-12-25')",
+        "12/25/08",
+        "VARCHAR(2000) NOT NULL");
+    f.checkScalar("FORMAT_DATE('The date is: %x', DATE '2008-12-25')",
+        "The date is: 12/25/08",
+        "VARCHAR(2000) NOT NULL");
+  }
+
+  @Test void testFormatTimestamp() {
+    final SqlOperatorFixture f = fixture()
+        .withLibrary(SqlLibrary.BIG_QUERY)
+        .setFor(SqlLibraryOperators.FORMAT_TIMESTAMP);
+    f.checkFails("^FORMAT_TIMESTAMP('%x', 123)^",
+        "Cannot apply 'FORMAT_TIMESTAMP' to arguments of type "
+            + "'FORMAT_TIMESTAMP\\(<CHAR\\(2\\)>, <INTEGER>\\)'\\. "
+            + "Supported form\\(s\\): "
+            + "FORMAT_TIMESTAMP\\(<CHARACTER>, "
+            + "<TIMESTAMP WITH LOCAL TIME ZONE>\\)\n"
+            + "FORMAT_TIMESTAMP\\(<CHARACTER>, "
+            + "<TIMESTAMP WITH LOCAL TIME ZONE>, <CHARACTER>\\)",
+        false);
+    f.checkScalar("FORMAT_TIMESTAMP('%c',"
+            + " TIMESTAMP WITH LOCAL TIME ZONE '2008-12-25 15:30:00')",
+        "Thu Dec 25 15:30:00 2008",
+        "VARCHAR(2000) NOT NULL");
+    f.checkScalar("FORMAT_TIMESTAMP('%b-%d-%Y',"
+            + " TIMESTAMP WITH LOCAL TIME ZONE '2008-12-25 15:30:00')",
+        "Dec-25-2008",
+        "VARCHAR(2000) NOT NULL");
+    f.checkScalar("FORMAT_TIMESTAMP('%b %Y',"
+            + " TIMESTAMP WITH LOCAL TIME ZONE '2008-12-25 15:30:00')",
+        "Dec 2008",
+        "VARCHAR(2000) NOT NULL");
+    f.checkScalar("FORMAT_TIMESTAMP('%x',"
+            + " TIMESTAMP WITH LOCAL TIME ZONE '2008-12-25 15:30:00')",
+        "12/25/08",
+        "VARCHAR(2000) NOT NULL");
+    f.checkScalar("FORMAT_TIMESTAMP('The time is: %R',"
+            + " TIMESTAMP WITH LOCAL TIME ZONE '2008-12-25 15:30:00')",
+        "The time is: 15:30",
+        "VARCHAR(2000) NOT NULL");
+    f.checkScalar("FORMAT_TIMESTAMP('The time is: %R.%E2S',"
+            + " TIMESTAMP WITH LOCAL TIME ZONE '2008-12-25 15:30:00.1235456')",
+        "The time is: 15:30.123",
+        "VARCHAR(2000) NOT NULL");
   }
 
   @Test void testDenseRankFunc() {
@@ -7584,7 +9069,7 @@ void checkArrayConcatAggFuncFails(SqlOperatorFixture t) {
     final SqlOperatorFixture f = fixture();
     f.setFor(SqlStdOperatorTable.PERCENTILE_CONT, VM_FENNEL, VM_JAVA);
     f.checkType("percentile_cont(0.25) within group (order by 1)",
-        "DOUBLE NOT NULL");
+        "INTEGER NOT NULL");
     f.checkFails("percentile_cont(0.25) within group (^order by 'a'^)",
         "Invalid type 'CHAR' in ORDER BY clause of 'PERCENTILE_CONT' function. "
             + "Only NUMERIC types are supported", false);
@@ -7601,7 +9086,7 @@ void checkArrayConcatAggFuncFails(SqlOperatorFixture t) {
     final SqlOperatorFixture f = fixture();
     f.setFor(SqlStdOperatorTable.PERCENTILE_DISC, VM_FENNEL, VM_JAVA);
     f.checkType("percentile_disc(0.25) within group (order by 1)",
-        "DOUBLE NOT NULL");
+        "INTEGER NOT NULL");
     f.checkFails("percentile_disc(0.25) within group (^order by 'a'^)",
         "Invalid type 'CHAR' in ORDER BY clause of 'PERCENTILE_DISC' function. "
             + "Only NUMERIC types are supported", false);
@@ -7713,7 +9198,7 @@ void checkArrayConcatAggFuncFails(SqlOperatorFixture t) {
             "(?s)Cannot apply 'SUM' to arguments of type "
                 + "'SUM\\(<CHAR\\(4\\)>\\)'\\. Supported form\\(s\\): "
                 + "'SUM\\(<NUMERIC>\\)'.*",
-        false);
+            false);
     f.checkType("sum('name')", "DECIMAL(19, 9)");
     f.checkAggType("sum(1)", "INTEGER NOT NULL");
     f.checkAggType("sum(1.2)", "DECIMAL(19, 1) NOT NULL");
@@ -7729,7 +9214,7 @@ void checkArrayConcatAggFuncFails(SqlOperatorFixture t) {
             "(?s)Cannot apply 'SUM' to arguments of type "
                 + "'SUM\\(<VARCHAR\\(2\\)>\\)'\\. Supported form\\(s\\): "
                 + "'SUM\\(<NUMERIC>\\)'.*",
-        false);
+            false);
     f.checkType("sum(cast(null as varchar(2)))", "DECIMAL(19, 9)");
     final String[] values = {"0", "CAST(null AS INTEGER)", "2", "2"};
     f.checkAgg("sum(x)", values, isSingle(4));
@@ -7939,7 +9424,7 @@ void checkArrayConcatAggFuncFails(SqlOperatorFixture t) {
             "(?s)Cannot apply 'STDDEV' to arguments of type "
                 + "'STDDEV\\(<VARCHAR\\(2\\)>\\)'\\. "
                 + "Supported form\\(s\\): 'STDDEV\\(<NUMERIC>\\)'.*",
-        false);
+            false);
     f.checkType("stddev(cast(null as varchar(2)))", "DECIMAL(19, 9)");
     f.checkType("stddev(CAST(NULL AS INTEGER))", "INTEGER");
     f.checkAggType("stddev(DISTINCT 1.5)", "DECIMAL(2, 1) NOT NULL");
@@ -8149,6 +9634,99 @@ void checkArrayConcatAggFuncFails(SqlOperatorFixture t) {
     f.checkAgg("some(x = 2)", values, isSingle("true"));
   }
 
+  /** Test case for
+   * <a href="https://issues.apache.org/jira/browse/CALCITE-5160">[CALCITE-5160]
+   * ANY/SOME, ALL operators should support collection expressions</a>. */
+  @Test void testQuantifyCollectionOperators() {
+    final SqlOperatorFixture f = fixture();
+    QUANTIFY_OPERATORS.forEach(operator -> f.setFor(operator, SqlOperatorFixture.VmName.EXPAND));
+
+    Function2<String, Boolean, Void> checkBoolean = (sql, result) -> {
+      f.checkBoolean(sql.replace("COLLECTION", "ARRAY"), result);
+      f.checkBoolean(sql.replace("COLLECTION", "MULTISET"), result);
+      return null;
+    };
+
+    Function1<String, Void> checkNull = sql -> {
+      f.checkNull(sql.replace("COLLECTION", "ARRAY"));
+      f.checkNull(sql.replace("COLLECTION", "MULTISET"));
+      return null;
+    };
+
+    checkNull.apply("1 = some (COLLECTION[2,3,null])");
+    checkNull.apply("null = some (COLLECTION[1,2,3])");
+    checkNull.apply("null = some (COLLECTION[1,2,null])");
+    checkNull.apply("1 = some (COLLECTION[null,null,null])");
+    checkNull.apply("null = some (COLLECTION[null,null,null])");
+
+    checkBoolean.apply("1 = some (COLLECTION[1,2,null])", true);
+    checkBoolean.apply("3 = some (COLLECTION[1,2])", false);
+
+    checkBoolean.apply("1 <> some (COLLECTION[1])", false);
+    checkBoolean.apply("2 <> some (COLLECTION[1,2,null])", true);
+    checkBoolean.apply("3 <> some (COLLECTION[1,2,null])", true);
+
+    checkBoolean.apply("1 < some (COLLECTION[1,2,null])", true);
+    checkBoolean.apply("0 < some (COLLECTION[1,2,null])", true);
+    checkBoolean.apply("2 < some (COLLECTION[1,2])", false);
+
+    checkBoolean.apply("2 <= some (COLLECTION[1,2,null])", true);
+    checkBoolean.apply("0 <= some (COLLECTION[1,2,null])", true);
+    checkBoolean.apply("3 <= some (COLLECTION[1,2])", false);
+
+    checkBoolean.apply("2 > some (COLLECTION[1,2,null])", true);
+    checkBoolean.apply("3 > some (COLLECTION[1,2,null])", true);
+    checkBoolean.apply("1 > some (COLLECTION[1,2])", false);
+
+    checkBoolean.apply("2 >= some (COLLECTION[1,2,null])", true);
+    checkBoolean.apply("3 >= some (COLLECTION[1,2,null])", true);
+    checkBoolean.apply("0 >= some (COLLECTION[1,2])", false);
+
+    f.check("SELECT 3 = some(x.t) FROM (SELECT ARRAY[1,2,3,null] as t) as x",
+        "BOOLEAN", true);
+    f.check("SELECT 4 = some(x.t) FROM (SELECT ARRAY[1,2,3] as t) as x",
+        "BOOLEAN NOT NULL", false);
+    f.check("SELECT 4 = some(x.t) FROM (SELECT ARRAY[1,2,3,null] as t) as x",
+        "BOOLEAN", isNullValue());
+    f.check("SELECT (SELECT * FROM UNNEST(ARRAY[3]) LIMIT 1) = "
+            + "some(x.t) FROM (SELECT ARRAY[1,2,3,null] as t) as x",
+        "BOOLEAN", true);
+
+
+    checkNull.apply("1 = all (COLLECTION[1,1,null])");
+    checkNull.apply("null = all (COLLECTION[1,2,3])");
+    checkNull.apply("null = all (COLLECTION[1,2,null])");
+    checkNull.apply("1 = all (COLLECTION[null,null,null])");
+    checkNull.apply("null = all (COLLECTION[null,null,null])");
+
+    checkBoolean.apply("1 = all (COLLECTION[1,1])", true);
+    checkBoolean.apply("3 = all (COLLECTION[1,3,null])", false);
+
+    checkBoolean.apply("1 <> all (COLLECTION[2,3,4])", true);
+    checkBoolean.apply("2 <> all (COLLECTION[2,null])", false);
+
+    checkBoolean.apply("1 < all (COLLECTION[2,3,4])", true);
+    checkBoolean.apply("2 < all (COLLECTION[1,2,null])", false);
+
+    checkBoolean.apply("2 <= all (COLLECTION[2,3,4])", true);
+    checkBoolean.apply("1 <= all (COLLECTION[0,1,null])", false);
+
+    checkBoolean.apply("2 > all (COLLECTION[0,1])", true);
+    checkBoolean.apply("3 > all (COLLECTION[1,3,null])", false);
+
+    checkBoolean.apply("2 >= all (COLLECTION[0,1,2])", true);
+    checkBoolean.apply("3 >= all (COLLECTION[3,4,null])", false);
+
+    f.check("SELECT 3 >= all(x.t) FROM (SELECT ARRAY[1,2,3] as t) as x",
+        "BOOLEAN NOT NULL", true);
+    f.check("SELECT 4 = all(x.t) FROM (SELECT ARRAY[1,2,3,null] as t) as x",
+        "BOOLEAN", false);
+    f.check("SELECT 4 = all(x.t) FROM (SELECT ARRAY[4,4,null] as t) as x",
+        "BOOLEAN", isNullValue());
+    f.check("SELECT (SELECT * FROM UNNEST(ARRAY[3]) LIMIT 1) = "
+            + "all(x.t) FROM (SELECT ARRAY[3,3] as t) as x",
+        "BOOLEAN", true);
+  }
 
   @Test void testAnyValueFunc() {
     final SqlOperatorFixture f = fixture();
@@ -8183,7 +9761,7 @@ void checkArrayConcatAggFuncFails(SqlOperatorFixture t) {
     checkBoolAndFunc(f.withLibrary(SqlLibrary.POSTGRESQL));
   }
 
-  void checkBoolAndFunc(SqlOperatorFixture f) {
+  private static void checkBoolAndFunc(SqlOperatorFixture f) {
     f.setFor(SqlLibraryOperators.BOOL_AND, VM_EXPAND);
 
     f.checkFails("bool_and(^*^)", "Unknown identifier '\\*'", false);
@@ -8219,7 +9797,7 @@ void checkBoolAndFunc(SqlOperatorFixture f) {
     checkBoolOrFunc(f.withLibrary(SqlLibrary.POSTGRESQL));
   }
 
-  void checkBoolOrFunc(SqlOperatorFixture f) {
+  private static void checkBoolOrFunc(SqlOperatorFixture f) {
     f.setFor(SqlLibraryOperators.BOOL_OR, VM_EXPAND);
 
     f.checkFails("bool_or(^*^)", "Unknown identifier '\\*'", false);
@@ -8255,7 +9833,7 @@ void checkBoolOrFunc(SqlOperatorFixture f) {
     checkLogicalAndFunc(f.withLibrary(SqlLibrary.BIG_QUERY));
   }
 
-  void checkLogicalAndFunc(SqlOperatorFixture f) {
+  private static void checkLogicalAndFunc(SqlOperatorFixture f) {
     f.setFor(SqlLibraryOperators.LOGICAL_AND, VM_EXPAND);
 
     f.checkFails("logical_and(^*^)", "Unknown identifier '\\*'", false);
@@ -8291,7 +9869,7 @@ void checkLogicalAndFunc(SqlOperatorFixture f) {
     checkLogicalOrFunc(f.withLibrary(SqlLibrary.BIG_QUERY));
   }
 
-  void checkLogicalOrFunc(SqlOperatorFixture f) {
+  private static void checkLogicalOrFunc(SqlOperatorFixture f) {
     f.setFor(SqlLibraryOperators.LOGICAL_OR, VM_EXPAND);
 
     f.checkFails("logical_or(^*^)", "Unknown identifier '\\*'", false);
@@ -8425,6 +10003,24 @@ void checkLogicalOrFunc(SqlOperatorFixture f) {
         isSingle("02"));
   }
 
+  @Test void testArgMin() {
+    final SqlOperatorFixture f0 = fixture().withTester(t -> TESTER);
+    final String[] xValues = {"2", "3", "4", "4", "5", "7"};
+
+    final Consumer<SqlOperatorFixture> consumer = f -> {
+      f.checkAgg("arg_min(mod(x, 3), x)", xValues, isSingle("2"));
+      f.checkAgg("arg_max(mod(x, 3), x)", xValues, isSingle("1"));
+    };
+
+    final Consumer<SqlOperatorFixture> consumer2 = f -> {
+      f.checkAgg("min_by(mod(x, 3), x)", xValues, isSingle("2"));
+      f.checkAgg("max_by(mod(x, 3), x)", xValues, isSingle("1"));
+    };
+
+    consumer.accept(f0);
+    consumer2.accept(f0.withLibrary(SqlLibrary.SPARK));
+  }
+
   /**
    * Tests that CAST fails when given a value just outside the valid range for
    * that type. For example,
@@ -8506,12 +10102,12 @@ void checkLogicalOrFunc(SqlOperatorFixture f) {
           // Casting overlarge string/binary values do not fail -
           // they are truncated. See testCastTruncates().
         } else {
+          // Value outside legal bound should fail at runtime (not
+          // validate time).
+          //
+          // NOTE: Because Java and Fennel calcs give
+          // different errors, the pattern hedges its bets.
           if (Bug.CALCITE_2539_FIXED) {
-            // Value outside legal bound should fail at runtime (not
-            // validate time).
-            //
-            // NOTE: Because Java and Fennel calcs give
-            // different errors, the pattern hedges its bets.
             f.checkFails("CAST(" + literalString + " AS " + type + ")",
                 "(?s).*(Overflow during calculation or cast\\.|Code=22003).*",
                 true);
@@ -8521,8 +10117,9 @@ void checkLogicalOrFunc(SqlOperatorFixture f) {
     }
   }
 
-  @Test void testCastTruncates() {
-    final SqlOperatorFixture f = fixture();
+  @ParameterizedTest
+  @MethodSource("safeParameters")
+  void testCastTruncates(boolean safe, SqlOperatorFixture f) {
     f.setFor(SqlStdOperatorTable.CAST, VmName.EXPAND);
     f.checkScalar("CAST('ABCD' AS CHAR(2))", "AB", "CHAR(2) NOT NULL");
     f.checkScalar("CAST('ABCD' AS VARCHAR(2))", "AB",
@@ -8741,6 +10338,20 @@ private static class ValueOrExceptionResultChecker
    * JDBC connection.
    */
   protected static class TesterImpl extends SqlRuntimeTester {
+    /** Assign a type system object to this thread-local, pass the name of the
+     * field as the {@link CalciteConnectionProperty#TYPE_SYSTEM} property,
+     * and any connection you make in the same thread will use your type
+     * system. */
+    public static final TryThreadLocal<RelDataTypeSystem> THREAD_TYPE_SYSTEM =
+        TryThreadLocal.of(RelDataTypeSystem.DEFAULT);
+
+    private static final Field FIELD =
+        Types.lookupField(TesterImpl.class, "THREAD_TYPE_SYSTEM");
+
+    private static String uri(Field field) {
+      return field.getDeclaringClass().getName() + '#' + field.getName();
+    }
+
     public TesterImpl() {
     }
 
@@ -8749,9 +10360,13 @@ public TesterImpl() {
         SqlTester.ParameterChecker parameterChecker,
         SqlTester.ResultChecker resultChecker) {
       super.check(factory, query, typeChecker, parameterChecker, resultChecker);
+      final RelDataTypeSystem typeSystem =
+          factory.typeSystemTransform.apply(RelDataTypeSystem.DEFAULT);
       final ConnectionFactory connectionFactory =
-          factory.connectionFactory;
-      try (Connection connection = connectionFactory.createConnection();
+          factory.connectionFactory
+              .with(CalciteConnectionProperty.TYPE_SYSTEM, uri(FIELD));
+      try (TryThreadLocal.Memo ignore = THREAD_TYPE_SYSTEM.push(typeSystem);
+           Connection connection = connectionFactory.createConnection();
            Statement statement = connection.createStatement()) {
         final ResultSet resultSet =
             statement.executeQuery(query);
@@ -8795,8 +10410,8 @@ private SqlNode literal(RelDataType type, Object value) {
         return SqlLiteral.createCharString(value.toString(), SqlParserPos.ZERO);
       case TIMESTAMP:
         TimestampString ts = TimestampString.fromMillisSinceEpoch((Long) value);
-        return SqlLiteral.createTimestamp(ts, type.getPrecision(),
-            SqlParserPos.ZERO);
+        return SqlLiteral.createTimestamp(type.getSqlTypeName(), ts,
+            type.getPrecision(), SqlParserPos.ZERO);
       default:
         throw new AssertionError(type);
       }
diff --git a/testkit/src/main/java/org/apache/calcite/test/SqlToRelTestBase.java b/testkit/src/main/java/org/apache/calcite/test/SqlToRelTestBase.java
index 2a5a83444fe..05d5b4efdd8 100644
--- a/testkit/src/main/java/org/apache/calcite/test/SqlToRelTestBase.java
+++ b/testkit/src/main/java/org/apache/calcite/test/SqlToRelTestBase.java
@@ -55,9 +55,12 @@ public SqlToRelFixture fixture() {
     return SqlToRelFixture.DEFAULT;
   }
 
-  /** Sets the SQL statement for a test. */
+  /**
+   * Creates a test context with a SQL query.
+   * Default catalog: {@link org.apache.calcite.test.catalog.MockCatalogReaderSimple#init()}.
+   */
   public final SqlToRelFixture sql(String sql) {
-    return fixture().expression(false).withSql(sql);
+    return fixture().withSql(sql);
   }
 
   public final SqlToRelFixture expr(String sql) {
diff --git a/testkit/src/main/java/org/apache/calcite/test/SqlValidatorFixture.java b/testkit/src/main/java/org/apache/calcite/test/SqlValidatorFixture.java
index e502eab9560..834357f0248 100644
--- a/testkit/src/main/java/org/apache/calcite/test/SqlValidatorFixture.java
+++ b/testkit/src/main/java/org/apache/calcite/test/SqlValidatorFixture.java
@@ -180,13 +180,13 @@ public SqlValidatorFixture withLenientOperatorLookup(boolean lenient) {
     return withValidatorConfig(c -> c.withLenientOperatorLookup(lenient));
   }
 
-  SqlValidatorFixture withWhole(boolean whole) {
+  public SqlValidatorFixture withWhole(boolean whole) {
     Preconditions.checkArgument(sap.cursor < 0);
     final StringAndPos sap = StringAndPos.of("^" + this.sap.sql + "^");
     return new SqlValidatorFixture(tester, factory, sap, expression, whole);
   }
 
-  SqlValidatorFixture ok() {
+  public SqlValidatorFixture ok() {
     tester.assertExceptionIsThrown(factory, toSql(false), null);
     return this;
   }
@@ -194,7 +194,7 @@ SqlValidatorFixture ok() {
   /**
    * Checks that a SQL expression gives a particular error.
    */
-  SqlValidatorFixture fails(String expected) {
+  public SqlValidatorFixture fails(String expected) {
     requireNonNull(expected, "expected");
     tester.assertExceptionIsThrown(factory, toSql(true), expected);
     return this;
@@ -204,7 +204,7 @@ SqlValidatorFixture fails(String expected) {
    * Checks that a SQL expression fails, giving an {@code expected} error,
    * if {@code b} is true, otherwise succeeds.
    */
-  SqlValidatorFixture failsIf(boolean b, String expected) {
+  public SqlValidatorFixture failsIf(boolean b, String expected) {
     if (b) {
       fails(expected);
     } else {
diff --git a/testkit/src/main/java/org/apache/calcite/test/SqlValidatorTestCase.java b/testkit/src/main/java/org/apache/calcite/test/SqlValidatorTestCase.java
index 1b7fb1eac09..3344090cc4f 100644
--- a/testkit/src/main/java/org/apache/calcite/test/SqlValidatorTestCase.java
+++ b/testkit/src/main/java/org/apache/calcite/test/SqlValidatorTestCase.java
@@ -49,7 +49,10 @@ public SqlValidatorFixture fixture() {
     return FIXTURE;
   }
 
-  /** Creates a test context with a SQL query. */
+  /**
+   * Creates a test context with a SQL query.
+   * Default catalog: {@link org.apache.calcite.test.catalog.MockCatalogReaderSimple#init()}.
+   */
   public final SqlValidatorFixture sql(String sql) {
     return fixture().withSql(sql);
   }
diff --git a/testkit/src/main/java/org/apache/calcite/test/catalog/Fixture.java b/testkit/src/main/java/org/apache/calcite/test/catalog/Fixture.java
index 92302c2c7f4..f1e97dc4699 100644
--- a/testkit/src/main/java/org/apache/calcite/test/catalog/Fixture.java
+++ b/testkit/src/main/java/org/apache/calcite/test/catalog/Fixture.java
@@ -68,6 +68,9 @@ final class Fixture extends AbstractFixture {
               .build())
       .kind(StructKind.PEEK_FIELDS_NO_EXPAND)
       .build();
+  final RelDataType singleRecordType = typeFactory.builder()
+      .add("TYPE", varchar10Type)
+      .build();
   final RelDataType abRecordType = typeFactory.builder()
       .add("A", varchar10Type)
       .add("B", varchar10Type)
@@ -85,40 +88,46 @@ final class Fixture extends AbstractFixture {
       .kind(StructKind.PEEK_FIELDS)
       .build();
   final RelDataType empListType = array(empRecordType);
-  final ObjectSqlType addressType = new ObjectSqlType(SqlTypeName.STRUCTURED,
-      new SqlIdentifier("ADDRESS", SqlParserPos.ZERO),
-      false,
-      Arrays.asList(
-          new RelDataTypeFieldImpl("STREET", 0, varchar20Type),
-          new RelDataTypeFieldImpl("CITY", 1, varchar20Type),
-          new RelDataTypeFieldImpl("ZIP", 2, intType),
-          new RelDataTypeFieldImpl("STATE", 3, varchar20Type)),
-      RelDataTypeComparability.NONE);
+  final ObjectSqlType addressType =
+      new ObjectSqlType(SqlTypeName.STRUCTURED,
+          new SqlIdentifier("ADDRESS", SqlParserPos.ZERO),
+          false,
+          Arrays.asList(new RelDataTypeFieldImpl("STREET", 0, varchar20Type),
+              new RelDataTypeFieldImpl("CITY", 1, varchar20Type),
+              new RelDataTypeFieldImpl("ZIP", 2, intType),
+              new RelDataTypeFieldImpl("STATE", 3, varchar20Type)),
+          RelDataTypeComparability.NONE);
   // Row(f0 int, f1 varchar)
-  final RelDataType recordType1 = typeFactory.createStructType(
-      Arrays.asList(intType, varcharType),
-      Arrays.asList("f0", "f1"));
+  final RelDataType recordType1 =
+      typeFactory.createStructType(Arrays.asList(intType, varcharType),
+          Arrays.asList("f0", "f1"));
   // Row(f0 int not null, f1 varchar null)
-  final RelDataType recordType2 = typeFactory.createStructType(
-      Arrays.asList(intType, nullable(varcharType)),
-      Arrays.asList("f0", "f1"));
+  final RelDataType recordType2 =
+      typeFactory.createStructType(Arrays.asList(intType, nullable(varcharType)),
+          Arrays.asList("f0", "f1"));
   // Row(f0 Row(ff0 int not null, ff1 varchar null) null, f1 timestamp not null)
-  final RelDataType recordType3 = typeFactory.createStructType(
-      Arrays.asList(
-          nullable(
-              typeFactory.createStructType(Arrays.asList(intType, varcharTypeNull),
-          Arrays.asList("ff0", "ff1"))), timestampType), Arrays.asList("f0", "f1"));
-  // Row(f0 bigint not null, f1 decimal null) array
-  final RelDataType recordType4 = array(
+  final RelDataType recordType3 =
       typeFactory.createStructType(
-      Arrays.asList(bigintType, nullable(decimalType)),
-      Arrays.asList("f0", "f1")));
+          Arrays.asList(
+              nullable(
+                  typeFactory.createStructType(
+                      Arrays.asList(intType, varcharTypeNull),
+                      Arrays.asList("ff0", "ff1"))),
+              timestampType),
+          Arrays.asList("f0", "f1"));
+  // Row(f0 bigint not null, f1 decimal null) array
+  final RelDataType recordType4 =
+      array(
+          typeFactory.createStructType(
+              Arrays.asList(bigintType, nullable(decimalType)),
+              Arrays.asList("f0", "f1")));
   // Row(f0 varchar not null, f1 timestamp null) multiset
-  final RelDataType recordType5 = typeFactory.createMultisetType(
-      typeFactory.createStructType(
-          Arrays.asList(varcharType, timestampTypeNull),
-          Arrays.asList("f0", "f1")),
-      -1);
+  final RelDataType recordType5 =
+      typeFactory.createMultisetType(
+          typeFactory.createStructType(
+              Arrays.asList(varcharType, timestampTypeNull),
+              Arrays.asList("f0", "f1")),
+          -1);
   final RelDataType intArrayType = array(intType);
   final RelDataType varchar5ArrayType = array(varchar5Type);
   final RelDataType intArrayArrayType = array(intArrayType);
@@ -129,12 +138,13 @@ final class Fixture extends AbstractFixture {
   final RelDataType varchar5MultisetArrayType = array(varchar5MultisetType);
   final RelDataType intArrayMultisetType = typeFactory.createMultisetType(intArrayType, -1);
   // Row(f0 int array multiset, f1 varchar(5) array) array multiset
-  final RelDataType rowArrayMultisetType = typeFactory.createMultisetType(
-      array(
-          typeFactory.createStructType(
-          Arrays.asList(intArrayMultisetType, varchar5ArrayType),
-          Arrays.asList("f0", "f1"))),
-      -1);
+  final RelDataType rowArrayMultisetType =
+      typeFactory.createMultisetType(
+          array(
+              typeFactory.createStructType(
+                  Arrays.asList(intArrayMultisetType, varchar5ArrayType),
+                  Arrays.asList("f0", "f1"))),
+          -1);
 
   Fixture(RelDataTypeFactory typeFactory) {
     super(typeFactory);
diff --git a/testkit/src/main/java/org/apache/calcite/test/catalog/MockCatalogReader.java b/testkit/src/main/java/org/apache/calcite/test/catalog/MockCatalogReader.java
index edffe58ec81..fc729703263 100644
--- a/testkit/src/main/java/org/apache/calcite/test/catalog/MockCatalogReader.java
+++ b/testkit/src/main/java/org/apache/calcite/test/catalog/MockCatalogReader.java
@@ -40,6 +40,9 @@
 import org.apache.calcite.rel.logical.LogicalFilter;
 import org.apache.calcite.rel.logical.LogicalProject;
 import org.apache.calcite.rel.logical.LogicalTableScan;
+import org.apache.calcite.rel.metadata.BuiltInMetadata;
+import org.apache.calcite.rel.metadata.MetadataDef;
+import org.apache.calcite.rel.metadata.RelMetadataQuery;
 import org.apache.calcite.rel.type.DynamicRecordTypeImpl;
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeFactory;
@@ -86,6 +89,7 @@
 import org.apache.calcite.util.Util;
 
 import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
@@ -180,8 +184,9 @@ protected void registerTablesWithRollUp(MockSchema schema, Fixture f) {
   protected void registerType(final List<String> names, final RelProtoDataType relProtoDataType) {
     assert names.get(0).equals(DEFAULT_CATALOG);
     final List<String> schemaPath = Util.skipLast(names);
-    final CalciteSchema schema = SqlValidatorUtil.getSchema(rootSchema,
-        schemaPath, SqlNameMatchers.withCaseSensitive(true));
+    final CalciteSchema schema =
+        SqlValidatorUtil.getSchema(rootSchema,
+            schemaPath, SqlNameMatchers.withCaseSensitive(true));
     schema.add(Util.last(names), relProtoDataType);
   }
 
@@ -209,8 +214,9 @@ void reregisterTable(MockDynamicTable table) {
     assert names.get(0).equals(DEFAULT_CATALOG);
     List<String> schemaPath = Util.skipLast(names);
     String tableName = Util.last(names);
-    CalciteSchema schema = SqlValidatorUtil.getSchema(rootSchema,
-        schemaPath, SqlNameMatchers.withCaseSensitive(true));
+    CalciteSchema schema =
+        SqlValidatorUtil.getSchema(rootSchema,
+            schemaPath, SqlNameMatchers.withCaseSensitive(true));
     schema.removeTable(tableName);
     schema.add(tableName, table);
   }
@@ -219,8 +225,9 @@ private void registerTable(final List<String> names, final Table table) {
     assert names.get(0).equals(DEFAULT_CATALOG);
     final List<String> schemaPath = Util.skipLast(names);
     final String tableName = Util.last(names);
-    final CalciteSchema schema = SqlValidatorUtil.getSchema(rootSchema,
-        schemaPath, SqlNameMatchers.withCaseSensitive(true));
+    final CalciteSchema schema =
+        SqlValidatorUtil.getSchema(rootSchema,
+            schemaPath, SqlNameMatchers.withCaseSensitive(true));
     schema.add(tableName, table);
   }
 
@@ -290,7 +297,9 @@ public String getName() {
    * Mock implementation of
    * {@link org.apache.calcite.prepare.Prepare.PreparingTable}.
    */
-  public static class MockTable extends Prepare.AbstractPreparingTable {
+  public static class MockTable extends Prepare.AbstractPreparingTable
+      implements BuiltInMetadata.MaxRowCount.Handler {
+
     protected final MockCatalogReader catalogReader;
     protected final boolean stream;
     protected final double rowCount;
@@ -302,6 +311,7 @@ public static class MockTable extends Prepare.AbstractPreparingTable {
     protected RelDataType rowType;
     protected List<RelCollation> collationList;
     protected final List<String> names;
+    protected final Double maxRowCount;
     protected final Set<String> monotonicColumnSet = new HashSet<>();
     protected StructKind kind = StructKind.FULLY_QUALIFIED;
     protected final ColumnResolver resolver;
@@ -320,7 +330,16 @@ public MockTable(MockCatalogReader catalogReader, String catalogName,
         InitializerExpressionFactory initializerFactory) {
       this(catalogReader, ImmutableList.of(catalogName, schemaName, name),
           stream, temporal, rowCount, resolver, initializerFactory,
-          ImmutableList.of());
+          ImmutableList.of(), Double.POSITIVE_INFINITY);
+    }
+
+    public MockTable(MockCatalogReader catalogReader, String catalogName,
+        String schemaName, String name, boolean stream, boolean temporal,
+        double rowCount, ColumnResolver resolver,
+        InitializerExpressionFactory initializerFactory, Double maxRowCount) {
+      this(catalogReader, ImmutableList.of(catalogName, schemaName, name),
+          stream, temporal, rowCount, resolver, initializerFactory,
+          ImmutableList.of(), maxRowCount);
     }
 
     public void registerRolledUpColumn(String columnName) {
@@ -330,7 +349,8 @@ public void registerRolledUpColumn(String columnName) {
     private MockTable(MockCatalogReader catalogReader, List<String> names,
         boolean stream, boolean temporal, double rowCount,
         ColumnResolver resolver,
-        InitializerExpressionFactory initializerFactory, List<Object> wraps) {
+        InitializerExpressionFactory initializerFactory, List<Object> wraps,
+        Double maxRowCount) {
       this.catalogReader = catalogReader;
       this.stream = stream;
       this.temporal = temporal;
@@ -339,6 +359,7 @@ private MockTable(MockCatalogReader catalogReader, List<String> names,
       this.resolver = resolver;
       this.initializerFactory = initializerFactory;
       this.wraps = ImmutableList.copyOf(wraps);
+      this.maxRowCount = maxRowCount;
     }
 
     /**
@@ -359,6 +380,7 @@ protected MockTable(MockCatalogReader catalogReader, boolean stream,
       this.names = names;
       this.kind = kind;
       this.resolver = resolver;
+      this.maxRowCount = Double.POSITIVE_INFINITY;
       this.initializerFactory = initializerFactory;
       for (String name : monotonicColumnSet) {
         addMonotonic(name);
@@ -366,13 +388,21 @@ protected MockTable(MockCatalogReader catalogReader, boolean stream,
       this.wraps = ImmutableList.of();
     }
 
-    void addWrap(Object wrap) {
+    public void addWrap(Object wrap) {
       if (wraps instanceof ImmutableList) {
         wraps = new ArrayList<>(wraps);
       }
       wraps.add(wrap);
     }
 
+    @Override public @Nullable Double getMaxRowCount(RelNode r, RelMetadataQuery mq) {
+      return maxRowCount;
+    }
+
+    @Override public MetadataDef<BuiltInMetadata.MaxRowCount> getDef() {
+      return BuiltInMetadata.MaxRowCount.Handler.super.getDef();
+    }
+
     /** Implementation of AbstractModifiableTable. */
     private class ModifiableTable extends AbstractModifiableTable
         implements ExtensibleTable, Wrapper {
@@ -415,10 +445,11 @@ protected ModifiableTable(String tableName) {
       @Override public Table extend(final List<RelDataTypeField> fields) {
         return new ModifiableTable(Util.last(names)) {
           @Override public RelDataType getRowType(RelDataTypeFactory typeFactory) {
-            ImmutableList<RelDataTypeField> allFields = ImmutableList.copyOf(
-                Iterables.concat(
-                    ModifiableTable.this.getRowType(typeFactory).getFieldList(),
-                    fields));
+            ImmutableList<RelDataTypeField> allFields =
+                ImmutableList.copyOf(
+                    Iterables.concat(
+                        ModifiableTable.this.getRowType(typeFactory).getFieldList(),
+                        fields));
             return typeFactory.createStructType(allFields);
           }
         };
@@ -442,7 +473,7 @@ protected ModifiableTable(String tableName) {
 
     @Override protected RelOptTable extend(final Table extendedTable) {
       return new MockTable(catalogReader, names, stream, temporal, rowCount,
-          resolver, initializerFactory, wraps) {
+          resolver, initializerFactory, wraps, maxRowCount) {
         @Override public RelDataType getRowType() {
           return extendedTable.getRowType(catalogReader.typeFactory);
         }
@@ -454,10 +485,15 @@ public static MockTable create(MockCatalogReader catalogReader,
       return create(catalogReader, schema, name, stream, rowCount, null);
     }
 
+    public static MockTable create(MockCatalogReader catalogReader,
+        MockSchema schema, String name, boolean stream, double rowCount, double maxRowCount) {
+      return create(catalogReader, schema, name, stream, rowCount, null, maxRowCount);
+    }
+
     public static MockTable create(MockCatalogReader catalogReader,
         List<String> names, boolean stream, double rowCount) {
       return new MockTable(catalogReader, names, stream, false, rowCount, null,
-          NullInitializerExpressionFactory.INSTANCE, ImmutableList.of());
+          NullInitializerExpressionFactory.INSTANCE, ImmutableList.of(), Double.POSITIVE_INFINITY);
     }
 
     public static MockTable create(MockCatalogReader catalogReader,
@@ -467,6 +503,26 @@ public static MockTable create(MockCatalogReader catalogReader,
           NullInitializerExpressionFactory.INSTANCE, false);
     }
 
+    public static MockTable create(MockCatalogReader catalogReader,
+        MockSchema schema, String name, boolean stream, double rowCount,
+        ColumnResolver resolver, double maxRowCount) {
+      return create(catalogReader, schema, name, stream, rowCount, resolver,
+          NullInitializerExpressionFactory.INSTANCE, false, maxRowCount);
+    }
+
+    public static MockTable create(MockCatalogReader catalogReader,
+        MockSchema schema, String name, boolean stream, double rowCount,
+        ColumnResolver resolver,
+        InitializerExpressionFactory initializerExpressionFactory,
+        boolean temporal, Double maxRowCount) {
+      MockTable table =
+          new MockTable(catalogReader, schema.getCatalogName(), schema.name,
+              name, stream, temporal, rowCount, resolver,
+              initializerExpressionFactory, maxRowCount);
+      schema.addTable(name);
+      return table;
+    }
+
     public static MockTable create(MockCatalogReader catalogReader,
         MockSchema schema, String name, boolean stream, double rowCount,
         ColumnResolver resolver,
@@ -550,8 +606,9 @@ public static MockTable create(MockCatalogReader catalogReader,
     }
 
     public void onRegister(RelDataTypeFactory typeFactory) {
-      rowType = typeFactory.createStructType(kind, Pair.right(columnList),
-          Pair.left(columnList));
+      rowType =
+          typeFactory.createStructType(kind, Pair.right(columnList),
+              Pair.left(columnList));
       collationList = deduceMonotonicity(this);
     }
 
@@ -630,7 +687,7 @@ private MockModifiableViewRelOptTable(MockModifiableViewTable modifiableViewTabl
         InitializerExpressionFactory initializerExpressionFactory) {
       super(catalogReader, ImmutableList.of(catalogName, schemaName, name),
           stream, false, rowCount, resolver, initializerExpressionFactory,
-          ImmutableList.of());
+          ImmutableList.of(), Double.POSITIVE_INFINITY);
       this.modifiableViewTable = modifiableViewTable;
     }
 
@@ -743,7 +800,7 @@ private MockRelViewTable(ViewTable viewTable,
         InitializerExpressionFactory initializerExpressionFactory) {
       super(catalogReader, ImmutableList.of(catalogName, schemaName, name),
           stream, false, rowCount, resolver, initializerExpressionFactory,
-          ImmutableList.of());
+          ImmutableList.of(), Double.POSITIVE_INFINITY);
       this.viewTable = viewTable;
     }
 
@@ -883,11 +940,12 @@ protected abstract RexNode getConstraint(RexBuilder rexBuilder,
     }
 
     @Override public RelNode toRel(ToRelContext context) {
-      RelNode rel = LogicalTableScan.create(context.getCluster(), fromTable,
-          context.getTableHints());
+      RelNode rel =
+          LogicalTableScan.create(context.getCluster(), fromTable,
+              context.getTableHints());
       final RexBuilder rexBuilder = context.getCluster().getRexBuilder();
-      rel = LogicalFilter.create(
-          rel, getConstraint(rexBuilder, rel.getRowType()));
+      rel =
+          LogicalFilter.create(rel, getConstraint(rexBuilder, rel.getRowType()));
       final List<RelDataTypeField> fieldList =
           rel.getRowType().getFieldList();
       final List<Pair<RexNode, String>> projects =
@@ -903,7 +961,8 @@ protected abstract RexNode getConstraint(RexBuilder rexBuilder,
       return LogicalProject.create(rel,
           ImmutableList.of(),
           Pair.left(projects),
-          Pair.right(projects));
+          Pair.right(projects),
+          ImmutableSet.of());
     }
 
     @Override public <T> T unwrap(Class<T> clazz) {
diff --git a/testkit/src/main/java/org/apache/calcite/test/catalog/MockCatalogReaderDynamic.java b/testkit/src/main/java/org/apache/calcite/test/catalog/MockCatalogReaderDynamic.java
index f620b6702f4..5b859e578c8 100644
--- a/testkit/src/main/java/org/apache/calcite/test/catalog/MockCatalogReaderDynamic.java
+++ b/testkit/src/main/java/org/apache/calcite/test/catalog/MockCatalogReaderDynamic.java
@@ -85,16 +85,21 @@ protected MockCatalogReaderDynamic(RelDataTypeFactory typeFactory,
     regionTable.addColumn("R_COMMENT", varcharType);
     registerTable(regionTable);
 
-    List<String> custModifiableViewNames = Arrays.asList(
-        schema.getCatalogName(), schema.getName(), "CUSTOMER_MODIFIABLEVIEW");
-    TableMacro custModifiableViewMacro = MockModifiableViewRelOptTable.viewMacro(rootSchema,
-        "select n_name from SALES.CUSTOMER", custModifiableViewNames.subList(0, 2),
-        Collections.singletonList(custModifiableViewNames.get(2)), true);
-    TranslatableTable empModifiableView = custModifiableViewMacro.apply(Collections.emptyList());
-    MockTable mockCustViewTable = MockRelViewTable.create(
-        (ViewTable) empModifiableView, this,
-        custModifiableViewNames.get(0), custModifiableViewNames.get(1),
-        custModifiableViewNames.get(2), false, 20, null);
+    List<String> custModifiableViewNames =
+        Arrays.asList(schema.getCatalogName(), schema.getName(),
+            "CUSTOMER_MODIFIABLEVIEW");
+    TableMacro custModifiableViewMacro =
+        MockModifiableViewRelOptTable.viewMacro(rootSchema,
+            "select n_name from SALES.CUSTOMER",
+            custModifiableViewNames.subList(0, 2),
+            Collections.singletonList(custModifiableViewNames.get(2)),
+            true);
+    TranslatableTable empModifiableView =
+        custModifiableViewMacro.apply(Collections.emptyList());
+    MockTable mockCustViewTable =
+        MockRelViewTable.create((ViewTable) empModifiableView, this,
+            custModifiableViewNames.get(0), custModifiableViewNames.get(1),
+            custModifiableViewNames.get(2), false, 20, null);
     registerTable(mockCustViewTable);
 
     // re-registers customer table to clear its row type after view registration
diff --git a/testkit/src/main/java/org/apache/calcite/test/catalog/MockCatalogReaderExtended.java b/testkit/src/main/java/org/apache/calcite/test/catalog/MockCatalogReaderExtended.java
index c9890a5915c..e8ef58f84ae 100644
--- a/testkit/src/main/java/org/apache/calcite/test/catalog/MockCatalogReaderExtended.java
+++ b/testkit/src/main/java/org/apache/calcite/test/catalog/MockCatalogReaderExtended.java
@@ -68,60 +68,100 @@ protected MockCatalogReaderExtended(RelDataTypeFactory typeFactory,
   @Override public MockCatalogReaderExtended init() {
     super.init();
 
+    final Fixture f = new Fixture(typeFactory);
     MockSchema salesSchema = new MockSchema("SALES");
     // Same as "EMP_20" except it uses ModifiableViewTable which populates
     // constrained columns with default values on INSERT and has a single constraint on DEPTNO.
-    List<String> empModifiableViewNames = ImmutableList.of(
-        salesSchema.getCatalogName(), salesSchema.getName(), "EMP_MODIFIABLEVIEW");
-    TableMacro empModifiableViewMacro = MockModifiableViewRelOptTable.viewMacro(rootSchema,
-        "select EMPNO, ENAME, JOB, MGR, HIREDATE, SAL, COMM, SLACKER from EMPDEFAULTS"
-            + " where DEPTNO = 20", empModifiableViewNames.subList(0, 2),
-        ImmutableList.of(empModifiableViewNames.get(2)), true);
-    TranslatableTable empModifiableView = empModifiableViewMacro.apply(ImmutableList.of());
-    MockModifiableViewRelOptTable mockEmpViewTable = MockModifiableViewRelOptTable.create(
-        (MockModifiableViewRelOptTable.MockModifiableViewTable) empModifiableView, this,
-        empModifiableViewNames.get(0), empModifiableViewNames.get(1),
-        empModifiableViewNames.get(2), false, 20, null);
+    List<String> empModifiableViewNames =
+        ImmutableList.of(salesSchema.getCatalogName(), salesSchema.getName(),
+            "EMP_MODIFIABLEVIEW");
+    TableMacro empModifiableViewMacro =
+        MockModifiableViewRelOptTable.viewMacro(rootSchema,
+            "select EMPNO, ENAME, JOB, MGR, HIREDATE, SAL, COMM, SLACKER\n"
+                + "from EMPDEFAULTS\n"
+                + "where DEPTNO = 20",
+            empModifiableViewNames.subList(0, 2),
+            ImmutableList.of(empModifiableViewNames.get(2)), true);
+    TranslatableTable empModifiableView =
+        empModifiableViewMacro.apply(ImmutableList.of());
+    MockModifiableViewRelOptTable mockEmpViewTable =
+        MockModifiableViewRelOptTable.create(
+            (MockModifiableViewRelOptTable.MockModifiableViewTable)
+                empModifiableView, this,
+            empModifiableViewNames.get(0), empModifiableViewNames.get(1),
+            empModifiableViewNames.get(2), false, 20, null);
     registerTable(mockEmpViewTable);
 
     // Same as "EMP_MODIFIABLEVIEW" except that all columns are in the view, columns are reordered,
     // and there is an `extra` extended column.
-    List<String> empModifiableViewNames2 = ImmutableList.of(
-        salesSchema.getCatalogName(), salesSchema.getName(), "EMP_MODIFIABLEVIEW2");
-    TableMacro empModifiableViewMacro2 = MockModifiableViewRelOptTable.viewMacro(rootSchema,
-        "select ENAME, EMPNO, JOB, DEPTNO, SLACKER, SAL, EXTRA, HIREDATE, MGR, COMM"
-            + " from EMPDEFAULTS extend (EXTRA boolean)"
-            + " where DEPTNO = 20", empModifiableViewNames2.subList(0, 2),
-        ImmutableList.of(empModifiableViewNames.get(2)), true);
-    TranslatableTable empModifiableView2 = empModifiableViewMacro2.apply(ImmutableList.of());
-    MockModifiableViewRelOptTable mockEmpViewTable2 = MockModifiableViewRelOptTable.create(
-        (MockModifiableViewRelOptTable.MockModifiableViewTable) empModifiableView2, this,
-        empModifiableViewNames2.get(0), empModifiableViewNames2.get(1),
-        empModifiableViewNames2.get(2), false, 20, null);
+    List<String> empModifiableViewNames2 =
+        ImmutableList.of(salesSchema.getCatalogName(), salesSchema.getName(),
+            "EMP_MODIFIABLEVIEW2");
+    TableMacro empModifiableViewMacro2 =
+        MockModifiableViewRelOptTable.viewMacro(rootSchema,
+            "select ENAME, EMPNO, JOB, DEPTNO, SLACKER, SAL, EXTRA, HIREDATE,"
+                + " MGR, COMM\n"
+                + "from EMPDEFAULTS extend (EXTRA boolean)\n"
+                + "where DEPTNO = 20",
+            empModifiableViewNames2.subList(0, 2),
+            ImmutableList.of(empModifiableViewNames.get(2)),
+            true);
+    TranslatableTable empModifiableView2 =
+        empModifiableViewMacro2.apply(ImmutableList.of());
+    MockModifiableViewRelOptTable mockEmpViewTable2 =
+        MockModifiableViewRelOptTable.create(
+            (MockModifiableViewRelOptTable.MockModifiableViewTable)
+                empModifiableView2, this,
+            empModifiableViewNames2.get(0), empModifiableViewNames2.get(1),
+            empModifiableViewNames2.get(2), false, 20, null);
     registerTable(mockEmpViewTable2);
 
     // Same as "EMP_MODIFIABLEVIEW" except that comm is not in the view.
-    List<String> empModifiableViewNames3 = ImmutableList.of(
-        salesSchema.getCatalogName(), salesSchema.getName(), "EMP_MODIFIABLEVIEW3");
-    TableMacro empModifiableViewMacro3 = MockModifiableViewRelOptTable.viewMacro(rootSchema,
-        "select EMPNO, ENAME, JOB, MGR, HIREDATE, SAL, SLACKER from EMPDEFAULTS"
-            + " where DEPTNO = 20", empModifiableViewNames3.subList(0, 2),
-        ImmutableList.of(empModifiableViewNames3.get(2)), true);
-    TranslatableTable empModifiableView3 = empModifiableViewMacro3.apply(ImmutableList.of());
-    MockModifiableViewRelOptTable mockEmpViewTable3 = MockModifiableViewRelOptTable.create(
-        (MockModifiableViewRelOptTable.MockModifiableViewTable) empModifiableView3, this,
-        empModifiableViewNames3.get(0), empModifiableViewNames3.get(1),
-        empModifiableViewNames3.get(2), false, 20, null);
+    List<String> empModifiableViewNames3 =
+        ImmutableList.of(salesSchema.getCatalogName(), salesSchema.getName(),
+            "EMP_MODIFIABLEVIEW3");
+    TableMacro empModifiableViewMacro3 =
+        MockModifiableViewRelOptTable.viewMacro(rootSchema,
+            "select EMPNO, ENAME, JOB, MGR, HIREDATE, SAL, SLACKER\n"
+                + "from EMPDEFAULTS\n"
+                + "where DEPTNO = 20",
+            empModifiableViewNames3.subList(0, 2),
+            ImmutableList.of(empModifiableViewNames3.get(2)),
+            true);
+    TranslatableTable empModifiableView3 =
+        empModifiableViewMacro3.apply(ImmutableList.of());
+    MockModifiableViewRelOptTable mockEmpViewTable3 =
+        MockModifiableViewRelOptTable.create(
+            (MockModifiableViewRelOptTable.MockModifiableViewTable)
+                empModifiableView3, this,
+            empModifiableViewNames3.get(0), empModifiableViewNames3.get(1),
+            empModifiableViewNames3.get(2), false, 20, null);
     registerTable(mockEmpViewTable3);
 
+    // Register "EMPM" table.
+    // Same as "EMP" but with a "COUNT_PLUS_100" measure column.
+    final MockTable empmTable =
+        MockTable.create(this, salesSchema, "EMPM", false, 14);
+    empmTable.addColumn("EMPNO", f.intType, true);
+    empmTable.addColumn("ENAME", f.varchar20Type);
+    empmTable.addColumn("JOB", f.varchar10Type);
+    empmTable.addColumn("MGR", f.intTypeNull);
+    empmTable.addColumn("HIREDATE", f.timestampType);
+    empmTable.addColumn("SAL", f.intType);
+    empmTable.addColumn("COMM", f.intType);
+    empmTable.addColumn("DEPTNO", f.intType);
+    empmTable.addColumn("SLACKER", f.booleanType);
+    empmTable.addColumn("COUNT_PLUS_100",
+        f.typeFactory.createMeasureType(f.intType));
+    registerTable(empmTable);
+
     MockSchema structTypeSchema = new MockSchema("STRUCT");
     registerSchema(structTypeSchema);
-    final Fixture f = new Fixture(typeFactory);
-    final List<CompoundNameColumn> columnsExtended = Arrays.asList(
-        new CompoundNameColumn("", "K0", f.varchar20TypeNull),
-        new CompoundNameColumn("", "C1", f.varchar20TypeNull),
-        new CompoundNameColumn("F0", "C0", f.intType),
-        new CompoundNameColumn("F1", "C1", f.intTypeNull));
+    final List<CompoundNameColumn> columnsExtended =
+        Arrays.asList(new CompoundNameColumn("", "K0", f.varchar20TypeNull),
+            new CompoundNameColumn("", "C1", f.varchar20TypeNull),
+            new CompoundNameColumn("F0", "C0", f.intType),
+            new CompoundNameColumn("F1", "C1", f.intTypeNull));
     final List<CompoundNameColumn> extendedColumns =
         new ArrayList<>(columnsExtended);
     extendedColumns.add(new CompoundNameColumn("F2", "C2", f.varchar20Type));
diff --git a/testkit/src/main/java/org/apache/calcite/test/catalog/MockCatalogReaderSimple.java b/testkit/src/main/java/org/apache/calcite/test/catalog/MockCatalogReaderSimple.java
index 5b69c1e2792..75704b3a084 100644
--- a/testkit/src/main/java/org/apache/calcite/test/catalog/MockCatalogReaderSimple.java
+++ b/testkit/src/main/java/org/apache/calcite/test/catalog/MockCatalogReaderSimple.java
@@ -76,27 +76,7 @@ protected MockCatalogReaderSimple(RelDataTypeFactory typeFactory,
     }
   }
 
-  @Override public MockCatalogReaderSimple init() {
-    final Fixture fixture = new Fixture(typeFactory);
-
-    // Register "SALES" schema.
-    MockSchema salesSchema = new MockSchema("SALES");
-    registerSchema(salesSchema);
-
-    // Register "EMP" table with customer InitializerExpressionFactory
-    // to check whether newDefaultValue method called or not.
-    final InitializerExpressionFactory countingInitializerExpressionFactory =
-        new CountingFactory(ImmutableList.of("DEPTNO"));
-
-    registerType(
-        ImmutableList.of(salesSchema.getCatalogName(), salesSchema.getName(),
-            "customBigInt"),
-        typeFactory -> typeFactory.createSqlType(SqlTypeName.BIGINT));
-
-    // Register "EMP" table.
-    final MockTable empTable =
-        MockTable.create(this, salesSchema, "EMP", false, 14, null,
-            countingInitializerExpressionFactory, false);
+  private void registerTableEmp(MockTable empTable, Fixture fixture) {
     empTable.addColumn("EMPNO", fixture.intType, true);
     empTable.addColumn("ENAME", fixture.varchar20Type);
     empTable.addColumn("JOB", fixture.varchar10Type);
@@ -107,10 +87,9 @@ protected MockCatalogReaderSimple(RelDataTypeFactory typeFactory,
     empTable.addColumn("DEPTNO", fixture.intType);
     empTable.addColumn("SLACKER", fixture.booleanType);
     registerTable(empTable);
+  }
 
-    // Register "EMPNULLABLES" table with nullable columns.
-    final MockTable empNullablesTable =
-        MockTable.create(this, salesSchema, "EMPNULLABLES", false, 14);
+  private void registerTableEmpNullables(MockTable empNullablesTable, Fixture fixture) {
     empNullablesTable.addColumn("EMPNO", fixture.intType, true);
     empNullablesTable.addColumn("ENAME", fixture.varchar20TypeNull);
     empNullablesTable.addColumn("JOB", fixture.varchar10TypeNull);
@@ -121,8 +100,9 @@ protected MockCatalogReaderSimple(RelDataTypeFactory typeFactory,
     empNullablesTable.addColumn("DEPTNO", fixture.intTypeNull);
     empNullablesTable.addColumn("SLACKER", fixture.booleanTypeNull);
     registerTable(empNullablesTable);
+  }
 
-    // Register "EMPDEFAULTS" table with default values for some columns.
+  private void registerTableEmpDefaults(MockSchema salesSchema, Fixture fixture) {
     final MockTable empDefaultsTable =
         MockTable.create(this, salesSchema, "EMPDEFAULTS", false, 14, null,
             new EmpInitializerExpressionFactory(), false);
@@ -136,8 +116,9 @@ protected MockCatalogReaderSimple(RelDataTypeFactory typeFactory,
     empDefaultsTable.addColumn("DEPTNO", fixture.intTypeNull);
     empDefaultsTable.addColumn("SLACKER", fixture.booleanTypeNull);
     registerTable(empDefaultsTable);
+  }
 
-    // Register "EMP_B" table. As "EMP", birth with a "BIRTHDATE" column.
+  private void registerTableEmpB(MockSchema salesSchema, Fixture fixture) {
     final MockTable empBTable =
         MockTable.create(this, salesSchema, "EMP_B", false, 14);
     empBTable.addColumn("EMPNO", fixture.intType, true);
@@ -151,14 +132,23 @@ protected MockCatalogReaderSimple(RelDataTypeFactory typeFactory,
     empBTable.addColumn("SLACKER", fixture.booleanType);
     empBTable.addColumn("BIRTHDATE", fixture.dateType);
     registerTable(empBTable);
+  }
 
-    // Register "DEPT" table.
+  private void registerTableDept(MockSchema salesSchema, Fixture fixture) {
     MockTable deptTable = MockTable.create(this, salesSchema, "DEPT", false, 4);
     deptTable.addColumn("DEPTNO", fixture.intType, true);
     deptTable.addColumn("NAME", fixture.varchar10Type);
     registerTable(deptTable);
+  }
 
-    // Register "DEPT_NESTED" table.
+  private void registerTableDeptSingle(MockSchema salesSchema, Fixture fixture) {
+    MockTable deptSingleTable =
+        MockTable.create(this, salesSchema, "DEPT_SINGLE", false, 4);
+    deptSingleTable.addColumn("SKILL", fixture.singleRecordType);
+    registerTable(deptSingleTable);
+  }
+
+  private void registerTableDeptNested(MockSchema salesSchema, Fixture fixture) {
     MockTable deptNestedTable =
         MockTable.create(this, salesSchema, "DEPT_NESTED", false, 4);
     deptNestedTable.addColumn("DEPTNO", fixture.intType, true);
@@ -166,8 +156,9 @@ protected MockCatalogReaderSimple(RelDataTypeFactory typeFactory,
     deptNestedTable.addColumn("SKILL", fixture.skillRecordType);
     deptNestedTable.addColumn("EMPLOYEES", fixture.empListType);
     registerTable(deptNestedTable);
+  }
 
-    // Register "DEPT_NESTED_EXPANDED" table.
+  private void registerTableDeptNestedExpanded(MockSchema salesSchema, Fixture fixture) {
     MockTable deptNestedExpandedTable =
         MockTable.create(this, salesSchema, "DEPT_NESTED_EXPANDED", false, 4);
     deptNestedExpandedTable.addColumn("DEPTNO", fixture.intType, true);
@@ -176,8 +167,9 @@ protected MockCatalogReaderSimple(RelDataTypeFactory typeFactory,
     deptNestedExpandedTable.addColumn("ADMINS", fixture.varchar5ArrayType);
     deptNestedExpandedTable.addColumn("OFFICES", fixture.rectilinearPeekCoordMultisetType);
     registerTable(deptNestedExpandedTable);
+  }
 
-    // Register "BONUS" table.
+  private void registerTableBonus(MockSchema salesSchema, Fixture fixture) {
     MockTable bonusTable =
         MockTable.create(this, salesSchema, "BONUS", false, 0);
     bonusTable.addColumn("ENAME", fixture.varchar20Type);
@@ -185,16 +177,18 @@ protected MockCatalogReaderSimple(RelDataTypeFactory typeFactory,
     bonusTable.addColumn("SAL", fixture.intType);
     bonusTable.addColumn("COMM", fixture.intType);
     registerTable(bonusTable);
+  }
 
-    // Register "SALGRADE" table.
+  private void registerTableSalgrade(MockSchema salesSchema, Fixture fixture) {
     MockTable salgradeTable =
         MockTable.create(this, salesSchema, "SALGRADE", false, 5);
     salgradeTable.addColumn("GRADE", fixture.intType, true);
     salgradeTable.addColumn("LOSAL", fixture.intType);
     salgradeTable.addColumn("HISAL", fixture.intType);
     registerTable(salgradeTable);
+  }
 
-    // Register "EMP_ADDRESS" table
+  private void registerTableEmpAddress(MockSchema salesSchema, Fixture fixture) {
     MockTable contactAddressTable =
         MockTable.create(this, salesSchema, "EMP_ADDRESS", false, 26);
     contactAddressTable.addColumn("EMPNO", fixture.intType, true);
@@ -202,21 +196,20 @@ protected MockCatalogReaderSimple(RelDataTypeFactory typeFactory,
     contactAddressTable.addColumn("MAILING_ADDRESS", addressType);
     registerTable(contactAddressTable);
 
-    // Register "CUSTOMER" schema.
-    MockSchema customerSchema = new MockSchema("CUSTOMER");
-    registerSchema(customerSchema);
+  }
 
-    // Register "CONTACT" table.
-    MockTable contactTable = MockTable.create(this, customerSchema, "CONTACT",
-        false, 1000);
+  private void registerTableContact(MockSchema customerSchema, Fixture fixture) {
+    MockTable contactTable =
+        MockTable.create(this, customerSchema, "CONTACT", false, 1000);
     contactTable.addColumn("CONTACTNO", fixture.intType);
     contactTable.addColumn("FNAME", fixture.varchar10Type);
     contactTable.addColumn("LNAME", fixture.varchar10Type);
     contactTable.addColumn("EMAIL", fixture.varchar20Type);
     contactTable.addColumn("COORD", fixture.rectilinearCoordType);
     registerTable(contactTable);
+  }
 
-    // Register "CONTACT_PEEK" table. The
+  private void registerTableContactPeek(MockSchema customerSchema, Fixture fixture) {
     MockTable contactPeekTable =
         MockTable.create(this, customerSchema, "CONTACT_PEEK", false, 1000);
     contactPeekTable.addColumn("CONTACTNO", fixture.intType);
@@ -226,68 +219,79 @@ protected MockCatalogReaderSimple(RelDataTypeFactory typeFactory,
     contactPeekTable.addColumn("COORD", fixture.rectilinearPeekCoordType);
     contactPeekTable.addColumn("COORD_NE", fixture.rectilinearPeekNoExpandCoordType);
     registerTable(contactPeekTable);
+  }
 
-    // Register "ACCOUNT" table.
-    MockTable accountTable = MockTable.create(this, customerSchema, "ACCOUNT",
-        false, 457);
+  private void registerTableAccount(MockSchema customerSchema, Fixture fixture) {
+    MockTable accountTable =
+        MockTable.create(this, customerSchema, "ACCOUNT", false, 457);
     accountTable.addColumn("ACCTNO", fixture.intType);
     accountTable.addColumn("TYPE", fixture.varchar20Type);
     accountTable.addColumn("BALANCE", fixture.intType);
     registerTable(accountTable);
+  }
 
-    // Register "ORDERS" stream.
-    MockTable ordersStream = MockTable.create(this, salesSchema, "ORDERS",
-        true, Double.POSITIVE_INFINITY);
+  private void registerTableOrders(MockSchema salesSchema, Fixture fixture) {
+    MockTable ordersStream =
+        MockTable.create(this, salesSchema, "ORDERS", true,
+            Double.POSITIVE_INFINITY);
     ordersStream.addColumn("ROWTIME", fixture.timestampType);
     ordersStream.addMonotonic("ROWTIME");
     ordersStream.addColumn("PRODUCTID", fixture.intType);
     ordersStream.addColumn("ORDERID", fixture.intType);
     registerTable(ordersStream);
+  }
 
-    // Register "SHIPMENTS" stream.
+  private void registerTableShipments(MockSchema salesSchema, Fixture fixture) {
     // "ROWTIME" is not column 0, just to mix things up.
-    MockTable shipmentsStream = MockTable.create(this, salesSchema, "SHIPMENTS",
-        true, Double.POSITIVE_INFINITY);
+    MockTable shipmentsStream =
+        MockTable.create(this, salesSchema, "SHIPMENTS", true,
+            Double.POSITIVE_INFINITY);
     shipmentsStream.addColumn("ORDERID", fixture.intType);
     shipmentsStream.addColumn("ROWTIME", fixture.timestampType);
     shipmentsStream.addMonotonic("ROWTIME");
     registerTable(shipmentsStream);
+  }
 
-    // Register "PRODUCTS" table.
-    MockTable productsTable = MockTable.create(this, salesSchema, "PRODUCTS",
-        false, 200D);
+  private void registerTableProducts(MockSchema salesSchema, Fixture fixture) {
+    MockTable productsTable =
+        MockTable.create(this, salesSchema, "PRODUCTS", false, 200D);
     productsTable.addColumn("PRODUCTID", fixture.intType);
     productsTable.addColumn("NAME", fixture.varchar20Type);
     productsTable.addColumn("SUPPLIERID", fixture.intType);
     registerTable(productsTable);
+  }
 
-    // Register "PRODUCTS_TEMPORAL" table.
+  private void registerTableEmptyProducts(MockSchema salesSchema, Fixture fixture) {
+    MockTable emptyProductsTable =
+        MockTable.create(this, salesSchema, "EMPTY_PRODUCTS", false, 0D, 0D);
+    emptyProductsTable.addColumn("PRODUCTID", fixture.intType);
+    emptyProductsTable.addColumn("NAME", fixture.varchar20Type);
+    emptyProductsTable.addColumn("SUPPLIERID", fixture.intType);
+    registerTable(emptyProductsTable);
+  }
+
+  private void registerTableProductsTemporal(MockSchema salesSchema, Fixture fixture) {
     MockTable productsTemporalTable =
         MockTable.create(this, salesSchema, "PRODUCTS_TEMPORAL", false, 200D,
-        null, NullInitializerExpressionFactory.INSTANCE, true);
+            null, NullInitializerExpressionFactory.INSTANCE, true);
     productsTemporalTable.addColumn("PRODUCTID", fixture.intType);
     productsTemporalTable.addColumn("NAME", fixture.varchar20Type);
     productsTemporalTable.addColumn("SUPPLIERID", fixture.intType);
     productsTemporalTable.addColumn("SYS_START", fixture.timestampType);
     productsTemporalTable.addColumn("SYS_END", fixture.timestampType);
     registerTable(productsTemporalTable);
+  }
 
-    // Register "SUPPLIERS" table.
-    MockTable suppliersTable = MockTable.create(this, salesSchema, "SUPPLIERS",
-        false, 10D);
+  private void registerTableSuppliers(MockSchema salesSchema, Fixture fixture) {
+    MockTable suppliersTable =
+        MockTable.create(this, salesSchema, "SUPPLIERS", false, 10D);
     suppliersTable.addColumn("SUPPLIERID", fixture.intType);
     suppliersTable.addColumn("NAME", fixture.varchar20Type);
     suppliersTable.addColumn("CITY", fixture.intType);
     registerTable(suppliersTable);
+  }
 
-    // Register "EMP_20" and "EMPNULLABLES_20 views.
-    // Same columns as "EMP" amd "EMPNULLABLES",
-    // but "DEPTNO" not visible and set to 20 by default
-    // and "SAL" is visible but must be greater than 1000,
-    // which is the equivalent of:
-    //   SELECT EMPNO, ENAME, JOB, MGR, HIREDATE, SAL, COMM, SLACKER
-    //   FROM EMP
-    //   WHERE DEPTNO = 20 AND SAL > 1000
+  private void registerViewEmp20(MockSchema salesSchema, MockTable empTable, Fixture fixture) {
     final ImmutableIntList m0 = ImmutableIntList.of(0, 1, 2, 3, 4, 5, 6, 8);
     MockTable emp20View =
         new MockViewTable(this, salesSchema.getCatalogName(), salesSchema.getName(),
@@ -299,17 +303,18 @@ protected MockCatalogReaderSimple(RelDataTypeFactory typeFactory,
                 tableRowType.getFieldList().get(7);
             final RelDataTypeField salField =
                 tableRowType.getFieldList().get(5);
-            final List<RexNode> nodes = Arrays.asList(
-                rexBuilder.makeCall(SqlStdOperatorTable.EQUALS,
-                    rexBuilder.makeInputRef(deptnoField.getType(),
-                        deptnoField.getIndex()),
-                    rexBuilder.makeExactLiteral(BigDecimal.valueOf(20L),
-                        deptnoField.getType())),
-                rexBuilder.makeCall(SqlStdOperatorTable.GREATER_THAN,
-                    rexBuilder.makeInputRef(salField.getType(),
-                        salField.getIndex()),
-                    rexBuilder.makeExactLiteral(BigDecimal.valueOf(1000L),
-                        salField.getType())));
+            final List<RexNode> nodes =
+                Arrays.asList(
+                    rexBuilder.makeCall(SqlStdOperatorTable.EQUALS,
+                        rexBuilder.makeInputRef(deptnoField.getType(),
+                            deptnoField.getIndex()),
+                        rexBuilder.makeExactLiteral(BigDecimal.valueOf(20L),
+                            deptnoField.getType())),
+                    rexBuilder.makeCall(SqlStdOperatorTable.GREATER_THAN,
+                        rexBuilder.makeInputRef(salField.getType(),
+                            salField.getIndex()),
+                        rexBuilder.makeExactLiteral(BigDecimal.valueOf(1000L),
+                            salField.getType())));
             return RexUtil.composeConjunction(rexBuilder, nodes);
           }
         };
@@ -323,7 +328,11 @@ protected MockCatalogReaderSimple(RelDataTypeFactory typeFactory,
     emp20View.addColumn("COMM", fixture.intType);
     emp20View.addColumn("SLACKER", fixture.booleanType);
     registerTable(emp20View);
+  }
 
+  private void registerViewEmpNullables20(
+      MockSchema salesSchema, MockTable empNullablesTable, Fixture fixture) {
+    final ImmutableIntList m0 = ImmutableIntList.of(0, 1, 2, 3, 4, 5, 6, 8);
     MockTable empNullables20View =
         new MockViewTable(this, salesSchema.getCatalogName(), salesSchema.getName(),
             "EMPNULLABLES_20", false, 600, empNullablesTable, m0, null,
@@ -334,17 +343,18 @@ protected MockCatalogReaderSimple(RelDataTypeFactory typeFactory,
                 tableRowType.getFieldList().get(7);
             final RelDataTypeField salField =
                 tableRowType.getFieldList().get(5);
-            final List<RexNode> nodes = Arrays.asList(
-                rexBuilder.makeCall(SqlStdOperatorTable.EQUALS,
-                    rexBuilder.makeInputRef(deptnoField.getType(),
-                        deptnoField.getIndex()),
-                    rexBuilder.makeExactLiteral(BigDecimal.valueOf(20L),
-                        deptnoField.getType())),
-                rexBuilder.makeCall(SqlStdOperatorTable.GREATER_THAN,
-                    rexBuilder.makeInputRef(salField.getType(),
-                        salField.getIndex()),
-                    rexBuilder.makeExactLiteral(BigDecimal.valueOf(1000L),
-                        salField.getType())));
+            final List<RexNode> nodes =
+                Arrays.asList(
+                    rexBuilder.makeCall(SqlStdOperatorTable.EQUALS,
+                        rexBuilder.makeInputRef(deptnoField.getType(),
+                            deptnoField.getIndex()),
+                        rexBuilder.makeExactLiteral(BigDecimal.valueOf(20L),
+                            deptnoField.getType())),
+                    rexBuilder.makeCall(SqlStdOperatorTable.GREATER_THAN,
+                        rexBuilder.makeInputRef(salField.getType(),
+                            salField.getIndex()),
+                        rexBuilder.makeExactLiteral(BigDecimal.valueOf(1000L),
+                            salField.getType())));
             return RexUtil.composeConjunction(rexBuilder, nodes);
           }
         };
@@ -358,19 +368,21 @@ protected MockCatalogReaderSimple(RelDataTypeFactory typeFactory,
     empNullables20View.addColumn("COMM", fixture.intTypeNull);
     empNullables20View.addColumn("SLACKER", fixture.booleanTypeNull);
     registerTable(empNullables20View);
+  }
 
+  private void registerStructTypeTables(Fixture fixture) {
     MockSchema structTypeSchema = new MockSchema("STRUCT");
     registerSchema(structTypeSchema);
-    final List<CompoundNameColumn> columns = Arrays.asList(
-        new CompoundNameColumn("", "K0", fixture.varchar20Type),
-        new CompoundNameColumn("", "C1", fixture.varchar20Type),
-        new CompoundNameColumn("F1", "A0", fixture.intType),
-        new CompoundNameColumn("F2", "A0", fixture.booleanType),
-        new CompoundNameColumn("F0", "C0", fixture.intType),
-        new CompoundNameColumn("F1", "C0", fixture.intTypeNull),
-        new CompoundNameColumn("F0", "C1", fixture.intType),
-        new CompoundNameColumn("F1", "C2", fixture.intType),
-        new CompoundNameColumn("F2", "C3", fixture.intType));
+    final List<CompoundNameColumn> columns =
+        Arrays.asList(new CompoundNameColumn("", "K0", fixture.varchar20Type),
+            new CompoundNameColumn("", "C1", fixture.varchar20Type),
+            new CompoundNameColumn("F1", "A0", fixture.intType),
+            new CompoundNameColumn("F2", "A0", fixture.booleanType),
+            new CompoundNameColumn("F0", "C0", fixture.intType),
+            new CompoundNameColumn("F1", "C0", fixture.intTypeNull),
+            new CompoundNameColumn("F0", "C1", fixture.intType),
+            new CompoundNameColumn("F1", "C2", fixture.intType),
+            new CompoundNameColumn("F2", "C3", fixture.intType));
     final CompoundNameColumnResolver structTypeTableResolver =
         new CompoundNameColumnResolver(columns, "F0");
     final MockTable structTypeTable =
@@ -381,16 +393,16 @@ protected MockCatalogReaderSimple(RelDataTypeFactory typeFactory,
     }
     registerTable(structTypeTable);
 
-    final List<CompoundNameColumn> columnsNullable = Arrays.asList(
-        new CompoundNameColumn("", "K0", fixture.varchar20TypeNull),
-        new CompoundNameColumn("", "C1", fixture.varchar20TypeNull),
-        new CompoundNameColumn("F1", "A0", fixture.intTypeNull),
-        new CompoundNameColumn("F2", "A0", fixture.booleanTypeNull),
-        new CompoundNameColumn("F0", "C0", fixture.intTypeNull),
-        new CompoundNameColumn("F1", "C0", fixture.intTypeNull),
-        new CompoundNameColumn("F0", "C1", fixture.intTypeNull),
-        new CompoundNameColumn("F1", "C2", fixture.intType),
-        new CompoundNameColumn("F2", "C3", fixture.intTypeNull));
+    final List<CompoundNameColumn> columnsNullable =
+        Arrays.asList(new CompoundNameColumn("", "K0", fixture.varchar20TypeNull),
+            new CompoundNameColumn("", "C1", fixture.varchar20TypeNull),
+            new CompoundNameColumn("F1", "A0", fixture.intTypeNull),
+            new CompoundNameColumn("F2", "A0", fixture.booleanTypeNull),
+            new CompoundNameColumn("F0", "C0", fixture.intTypeNull),
+            new CompoundNameColumn("F1", "C0", fixture.intTypeNull),
+            new CompoundNameColumn("F0", "C1", fixture.intTypeNull),
+            new CompoundNameColumn("F1", "C2", fixture.intType),
+            new CompoundNameColumn("F2", "C3", fixture.intTypeNull));
     final MockTable structNullableTypeTable =
         MockTable.create(this, structTypeSchema, "T_NULLABLES", false, 100,
             structTypeTableResolver);
@@ -400,12 +412,8 @@ protected MockCatalogReaderSimple(RelDataTypeFactory typeFactory,
     registerTable(structNullableTypeTable);
 
     // Register "STRUCT.T_10" view.
-    // Same columns as "STRUCT.T",
-    // but "F0.C0" is set to 10 by default,
-    // which is the equivalent of:
-    //   SELECT *
-    //   FROM T
-    //   WHERE F0.C0 = 10
+    // Same columns as "STRUCT.T", but "F0.C0" is set to 10 by default, which is the equivalent of:
+    //   SELECT * FROM T WHERE F0.C0 = 10
     // This table uses MockViewTable which does not populate the constrained columns with default
     // values on INSERT.
     final ImmutableIntList m1 = ImmutableIntList.of(0, 1, 2, 3, 4, 5, 6, 7, 8);
@@ -430,8 +438,106 @@ protected MockCatalogReaderSimple(RelDataTypeFactory typeFactory,
       struct10View.addColumn(column.getName(), column.type);
     }
     registerTable(struct10View);
+  }
+
+  @Override public MockCatalogReaderSimple init() {
+    final Fixture fixture = new Fixture(typeFactory);
+
+    // Register "SALES" schema.
+    MockSchema salesSchema = new MockSchema("SALES");
+    registerSchema(salesSchema);
+
+    // Register "EMP" table with customer InitializerExpressionFactory
+    // to check whether newDefaultValue method called or not.
+    final InitializerExpressionFactory countingInitializerExpressionFactory =
+        new CountingFactory(ImmutableList.of("DEPTNO"));
+
+    registerType(
+        ImmutableList.of(salesSchema.getCatalogName(), salesSchema.getName(),
+            "customBigInt"),
+        typeFactory -> typeFactory.createSqlType(SqlTypeName.BIGINT));
+
+    // Register "EMP" table.
+    final MockTable empTable =
+        MockTable.create(this, salesSchema, "EMP", false, 14, null,
+            countingInitializerExpressionFactory, false);
+    registerTableEmp(empTable, fixture);
+
+    // Register "EMPNULLABLES" table with nullable columns.
+    final MockTable empNullablesTable =
+        MockTable.create(this, salesSchema, "EMPNULLABLES", false, 14);
+    registerTableEmpNullables(empNullablesTable, fixture);
+
+    // Register "EMPDEFAULTS" table with default values for some columns.
+    registerTableEmpDefaults(salesSchema, fixture);
+
+    // Register "EMP_B" table. As "EMP", birth with a "BIRTHDATE" column.
+    registerTableEmpB(salesSchema, fixture);
+
+    // Register "DEPT" table.
+    registerTableDept(salesSchema, fixture);
+
+    // Register "DEPT_SINGLE" table.
+    registerTableDeptSingle(salesSchema, fixture);
+
+    // Register "DEPT_NESTED" table.
+    registerTableDeptNested(salesSchema, fixture);
+
+    // Register "DEPT_NESTED_EXPANDED" table.
+    registerTableDeptNestedExpanded(salesSchema, fixture);
+
+    // Register "BONUS" table.
+    registerTableBonus(salesSchema, fixture);
+
+    // Register "SALGRADE" table.
+    registerTableSalgrade(salesSchema, fixture);
+
+    // Register "EMP_ADDRESS" table
+    registerTableEmpAddress(salesSchema, fixture);
+
+    // Register "CUSTOMER" schema.
+    MockSchema customerSchema = new MockSchema("CUSTOMER");
+    registerSchema(customerSchema);
+
+    // Register "CONTACT" table.
+    registerTableContact(customerSchema, fixture);
+
+    // Register "CONTACT_PEEK" table. The
+    registerTableContactPeek(customerSchema, fixture);
+
+    // Register "ACCOUNT" table.
+    registerTableAccount(customerSchema, fixture);
+
+    // Register "ORDERS" stream.
+    registerTableOrders(salesSchema, fixture);
+
+    // Register "SHIPMENTS" stream.
+    registerTableShipments(salesSchema, fixture);
+
+    // Register "PRODUCTS" table.
+    registerTableProducts(salesSchema, fixture);
+
+    // Register "EMPTY_PRODUCTS" table.
+    registerTableEmptyProducts(salesSchema, fixture);
+
+    // Register "PRODUCTS_TEMPORAL" table.
+    registerTableProductsTemporal(salesSchema, fixture);
+
+    // Register "SUPPLIERS" table.
+    registerTableSuppliers(salesSchema, fixture);
+
+    // Register "EMP_20" and "EMPNULLABLES_20 views.
+    // Same columns as "EMP" amd "EMPNULLABLES", but "DEPTNO" not visible and set to 20 by default
+    // and "SAL" is visible but must be greater than 1000, which is the equivalent of:
+    //   SELECT EMPNO, ENAME, JOB, MGR, HIREDATE, SAL, COMM, SLACKER
+    //   FROM EMP WHERE DEPTNO = 20 AND SAL > 1000
+    registerViewEmp20(salesSchema, empTable, fixture);
+
+    registerViewEmpNullables20(salesSchema, empNullablesTable, fixture);
+
+    registerStructTypeTables(fixture);
+
     registerTablesWithRollUp(salesSchema, fixture);
     return this;
-
   }
 }
diff --git a/testkit/src/main/java/org/apache/calcite/util/Smalls.java b/testkit/src/main/java/org/apache/calcite/util/Smalls.java
index fefa324915e..deba6b01059 100644
--- a/testkit/src/main/java/org/apache/calcite/util/Smalls.java
+++ b/testkit/src/main/java/org/apache/calcite/util/Smalls.java
@@ -17,6 +17,7 @@
 package org.apache.calcite.util;
 
 import org.apache.calcite.DataContext;
+import org.apache.calcite.adapter.enumerable.EnumerableTableScan;
 import org.apache.calcite.adapter.java.AbstractQueryableTable;
 import org.apache.calcite.config.CalciteConnectionConfig;
 import org.apache.calcite.linq4j.AbstractEnumerable;
@@ -29,21 +30,30 @@
 import org.apache.calcite.linq4j.function.Deterministic;
 import org.apache.calcite.linq4j.function.Parameter;
 import org.apache.calcite.linq4j.function.SemiStrict;
+import org.apache.calcite.linq4j.tree.Expression;
+import org.apache.calcite.linq4j.tree.Expressions;
+import org.apache.calcite.linq4j.tree.MethodCallExpression;
 import org.apache.calcite.linq4j.tree.Types;
+import org.apache.calcite.plan.RelOptTable;
+import org.apache.calcite.rel.RelNode;
 import org.apache.calcite.rel.externalize.RelJsonReader;
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeFactory;
 import org.apache.calcite.rex.RexLiteral;
 import org.apache.calcite.runtime.SqlFunctions;
 import org.apache.calcite.schema.FunctionContext;
+import org.apache.calcite.schema.FunctionParameter;
 import org.apache.calcite.schema.QueryableTable;
 import org.apache.calcite.schema.ScannableTable;
 import org.apache.calcite.schema.Schema;
 import org.apache.calcite.schema.SchemaPlus;
+import org.apache.calcite.schema.Schemas;
 import org.apache.calcite.schema.Statistic;
 import org.apache.calcite.schema.Statistics;
+import org.apache.calcite.schema.TableMacro;
 import org.apache.calcite.schema.TranslatableTable;
 import org.apache.calcite.schema.impl.AbstractTable;
+import org.apache.calcite.schema.impl.AbstractTableQueryable;
 import org.apache.calcite.schema.impl.ViewTable;
 import org.apache.calcite.sql.SqlCall;
 import org.apache.calcite.sql.SqlNode;
@@ -61,7 +71,10 @@
 import java.sql.Time;
 import java.sql.Timestamp;
 import java.util.AbstractList;
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
@@ -1313,4 +1326,122 @@ public WideProductSale(int prodId, double sale) {
       this.sale0 = sale;
     }
   }
+
+  /**
+   * Implementation of {@link TableMacro} interface with
+   * {@link #apply} method that returns {@link Queryable} table.
+   */
+  public static class SimpleTableMacro implements TableMacro {
+
+    @Override public TranslatableTable apply(List<?> arguments) {
+      return new SimpleTable();
+    }
+
+    @Override public List<FunctionParameter> getParameters() {
+      return Collections.emptyList();
+    }
+  }
+
+  /** Table with columns (A, B). */
+  public static class SimpleTable extends AbstractQueryableTable
+      implements TranslatableTable {
+    private final String[] columnNames = { "A", "B" };
+    private final Class<?>[] columnTypes = { String.class, Integer.class };
+    private final Object[][] rows = new Object[3][];
+
+    public SimpleTable() {
+      super(Object[].class);
+
+      rows[0] = new Object[] { "foo", 5 };
+      rows[1] = new Object[] { "bar", 4 };
+      rows[2] = new Object[] { "foo", 3 };
+    }
+
+    @Override public RelDataType getRowType(RelDataTypeFactory typeFactory) {
+      int columnCount = columnNames.length;
+      final List<Pair<String, RelDataType>> columnDesc =
+          new ArrayList<>(columnCount);
+      for (int i = 0; i < columnCount; i++) {
+        final RelDataType colType = typeFactory
+            .createJavaType(columnTypes[i]);
+        columnDesc.add(Pair.of(columnNames[i], colType));
+      }
+      return typeFactory.createStructType(columnDesc);
+    }
+
+    public Iterator<Object[]> iterator() {
+      return Linq4j.enumeratorIterator(enumerator());
+    }
+
+    public Enumerator<Object[]> enumerator() {
+      return enumeratorImpl(null);
+    }
+
+    @Override public <T> Queryable<T> asQueryable(QueryProvider queryProvider,
+        SchemaPlus schema, String tableName) {
+      return new AbstractTableQueryable<T>(queryProvider, schema, this,
+          tableName) {
+        @Override public Enumerator<T> enumerator() {
+          //noinspection unchecked
+          return (Enumerator<T>) enumeratorImpl(null);
+        }
+      };
+    }
+
+    private Enumerator<Object[]> enumeratorImpl(final int[] fields) {
+      return new Enumerator<Object[]>() {
+        private Object[] current;
+        private final Iterator<Object[]> iterator = Arrays.asList(rows)
+            .iterator();
+
+        @Override public Object[] current() {
+          return current;
+        }
+
+        @Override public boolean moveNext() {
+          if (iterator.hasNext()) {
+            Object[] full = iterator.next();
+            current = fields != null ? convertRow(full) : full;
+            return true;
+          } else {
+            current = null;
+            return false;
+          }
+        }
+
+        @Override public void reset() {
+          throw new UnsupportedOperationException();
+        }
+
+        @Override public void close() {
+          // noop
+        }
+
+        private Object[] convertRow(Object[] full) {
+          final Object[] objects = new Object[fields.length];
+          for (int i = 0; i < fields.length; i++) {
+            objects[i] = full[fields[i]];
+          }
+          return objects;
+        }
+      };
+    }
+
+    @Override public RelNode toRel(
+        RelOptTable.ToRelContext context,
+        RelOptTable relOptTable) {
+      return EnumerableTableScan.create(context.getCluster(), relOptTable);
+    }
+
+    @Override public Expression getExpression(SchemaPlus schema, String tableName, Class clazz) {
+      MethodCallExpression queryableExpression =
+          Expressions.call(Expressions.new_(SimpleTable.class),
+              BuiltInMethod.QUERYABLE_TABLE_AS_QUERYABLE.method,
+              Expressions.constant(null),
+              Schemas.expression(schema),
+              Expressions.constant(tableName));
+      return Expressions.call(queryableExpression,
+          BuiltInMethod.QUERYABLE_AS_ENUMERABLE.method);
+    }
+  }
 }
diff --git a/ubenchmark/src/jmh/java/org/apache/calcite/adapter/enumerable/CodeGenerationBenchmark.java b/ubenchmark/src/jmh/java/org/apache/calcite/adapter/enumerable/CodeGenerationBenchmark.java
index 32d65c8f508..22c745dd8f8 100644
--- a/ubenchmark/src/jmh/java/org/apache/calcite/adapter/enumerable/CodeGenerationBenchmark.java
+++ b/ubenchmark/src/jmh/java/org/apache/calcite/adapter/enumerable/CodeGenerationBenchmark.java
@@ -39,6 +39,7 @@
 import com.google.common.cache.Cache;
 import com.google.common.cache.CacheBuilder;
 
+import org.codehaus.commons.compiler.CompileException;
 import org.codehaus.commons.compiler.CompilerFactoryFactory;
 import org.codehaus.commons.compiler.IClassBodyEvaluator;
 import org.codehaus.commons.compiler.ICompilerFactory;
@@ -61,6 +62,7 @@
 import org.openjdk.jmh.runner.options.Options;
 import org.openjdk.jmh.runner.options.OptionsBuilder;
 
+import java.io.IOException;
 import java.io.StringReader;
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -111,6 +113,8 @@ public static class QueryState {
      */
     PlanInfo[] planInfos;
 
+    ICompilerFactory compilerFactory;
+
     private int currentPlan = 0;
 
     @Setup(Level.Trial)
@@ -182,27 +186,33 @@ public void setup() {
         info.classExpr = relImplementor.implementRoot(plan, EnumerableRel.Prefer.ARRAY);
         info.javaCode =
             Expressions.toString(info.classExpr.memberDeclarations, "\n", false);
-
-        ICompilerFactory compilerFactory;
-        try {
-          compilerFactory = CompilerFactoryFactory.getDefaultCompilerFactory(
-              CodeGenerationBenchmark.class.getClassLoader());
-        } catch (Exception e) {
-          throw new IllegalStateException(
-              "Unable to instantiate java compiler", e);
-        }
-        IClassBodyEvaluator cbe = compilerFactory.newClassBodyEvaluator();
-        cbe.setClassName(info.classExpr.name);
-        cbe.setExtendedClass(Utilities.class);
-        cbe.setImplementedInterfaces(
-            plan.getRowType().getFieldCount() == 1
-                ? new Class[]{Bindable.class, Typed.class}
-                : new Class[]{ArrayBindable.class});
-        cbe.setParentClassLoader(EnumerableInterpretable.class.getClassLoader());
-        info.cbe = cbe;
+        info.plan = plan;
         planInfos[i] = info;
       }
 
+      try {
+        compilerFactory =
+            CompilerFactoryFactory.getDefaultCompilerFactory(
+                CodeGenerationBenchmark.class.getClassLoader());
+      } catch (Exception e) {
+        throw new IllegalStateException(
+            "Unable to instantiate java compiler", e);
+      }
+
+    }
+
+    Bindable compile(EnumerableRel plan, String className, String code)
+        throws CompileException, IOException {
+      final StringReader stringReader = new StringReader(code);
+      IClassBodyEvaluator cbe = compilerFactory.newClassBodyEvaluator();
+      cbe.setClassName(className);
+      cbe.setExtendedClass(Utilities.class);
+      cbe.setImplementedInterfaces(
+          plan.getRowType().getFieldCount() == 1
+              ? new Class[]{Bindable.class, Typed.class}
+              : new Class[]{ArrayBindable.class});
+      cbe.setParentClassLoader(EnumerableInterpretable.class.getClassLoader());
+      return (Bindable) cbe.createInstance(stringReader);
     }
 
     int nextPlan() {
@@ -215,7 +225,7 @@ int nextPlan() {
   /** Plan information. */
   private static class PlanInfo {
     ClassDeclaration classExpr;
-    IClassBodyEvaluator cbe;
+    EnumerableRel plan;
     String javaCode;
   }
 
@@ -246,7 +256,7 @@ public void setup() {
   @Benchmark
   public Bindable<?> getBindableNoCache(QueryState state) throws Exception {
     PlanInfo info = state.planInfos[state.nextPlan()];
-    return (Bindable) info.cbe.createInstance(new StringReader(info.javaCode));
+    return state.compile(info.plan, info.classExpr.name, info.javaCode);
   }
 
   /**
@@ -267,7 +277,7 @@ public Bindable<?> getBindableWithCache(
     if (!detector.containsStaticField) {
       return cache.get(
           info.javaCode,
-          () -> (Bindable) info.cbe.createInstance(new StringReader(info.javaCode)));
+          () -> jState.compile(info.plan, info.classExpr.name, info.javaCode));
     }
     throw new IllegalStateException("Benchmark queries should not arrive here");
   }
diff --git a/ubenchmark/src/jmh/java/org/apache/calcite/benchmarks/MetadataBenchmark.java b/ubenchmark/src/jmh/java/org/apache/calcite/benchmarks/MetadataBenchmark.java
index 46932474fd7..a78c79eb15c 100644
--- a/ubenchmark/src/jmh/java/org/apache/calcite/benchmarks/MetadataBenchmark.java
+++ b/ubenchmark/src/jmh/java/org/apache/calcite/benchmarks/MetadataBenchmark.java
@@ -133,8 +133,7 @@ public void proxying() {
     test(
         () -> new RelMetadataQuery(
             new ProxyingMetadataHandlerProvider(
-        DefaultRelMetadataProvider.INSTANCE
-    )));
+        DefaultRelMetadataProvider.INSTANCE)));
   }
 
 }
diff --git a/ubenchmark/src/jmh/java/org/apache/calcite/benchmarks/RelNodeConversionBenchmark.java b/ubenchmark/src/jmh/java/org/apache/calcite/benchmarks/RelNodeConversionBenchmark.java
index a6efb55ff7d..52613a3fb0c 100644
--- a/ubenchmark/src/jmh/java/org/apache/calcite/benchmarks/RelNodeConversionBenchmark.java
+++ b/ubenchmark/src/jmh/java/org/apache/calcite/benchmarks/RelNodeConversionBenchmark.java
@@ -92,8 +92,7 @@ public void setup(int length, int columnLength) {
             String.format(Locale.ROOT, "c%s / CASE WHEN c%s > %d THEN c%s ELSE c%s END ",
                 String.valueOf(rnd.nextInt(columnLength)), String.valueOf(i % columnLength),
                 rnd.nextInt(columnLength), String.valueOf(rnd.nextInt(columnLength)),
-                String.valueOf(rnd.nextInt(columnLength)))
-        );
+                String.valueOf(rnd.nextInt(columnLength))));
       }
       sb.append(" FROM test1");
       sql = sb.toString();