From ac19b148c2462e29874fdbfc204aacd23dc77434 Mon Sep 17 00:00:00 2001
From: Zoltan Haindrich <kirk@rxd.hu>
Date: Thu, 13 Jun 2024 08:47:50 +0200
Subject: [PATCH] Upgrade calcite to 1.37.0 (#16504)

* contains Make a full copy of the parser and apply our modifications to it #16503
* some minor api changes pair/entry
* some unnecessary aggregation was removed from a set of queries in `CalciteSubqueryTest`
* `AliasedOperatorConversion` was detecting `CHAR_LENGTH` as not a function ; I've removed the check
  * the field it was using doesn't look maintained that much
  * the `kind` is passed for the created `SqlFunction` so I don't think this check is actually needed
* some decoupled test cases become broken - will be fixed later
* some aggregate related changes: due to the fact that SUM() and COUNT() of no inputs are different
* upgrade avatica to 1.25.0
* `CalciteQueryTest#testExactCountDistinctWithFilter` is now executable

Close apache/druid#16503
---
 dev/upgrade-calcite-parser                    |   72 +
 .../druid/msq/sql/MSQTaskQueryMaker.java      |   10 +-
 .../druid/msq/sql/MSQTaskSqlEngine.java       |   28 +-
 .../msq/test/CalciteSelectQueryMSQTest.java   |    8 +
 licenses.yaml                                 |    4 +-
 pom.xml                                       |   10 +-
 processing/src/test/resources/log4j2.xml      |    3 +
 sql/pom.xml                                   |   80 +-
 sql/src/main/codegen/config.fmpp              |    2 -
 sql/src/main/codegen/default_config.fmpp      |  459 +
 sql/src/main/codegen/includes/from.ftl        |  306 -
 sql/src/main/codegen/includes/insert.ftl      |  113 -
 sql/src/main/codegen/templates/Parser.jj      | 9235 +++++++++++++++++
 .../expression/AliasedOperatorConversion.java |    6 -
 .../calcite/parser/DruidSqlParserUtils.java   |    6 +-
 .../druid/sql/calcite/planner/QueryUtils.java |    6 +-
 .../sql/calcite/rel/logical/DruidWindow.java  |    6 +
 .../sql/calcite/run/NativeQueryMaker.java     |   10 +-
 .../calcite/CalciteNestedDataQueryTest.java   |  121 +-
 .../druid/sql/calcite/CalciteQueryTest.java   |  120 +-
 .../sql/calcite/CalciteSelectQueryTest.java   |   13 +-
 .../sql/calcite/CalciteSubqueryTest.java      |  359 +-
 .../druid/sql/calcite/NotYetSupported.java    |    3 +-
 .../parser/DruidSqlParserUtilsTest.java       |   41 +-
 ...ccess@all_disabled@NullHandling=default.iq |   10 +-
 ...ectAccess@all_disabled@NullHandling=sql.iq |   10 +-
 ...Access@all_enabled@NullHandling=default.iq |   10 +-
 ...rectAccess@all_enabled@NullHandling=sql.iq |   10 +-
 ...rectAccess@default@NullHandling=default.iq |   10 +-
 ...ftDirectAccess@default@NullHandling=sql.iq |   10 +-
 ...ue-column_disabled@NullHandling=default.iq |   10 +-
 ...-value-column_disabled@NullHandling=sql.iq |   10 +-
 ...-rewrites-disabled@NullHandling=default.iq |   10 +-
 ...lter-rewrites-disabled@NullHandling=sql.iq |   10 +-
 ...ss@filter-rewrites@NullHandling=default.iq |   10 +-
 ...Access@filter-rewrites@NullHandling=sql.iq |   10 +-
 ...ess@join-to-filter@NullHandling=default.iq |   10 +-
 ...tAccess@join-to-filter@NullHandling=sql.iq |   10 +-
 ...ccess@all_disabled@NullHandling=default.iq |   10 +-
 ...ectAccess@all_disabled@NullHandling=sql.iq |   10 +-
 ...Access@all_enabled@NullHandling=default.iq |   10 +-
 ...rectAccess@all_enabled@NullHandling=sql.iq |   10 +-
 ...rectAccess@default@NullHandling=default.iq |   10 +-
 ...ftDirectAccess@default@NullHandling=sql.iq |   10 +-
 ...ue-column_disabled@NullHandling=default.iq |   10 +-
 ...-value-column_disabled@NullHandling=sql.iq |   10 +-
 ...-rewrites-disabled@NullHandling=default.iq |   10 +-
 ...lter-rewrites-disabled@NullHandling=sql.iq |   10 +-
 ...ss@filter-rewrites@NullHandling=default.iq |   10 +-
 ...Access@filter-rewrites@NullHandling=sql.iq |   10 +-
 ...ess@join-to-filter@NullHandling=default.iq |   10 +-
 ...tAccess@join-to-filter@NullHandling=sql.iq |   10 +-
 ...ccess@all_disabled@NullHandling=default.iq |   10 +-
 ...ectAccess@all_disabled@NullHandling=sql.iq |   10 +-
 ...Access@all_enabled@NullHandling=default.iq |   10 +-
 ...rectAccess@all_enabled@NullHandling=sql.iq |   10 +-
 ...rectAccess@default@NullHandling=default.iq |   10 +-
 ...ftDirectAccess@default@NullHandling=sql.iq |   10 +-
 ...ue-column_disabled@NullHandling=default.iq |   10 +-
 ...-value-column_disabled@NullHandling=sql.iq |   10 +-
 ...-rewrites-disabled@NullHandling=default.iq |   10 +-
 ...lter-rewrites-disabled@NullHandling=sql.iq |   10 +-
 ...ss@filter-rewrites@NullHandling=default.iq |   10 +-
 ...Access@filter-rewrites@NullHandling=sql.iq |   10 +-
 ...ess@join-to-filter@NullHandling=default.iq |   10 +-
 ...tAccess@join-to-filter@NullHandling=sql.iq |   10 +-
 ...ccess@all_disabled@NullHandling=default.iq |   10 +-
 ...ectAccess@all_disabled@NullHandling=sql.iq |   10 +-
 ...Access@all_enabled@NullHandling=default.iq |   10 +-
 ...rectAccess@all_enabled@NullHandling=sql.iq |   10 +-
 ...rectAccess@default@NullHandling=default.iq |   10 +-
 ...ftDirectAccess@default@NullHandling=sql.iq |   10 +-
 ...ue-column_disabled@NullHandling=default.iq |   10 +-
 ...-value-column_disabled@NullHandling=sql.iq |   10 +-
 ...-rewrites-disabled@NullHandling=default.iq |   10 +-
 ...lter-rewrites-disabled@NullHandling=sql.iq |   10 +-
 ...ss@filter-rewrites@NullHandling=default.iq |   10 +-
 ...Access@filter-rewrites@NullHandling=sql.iq |   10 +-
 ...ess@join-to-filter@NullHandling=default.iq |   10 +-
 ...tAccess@join-to-filter@NullHandling=sql.iq |   10 +-
 ...ccess@all_disabled@NullHandling=default.iq |   10 +-
 ...ectAccess@all_disabled@NullHandling=sql.iq |   10 +-
 ...Access@all_enabled@NullHandling=default.iq |   10 +-
 ...rectAccess@all_enabled@NullHandling=sql.iq |   10 +-
 ...rectAccess@default@NullHandling=default.iq |   10 +-
 ...ftDirectAccess@default@NullHandling=sql.iq |   10 +-
 ...ue-column_disabled@NullHandling=default.iq |   10 +-
 ...-value-column_disabled@NullHandling=sql.iq |   10 +-
 ...-rewrites-disabled@NullHandling=default.iq |   10 +-
 ...lter-rewrites-disabled@NullHandling=sql.iq |   10 +-
 ...ss@filter-rewrites@NullHandling=default.iq |   10 +-
 ...Access@filter-rewrites@NullHandling=sql.iq |   10 +-
 ...ess@join-to-filter@NullHandling=default.iq |   10 +-
 ...tAccess@join-to-filter@NullHandling=sql.iq |   10 +-
 ...pByTimeFloorAndDim@NullHandling=default.iq |   16 +-
 ...GroupByTimeFloorAndDim@NullHandling=sql.iq |   18 +-
 ...estGroupByWithLiteralInSubqueryGrouping.iq |    2 +-
 ...ojectDoesNotRename@NullHandling=default.iq |   32 +-
 ...tyProjectDoesNotRename@NullHandling=sql.iq |   30 +-
 99 files changed, 10532 insertions(+), 1287 deletions(-)
 create mode 100755 dev/upgrade-calcite-parser
 create mode 100644 sql/src/main/codegen/default_config.fmpp
 delete mode 100644 sql/src/main/codegen/includes/from.ftl
 delete mode 100644 sql/src/main/codegen/includes/insert.ftl
 create mode 100644 sql/src/main/codegen/templates/Parser.jj

diff --git a/dev/upgrade-calcite-parser b/dev/upgrade-calcite-parser
new file mode 100755
index 000000000000..f311d3ea7381
--- /dev/null
+++ b/dev/upgrade-calcite-parser
@@ -0,0 +1,72 @@
+#!/bin/bash
+
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#--------------------------------------------------------------------
+
+# Adopts base Calcite parser changes 
+#
+# Establishes a git friendly merge situation:
+#
+# Creates a commit which matches the original state of the calcite parser;
+# To this point creates to alternates:
+#   * one with local customizations
+#   * another with all the upstream updates
+# merges the two branches to obtain the upgrade state
+#
+
+[ $# -ne 2 ] && echo -e "updates base parser sources.\n usage: $0 <old_calcite_version> <new_calcite_version>" && exit 1
+
+CALCITE_OLD=$1
+CALCITE_NEW=$2
+
+set -e
+set -x
+
+BRANCH=`git name-rev --name-only HEAD`
+
+REPO=.git/calcite-upgrade
+rm -rf "$REPO"
+git clone $PWD --reference $PWD --branch $BRANCH $REPO
+
+cd "$REPO"
+git checkout -b curr-changes
+
+mvn -q generate-sources -pl sql -Dcalcite.version=$CALCITE_OLD -Pskip-static-checks
+cp -r sql/target/calcite-base-parser/codegen/./  sql/src/main/codegen/./
+git commit -m 'current reverse' -a
+git revert --no-edit HEAD
+# HEAD is now at the same as before; but parent are the base calcite changes
+
+git branch base-changes curr-changes^
+git checkout base-changes
+git show|patch -p0 -R # undo temproarily to ensure maven runs
+
+mvn -q generate-sources -pl sql -Dcalcite.version=$CALCITE_NEW -Pskip-static-checks
+cp -r sql/target/calcite-base-parser/codegen/./  sql/src/main/codegen/./
+
+git commit --allow-empty -m base-changes -a
+git checkout -b new-state
+git merge --no-edit curr-changes
+
+echo ok
+cd -
+
+git remote remove calcite-upgrade &>/dev/null || echo -n
+git remote add -f calcite-upgrade "$REPO"
+
+
+echo "merge branch calcite-upgrade/curr-changes if satisfied with those changes"
+
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskQueryMaker.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskQueryMaker.java
index 4debe4d9d43e..58031558a0a7 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskQueryMaker.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskQueryMaker.java
@@ -24,7 +24,6 @@
 import com.google.common.base.Preconditions;
 import org.apache.calcite.runtime.Hook;
 import org.apache.calcite.sql.type.SqlTypeName;
-import org.apache.calcite.util.Pair;
 import org.apache.druid.common.guava.FutureUtils;
 import org.apache.druid.error.DruidException;
 import org.apache.druid.error.InvalidInput;
@@ -78,6 +77,7 @@
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Optional;
 import java.util.stream.Collectors;
 
@@ -91,7 +91,7 @@ public class MSQTaskQueryMaker implements QueryMaker
   private final OverlordClient overlordClient;
   private final PlannerContext plannerContext;
   private final ObjectMapper jsonMapper;
-  private final List<Pair<Integer, String>> fieldMapping;
+  private final List<Entry<Integer, String>> fieldMapping;
 
 
   MSQTaskQueryMaker(
@@ -99,7 +99,7 @@ public class MSQTaskQueryMaker implements QueryMaker
       final OverlordClient overlordClient,
       final PlannerContext plannerContext,
       final ObjectMapper jsonMapper,
-      final List<Pair<Integer, String>> fieldMapping
+      final List<Entry<Integer, String>> fieldMapping
   )
   {
     this.targetDataSource = targetDataSource;
@@ -193,7 +193,7 @@ public QueryResponse<Object[]> runQuery(final DruidQuery druidQuery)
     final List<ColumnType> columnTypeList = new ArrayList<>();
     final List<ColumnMapping> columnMappings = QueryUtils.buildColumnMappings(fieldMapping, druidQuery);
 
-    for (final Pair<Integer, String> entry : fieldMapping) {
+    for (final Entry<Integer, String> entry : fieldMapping) {
       final String queryColumn = druidQuery.getOutputRowSignature().getColumnName(entry.getKey());
 
       final SqlTypeName sqlTypeName;
@@ -238,7 +238,7 @@ public QueryResponse<Object[]> runQuery(final DruidQuery druidQuery)
 
       MSQTaskQueryMakerUtils.validateSegmentSortOrder(
           segmentSortOrder,
-          fieldMapping.stream().map(f -> f.right).collect(Collectors.toList())
+          fieldMapping.stream().map(f -> f.getValue()).collect(Collectors.toList())
       );
 
       final DataSourceMSQDestination dataSourceMSQDestination = new DataSourceMSQDestination(
diff --git a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskSqlEngine.java b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskSqlEngine.java
index 99fc71f1b81a..e3baa058b41a 100644
--- a/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskSqlEngine.java
+++ b/extensions-core/multi-stage-query/src/main/java/org/apache/druid/msq/sql/MSQTaskSqlEngine.java
@@ -33,7 +33,6 @@
 import org.apache.calcite.schema.Table;
 import org.apache.calcite.sql.dialect.CalciteSqlDialect;
 import org.apache.calcite.sql.type.SqlTypeName;
-import org.apache.calcite.util.Pair;
 import org.apache.druid.error.DruidException;
 import org.apache.druid.error.InvalidInput;
 import org.apache.druid.error.InvalidSqlInput;
@@ -65,6 +64,7 @@
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Map.Entry;
 import java.util.Set;
 
 public class MSQTaskSqlEngine implements SqlEngine
@@ -222,7 +222,7 @@ private static void validateSelect(final PlannerContext plannerContext)
    */
   private static void validateInsert(
       final RelNode rootRel,
-      final List<Pair<Integer, String>> fieldMappings,
+      final List<Entry<Integer, String>> fieldMappings,
       @Nullable Table targetTable,
       final PlannerContext plannerContext
   )
@@ -241,13 +241,13 @@ private static void validateInsert(
    * SQL allows multiple output columns with the same name. However, we don't allow this for INSERT or REPLACE
    * queries, because we use these output names to generate columns in segments. They must be unique.
    */
-  private static void validateNoDuplicateAliases(final List<Pair<Integer, String>> fieldMappings)
+  private static void validateNoDuplicateAliases(final List<Entry<Integer, String>> fieldMappings)
   {
     final Set<String> aliasesSeen = new HashSet<>();
 
-    for (final Pair<Integer, String> field : fieldMappings) {
-      if (!aliasesSeen.add(field.right)) {
-        throw InvalidSqlInput.exception("Duplicate field in SELECT: [%s]", field.right);
+    for (final Entry<Integer, String> field : fieldMappings) {
+      if (!aliasesSeen.add(field.getValue())) {
+        throw InvalidSqlInput.exception("Duplicate field in SELECT: [%s]", field.getValue());
       }
     }
   }
@@ -353,7 +353,7 @@ private static void validateLimitAndOffset(final RelNode rootRel, final boolean
    */
   private static void validateTypeChanges(
       final RelNode rootRel,
-      final List<Pair<Integer, String>> fieldMappings,
+      final List<Entry<Integer, String>> fieldMappings,
       @Nullable final Table targetTable,
       final PlannerContext plannerContext
   )
@@ -366,9 +366,9 @@ private static void validateTypeChanges(
         MultiStageQueryContext.getColumnsExcludedFromTypeVerification(plannerContext.queryContext());
     final ArrayIngestMode arrayIngestMode = MultiStageQueryContext.getArrayIngestMode(plannerContext.queryContext());
 
-    for (Pair<Integer, String> fieldMapping : fieldMappings) {
-      final int columnIndex = fieldMapping.left;
-      final String columnName = fieldMapping.right;
+    for (Entry<Integer, String> fieldMapping : fieldMappings) {
+      final int columnIndex = fieldMapping.getKey();
+      final String columnName = fieldMapping.getValue();
       final RelDataTypeField oldSqlTypeField =
           targetTable.getRowType(DruidTypeSystem.TYPE_FACTORY).getField(columnName, true, false);
 
@@ -427,11 +427,11 @@ private static void validateTypeChanges(
    *
    * Returns -1 if the list does not contain a time column.
    */
-  private static int getTimeColumnIndex(final List<Pair<Integer, String>> fieldMappings)
+  private static int getTimeColumnIndex(final List<Entry<Integer, String>> fieldMappings)
   {
-    for (final Pair<Integer, String> field : fieldMappings) {
-      if (field.right.equals(ColumnHolder.TIME_COLUMN_NAME)) {
-        return field.left;
+    for (final Entry<Integer, String> field : fieldMappings) {
+      if (field.getValue().equals(ColumnHolder.TIME_COLUMN_NAME)) {
+        return field.getKey();
       }
     }
 
diff --git a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/CalciteSelectQueryMSQTest.java b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/CalciteSelectQueryMSQTest.java
index 87a794f8f863..3008f9d43b47 100644
--- a/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/CalciteSelectQueryMSQTest.java
+++ b/extensions-core/multi-stage-query/src/test/java/org/apache/druid/msq/test/CalciteSelectQueryMSQTest.java
@@ -150,6 +150,14 @@ public void testExactCountDistinctWithFilter()
 
   }
 
+  @Disabled
+  @Override
+  @Test
+  public void testExactCountDistinctWithFilter2()
+  {
+
+  }
+
   @Disabled
   @Override
   @Test
diff --git a/licenses.yaml b/licenses.yaml
index 752e82081643..3c1f7b0b2d46 100644
--- a/licenses.yaml
+++ b/licenses.yaml
@@ -1616,7 +1616,7 @@ name: Apache Calcite
 license_category: binary
 module: java-core
 license_name: Apache License version 2.0
-version: 1.35.0
+version: 1.37.0
 libraries:
   - org.apache.calcite: calcite-core
   - org.apache.calcite: calcite-linq4j
@@ -1634,7 +1634,7 @@ name: Apache Calcite Avatica
 license_category: binary
 module: java-core
 license_name: Apache License version 2.0
-version: 1.23.0
+version: 1.25.0
 libraries:
   - org.apache.calcite.avatica: avatica-core
   - org.apache.calcite.avatica: avatica-metrics
diff --git a/pom.xml b/pom.xml
index f4dd5f0d4512..0ab733968574 100644
--- a/pom.xml
+++ b/pom.xml
@@ -82,13 +82,12 @@
         <apache.ranger.version>2.4.0</apache.ranger.version>
         <gson.version>2.10.1</gson.version>
         <scala.library.version>2.13.14</scala.library.version>
-        <avatica.version>1.23.0</avatica.version>
+        <avatica.version>1.25.0</avatica.version>
         <avro.version>1.11.3</avro.version>
-        <!-- When updating Calcite, also propagate updates to these files which we've copied and modified:
-             default_config.fmpp
-             sql/src/main/codegen/includes/*
+        <!--
+            The base calcite parser was copied into the project; when updating Calcite run dev/upgrade-calcite-parser to adopt upstream changes
           -->
-        <calcite.version>1.35.0</calcite.version>
+        <calcite.version>1.37.0</calcite.version>
         <confluent.version>6.2.12</confluent.version>
         <datasketches.version>4.2.0</datasketches.version>
         <datasketches.memory.version>2.2.0</datasketches.memory.version>
@@ -2189,6 +2188,7 @@
                                 <exclude>**/.classpath</exclude> <!-- Eclipse -->
                                 <exclude>**/.project</exclude> <!-- Eclipse -->
                                 <exclude>**/*.iq</exclude> <!-- quidem testfiles -->
+                                <exclude>**/*.iq.out</exclude> <!-- quidem testfiles -->
                             </excludes>
                         </configuration>
                     </plugin>
diff --git a/processing/src/test/resources/log4j2.xml b/processing/src/test/resources/log4j2.xml
index d335523d0863..ed8a48d02c11 100644
--- a/processing/src/test/resources/log4j2.xml
+++ b/processing/src/test/resources/log4j2.xml
@@ -31,5 +31,8 @@
     <Logger level="info" name="org.apache.druid" additivity="false">
       <AppenderRef ref="Console"/>
     </Logger>
+    <Logger level="debug" name="org.apache.calcite.plan.AbstractRelOptPlanner.rule_execution_summary" additivity="false">
+      <AppenderRef ref="Console"/>
+    </Logger>
   </Loggers>
 </Configuration>
diff --git a/sql/pom.xml b/sql/pom.xml
index a90d9e5f2987..b3ccc6ad2586 100644
--- a/sql/pom.xml
+++ b/sql/pom.xml
@@ -333,8 +333,8 @@
         </executions>
       </plugin>
 
-      <!-- Following plugins and their configurations are used to generate the custom Calcite's SQL parser for Druid -->
-      <!-- Extracts the Parser.jj from Calcite to ${project.build.directory}, where all the Freemarker templates are -->
+      <!-- Extracts the base parser from the calcite-core artifcat. -->
+      <!-- This is provided to have the base available - to compare changes to -->
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-dependency-plugin</artifactId>
@@ -353,17 +353,8 @@
                   <version>${calcite.version}</version>
                   <type>jar</type>
                   <overWrite>true</overWrite>
-                  <outputDirectory>${project.build.directory}/</outputDirectory>
-                  <includes>**/Parser.jj</includes>
-                </artifactItem>
-                <artifactItem>
-                  <groupId>org.apache.calcite</groupId>
-                  <artifactId>calcite-core</artifactId>
-                  <version>${calcite.version}</version>
-                  <type>jar</type>
-                  <overWrite>true</overWrite>
-                  <outputDirectory>${project.build.directory}/</outputDirectory>
-                  <includes>**/default_config.fmpp</includes>
+                  <outputDirectory>${project.build.directory}/calcite-base-parser</outputDirectory>
+                  <includes>codegen/**</includes>
                 </artifactItem>
               </artifactItems>
             </configuration>
@@ -371,32 +362,7 @@
         </executions>
       </plugin>
 
-      <!-- Copy the templates present in the codegen directory of druid-sql containing custom SQL rules to
-        ${project.build.directory}/codegen -->
-      <plugin>
-        <artifactId>maven-resources-plugin</artifactId>
-        <executions>
-          <execution>
-            <id>copy-fmpp-resources</id>
-            <phase>generate-sources</phase>
-            <goals>
-              <goal>copy-resources</goal>
-            </goals>
-            <configuration>
-              <outputDirectory>${project.build.directory}/codegen</outputDirectory>
-              <resources>
-                <resource>
-                  <directory>src/main/codegen</directory>
-                  <filtering>false</filtering>
-                </resource>
-              </resources>
-            </configuration>
-          </execution>
-        </executions>
-      </plugin>
-
-      <!-- "Plugs in" the Calcite's Parser.jj with the variables present in config.fmpp. These contain the custom rules
-        as well as the class to which the custom implementation will get generated -->
+      <!-- Applies the fmpp templates to produce the final Parser.jj -->
       <plugin>
         <groupId>com.googlecode.fmpp-maven-plugin</groupId>
         <artifactId>fmpp-maven-plugin</artifactId>
@@ -408,9 +374,9 @@
               <goal>generate</goal>
             </goals>
             <configuration>
-              <cfgFile>${project.build.directory}/codegen/config.fmpp</cfgFile>
+              <cfgFile>src/main/codegen/config.fmpp</cfgFile>
               <outputDirectory>${project.build.directory}/generated-sources</outputDirectory>
-              <templateDirectory>${project.build.directory}/codegen/templates</templateDirectory>
+              <templateDirectory>src/main/codegen/templates</templateDirectory>
             </configuration>
           </execution>
         </executions>
@@ -440,38 +406,6 @@
         </executions>
       </plugin>
 
-      <!-- This plugin is used to replace the production rule for FROM clause in the calcite grammar.
-           It is done by a search and replace since calcite doesn't allow to override production rules generally
-           in its grammar (override is possible only if there's a hook for it in the grammar). And the FROM clause
-           doesn't contain any hook for extension. For the custom changes done in
-           extension, please check from.ftl file in sql module.
-      -->
-      <plugin>
-        <groupId>com.google.code.maven-replacer-plugin</groupId>
-        <artifactId>replacer</artifactId>
-        <version>1.5.3</version>
-        <executions>
-          <execution>
-            <phase>generate-sources</phase>
-            <goals>
-              <goal>replace</goal>
-            </goals>
-          </execution>
-        </executions>
-        <configuration>
-          <basedir>${project.build.directory}/generated-sources/org/apache/druid/sql/calcite/parser</basedir>
-          <includes>
-            <include>**/DruidSqlParserImpl.java</include>
-          </includes>
-          <replacements>
-            <replacement>
-              <token>fromClause = FromClause</token>
-              <value>fromClause = DruidFromClause</value>
-            </replacement>
-          </replacements>
-        </configuration>
-      </plugin>
-
       <!-- Adds the path of the generated parser to the build path -->
       <plugin>
         <groupId>org.codehaus.mojo</groupId>
diff --git a/sql/src/main/codegen/config.fmpp b/sql/src/main/codegen/config.fmpp
index 12bd51351d27..837c04f42a63 100644
--- a/sql/src/main/codegen/config.fmpp
+++ b/sql/src/main/codegen/config.fmpp
@@ -100,10 +100,8 @@ data: {
     # "dataTypeParserMethods".
     implementationFiles: [
       "common.ftl"
-      "insert.ftl"
       "explain.ftl"
       "replace.ftl"
-      "from.ftl"
     ]
   }
 }
diff --git a/sql/src/main/codegen/default_config.fmpp b/sql/src/main/codegen/default_config.fmpp
new file mode 100644
index 000000000000..5f48306c6526
--- /dev/null
+++ b/sql/src/main/codegen/default_config.fmpp
@@ -0,0 +1,459 @@
+# 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.
+
+# Default data declarations for parsers.
+# Each of these may be overridden in a parser's config.fmpp file.
+# In addition, each parser must define "package" and "class".
+parser: {
+  # List of additional classes and packages to import.
+  # Example: "org.apache.calcite.sql.*", "java.util.List".
+  imports: [
+  ]
+
+  # List of new keywords. Example: "DATABASES", "TABLES". If the keyword is
+  # not a reserved keyword, add it to the 'nonReservedKeywords' section.
+  keywords: [
+  ]
+
+  # List of keywords from "keywords" section that are not reserved.
+  nonReservedKeywords: [
+    "A"
+    "ABSENT"
+    "ABSOLUTE"
+    "ACTION"
+    "ADA"
+    "ADD"
+    "ADMIN"
+    "AFTER"
+    "ALWAYS"
+    "APPLY"
+    "ARRAY_AGG"
+    "ARRAY_CONCAT_AGG"
+    "ASC"
+    "ASSERTION"
+    "ASSIGNMENT"
+    "ATTRIBUTE"
+    "ATTRIBUTES"
+    "BEFORE"
+    "BERNOULLI"
+    "BREADTH"
+    "C"
+    "CASCADE"
+    "CATALOG"
+    "CATALOG_NAME"
+    "CENTURY"
+    "CHAIN"
+    "CHARACTERISTICS"
+    "CHARACTERS"
+    "CHARACTER_SET_CATALOG"
+    "CHARACTER_SET_NAME"
+    "CHARACTER_SET_SCHEMA"
+    "CLASS_ORIGIN"
+    "COBOL"
+    "COLLATION"
+    "COLLATION_CATALOG"
+    "COLLATION_NAME"
+    "COLLATION_SCHEMA"
+    "COLUMN_NAME"
+    "COMMAND_FUNCTION"
+    "COMMAND_FUNCTION_CODE"
+    "COMMITTED"
+    "CONDITIONAL"
+    "CONDITION_NUMBER"
+    "CONNECTION"
+    "CONNECTION_NAME"
+    "CONSTRAINT_CATALOG"
+    "CONSTRAINT_NAME"
+    "CONSTRAINTS"
+    "CONSTRAINT_SCHEMA"
+    "CONSTRUCTOR"
+    "CONTAINS_SUBSTR"
+    "CONTINUE"
+    "CURSOR_NAME"
+    "DATA"
+    "DATABASE"
+    "DATE_DIFF"
+    "DATE_TRUNC"
+    "DATETIME_DIFF"
+    "DATETIME_INTERVAL_CODE"
+    "DATETIME_INTERVAL_PRECISION"
+    "DATETIME_TRUNC"
+    "DAYOFWEEK"
+    "DAYOFYEAR"
+    "DAYS"
+    "DECADE"
+    "DEFAULTS"
+    "DEFERRABLE"
+    "DEFERRED"
+    "DEFINED"
+    "DEFINER"
+    "DEGREE"
+    "DEPTH"
+    "DERIVED"
+    "DESC"
+    "DESCRIPTION"
+    "DESCRIPTOR"
+    "DIAGNOSTICS"
+    "DISPATCH"
+    "DOMAIN"
+    "DOW"
+    "DOY"
+    "DOT_FORMAT"
+    "DYNAMIC_FUNCTION"
+    "DYNAMIC_FUNCTION_CODE"
+    "ENCODING"
+    "EPOCH"
+    "ERROR"
+    "EXCEPTION"
+    "EXCLUDE"
+    "EXCLUDING"
+    "FINAL"
+    "FIRST"
+    "FOLLOWING"
+    "FORMAT"
+    "FORTRAN"
+    "FOUND"
+    "FRAC_SECOND"
+    "G"
+    "GENERAL"
+    "GENERATED"
+    "GEOMETRY"
+    "GO"
+    "GOTO"
+    "GRANTED"
+    "GROUP_CONCAT"
+    "HIERARCHY"
+    "HOP"
+    "HOURS"
+    "IGNORE"
+    "ILIKE"
+    "IMMEDIATE"
+    "IMMEDIATELY"
+    "IMPLEMENTATION"
+    "INCLUDE"
+    "INCLUDING"
+    "INCREMENT"
+    "INITIALLY"
+    "INPUT"
+    "INSTANCE"
+    "INSTANTIABLE"
+    "INVOKER"
+    "ISODOW"
+    "ISOLATION"
+    "ISOYEAR"
+    "JAVA"
+    "JSON"
+    "K"
+    "KEY"
+    "KEY_MEMBER"
+    "KEY_TYPE"
+    "LABEL"
+    "LAST"
+    "LENGTH"
+    "LEVEL"
+    "LIBRARY"
+    "LOCATOR"
+    "M"
+    "MAP"
+    "MATCHED"
+    "MAXVALUE"
+    "MESSAGE_LENGTH"
+    "MESSAGE_OCTET_LENGTH"
+    "MESSAGE_TEXT"
+    "MICROSECOND"
+    "MILLENNIUM"
+    "MILLISECOND"
+    "MINUTES"
+    "MINVALUE"
+    "MONTHS"
+    "MORE_"
+    "MUMPS"
+    "NAME"
+    "NAMES"
+    "NANOSECOND"
+    "NESTING"
+    "NORMALIZED"
+    "NULLABLE"
+    "NULLS"
+    "NUMBER"
+    "OBJECT"
+    "OCTETS"
+    "OPTION"
+    "OPTIONS"
+    "ORDERING"
+    "ORDINALITY"
+    "OTHERS"
+    "OUTPUT"
+    "OVERRIDING"
+    "PAD"
+    "PARAMETER_MODE"
+    "PARAMETER_NAME"
+    "PARAMETER_ORDINAL_POSITION"
+    "PARAMETER_SPECIFIC_CATALOG"
+    "PARAMETER_SPECIFIC_NAME"
+    "PARAMETER_SPECIFIC_SCHEMA"
+    "PARTIAL"
+    "PASCAL"
+    "PASSING"
+    "PASSTHROUGH"
+    "PAST"
+    "PATH"
+    "PIVOT"
+    "PLACING"
+    "PLAN"
+    "PLI"
+    "PRECEDING"
+    "PRESERVE"
+    "PRIOR"
+    "PRIVILEGES"
+    "PUBLIC"
+    "QUARTER"
+    "QUARTERS"
+    "READ"
+    "RELATIVE"
+    "REPEATABLE"
+    "REPLACE"
+    "RESPECT"
+    "RESTART"
+    "RESTRICT"
+    "RETURNED_CARDINALITY"
+    "RETURNED_LENGTH"
+    "RETURNED_OCTET_LENGTH"
+    "RETURNED_SQLSTATE"
+    "RETURNING"
+    "RLIKE"
+    "ROLE"
+    "ROUTINE"
+    "ROUTINE_CATALOG"
+    "ROUTINE_NAME"
+    "ROUTINE_SCHEMA"
+    "ROW_COUNT"
+    "SCALAR"
+    "SCALE"
+    "SCHEMA"
+    "SCHEMA_NAME"
+    "SCOPE_CATALOGS"
+    "SCOPE_NAME"
+    "SCOPE_SCHEMA"
+    "SECONDS"
+    "SECTION"
+    "SECURITY"
+    "SELF"
+    "SEPARATOR"
+    "SEQUENCE"
+    "SERIALIZABLE"
+    "SERVER"
+    "SERVER_NAME"
+    "SESSION"
+    "SETS"
+    "SIMPLE"
+    "SIZE"
+    "SOURCE"
+    "SPACE"
+    "SPECIFIC_NAME"
+    "SQL_BIGINT"
+    "SQL_BINARY"
+    "SQL_BIT"
+    "SQL_BLOB"
+    "SQL_BOOLEAN"
+    "SQL_CHAR"
+    "SQL_CLOB"
+    "SQL_DATE"
+    "SQL_DECIMAL"
+    "SQL_DOUBLE"
+    "SQL_FLOAT"
+    "SQL_INTEGER"
+    "SQL_INTERVAL_DAY"
+    "SQL_INTERVAL_DAY_TO_HOUR"
+    "SQL_INTERVAL_DAY_TO_MINUTE"
+    "SQL_INTERVAL_DAY_TO_SECOND"
+    "SQL_INTERVAL_HOUR"
+    "SQL_INTERVAL_HOUR_TO_MINUTE"
+    "SQL_INTERVAL_HOUR_TO_SECOND"
+    "SQL_INTERVAL_MINUTE"
+    "SQL_INTERVAL_MINUTE_TO_SECOND"
+    "SQL_INTERVAL_MONTH"
+    "SQL_INTERVAL_SECOND"
+    "SQL_INTERVAL_YEAR"
+    "SQL_INTERVAL_YEAR_TO_MONTH"
+    "SQL_LONGVARBINARY"
+    "SQL_LONGVARCHAR"
+    "SQL_LONGVARNCHAR"
+    "SQL_NCHAR"
+    "SQL_NCLOB"
+    "SQL_NUMERIC"
+    "SQL_NVARCHAR"
+    "SQL_REAL"
+    "SQL_SMALLINT"
+    "SQL_TIME"
+    "SQL_TIMESTAMP"
+    "SQL_TINYINT"
+    "SQL_TSI_DAY"
+    "SQL_TSI_FRAC_SECOND"
+    "SQL_TSI_HOUR"
+    "SQL_TSI_MICROSECOND"
+    "SQL_TSI_MINUTE"
+    "SQL_TSI_MONTH"
+    "SQL_TSI_QUARTER"
+    "SQL_TSI_SECOND"
+    "SQL_TSI_WEEK"
+    "SQL_TSI_YEAR"
+    "SQL_VARBINARY"
+    "SQL_VARCHAR"
+    "STATE"
+    "STATEMENT"
+    "STRING_AGG"
+    "STRUCTURE"
+    "STYLE"
+    "SUBCLASS_ORIGIN"
+    "SUBSTITUTE"
+    "TABLE_NAME"
+    "TEMPORARY"
+    "TIES"
+    "TIME_DIFF"
+    "TIME_TRUNC"
+    "TIMESTAMPADD"
+    "TIMESTAMPDIFF"
+    "TIMESTAMP_DIFF"
+    "TIMESTAMP_TRUNC"
+    "TOP_LEVEL_COUNT"
+    "TRANSACTION"
+    "TRANSACTIONS_ACTIVE"
+    "TRANSACTIONS_COMMITTED"
+    "TRANSACTIONS_ROLLED_BACK"
+    "TRANSFORM"
+    "TRANSFORMS"
+    "TRIGGER_CATALOG"
+    "TRIGGER_NAME"
+    "TRIGGER_SCHEMA"
+    "TUMBLE"
+    "TYPE"
+    "UNBOUNDED"
+    "UNCOMMITTED"
+    "UNCONDITIONAL"
+    "UNDER"
+    "UNPIVOT"
+    "UNNAMED"
+    "USAGE"
+    "USER_DEFINED_TYPE_CATALOG"
+    "USER_DEFINED_TYPE_CODE"
+    "USER_DEFINED_TYPE_NAME"
+    "USER_DEFINED_TYPE_SCHEMA"
+    "UTF16"
+    "UTF32"
+    "UTF8"
+    "VERSION"
+    "VIEW"
+    "WEEK"
+    "WEEKS"
+    "WORK"
+    "WRAPPER"
+    "WRITE"
+    "XML"
+    "YEARS"
+    "ZONE"
+  ]
+
+  # List of non-reserved keywords to add;
+  # items in this list become non-reserved.
+  nonReservedKeywordsToAdd: [
+  ]
+
+  # List of non-reserved keywords to remove;
+  # items in this list become reserved.
+  nonReservedKeywordsToRemove: [
+  ]
+
+  # List of additional join types. Each is a method with no arguments.
+  # Example: "LeftSemiJoin".
+  joinTypes: [
+  ]
+
+  # List of methods for parsing custom SQL statements.
+  # Return type of method implementation should be 'SqlNode'.
+  # Example: "SqlShowDatabases()", "SqlShowTables()".
+  statementParserMethods: [
+  ]
+
+  # List of methods for parsing custom literals.
+  # Return type of method implementation should be "SqlNode".
+  # Example: ParseJsonLiteral().
+  literalParserMethods: [
+  ]
+
+  # List of methods for parsing custom data types.
+  # Return type of method implementation should be "SqlTypeNameSpec".
+  # Example: SqlParseTimeStampZ().
+  dataTypeParserMethods: [
+  ]
+
+  # List of methods for parsing builtin function calls.
+  # Return type of method implementation should be "SqlNode".
+  # Example: "DateTimeConstructorCall()".
+  builtinFunctionCallMethods: [
+  ]
+
+  # List of methods for parsing extensions to "ALTER <scope>" calls.
+  # Each must accept arguments "(SqlParserPos pos, String scope)".
+  # Example: "SqlAlterTable".
+  alterStatementParserMethods: [
+  ]
+
+  # List of methods for parsing extensions to "CREATE [OR REPLACE]" calls.
+  # Each must accept arguments "(SqlParserPos pos, boolean replace)".
+  # Example: "SqlCreateForeignSchema".
+  createStatementParserMethods: [
+  ]
+
+  # List of methods for parsing extensions to "DROP" calls.
+  # Each must accept arguments "(SqlParserPos pos)".
+  # Example: "SqlDropSchema".
+  dropStatementParserMethods: [
+  ]
+
+  # List of methods for parsing extensions to "TRUNCATE" calls.
+  # Each must accept arguments "(SqlParserPos pos)".
+  # Example: "SqlTruncate".
+  truncateStatementParserMethods: [
+  ]
+
+  # Binary operators tokens.
+  # Example: "< INFIX_CAST: \"::\" >".
+  binaryOperatorsTokens: [
+  ]
+
+  # Binary operators initialization.
+  # Example: "InfixCast".
+  extraBinaryExpressions: [
+  ]
+
+  # List of files in @includes directory that have parser method
+  # implementations for parsing custom SQL statements, literals or types
+  # given as part of "statementParserMethods", "literalParserMethods" or
+  # "dataTypeParserMethods".
+  # Example: "parserImpls.ftl".
+  implementationFiles: [
+  ]
+
+  # Custom identifier token.
+  # Example: "< IDENTIFIER: (<LETTER>|<DIGIT>)+ >".
+  customIdentifierToken: ""
+
+  includePosixOperators: false
+  includeCompoundIdentifier: true
+  includeBraces: true
+  includeAdditionalDeclarations: false
+  includeParsingStringLiteralAsArrayLiteral: false
+}
diff --git a/sql/src/main/codegen/includes/from.ftl b/sql/src/main/codegen/includes/from.ftl
deleted file mode 100644
index ae6d03b841cb..000000000000
--- a/sql/src/main/codegen/includes/from.ftl
+++ /dev/null
@@ -1,306 +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.
- */
-
-/*
- * Druid note: this file is copied from core/src/main/codegen/templates/Parser.jj in Calcite 1.35.0, with changes to
- * to add two elements of Druid syntax to the FROM clause:
- *
- * id [ (<args>) ]
- *
- * And
- *
- * TABLE(<fn>(<args>)) (<schema>)
- *
- * These changes were originally in https://github.com/apache/druid/pull/13360 as a patch script (sql/edit-parser.py),
- * then later moved to this copied-and-edited file in https://github.com/apache/druid/pull/13553.*
- *
- * This file prefixes the required production rules with 'Druid' so that the whole FROM production rule can be
- * derived from this file itself. The production clause is injected in the grammar using the maven replace plugin in
- * sql module's pom.
- */
-
-/**
- * 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 DruidFromClause() :
-{
-    SqlNode e, e2;
-    SqlLiteral joinType;
-}
-{
-    e = DruidJoin()
-    (
-        // 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 = DruidJoin() {
-            e = new SqlJoin(joinType.getParserPosition(),
-                e,
-                SqlLiteral.createBoolean(false, joinType.getParserPosition()),
-                joinType,
-                e2,
-                JoinConditionType.NONE.symbol(SqlParserPos.ZERO),
-                null);
-        }
-    )*
-    { return e; }
-}
-
-SqlNode DruidJoin() :
-{
-    SqlNode e;
-}
-{
-    e = DruidTableRef1(ExprContext.ACCEPT_QUERY_OR_JOIN)
-    (
-        LOOKAHEAD(2)
-        e = DruidJoinTable(e)
-    )*
-    {
-        return e;
-    }
-}
-
-/** Matches "LEFT JOIN t ON ...", "RIGHT JOIN t USING ...", "JOIN t". */
-SqlNode DruidJoinTable(SqlNode e) :
-{
-    SqlNode e2, condition;
-    final SqlLiteral natural, joinType, on, using;
-    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 = DruidTableRef1(ExprContext.ACCEPT_QUERY_OR_JOIN)
-    (
-        <ON> { on = JoinConditionType.ON.symbol(getPos()); }
-        condition = Expression(ExprContext.ACCEPT_SUB_QUERY) {
-            return new SqlJoin(joinType.getParserPosition(),
-                e,
-                natural,
-                joinType,
-                e2,
-                on,
-                condition);
-        }
-    |
-        <USING> { using = JoinConditionType.USING.symbol(getPos()); }
-        list = ParenthesizedSimpleIdentifierList() {
-            return new SqlJoin(joinType.getParserPosition(),
-                e,
-                natural,
-                joinType,
-                e2,
-                using,
-                new SqlNodeList(list, Span.of(using).end(this)));
-        }
-    |
-        {
-            return new SqlJoin(joinType.getParserPosition(),
-                e,
-                natural,
-                joinType,
-                e2,
-                JoinConditionType.NONE.symbol(joinType.getParserPosition()),
-                null);
-        }
-    )
-|
-    <CROSS> { joinType = JoinType.CROSS.symbol(getPos()); } <APPLY>
-    e2 = DruidTableRef2(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 = DruidTableRef2(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()));
-    }
-}
-
-/**
- * Parses a table reference in a FROM clause, not lateral unless LATERAL
- * is explicitly specified.
- */
-SqlNode DruidTableRef() :
-{
-    final SqlNode e;
-}
-{
-    e = DruidTableRef3(ExprContext.ACCEPT_QUERY, false) { return e; }
-}
-
-SqlNode DruidTableRef1(ExprContext exprContext) :
-{
-    final SqlNode e;
-}
-{
-    e = DruidTableRef3(exprContext, false) { return e; }
-}
-
-/**
- * Parses a table reference in a FROM clause.
- */
-SqlNode DruidTableRef2(boolean lateral) :
-{
-    final SqlNode e;
-}
-{
-    e = DruidTableRef3(ExprContext.ACCEPT_QUERY, lateral) { return e; }
-}
-
-SqlNode DruidTableRef3(ExprContext exprContext, boolean lateral) :
-{
-    final SqlIdentifier tableName;
-    SqlNode tableRef;
-    List<SqlNode> paramList;
-    final SqlIdentifier alias;
-    final Span s;
-    SqlNodeList args;
-    final SqlNodeList columnAliasList;
-    SqlUnnestOperator unnestOp = SqlStdOperatorTable.UNNEST;
-    SqlNodeList extendList = null;
-}
-{
-    (
-        LOOKAHEAD(2)
-        tableName = CompoundTableIdentifier()
-        ( tableRef = TableHints(tableName) | { tableRef = tableName; } )
-        // BEGIN: Druid-specific code
-        [
-            paramList = FunctionParameterList(ExprContext.ACCEPT_NONCURSOR)
-            {
-                tableRef = ParameterizeOperator.PARAM.createCall(tableRef, paramList);
-            }
-        ]
-        // END: Druid-specific code
-        tableRef = Over(tableRef)
-        [ tableRef = Snapshot(tableRef) ]
-        [ tableRef = MatchRecognize(tableRef) ]
-    |
-        LOOKAHEAD(2)
-        [ <LATERAL> { lateral = true; } ]
-        tableRef = ParenthesizedExpression(exprContext)
-        tableRef = Over(tableRef)
-        tableRef = addLateral(tableRef, lateral)
-        [ tableRef = MatchRecognize(tableRef) ]
-    |
-        <UNNEST> { s = span(); }
-        args = ParenthesizedQueryOrCommaList(ExprContext.ACCEPT_SUB_QUERY)
-        [
-            <WITH> <ORDINALITY> {
-                unnestOp = SqlStdOperatorTable.UNNEST_WITH_ORDINALITY;
-            }
-        ]
-        {
-            tableRef = unnestOp.createCall(s.end(this), (List<SqlNode>) args);
-        }
-    |
-        [ <LATERAL> { lateral = true; } ]
-        tableRef = TableFunctionCall()
-        // BEGIN: Druid-specific code
-        [
-            [ <EXTEND> ]
-            extendList = ExtendList()
-            {
-                tableRef = ExtendOperator.EXTEND.createCall(
-                      Span.of(tableRef, extendList).pos(), tableRef, extendList);
-            }
-        ]
-        // END: Druid-specific code
-        tableRef = addLateral(tableRef, lateral)
-    |
-        tableRef = ExtendedTableRef()
-    )
-    [
-        LOOKAHEAD(2)
-        tableRef = Pivot(tableRef)
-    ]
-    [
-        LOOKAHEAD(2)
-        tableRef = Unpivot(tableRef)
-    ]
-    [
-        [ <AS> ] alias = SimpleIdentifier()
-        (
-            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);
-            } else {
-                List<SqlNode> idList = new ArrayList<SqlNode>();
-                idList.add(tableRef);
-                idList.add(alias);
-                idList.addAll(columnAliasList.getList());
-                tableRef = SqlStdOperatorTable.AS.createCall(
-                    Span.of(tableRef).end(this), idList);
-            }
-        }
-    ]
-    [ tableRef = Tablesample(tableRef) ]
-    { return tableRef; }
-}
diff --git a/sql/src/main/codegen/includes/insert.ftl b/sql/src/main/codegen/includes/insert.ftl
deleted file mode 100644
index 0f053a4f655a..000000000000
--- a/sql/src/main/codegen/includes/insert.ftl
+++ /dev/null
@@ -1,113 +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.
- */
-
-/**
- * Parses an INSERT statement. This function is copied from SqlInsert in core/src/main/codegen/templates/Parser.jj,
- * with some changes to allow a custom error message if an OVERWRITE clause is present.
- */
-// Using fully qualified name for Pair class, since Calcite also has a same class name being used in the Parser.jj
-SqlNode DruidSqlInsertEof() :
-{
-  SqlNode insertNode;
-  final List<SqlLiteral> keywords = new ArrayList<SqlLiteral>();
-  final SqlNodeList keywordList;
-  final SqlIdentifier destination;
-  SqlNode tableRef = null;
-  SqlNode source;
-  final SqlNodeList columnList;
-  final Span s;
-  final Pair<SqlNodeList, SqlNodeList> p;
-  SqlGranularityLiteral partitionedBy = null;
-  SqlNodeList clusteredBy = null;
-  SqlIdentifier exportFileFormat = null;
-}
-{
-  (
-    <INSERT>
-    |
-    <UPSERT> { keywords.add(SqlInsertKeyword.UPSERT.symbol(getPos())); }
-  )
-  { s = span(); }
-  SqlInsertKeywords(keywords) {
-    keywordList = new SqlNodeList(keywords, s.addAll(keywords).pos());
-  }
-  <INTO>
-  (
-    LOOKAHEAD(2)
-    <EXTERN> <LPAREN> destination = ExternalDestination() <RPAREN>
-    |
-    destination = CompoundTableIdentifier()
-    ( tableRef = TableHints(destination) | { tableRef = destination; } )
-    [ LOOKAHEAD(5) tableRef = ExtendTable(tableRef) ]
-  )
-  (
-    LOOKAHEAD(2)
-    p = ParenthesizedCompoundIdentifierList() {
-      if (p.right.size() > 0) {
-        tableRef = extend(tableRef, p.right);
-      }
-      if (p.left.size() > 0) {
-        columnList = p.left;
-      } else {
-        columnList = null;
-      }
-    }
-    | { columnList = null; }
-  )
-  [
-    <AS> exportFileFormat = FileFormat()
-  ]
-  (
-    <OVERWRITE>
-    {
-      throw org.apache.druid.sql.calcite.parser.DruidSqlParserUtils.problemParsing(
-          "An OVERWRITE clause is not allowed with INSERT statements. Use REPLACE statements if overwriting existing segments is required or remove the OVERWRITE clause."
-      );
-    }
-    |
-    source = OrderedQueryOrExpr(ExprContext.ACCEPT_QUERY)
-  )
-  // PARTITIONED BY is necessary, but is kept optional in the grammar. It is asserted that it is not missing in the
-  // IngestHandler#validate() so that we can return a custom error message.
-  [
-    <PARTITIONED> <BY>
-    partitionedBy = PartitionGranularity()
-  ]
-  [
-    clusteredBy = ClusteredBy()
-  ]
-  {
-
-  }
-  // EOF is also present in SqlStmtEof but EOF is a special case and a single EOF can be consumed multiple times.
-  // The reason for adding EOF here is to ensure that we create a DruidSqlInsert node after the syntax has been
-  // validated and throw SQL syntax errors before performing validations in the DruidSqlInsert which can overshadow the
-  // actual error message.
-  <EOF>
-  {
-    insertNode = new SqlInsert(s.end(source), keywordList, destination, source, columnList);
-    if (!(insertNode instanceof SqlInsert)) {
-      // This shouldn't be encountered, but done as a defensive practice. SqlInsert() always returns a node of type
-      // SqlInsert
-      return insertNode;
-    }
-    SqlInsert sqlInsert = (SqlInsert) insertNode;
-    return DruidSqlInsert.create(sqlInsert, partitionedBy, clusteredBy, exportFileFormat);
-  }
-}
diff --git a/sql/src/main/codegen/templates/Parser.jj b/sql/src/main/codegen/templates/Parser.jj
new file mode 100644
index 000000000000..0f8ae7e5f6d4
--- /dev/null
+++ b/sql/src/main/codegen/templates/Parser.jj
@@ -0,0 +1,9235 @@
+/*
+ * 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.
+ */
+<@pp.dropOutputFile />
+
+<@pp.changeOutputFile name="javacc/Parser.jj" />
+
+options {
+    STATIC = false;
+    IGNORE_CASE = true;
+    UNICODE_INPUT = true;
+}
+
+
+PARSER_BEGIN(${parser.class})
+
+package ${parser.package};
+
+<#list (parser.imports!default.parser.imports) as importStr>
+import ${importStr};
+</#list>
+
+import org.apache.calcite.avatica.util.Casing;
+import org.apache.calcite.avatica.util.TimeUnit;
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.runtime.CalciteContextException;
+import org.apache.calcite.sql.JoinConditionType;
+import org.apache.calcite.sql.JoinType;
+import org.apache.calcite.sql.SqlAlter;
+import org.apache.calcite.sql.SqlBasicTypeNameSpec;
+import org.apache.calcite.sql.SqlBinaryOperator;
+import org.apache.calcite.sql.SqlCall;
+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.SqlDelete;
+import org.apache.calcite.sql.SqlDescribeSchema;
+import org.apache.calcite.sql.SqlDescribeTable;
+import org.apache.calcite.sql.SqlDynamicParam;
+import org.apache.calcite.sql.SqlExplain;
+import org.apache.calcite.sql.SqlExplainFormat;
+import org.apache.calcite.sql.SqlExplainLevel;
+import org.apache.calcite.sql.SqlFunction;
+import org.apache.calcite.sql.SqlFunctionCategory;
+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.SqlIntervalQualifier;
+import org.apache.calcite.sql.SqlJdbcDataTypeName;
+import org.apache.calcite.sql.SqlJdbcFunctionCall;
+import org.apache.calcite.sql.SqlJoin;
+import org.apache.calcite.sql.SqlJsonConstructorNullClause;
+import org.apache.calcite.sql.SqlJsonEncoding;
+import org.apache.calcite.sql.SqlJsonExistsErrorBehavior;
+import org.apache.calcite.sql.SqlJsonEmptyOrError;
+import org.apache.calcite.sql.SqlJsonQueryEmptyOrErrorBehavior;
+import org.apache.calcite.sql.SqlJsonQueryWrapperBehavior;
+import org.apache.calcite.sql.SqlJsonValueEmptyOrErrorBehavior;
+import org.apache.calcite.sql.SqlJsonValueReturning;
+import org.apache.calcite.sql.SqlKind;
+import org.apache.calcite.sql.SqlLambda;
+import org.apache.calcite.sql.SqlLiteral;
+import org.apache.calcite.sql.SqlMatchRecognize;
+import org.apache.calcite.sql.SqlMerge;
+import org.apache.calcite.sql.SqlMapTypeNameSpec;
+import org.apache.calcite.sql.SqlNode;
+import org.apache.calcite.sql.SqlNodeList;
+import org.apache.calcite.sql.SqlNumericLiteral;
+import org.apache.calcite.sql.SqlOperator;
+import org.apache.calcite.sql.SqlOrderBy;
+import org.apache.calcite.sql.SqlPivot;
+import org.apache.calcite.sql.SqlPostfixOperator;
+import org.apache.calcite.sql.SqlPrefixOperator;
+import org.apache.calcite.sql.SqlRowTypeNameSpec;
+import org.apache.calcite.sql.SqlSampleSpec;
+import org.apache.calcite.sql.SqlSelect;
+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.SqlTypeNameSpec;
+import org.apache.calcite.sql.SqlUnnestOperator;
+import org.apache.calcite.sql.SqlUnpivot;
+import org.apache.calcite.sql.SqlUpdate;
+import org.apache.calcite.sql.SqlUserDefinedTypeNameSpec;
+import org.apache.calcite.sql.SqlUtil;
+import org.apache.calcite.sql.SqlWindow;
+import org.apache.calcite.sql.SqlWith;
+import org.apache.calcite.sql.SqlWithItem;
+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.fun.SqlTrimFunction;
+import org.apache.calcite.sql.parser.Span;
+import org.apache.calcite.sql.parser.SqlAbstractParserImpl;
+import org.apache.calcite.sql.parser.SqlParseException;
+import org.apache.calcite.sql.parser.SqlParser;
+import org.apache.calcite.sql.parser.SqlParserImplFactory;
+import org.apache.calcite.sql.parser.SqlParserPos;
+import org.apache.calcite.sql.parser.SqlParserUtil;
+import org.apache.calcite.sql.type.SqlTypeName;
+import org.apache.calcite.sql.validate.SqlConformance;
+import org.apache.calcite.sql.validate.SqlConformanceEnum;
+import org.apache.calcite.util.Glossary;
+import org.apache.calcite.util.Pair;
+import org.apache.calcite.util.SourceStringReader;
+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.Collections;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+
+import static org.apache.calcite.util.Static.RESOURCE;
+
+/**
+ * SQL parser, generated from Parser.jj by JavaCC.
+ *
+ * <p>The public wrapper for this parser is {@link SqlParser}.
+ */
+public class ${parser.class} extends SqlAbstractParserImpl
+{
+    private static final Logger LOGGER = CalciteTrace.getParserTracer();
+
+    // Can't use quoted literal because of a bug in how JavaCC translates
+    // backslash-backslash.
+    private static final char BACKSLASH = 0x5c;
+    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 final BigDecimal ONE_HUNDRED = BigDecimal.valueOf(100L);
+
+    private static Metadata metadata;
+
+    private Casing unquotedCasing;
+    private Casing quotedCasing;
+    private int identifierMaxLength;
+    private SqlConformance conformance;
+
+    /**
+     * {@link SqlParserImplFactory} implementation for creating parser.
+     */
+    public static final SqlParserImplFactory FACTORY = new SqlParserImplFactory() {
+        public SqlAbstractParserImpl getParser(Reader reader) {
+            final ${parser.class} parser = new ${parser.class}(reader);
+            if (reader instanceof SourceStringReader) {
+                final String sql =
+                    ((SourceStringReader) reader).getSourceString();
+                parser.setOriginalSql(sql);
+            }
+          return parser;
+        }
+    };
+
+    public SqlParseException normalizeException(Throwable ex) {
+        try {
+            if (ex instanceof ParseException) {
+                ex = cleanupParseException((ParseException) ex);
+            }
+            return convertException(ex);
+        } catch (ParseException e) {
+            throw new AssertionError(e);
+        }
+    }
+
+    public Metadata getMetadata() {
+        synchronized (${parser.class}.class) {
+            if (metadata == null) {
+                metadata = new MetadataImpl(
+                    new ${parser.class}(new java.io.StringReader("")));
+            }
+            return metadata;
+        }
+    }
+
+    public void setTabSize(int tabSize) {
+        jj_input_stream.setTabSize(tabSize);
+    }
+
+    public void switchTo(SqlAbstractParserImpl.LexicalState state) {
+        final int stateOrdinal =
+            Arrays.asList(${parser.class}TokenManager.lexStateNames)
+                .indexOf(state.name());
+        token_source.SwitchTo(stateOrdinal);
+    }
+
+    public void setQuotedCasing(Casing quotedCasing) {
+        this.quotedCasing = quotedCasing;
+    }
+
+    public void setUnquotedCasing(Casing unquotedCasing) {
+        this.unquotedCasing = unquotedCasing;
+    }
+
+    public void setIdentifierMaxLength(int identifierMaxLength) {
+        this.identifierMaxLength = identifierMaxLength;
+    }
+
+    public void setConformance(SqlConformance conformance) {
+        this.conformance = conformance;
+    }
+
+    public SqlNode parseSqlExpressionEof() throws Exception {
+        return SqlExpressionEof();
+    }
+
+    public SqlNode parseSqlStmtEof() throws Exception {
+        return SqlStmtEof();
+    }
+
+    public SqlNodeList parseSqlStmtList() throws Exception {
+        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);
+    }
+
+    /** Adds a warning that a token such as "HOURS" was used,
+    * whereas the SQL standard only allows "HOUR".
+    *
+    * <p>Currently, we silently add an exception to a list of warnings. In
+    * future, we may have better compliance checking, for example a strict
+    * compliance mode that throws if any non-standard features are used. */
+    private TimeUnit warn(TimeUnit timeUnit) throws ParseException {
+        final String token = getToken(0).image.toUpperCase(Locale.ROOT);
+        warnings.add(
+            SqlUtil.newContextException(getPos(),
+                RESOURCE.nonStandardFeatureUsed(token)));
+        return timeUnit;
+    }
+}
+
+PARSER_END(${parser.class})
+
+
+/***************************************
+ * Utility Codes for Semantic Analysis *
+ ***************************************/
+
+/* For Debug */
+JAVACODE
+void debug_message1() {
+    LOGGER.info("{} , {}", getToken(0).image, getToken(1).image);
+}
+
+JAVACODE String unquotedIdentifier() {
+    return SqlParserUtil.toCase(getToken(0).image, unquotedCasing);
+}
+
+/**
+ * Allows parser to be extended with new types of table references.  The
+ * default implementation of this production is empty.
+ */
+SqlNode ExtendedTableRef() :
+{
+}
+{
+    UnusedExtension()
+    {
+        return null;
+    }
+}
+
+/**
+ * Allows an OVER clause following a table expression as an extension to
+ * standard SQL syntax. The default implementation of this production is empty.
+ */
+SqlNode TableOverOpt() :
+{
+}
+{
+    {
+        return null;
+    }
+}
+
+/*
+ * Parses dialect-specific keywords immediately following the SELECT keyword.
+ */
+void SqlSelectKeywords(List<SqlLiteral> keywords) :
+{}
+{
+    E()
+}
+
+/*
+ * Parses dialect-specific keywords immediately following the INSERT keyword.
+ */
+void SqlInsertKeywords(List<SqlLiteral> keywords) :
+{}
+{
+    E()
+}
+
+/*
+* Parse Floor/Ceil function parameters
+*/
+SqlNode FloorCeilOptions(Span s, boolean floorFlag) :
+{
+    SqlNode node;
+}
+{
+    node = StandardFloorCeilOptions(s, floorFlag) {
+        return node;
+    }
+}
+
+/*
+// This file contains the heart of a parser for SQL SELECT statements.
+// code can be shared between various parsers (for example, a DDL parser and a
+// DML parser) but is not a standalone JavaCC file. You need to prepend a
+// parser declaration (such as that in Parser.jj).
+*/
+
+/* Epsilon */
+JAVACODE
+void E() {}
+
+/** @Deprecated */
+JAVACODE List startList(Object o)
+{
+    List list = new ArrayList();
+    list.add(o);
+    return list;
+}
+
+/*
+ * NOTE jvs 6-Feb-2004: The straightforward way to implement the SQL grammar is
+ * to keep query expressions (SELECT, UNION, etc) separate from row expressions
+ * (+, LIKE, etc).  However, this is not possible with an LL(k) parser, because
+ * both kinds of expressions allow parenthesization, so no fixed amount of left
+ * context is ever good enough.  A sub-query can be a leaf in a row expression,
+ * and can include operators like UNION, so it's not even possible to use a
+ * syntactic lookahead rule like "look past an indefinite number of parentheses
+ * until you see SELECT, VALUES, or TABLE" (since at that point we still
+ * don't know whether we're parsing a sub-query like ((select ...) + x)
+ * vs. (select ... union select ...).
+ *
+ * The somewhat messy solution is to unify the two kinds of expression,
+ * and to enforce syntax rules using parameterized context.  This
+ * is the purpose of the ExprContext parameter.  It is passed to
+ * most expression productions, which check the expressions encountered
+ * against the context for correctness.  When a query
+ * element like SELECT is encountered, the production calls
+ * checkQueryExpression, which will throw an exception if
+ * a row expression was expected instead.  When a row expression like
+ * IN is encountered, the production calls checkNonQueryExpression
+ * instead.  It is very important to understand how this works
+ * when modifying the grammar.
+ *
+ * The commingling of expressions results in some bogus ambiguities which are
+ * resolved with LOOKAHEAD hints.  The worst example is comma.  SQL allows both
+ * (WHERE x IN (1,2)) and (WHERE x IN (select ...)).  This means when we parse
+ * the right-hand-side of an IN, we have to allow any kind of expression inside
+ * the parentheses.  Now consider the expression "WHERE x IN(SELECT a FROM b
+ * GROUP BY c,d)".  When the parser gets to "c,d" it doesn't know whether the
+ * comma indicates the end of the GROUP BY or the end of one item in an IN
+ * list.  Luckily, we know that select and comma-list are mutually exclusive
+ * within IN, so we use maximal munch for the GROUP BY comma.  However, this
+ * usage of hints could easily mask unintended ambiguities resulting from
+ * future changes to the grammar, making it very brittle.
+ */
+
+JAVACODE protected SqlParserPos getPos()
+{
+    return new SqlParserPos(
+        token.beginLine,
+        token.beginColumn,
+        token.endLine,
+        token.endColumn);
+}
+
+/** Starts a span at the current position. */
+JAVACODE Span span()
+{
+    return Span.of(getPos());
+}
+
+JAVACODE void checkQueryExpression(ExprContext exprContext)
+{
+    switch (exprContext) {
+    case ACCEPT_NON_QUERY:
+    case ACCEPT_SUB_QUERY:
+    case ACCEPT_CURSOR:
+        throw SqlUtil.newContextException(getPos(),
+            RESOURCE.illegalQueryExpression());
+    }
+}
+
+JAVACODE void checkNonQueryExpression(ExprContext exprContext)
+{
+    switch (exprContext) {
+    case ACCEPT_QUERY:
+        throw SqlUtil.newContextException(getPos(),
+            RESOURCE.illegalNonQueryExpression());
+    }
+}
+
+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).
+ */
+JAVACODE SqlParseException convertException(Throwable ex)
+{
+    if (ex instanceof SqlParseException) {
+        return (SqlParseException) ex;
+    }
+    SqlParserPos pos = null;
+    int[][] expectedTokenSequences = null;
+    String[] tokenImage = null;
+    if (ex instanceof ParseException) {
+        ParseException pex = (ParseException) ex;
+        expectedTokenSequences = pex.expectedTokenSequences;
+        tokenImage = pex.tokenImage;
+        if (pex.currentToken != null) {
+            final Token token = pex.currentToken.next;
+            // Checks token.image.equals("1") to avoid recursive call.
+            // The SqlAbstractParserImpl#MetadataImpl constructor uses constant "1" to
+            // throw intentionally to collect the expected tokens.
+            if (!token.image.equals("1")
+                && getMetadata().isKeyword(token.image)
+                && SqlParserUtil.allowsIdentifier(tokenImage, expectedTokenSequences)) {
+                // If the next token is a keyword, reformat the error message as:
+
+                // Incorrect syntax near the keyword '{keyword}' at line {line_number},
+                // column {column_number}.
+                final String expecting = ex.getMessage()
+                    .substring(ex.getMessage().indexOf("Was expecting"));
+                final String errorMsg = String.format("Incorrect syntax near the keyword '%s' "
+                        + "at line %d, column %d.\n%s",
+                    token.image,
+                    token.beginLine,
+                    token.beginColumn,
+                    expecting);
+                // Replace the ParseException with explicit error message.
+                ex = new ParseException(errorMsg);
+            }
+            pos = new SqlParserPos(
+                token.beginLine,
+                token.beginColumn,
+                token.endLine,
+                token.endColumn);
+        }
+    } else if (ex instanceof TokenMgrError) {
+        expectedTokenSequences = null;
+        tokenImage = null;
+        // Example:
+        //    Lexical error at line 3, column 24.  Encountered "#" after "a".
+        final java.util.regex.Pattern pattern = java.util.regex.Pattern.compile(
+            "(?s)Lexical error at line ([0-9]+), column ([0-9]+).*");
+        java.util.regex.Matcher matcher = pattern.matcher(ex.getMessage());
+        if (matcher.matches()) {
+            int line = Integer.parseInt(matcher.group(1));
+            int column = Integer.parseInt(matcher.group(2));
+            pos = new SqlParserPos(line, column, line, column);
+        }
+    } else if (ex instanceof CalciteContextException) {
+        // CalciteContextException is the standard wrapper for exceptions
+        // produced by the validator, but in the parser, the standard is
+        // SqlParseException; so, strip it away. In case you were wondering,
+        // the CalciteContextException appears because the parser
+        // occasionally calls into validator-style code such as
+        // SqlSpecialOperator.reduceExpr.
+        CalciteContextException ece =
+            (CalciteContextException) ex;
+        pos = new SqlParserPos(
+            ece.getPosLine(),
+            ece.getPosColumn(),
+            ece.getEndPosLine(),
+            ece.getEndPosColumn());
+        ex = ece.getCause();
+    }
+
+    return new SqlParseException(
+        ex.getMessage(), pos, expectedTokenSequences, tokenImage, ex);
+}
+
+/**
+ * Removes or transforms misleading information from a parse exception.
+ *
+ * @param e dirty excn
+ *
+ * @return clean excn
+ */
+JAVACODE ParseException cleanupParseException(ParseException ex)
+{
+    if (ex.expectedTokenSequences == null) {
+        return ex;
+    }
+    int iIdentifier = Arrays.asList(ex.tokenImage).indexOf("<IDENTIFIER>");
+
+    // Find all sequences in the error which contain identifier. For
+    // example,
+    //       {<IDENTIFIER>}
+    //       {A}
+    //       {B, C}
+    //       {D, <IDENTIFIER>}
+    //       {D, A}
+    //       {D, B}
+    //
+    // would yield
+    //       {}
+    //       {D}
+    final List<int[]> prefixList = new ArrayList<int[]>();
+    for (int i = 0; i < ex.expectedTokenSequences.length; ++i) {
+        int[] seq = ex.expectedTokenSequences[i];
+        int j = seq.length - 1;
+        int i1 = seq[j];
+        if (i1 == iIdentifier) {
+            int[] prefix = new int[j];
+            System.arraycopy(seq, 0, prefix, 0, j);
+            prefixList.add(prefix);
+        }
+    }
+
+    if (prefixList.isEmpty()) {
+        return ex;
+    }
+
+    int[][] prefixes = (int[][])
+        prefixList.toArray(new int[prefixList.size()][]);
+
+    // Since <IDENTIFIER> was one of the possible productions,
+    // we know that the parser will also have included all
+    // of the non-reserved keywords (which are treated as
+    // identifiers in non-keyword contexts).  So, now we need
+    // to clean those out, since they're totally irrelevant.
+
+    final List<int[]> list = new ArrayList<int[]>();
+    Metadata metadata = getMetadata();
+    for (int i = 0; i < ex.expectedTokenSequences.length; ++i) {
+        int [] seq = ex.expectedTokenSequences[i];
+        String tokenImage = ex.tokenImage[seq[seq.length - 1]];
+        String token = SqlParserUtil.getTokenVal(tokenImage);
+        if (token == null  || !metadata.isNonReservedKeyword(token)) {
+            list.add(seq);
+            continue;
+        }
+        boolean match = matchesPrefix(seq, prefixes);
+        if (!match) {
+            list.add(seq);
+        }
+    }
+
+    ex.expectedTokenSequences =
+        (int [][]) list.toArray(new int [list.size()][]);
+    return ex;
+}
+
+JAVACODE boolean matchesPrefix(int[] seq, int[][] prefixes)
+{
+    nextPrefix:
+    for (int[] prefix : prefixes) {
+        if (seq.length == prefix.length + 1) {
+            for (int k = 0; k < prefix.length; k++) {
+                if (prefix[k] != seq[k]) {
+                    continue nextPrefix;
+                }
+            }
+            return true;
+        }
+    }
+    return false;
+}
+
+/*****************************************
+ * 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.
+ *
+ * <p>Postgres syntax for limit:
+ *
+ * <blockquote><pre>
+ *    [ LIMIT { count | ALL } ]
+ *    [ 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>
+ *    [ LIMIT { count | start, count } ]</pre>
+ * </blockquote>
+ *
+ * <p>SQL:2008 syntax for limit:
+ *
+ * <blockquote><pre>
+ *    [ OFFSET start { ROW | ROWS } ]
+ *    [ FETCH { FIRST | NEXT } [ count ] { ROW | ROWS } ONLY ]</pre>
+ * </blockquote>
+ */
+SqlNode OrderedQueryOrExpr(ExprContext exprContext) :
+{
+    SqlNode e;
+}
+{
+    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};
+}
+{
+    (
+        // 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; }
+    )
+    [
+        LimitClause(s, offsetFetch)
+        [ OffsetClause(s, offsetFetch) ]
+    |
+        OffsetClause(s, offsetFetch)
+        [
+            LimitClause(s, offsetFetch) {
+                if (!this.conformance.isOffsetLimitAllowed()) {
+                    throw SqlUtil.newContextException(s.end(this),
+                        RESOURCE.offsetLimitNotAllowed());
+                }
+            }
+        |
+            FetchClause(offsetFetch)
+        ]
+    |
+        FetchClause(offsetFetch)
+    ]
+    {
+        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) :
+{
+    final String error;
+}
+{
+    // Postgres-style syntax. "LIMIT ... OFFSET ..."
+    <LIMIT> { s.add(this); }
+    (
+        // MySQL-style syntax. "LIMIT start, count" or "LIMIT start, ALL"
+        LOOKAHEAD(2)
+        offsetFetch[0] = UnsignedNumericLiteralOrParam()
+        <COMMA>
+        (
+            offsetFetch[1] = UnsignedNumericLiteralOrParam() {
+                error = "count";
+            }
+        |
+            <ALL> {
+                error = "ALL";
+            }
+        ) {
+            if (!this.conformance.isLimitStartCountAllowed()) {
+                throw SqlUtil.newContextException(s.end(this),
+                    RESOURCE.limitStartCountOrAllNotAllowed(error));
+            }
+        }
+    |
+        offsetFetch[1] = UnsignedNumericLiteralOrParam()
+    |
+        <ALL>
+    )
+}
+
+/**
+ * Parses a leaf in a query expression (SELECT, VALUES or TABLE).
+ */
+SqlNode LeafQuery(ExprContext exprContext) :
+{
+    SqlNode e;
+}
+{
+    {
+        // ensure a query is legal in this context
+        checkQueryExpression(exprContext);
+    }
+    e = SqlSelect() { return e; }
+|
+    e = TableConstructor() { return e; }
+|
+    e = ExplicitTable(getPos()) { return e; }
+}
+
+/**
+ * Parses a parenthesized query or single row expression.
+ * Depending on {@code exprContext}, may also accept a join.
+ */
+SqlNode ParenthesizedExpression(ExprContext exprContext) :
+{
+    SqlNode e;
+}
+{
+    <LPAREN>
+    {
+        // we've now seen left paren, so queries inside should
+        // be allowed as sub-queries
+        switch (exprContext) {
+        case ACCEPT_SUB_QUERY:
+            exprContext = ExprContext.ACCEPT_NONCURSOR;
+            break;
+        case ACCEPT_CURSOR:
+            exprContext = ExprContext.ACCEPT_ALL;
+            break;
+        }
+    }
+    e = ExprOrJoinOrOrderedQuery(exprContext)
+    <RPAREN>
+    {
+        exprContext.throwIfNotCompatible(e);
+        return e;
+    }
+}
+
+/**
+ * Parses a parenthesized query or comma-list of row expressions.
+ *
+ * <p>REVIEW jvs 8-Feb-2004: There's a small hole in this production.  It can be
+ * used to construct something like
+ *
+ * <blockquote><pre>
+ * WHERE x IN (select count(*) from t where c=d,5)</pre>
+ * </blockquote>
+ *
+ * <p>which should be illegal.  The above is interpreted as equivalent to
+ *
+ * <blockquote><pre>
+ * WHERE x IN ((select count(*) from t where c=d),5)</pre>
+ * </blockquote>
+ *
+ * <p>which is a legal use of a sub-query.  The only way to fix the hole is to
+ * be able to remember whether a subexpression was parenthesized or not, which
+ * means preserving parentheses in the SqlNode tree.  This is probably
+ * desirable anyway for use in purely syntactic parsing applications (e.g. SQL
+ * pretty-printer).  However, if this is done, it's important to also make
+ * isA() on the paren node call down to its operand so that we can
+ * always correctly discriminate a query from a row expression.
+ */
+SqlNodeList ParenthesizedQueryOrCommaList(
+    ExprContext exprContext) :
+{
+    SqlNode e;
+    final List<SqlNode> list = new ArrayList<SqlNode>();
+    ExprContext firstExprContext = exprContext;
+    final Span s;
+}
+{
+    <LPAREN>
+    {
+        // we've now seen left paren, so a query by itself should
+        // be interpreted as a sub-query
+        s = span();
+        switch (exprContext) {
+        case ACCEPT_SUB_QUERY:
+            firstExprContext = ExprContext.ACCEPT_NONCURSOR;
+            break;
+        case ACCEPT_CURSOR:
+            firstExprContext = ExprContext.ACCEPT_ALL;
+            break;
+        }
+    }
+    e = OrderedQueryOrExpr(firstExprContext) { list.add(e); }
+    (
+        <COMMA>
+        {
+            // a comma-list can't appear where only a query is expected
+            checkNonQueryExpression(exprContext);
+        }
+        AddExpression(list, exprContext)
+    )*
+    <RPAREN>
+    {
+        return new SqlNodeList(list, s.end(this));
+    }
+}
+
+/** As ParenthesizedQueryOrCommaList, but allows DEFAULT
+ * in place of any of the expressions. For example,
+ * {@code (x, DEFAULT, null, DEFAULT)}. */
+SqlNodeList ParenthesizedQueryOrCommaListWithDefault(
+    ExprContext exprContext) :
+{
+    SqlNode e;
+    final List<SqlNode> list = new ArrayList<SqlNode>();
+    ExprContext firstExprContext = exprContext;
+    final Span s;
+}
+{
+    <LPAREN>
+    {
+        // we've now seen left paren, so a query by itself should
+        // be interpreted as a sub-query
+        s = span();
+        switch (exprContext) {
+        case ACCEPT_SUB_QUERY:
+            firstExprContext = ExprContext.ACCEPT_NONCURSOR;
+            break;
+        case ACCEPT_CURSOR:
+            firstExprContext = ExprContext.ACCEPT_ALL;
+            break;
+        }
+    }
+    (
+        e = OrderedQueryOrExpr(firstExprContext) { list.add(e); }
+    |
+        e = Default() { list.add(e); }
+    )
+    (
+        <COMMA>
+        {
+            // a comma-list can't appear where only a query is expected
+            checkNonQueryExpression(exprContext);
+        }
+        (
+            e = Expression(exprContext) { list.add(e); }
+        |
+            e = Default() { list.add(e); }
+        )
+    )*
+    <RPAREN>
+    {
+        return new SqlNodeList(list, s.end(this));
+    }
+}
+
+/**
+ * Parses function parameter lists.
+ * If the list starts with DISTINCT or ALL, it is discarded.
+ */
+List<SqlNode> UnquantifiedFunctionParameterList(ExprContext exprContext) :
+{
+    final List<SqlNode> args;
+}
+{
+    args = FunctionParameterList(exprContext) {
+        args.remove(0); // remove DISTINCT or ALL, if present
+        return args;
+    }
+}
+
+/**
+ * Parses function parameter lists including DISTINCT keyword recognition,
+ * DEFAULT, and named argument assignment.
+ */
+List<SqlNode> FunctionParameterList(ExprContext exprContext) :
+{
+    final SqlLiteral qualifier;
+    final List<SqlNode> list = new ArrayList<SqlNode>();
+}
+{
+    <LPAREN>
+    (
+        qualifier = AllOrDistinct() { list.add(qualifier); }
+    |
+        { list.add(null); }
+    )
+    AddArg0(list, exprContext)
+    (
+        <COMMA> {
+            // a comma-list can't appear where only a query is expected
+            checkNonQueryExpression(exprContext);
+        }
+        AddArg(list, exprContext)
+    )*
+    <RPAREN>
+    {
+        return list;
+    }
+}
+
+SqlLiteral AllOrDistinct() :
+{
+}
+{
+    <DISTINCT> { return SqlSelectKeyword.DISTINCT.symbol(getPos()); }
+|
+    <ALL> { return SqlSelectKeyword.ALL.symbol(getPos()); }
+}
+
+void AddArg0(List<SqlNode> list, ExprContext exprContext) :
+{
+    final SqlIdentifier name;
+    SqlNode e;
+    final ExprContext firstExprContext;
+    {
+        // we've now seen left paren, so queries inside should
+        // be allowed as sub-queries
+        switch (exprContext) {
+        case ACCEPT_SUB_QUERY:
+            firstExprContext = ExprContext.ACCEPT_NONCURSOR;
+            break;
+        case ACCEPT_CURSOR:
+            firstExprContext = ExprContext.ACCEPT_ALL;
+            break;
+        default:
+            firstExprContext = exprContext;
+            break;
+        }
+    }
+}
+{
+    (
+        LOOKAHEAD(2) name = SimpleIdentifier() <NAMED_ARGUMENT_ASSIGNMENT>
+    |   { name = null; }
+    )
+    (
+        e = Default()
+    |
+        LOOKAHEAD((SimpleIdentifierOrList() | <LPAREN> <RPAREN>) <LAMBDA>)
+        e = LambdaExpression()
+    |
+        LOOKAHEAD(3)
+        e = TableParam()
+    |
+        e = PartitionedQueryOrQueryOrExpr(firstExprContext)
+    )
+    {
+        if (name != null) {
+            e = SqlStdOperatorTable.ARGUMENT_ASSIGNMENT.createCall(
+                Span.of(name, e).pos(), e, name);
+        }
+        list.add(e);
+    }
+}
+
+void AddArg(List<SqlNode> list, ExprContext exprContext) :
+{
+    final SqlIdentifier name;
+    SqlNode e;
+}
+{
+    (
+        LOOKAHEAD(2) name = SimpleIdentifier() <NAMED_ARGUMENT_ASSIGNMENT>
+    |   { name = null; }
+    )
+    (
+        e = Default()
+    |
+        LOOKAHEAD((SimpleIdentifierOrList() | <LPAREN> <RPAREN>) <LAMBDA>)
+        e = LambdaExpression()
+    |
+        e = Expression(exprContext)
+    |
+        e = TableParam()
+    )
+    {
+        if (name != null) {
+            e = SqlStdOperatorTable.ARGUMENT_ASSIGNMENT.createCall(
+                Span.of(name, e).pos(), e, name);
+        }
+        list.add(e);
+    }
+}
+
+SqlNode Default() : {}
+{
+    <DEFAULT_> {
+        return SqlStdOperatorTable.DEFAULT.createCall(getPos());
+    }
+}
+
+/**
+ * Parses a query (SELECT, UNION, INTERSECT, EXCEPT, VALUES, TABLE) followed by
+ * the end-of-file symbol.
+ */
+SqlNode SqlQueryEof() :
+{
+    SqlNode query;
+}
+{
+    query = OrderedQueryOrExpr(ExprContext.ACCEPT_QUERY)
+    <EOF>
+    { return query; }
+}
+
+/**
+ * Parses a list of SQL statements separated by semicolon.
+ * The semicolon is required between statements, but is
+ * optional at the end.
+ */
+SqlNodeList SqlStmtList() :
+{
+    final List<SqlNode> stmtList = new ArrayList<SqlNode>();
+    SqlNode stmt;
+}
+{
+    stmt = SqlStmt() {
+        stmtList.add(stmt);
+    }
+    (
+        <SEMICOLON>
+        [
+            stmt = SqlStmt() {
+                stmtList.add(stmt);
+            }
+        ]
+    )*
+    <EOF>
+    {
+        return new SqlNodeList(stmtList, Span.of(stmtList).pos());
+    }
+}
+
+/**
+ * Parses an SQL statement.
+ */
+SqlNode SqlStmt() :
+{
+    SqlNode stmt;
+}
+{
+    (
+<#-- Add methods to parse additional statements here -->
+<#list (parser.statementParserMethods!default.parser.statementParserMethods) as method>
+        LOOKAHEAD(2) stmt = ${method}
+    |
+</#list>
+        stmt = SqlSetOption(Span.of(), null)
+    |
+        stmt = SqlAlter()
+    |
+<#if (parser.createStatementParserMethods!default.parser.createStatementParserMethods)?size != 0>
+        stmt = SqlCreate()
+    |
+</#if>
+<#if (parser.dropStatementParserMethods!default.parser.dropStatementParserMethods)?size != 0>
+        stmt = SqlDrop()
+    |
+</#if>
+<#if (parser.truncateStatementParserMethods!default.parser.truncateStatementParserMethods)?size != 0>
+        LOOKAHEAD(2)
+        stmt = SqlTruncate()
+    |
+</#if>
+        stmt = OrderedQueryOrExpr(ExprContext.ACCEPT_QUERY)
+    |
+        stmt = SqlExplain()
+    |
+        stmt = SqlDescribe()
+    |
+        stmt = SqlInsert()
+    |
+        stmt = SqlDelete()
+    |
+        stmt = SqlUpdate()
+    |
+        stmt = SqlMerge()
+    |
+        stmt = SqlProcedureCall()
+    )
+    {
+        return stmt;
+    }
+}
+
+/**
+ * Parses an SQL statement followed by the end-of-file symbol.
+ */
+SqlNode SqlStmtEof() :
+{
+    SqlNode stmt;
+}
+{
+    stmt = SqlStmt() <EOF>
+    {
+        return stmt;
+    }
+}
+
+<#-- Add implementations of additional parser statement calls here -->
+<#list (parser.implementationFiles!default.parser.implementationFiles) as file>
+    <#include "/@includes/"+file />
+</#list>
+
+SqlNodeList ParenthesizedKeyValueOptionCommaList() :
+{
+    final Span s;
+    final List<SqlNode> list = new ArrayList<SqlNode>();
+}
+{
+    { s = span(); }
+    <LPAREN>
+    AddKeyValueOption(list)
+    (
+        <COMMA>
+        AddKeyValueOption(list)
+    )*
+    <RPAREN> {
+        return new SqlNodeList(list, s.end(this));
+    }
+}
+
+/**
+* Parses an option with format key=val whose key is a simple identifier or string literal
+* and value is a string literal.
+*/
+void AddKeyValueOption(List<SqlNode> list) :
+{
+    final SqlNode key;
+    final SqlNode value;
+}
+{
+    (
+        key = SimpleIdentifier()
+    |
+        key = StringLiteral()
+    )
+    <EQ>
+    value = StringLiteral() {
+        list.add(key);
+        list.add(value);
+    }
+}
+
+/** 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() { list.add(value); }
+    |
+        value = StringLiteral() { list.add(value); }
+    )
+}
+
+/**
+ * Parses a literal list separated by comma. The literal is either a string or a numeric.
+ */
+SqlNodeList ParenthesizedLiteralOptionCommaList() :
+{
+    final Span s;
+    final List<SqlNode> list = new ArrayList<SqlNode>();
+}
+{
+    { s = span(); }
+    <LPAREN>
+    AddOptionValue(list) ( <COMMA> AddOptionValue(list) )*
+    <RPAREN> {
+        return new SqlNodeList(list, s.end(this));
+    }
+}
+
+void AddHint(List<SqlNode> hints) :
+{
+    final SqlIdentifier hintName;
+    final SqlNodeList hintOptions;
+    final SqlHint.HintOptionFormat optionFormat;
+}
+{
+    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 hints following a table reference,
+ * and returns the wrapped table reference. */
+SqlNode TableHints(SqlIdentifier tableName) :
+{
+    final List<SqlNode> hints = new ArrayList<SqlNode>();
+}
+{
+    <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);
+    }
+}
+
+/**
+ * Parses a leaf SELECT expression without ORDER BY.
+ */
+SqlSelect SqlSelect() :
+{
+    final List<SqlLiteral> keywords = new ArrayList<SqlLiteral>();
+    final SqlLiteral keyword;
+    final SqlNodeList keywordList;
+    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> AddHint(hints) ( <COMMA> AddHint(hints) )* <COMMENT_END> ]
+    SqlSelectKeywords(keywords)
+    (
+        <STREAM> {
+            keywords.add(SqlSelectKeyword.STREAM.symbol(getPos()));
+        }
+    )?
+    (
+        keyword = AllOrDistinct() { keywords.add(keyword); }
+    )?
+    {
+        keywordList = new SqlNodeList(keywords, s.addAll(keywords).pos());
+    }
+    AddSelectItem(selectList)
+    ( <COMMA> AddSelectItem(selectList) )*
+    (
+        <FROM> fromClause = FromClause()
+        ( where = Where() | { where = null; } )
+        ( groupBy = GroupBy() | { groupBy = null; } )
+        ( having = Having() | { having = null; } )
+        ( windowDecls = Window() | { windowDecls = null; } )
+        ( qualify = Qualify() | { qualify = null; } )
+    |
+        E() {
+            fromClause = null;
+            where = null;
+            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, qualify,
+            null, null, null, new SqlNodeList(hints, getPos()));
+    }
+}
+
+/*
+ * Abstract production:
+ *
+ *    void SqlSelectKeywords(List keywords)
+ *
+ * Parses dialect-specific keywords immediately following the SELECT keyword.
+ */
+
+/**
+ * Parses an EXPLAIN PLAN statement.
+ */
+SqlNode SqlExplain() :
+{
+    SqlNode stmt;
+    SqlExplainLevel detailLevel = SqlExplainLevel.EXPPLAN_ATTRIBUTES;
+    SqlExplain.Depth depth;
+    final SqlExplainFormat format;
+}
+{
+    <EXPLAIN> <PLAN>
+    [ detailLevel = ExplainDetailLevel() ]
+    depth = ExplainDepth()
+    (
+        LOOKAHEAD(2)
+        <AS> <XML> { format = SqlExplainFormat.XML; }
+    |
+        LOOKAHEAD(2)
+        <AS> <JSON> { format = SqlExplainFormat.JSON; }
+    |
+        <AS> <DOT_FORMAT> { format = SqlExplainFormat.DOT; }
+    |
+        { format = SqlExplainFormat.TEXT; }
+    )
+    <FOR> stmt = SqlQueryOrDml() {
+        return new SqlExplain(getPos(),
+            stmt,
+            detailLevel.symbol(SqlParserPos.ZERO),
+            depth.symbol(SqlParserPos.ZERO),
+            format.symbol(SqlParserPos.ZERO),
+            nDynamicParams);
+    }
+}
+
+/** Parses a query (SELECT or VALUES)
+ * or DML statement (INSERT, UPDATE, DELETE, MERGE). */
+SqlNode SqlQueryOrDml() :
+{
+    SqlNode stmt;
+}
+{
+    (
+        stmt = OrderedQueryOrExpr(ExprContext.ACCEPT_QUERY)
+    |
+        stmt = SqlInsert()
+    |
+        stmt = SqlDelete()
+    |
+        stmt = SqlUpdate()
+    |
+        stmt = SqlMerge()
+    ) { return stmt; }
+}
+
+/**
+ * Parses WITH TYPE | WITH IMPLEMENTATION | WITHOUT IMPLEMENTATION modifier for
+ * EXPLAIN PLAN.
+ */
+SqlExplain.Depth ExplainDepth() :
+{
+}
+{
+    (
+        LOOKAHEAD(2)
+        <WITH> <TYPE>
+        {
+            return SqlExplain.Depth.TYPE;
+        }
+        |
+        <WITH> <IMPLEMENTATION>
+        {
+            return SqlExplain.Depth.PHYSICAL;
+        }
+        |
+        <WITHOUT> <IMPLEMENTATION>
+        {
+            return SqlExplain.Depth.LOGICAL;
+        }
+        |
+        {
+            return SqlExplain.Depth.PHYSICAL;
+        }
+
+    )
+}
+
+/**
+ * Parses INCLUDING ALL ATTRIBUTES modifier for EXPLAIN PLAN.
+ */
+SqlExplainLevel ExplainDetailLevel() :
+{
+    SqlExplainLevel level = SqlExplainLevel.EXPPLAN_ATTRIBUTES;
+}
+{
+    (
+        <EXCLUDING> <ATTRIBUTES>
+        {
+            level = SqlExplainLevel.NO_ATTRIBUTES;
+        }
+        |
+        <INCLUDING>
+        [ <ALL> { level = SqlExplainLevel.ALL_ATTRIBUTES; } ]
+        <ATTRIBUTES>
+        {
+        }
+    )
+    {
+        return level;
+    }
+}
+
+/**
+ * Parses a DESCRIBE statement.
+ */
+SqlNode SqlDescribe() :
+{
+   final Span s;
+   final SqlIdentifier table;
+   final SqlIdentifier column;
+   final SqlIdentifier id;
+   final SqlNode stmt;
+}
+{
+    <DESCRIBE> { s = span(); }
+    (
+        LOOKAHEAD(2) (<DATABASE> | <CATALOG> | <SCHEMA>)
+        id = CompoundIdentifier() {
+            // DESCRIBE DATABASE and DESCRIBE CATALOG currently do the same as
+            // DESCRIBE SCHEMA but should be different. See
+            //   [CALCITE-1221] Implement DESCRIBE DATABASE, CATALOG, STATEMENT
+            return new SqlDescribeSchema(s.end(id), id);
+        }
+    |
+        // Use syntactic lookahead to determine whether a table name is coming.
+        // We do not allow SimpleIdentifier() because that includes <STATEMENT>.
+        LOOKAHEAD( <TABLE>
+           | <IDENTIFIER>
+           | <HYPHENATED_IDENTIFIER>
+           | <QUOTED_IDENTIFIER>
+           | <BACK_QUOTED_IDENTIFIER>
+           | <BIG_QUERY_BACK_QUOTED_IDENTIFIER>
+           | <BRACKET_QUOTED_IDENTIFIER> )
+        (<TABLE>)?
+        table = CompoundIdentifier()
+        ( column = SimpleIdentifier() | { column = null; } )
+        {
+            return new SqlDescribeTable(s.add(table).addIf(column).pos(),
+                table, column);
+        }
+    |
+        (LOOKAHEAD(1) <STATEMENT>)?
+        stmt = SqlQueryOrDml() {
+            // DESCRIBE STATEMENT currently does the same as EXPLAIN. See
+            //   [CALCITE-1221] Implement DESCRIBE DATABASE, CATALOG, STATEMENT
+            final SqlExplainLevel detailLevel = SqlExplainLevel.EXPPLAN_ATTRIBUTES;
+            final SqlExplain.Depth depth = SqlExplain.Depth.PHYSICAL;
+            final SqlExplainFormat format = SqlExplainFormat.TEXT;
+            return new SqlExplain(s.end(stmt),
+                stmt,
+                detailLevel.symbol(SqlParserPos.ZERO),
+                depth.symbol(SqlParserPos.ZERO),
+                format.symbol(SqlParserPos.ZERO),
+                nDynamicParams);
+        }
+    )
+}
+
+/**
+ * Parses a CALL statement.
+ */
+SqlNode SqlProcedureCall() :
+{
+    final Span s;
+    SqlNode routineCall;
+}
+{
+    <CALL> {
+        s = span();
+    }
+    routineCall = NamedRoutineCall(
+        SqlFunctionCategory.USER_DEFINED_PROCEDURE,
+        ExprContext.ACCEPT_SUB_QUERY)
+    {
+        return SqlStdOperatorTable.PROCEDURE_CALL.createCall(
+            s.end(routineCall), routineCall);
+    }
+}
+
+SqlNode NamedRoutineCall(
+    SqlFunctionCategory routineType,
+    ExprContext exprContext) :
+{
+    final SqlIdentifier name;
+    final List<SqlNode> list = new ArrayList<SqlNode>();
+    final Span s;
+}
+{
+    name = CompoundIdentifier() {
+        s = span();
+    }
+    <LPAREN>
+    [
+        AddArg0(list, exprContext)
+        (
+            <COMMA> {
+                // a comma-list can't appear where only a query is expected
+                checkNonQueryExpression(exprContext);
+            }
+            AddArg(list, exprContext)
+        )*
+    ]
+    <RPAREN>
+    {
+        return createCall(name, s.end(this), routineType, null, list);
+    }
+}
+
+/**
+ * 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.
+ */
+// Using fully qualified name for Pair class, since Calcite also has a same class name being used in the Parser.jj
+SqlNode SqlInsert() :
+{
+    final List<SqlLiteral> keywords = new ArrayList<SqlLiteral>();
+    final SqlNodeList keywordList;
+    final SqlIdentifier destination;
+    SqlNode tableRef = null;
+    SqlNode source;
+    final SqlNodeList columnList;
+    final Span s;
+    final Pair<SqlNodeList, SqlNodeList> p;
+    SqlInsert sqlInsert;
+    SqlGranularityLiteral partitionedBy = null;
+    SqlNodeList clusteredBy = null;
+    SqlIdentifier exportFileFormat = null;
+}
+{
+    (
+        <INSERT>
+    |
+        <UPSERT> { keywords.add(SqlInsertKeyword.UPSERT.symbol(getPos())); }
+    )
+    { s = span(); }
+    SqlInsertKeywords(keywords) {
+        keywordList = new SqlNodeList(keywords, s.addAll(keywords).pos());
+    }
+    <INTO>
+    (
+        LOOKAHEAD(2)
+        <EXTERN> <LPAREN> destination = ExternalDestination() <RPAREN>
+    |
+        destination = CompoundTableIdentifier()
+        ( tableRef = TableHints(destination) | { tableRef = destination; } )
+        [ LOOKAHEAD(5) tableRef = ExtendTable(tableRef) ]
+    )
+    (
+        LOOKAHEAD(2)
+        p = ParenthesizedCompoundIdentifierList() {
+            if (p.right.size() > 0) {
+                tableRef = extend(tableRef, p.right);
+            }
+            if (p.left.size() > 0) {
+                columnList = p.left;
+            } else {
+                columnList = null;
+            }
+        }
+    |   { columnList = null; }
+    )
+    [
+        <AS> exportFileFormat = FileFormat()
+    ]
+    (
+        <OVERWRITE>
+        {
+            throw org.apache.druid.sql.calcite.parser.DruidSqlParserUtils.problemParsing(
+                "An OVERWRITE clause is not allowed with INSERT statements. Use REPLACE statements if overwriting existing segments is required or remove the OVERWRITE clause."
+            );
+        }
+        |
+        source = OrderedQueryOrExpr(ExprContext.ACCEPT_QUERY)
+    )
+    // PARTITIONED BY is necessary, but is kept optional in the grammar. It is asserted that it is not missing in the
+    // IngestHandler#validate() so that we can return a custom error message.
+    [
+        <PARTITIONED> <BY>
+        partitionedBy = PartitionGranularity()
+    ]
+    [
+        clusteredBy = ClusteredBy()
+    ]
+    {
+        sqlInsert = new SqlInsert(s.end(source), keywordList, destination, source, columnList);
+        return DruidSqlInsert.create(sqlInsert, partitionedBy, clusteredBy, exportFileFormat);
+    }
+}
+
+SqlNode DruidSqlInsertEof() :
+{
+    SqlNode sqlInsert;
+}
+{
+    sqlInsert = SqlInsert()
+    <EOF>
+    {
+        return sqlInsert;
+    }
+}
+
+
+/*
+ * Abstract production:
+ *
+ *    void SqlInsertKeywords(List keywords)
+ *
+ * Parses dialect-specific keywords immediately following the INSERT keyword.
+ */
+
+/**
+ * Parses a DELETE statement.
+ */
+SqlNode SqlDelete() :
+{
+    final SqlIdentifier tableName;
+    SqlNode tableRef;
+    final SqlIdentifier alias;
+    final SqlNode where;
+    final Span s;
+}
+{
+    <DELETE> {
+        s = span();
+    }
+    <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(tableRef).addIf(alias).addIf(where).pos(),
+            tableRef, where, null, alias);
+    }
+}
+
+/**
+ * Parses an UPDATE statement.
+ */
+SqlNode SqlUpdate() :
+{
+    final SqlIdentifier tableName;
+    SqlNode tableRef;
+    final SqlIdentifier alias;
+    final SqlNode where;
+    final SqlNodeList sourceExpressionList;
+    final SqlNodeList targetColumnList;
+    SqlIdentifier id;
+    final Span s;
+}
+{
+    <UPDATE> {
+        s = span();
+        targetColumnList = new SqlNodeList(s.pos());
+        sourceExpressionList = new SqlNodeList(s.pos());
+    }
+    tableName = CompoundTableIdentifier()
+    ( tableRef = TableHints(tableName) | { tableRef = tableName; } )
+    [ tableRef = ExtendTable(tableRef) ]
+    ( [ <AS> ] alias = SimpleIdentifier() | { alias = null; } )
+    <SET> id = SimpleIdentifier() {
+        targetColumnList.add(id);
+    }
+    // TODO:  support DEFAULT also
+    <EQ> AddExpression(sourceExpressionList, ExprContext.ACCEPT_SUB_QUERY)
+    (
+        <COMMA>
+        id = SimpleIdentifier() { targetColumnList.add(id); }
+        <EQ> AddExpression(sourceExpressionList, ExprContext.ACCEPT_SUB_QUERY)
+    )*
+    ( where = Where() | { where = null; } )
+    {
+        final SqlParserPos pos = s.addAll(targetColumnList)
+            .addAll(sourceExpressionList).addIf(where).pos();
+        return new SqlUpdate(pos, tableRef, targetColumnList,
+            sourceExpressionList, where, null, alias);
+    }
+}
+
+/**
+ * Parses a MERGE statement.
+ */
+SqlNode SqlMerge() :
+{
+    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> 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(tableRef, alias)
+        ( insertCall = WhenNotMatchedClause(tableRef) | { insertCall = null; } )
+    |
+        { updateCall = null; }
+        insertCall = WhenNotMatchedClause(tableRef)
+    )
+    {
+        final SqlParserPos pos = s.addIf(updateCall).addIf(insertCall).pos();
+        return new SqlMerge(pos, tableRef, condition, sourceTableRef,
+            updateCall, insertCall, null, alias);
+    }
+}
+
+SqlUpdate WhenMatchedClause(SqlNode table, SqlIdentifier alias) :
+{
+    SqlIdentifier id;
+    final Span s;
+    final SqlNodeList updateColumnList = new SqlNodeList(SqlParserPos.ZERO);
+    final SqlNodeList updateExprList = new SqlNodeList(SqlParserPos.ZERO);
+}
+{
+    <WHEN> { s = span(); } <MATCHED> <THEN>
+    <UPDATE> <SET> id = CompoundIdentifier() {
+        updateColumnList.add(id);
+    }
+    <EQ> AddExpression(updateExprList, ExprContext.ACCEPT_SUB_QUERY)
+    (
+        <COMMA>
+        id = CompoundIdentifier() {
+            updateColumnList.add(id);
+        }
+        <EQ> AddExpression(updateExprList, ExprContext.ACCEPT_SUB_QUERY)
+    )*
+    {
+        return new SqlUpdate(s.addAll(updateExprList).pos(), table,
+            updateColumnList, updateExprList, null, null, alias);
+    }
+}
+
+SqlInsert WhenNotMatchedClause(SqlNode table) :
+{
+    final Span insertSpan, valuesSpan;
+    final List<SqlLiteral> keywords = new ArrayList<SqlLiteral>();
+    final SqlNodeList keywordList;
+    final SqlNodeList insertColumnList;
+    SqlNode rowConstructor;
+    SqlNode insertValues;
+}
+{
+    <WHEN> <NOT> <MATCHED> <THEN> <INSERT> {
+        insertSpan = span();
+    }
+    SqlInsertKeywords(keywords) {
+        keywordList = new SqlNodeList(keywords, insertSpan.end(this));
+    }
+    (
+        LOOKAHEAD(2)
+        insertColumnList = ParenthesizedSimpleIdentifierList()
+    |   { 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
+        // actually invalid SQL; should fix unparse
+        insertValues = SqlStdOperatorTable.VALUES.createCall(
+            valuesSpan.end(this), rowConstructor);
+        return new SqlInsert(insertSpan.end(this), keywordList,
+            table, insertValues, insertColumnList);
+    }
+}
+
+/**
+ * Parses one item in a select list.
+ */
+void AddSelectItem(List<SqlNode> list) :
+{
+    final SqlNode e;
+    final SqlIdentifier id;
+}
+{
+    e = SelectExpression()
+    (
+        [ <AS> ]
+        (
+            id = SimpleIdentifier()
+        |
+            // Mute the warning about ambiguity between alias and continued
+            // string literal.
+            LOOKAHEAD(1)
+            id = SimpleIdentifierFromStringLiteral()
+        )
+        { list.add(SqlStdOperatorTable.AS.createCall(span().end(e), e, id)); }
+    |   { list.add(e); }
+    )
+}
+
+/**
+ * Parses one unaliased expression in a select list.
+ */
+SqlNode SelectExpression() :
+{
+    SqlNode e;
+}
+{
+    <STAR> {
+        return SqlIdentifier.star(getPos());
+    }
+|
+    e = Expression(ExprContext.ACCEPT_SUB_QUERY) {
+        return e;
+    }
+}
+
+SqlLiteral Natural() :
+{
+}
+{
+    <NATURAL> { return SqlLiteral.createBoolean(true, getPos()); }
+|
+    { return SqlLiteral.createBoolean(false, getPos()); }
+}
+
+SqlLiteral JoinType() :
+{
+    JoinType joinType;
+}
+{
+    (
+<#list (parser.joinTypes!default.parser.joinTypes) as method>
+        LOOKAHEAD(3) // required for "LEFT SEMI JOIN" and "LEFT ANTI JOIN" in Babel
+        joinType = ${method}()
+    |
+</#list>
+        <JOIN> { joinType = JoinType.INNER; }
+    |
+        <INNER> <JOIN> { joinType = JoinType.INNER; }
+    |
+        <LEFT> [ <OUTER> ] <JOIN> { joinType = JoinType.LEFT; }
+    |
+        <RIGHT> [ <OUTER> ] <JOIN> { joinType = JoinType.RIGHT; }
+    |
+        <FULL> [ <OUTER> ] <JOIN> { joinType = JoinType.FULL; }
+    |
+        <CROSS> <JOIN> { joinType = JoinType.CROSS; }
+    )
+    {
+        return joinType.symbol(getPos());
+    }
+}
+
+/*
+ * Druid note: this file is copied from core/src/main/codegen/templates/Parser.jj in Calcite 1.35.0, with changes to
+ * to add two elements of Druid syntax to the FROM clause:
+ *
+ * id [ (<args>) ]
+ *
+ * And
+ *
+ * TABLE(<fn>(<args>)) (<schema>)
+ *
+ */
+/**
+ * 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) :
+{
+    SqlNode e2, condition;
+    final SqlLiteral natural, joinType, on, using;
+    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 = TableRef1(ExprContext.ACCEPT_QUERY_OR_JOIN)
+    (
+        <ON> { on = JoinConditionType.ON.symbol(getPos()); }
+        condition = Expression(ExprContext.ACCEPT_SUB_QUERY) {
+            return new SqlJoin(joinType.getParserPosition(),
+                e,
+                natural,
+                joinType,
+                e2,
+                on,
+                condition);
+        }
+    |
+        <USING> { using = JoinConditionType.USING.symbol(getPos()); }
+        list = ParenthesizedSimpleIdentifierList() {
+            return new SqlJoin(joinType.getParserPosition(),
+                e,
+                natural,
+                joinType,
+                e2,
+                using,
+                new SqlNodeList(list, Span.of(using).end(this)));
+        }
+    |
+        {
+            return new SqlJoin(joinType.getParserPosition(),
+                e,
+                natural,
+                joinType,
+                e2,
+                JoinConditionType.NONE.symbol(joinType.getParserPosition()),
+                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()));
+    }
+}
+
+/**
+ * Parses a table reference in a FROM clause, not lateral unless LATERAL
+ * is explicitly specified.
+ */
+SqlNode TableRef() :
+{
+    final SqlNode e;
+}
+{
+    e = TableRef3(ExprContext.ACCEPT_QUERY, false) { return e; }
+}
+
+SqlNode TableRef1(ExprContext exprContext) :
+{
+    final SqlNode e;
+}
+{
+    e = TableRef3(exprContext, false) { return e; }
+}
+
+/**
+ * Parses a table reference in a FROM clause.
+ */
+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;
+    List<SqlNode> paramList;
+    final SqlIdentifier alias;
+    final Span s;
+    SqlNodeList args;
+    final SqlNodeList columnAliasList;
+    SqlUnnestOperator unnestOp = SqlStdOperatorTable.UNNEST;
+    SqlNodeList extendList = null;
+}
+{
+    (
+        LOOKAHEAD(2)
+        tableName = CompoundTableIdentifier() { s = span(); }
+        (
+            // Table call syntax like FROM a.b() instead of FROM TABLE(a.b())
+            // Three tokens needed to disambiguate EXTEND syntax from CALCITE-493.
+            // Example: "FROM EventLog(lastGCTime TIME)".
+            LOOKAHEAD(3)
+            tableRef = ImplicitTableFunctionCallArgs(tableName)
+        |
+            ( tableRef = TableHints(tableName) | { tableRef = tableName; } )
+        // BEGIN: Druid-specific code
+        [
+            paramList = FunctionParameterList(ExprContext.ACCEPT_NONCURSOR)
+            {
+                tableRef = ParameterizeOperator.PARAM.createCall(tableRef, paramList);
+            }
+        ]
+        // END: Druid-specific code
+            tableRef = Over(tableRef)
+            [ tableRef = Snapshot(tableRef) ]
+            [ tableRef = MatchRecognize(tableRef) ]
+        )
+    |
+        LOOKAHEAD(2)
+        [ <LATERAL> { lateral = true; } ]
+        tableRef = ParenthesizedExpression(exprContext)
+        tableRef = Over(tableRef)
+        tableRef = addLateral(tableRef, lateral)
+        [ tableRef = MatchRecognize(tableRef) ]
+    |
+        <UNNEST> { s = span(); }
+        args = ParenthesizedQueryOrCommaList(ExprContext.ACCEPT_SUB_QUERY)
+        [
+            <WITH> <ORDINALITY> {
+                unnestOp = SqlStdOperatorTable.UNNEST_WITH_ORDINALITY;
+            }
+        ]
+        {
+            tableRef = unnestOp.createCall(s.end(this), (List<SqlNode>) args);
+        }
+    |
+        [ <LATERAL> { lateral = true; } ]
+        tableRef = TableFunctionCall()
+        // BEGIN: Druid-specific code
+        [
+            [ <EXTEND> ]
+            extendList = ExtendList()
+            {
+                tableRef = ExtendOperator.EXTEND.createCall(
+                      Span.of(tableRef, extendList).pos(), tableRef, extendList);
+            }
+        ]
+        // END: Druid-specific code
+        tableRef = addLateral(tableRef, lateral)
+    |
+        tableRef = ExtendedTableRef()
+    )
+    [
+        LOOKAHEAD(2)
+        tableRef = Pivot(tableRef)
+    ]
+    [
+        LOOKAHEAD(2)
+        tableRef = Unpivot(tableRef)
+    ]
+    [
+        [ <AS> ] alias = SimpleIdentifier()
+        (
+            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);
+            } else {
+                List<SqlNode> idList = new ArrayList<SqlNode>();
+                idList.add(tableRef);
+                idList.add(alias);
+                idList.addAll(columnAliasList.getList());
+                tableRef = SqlStdOperatorTable.AS.createCall(
+                    Span.of(tableRef).end(this), idList);
+            }
+        }
+    ]
+    [ 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));
+            return SqlStdOperatorTable.TABLESAMPLE.createCall(
+                s.add(tableRef).end(this), tableRef, sampleLiteral);
+        }
+    |
+        (
+            <BERNOULLI> { isBernoulli = true; }
+        |
+            <SYSTEM> { isBernoulli = false; }
+        )
+        <LPAREN> samplePercentage = UnsignedNumericLiteral() <RPAREN>
+        [
+            <REPEATABLE> <LPAREN> repeatableSeed = IntLiteral() <RPAREN>
+            {
+                isRepeatable = true;
+            }
+        ]
+        {
+            BigDecimal rate =
+                samplePercentage.bigDecimalValue().divide(ONE_HUNDRED);
+            SqlSampleSpec tableSampleSpec =
+                isRepeatable
+                    ? SqlSampleSpec.createTableSample(isBernoulli, rate,
+                        repeatableSeed)
+                    : SqlSampleSpec.createTableSample(isBernoulli, rate);
+            SqlLiteral tableSampleLiteral =
+                SqlLiteral.createSample(tableSampleSpec, s.end(this));
+            return SqlStdOperatorTable.TABLESAMPLE.createCall(
+                s.end(this), tableRef, tableSampleLiteral);
+        }
+    )
+}
+
+/** 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);
+    }
+}
+
+SqlNodeList ExtendList() :
+{
+    final Span s;
+    List<SqlNode> list = new ArrayList<SqlNode>();
+}
+{
+    <LPAREN> { s = span(); }
+    AddColumnType(list)
+    (
+        <COMMA> AddColumnType(list)
+    )*
+    <RPAREN> {
+        return new SqlNodeList(list, s.end(this));
+    }
+}
+
+void AddColumnType(List<SqlNode> list) :
+{
+    final SqlIdentifier name;
+    final SqlDataTypeSpec type;
+    final boolean nullable;
+}
+{
+    name = CompoundIdentifier()
+    type = DataType()
+    nullable = NotNullOpt()
+    {
+        list.add(name);
+        list.add(type.withNullable(nullable, getPos()));
+    }
+}
+
+/**
+ * Parses a compound identifier with optional type.
+ */
+void AddCompoundIdentifierType(List<SqlNode> list, List<SqlNode> extendList) :
+{
+    final SqlIdentifier name;
+    final SqlDataTypeSpec type;
+    final boolean nullable;
+}
+{
+    name = CompoundIdentifier()
+    (
+        type = DataType()
+        nullable = NotNullOpt()
+    |
+        { type = null; nullable = true; }
+    )
+    {
+        if (type != null) {
+            if (!this.conformance.allowExtend()) {
+                throw SqlUtil.newContextException(type.getParserPosition(),
+                    RESOURCE.extendNotAllowed());
+            }
+            extendList.add(name);
+            extendList.add(type.withNullable(nullable, getPos()));
+        }
+        list.add(name);
+    }
+}
+
+SqlNode ImplicitTableFunctionCallArgs(SqlIdentifier name) :
+{
+    final List<SqlNode> tableFuncArgs = new ArrayList<SqlNode>();
+    final SqlNode call;
+    final Span s;
+}
+{
+    // Table call syntax like FROM a.b() instead of FROM TABLE(a.b())
+    // We've already parsed the name, so we don't use NamedRoutineCall.
+    { s = span(); }
+    <LPAREN>
+    [
+        AddArg0(tableFuncArgs, ExprContext.ACCEPT_CURSOR)
+        (
+            <COMMA> {
+                // a comma-list can't appear where only a query is expected
+                checkNonQueryExpression(ExprContext.ACCEPT_CURSOR);
+            }
+            AddArg(tableFuncArgs, ExprContext.ACCEPT_CURSOR)
+        )*
+    ]
+    <RPAREN>
+    {
+        final SqlParserPos pos = s.end(this);
+        call = createCall(name, pos,
+            SqlFunctionCategory.USER_DEFINED_TABLE_FUNCTION, null,
+            tableFuncArgs);
+        return SqlStdOperatorTable.COLLECTION_TABLE.createCall(pos,
+            call);
+    }
+}
+
+SqlNode TableFunctionCall() :
+{
+    final Span s;
+    final SqlNode call;
+    SqlFunctionCategory funcType = SqlFunctionCategory.USER_DEFINED_TABLE_FUNCTION;
+}
+{
+    <TABLE> { s = span(); } <LPAREN>
+    [
+        <SPECIFIC>
+        {
+            funcType = SqlFunctionCategory.USER_DEFINED_TABLE_SPECIFIC_FUNCTION;
+        }
+    ]
+    call = NamedRoutineCall(funcType, ExprContext.ACCEPT_CURSOR)
+    <RPAREN>
+    {
+        return SqlStdOperatorTable.COLLECTION_TABLE.createCall(s.end(this), call);
+    }
+}
+
+/**
+ * Abstract production:
+ *    SqlNode ExtendedTableRef()
+ *
+ * <p>Allows parser to be extended with new types of table references.  The
+ * default implementation of this production is empty.
+ */
+
+/*
+ * Abstract production:
+ *
+ *    SqlNode TableOverOpt()
+ *
+ * Allows an OVER clause following a table expression as an extension to
+ * standard SQL syntax. The default implementation of this production is empty.
+ */
+
+/**
+ * Parses an explicit TABLE t reference.
+ */
+SqlNode ExplicitTable(SqlParserPos pos) :
+{
+    SqlNode tableRef;
+}
+{
+    <TABLE> tableRef = CompoundIdentifier()
+    {
+        return SqlStdOperatorTable.EXPLICIT_TABLE.createCall(pos, tableRef);
+    }
+}
+
+/**
+ * Parses a VALUES leaf query expression.
+ */
+SqlNode TableConstructor() :
+{
+    final List<SqlNode> list = new ArrayList<SqlNode>();
+    final Span s;
+}
+{
+    (
+        <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), list);
+    }
+}
+
+/** Parses a row constructor and adds it to a list. */
+void AddRowConstructor(List<SqlNode> list) :
+{
+    SqlNode e;
+}
+{
+    e = RowConstructor() { list.add(e); }
+}
+
+/**
+ * Parses a row constructor in the context of a VALUES expression.
+ */
+SqlNode RowConstructor() :
+{
+    final SqlNodeList valueList;
+    final SqlNode value;
+    final Span s;
+}
+{
+    // hints are necessary here due to common LPAREN prefixes
+    (
+        // TODO jvs 8-Feb-2004: extra parentheses are accepted here as a hack
+        // for unparse, but this is actually invalid SQL; should
+        // fix unparse
+        LOOKAHEAD(3)
+        <LPAREN> { s = span(); }
+        <ROW>
+        valueList = ParenthesizedQueryOrCommaListWithDefault(ExprContext.ACCEPT_NONCURSOR)
+        <RPAREN> { s.add(this); }
+    |
+        LOOKAHEAD(3)
+        (
+            <ROW> { s = span(); }
+        |
+            { s = Span.of(); }
+        )
+        valueList = ParenthesizedQueryOrCommaListWithDefault(ExprContext.ACCEPT_NONCURSOR)
+    |
+        value = Expression(ExprContext.ACCEPT_NONCURSOR)
+        {
+            // NOTE: A bare value here is standard SQL syntax, believe it or
+            // 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 TableConstructor().  It would be so much more
+            // reasonable to require parentheses.  Sigh.
+            s = Span.of(value);
+            valueList = new SqlNodeList(ImmutableList.of(value),
+                value.getParserPosition());
+        }
+    )
+    {
+        // REVIEW jvs 8-Feb-2004: Should we discriminate between scalar
+        // sub-queries inside of ROW and row sub-queries?  The standard does,
+        // but the distinction seems to be purely syntactic.
+        return SqlStdOperatorTable.ROW.createCall(s.end(valueList),
+            (List<SqlNode>) valueList);
+    }
+}
+
+/** Parses a WHERE clause for SELECT, DELETE, and UPDATE. */
+SqlNode Where() :
+{
+    SqlNode condition;
+}
+{
+    <WHERE> condition = Expression(ExprContext.ACCEPT_SUB_QUERY) {
+        return condition;
+    }
+}
+
+/** Parses a GROUP BY clause for SELECT. */
+SqlNodeList GroupBy() :
+{
+    final List<SqlNode> list;
+    final boolean distinct;
+    final Span s;
+}
+{
+    <GROUP> { s = span(); }
+    <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() :
+{
+    final List<SqlNode> list = new ArrayList<SqlNode>();
+}
+{
+    AddGroupingElement(list)
+    ( LOOKAHEAD(2) <COMMA> AddGroupingElement(list) )*
+    { return list; }
+}
+
+void AddGroupingElement(List<SqlNode> list) :
+{
+    final List<SqlNode> subList;
+    final SqlNodeList nodes;
+    final Span s;
+}
+{
+    LOOKAHEAD(2)
+    <GROUPING> { s = span(); }
+    <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> {
+        list.add(
+            SqlStdOperatorTable.ROLLUP.createCall(s.end(this), nodes.getList()));
+    }
+|   <CUBE> { s = span(); }
+    <LPAREN> nodes = ExpressionCommaList(s, ExprContext.ACCEPT_SUB_QUERY)
+    <RPAREN> {
+        list.add(
+            SqlStdOperatorTable.CUBE.createCall(s.end(this), nodes.getList()));
+    }
+|   LOOKAHEAD(3)
+    <LPAREN> { s = span(); } <RPAREN> {
+        list.add(new SqlNodeList(s.end(this)));
+    }
+|   AddExpression(list, ExprContext.ACCEPT_SUB_QUERY)
+}
+
+/**
+ * Parses a list of expressions separated by commas.
+ */
+SqlNodeList ExpressionCommaList(
+    final Span s,
+    ExprContext exprContext) :
+{
+    final List<SqlNode> list = new ArrayList<SqlNode>();
+}
+{
+    AddExpressions(list, exprContext) {
+        return new SqlNodeList(list, s.addAll(list).pos());
+    }
+}
+
+/**
+ * Parses a list of expressions separated by commas,
+ * appending expressions to a given list.
+ */
+void AddExpressions(List<SqlNode> list, ExprContext exprContext) :
+{
+}
+{
+    AddExpression(list, exprContext)
+    (
+        // NOTE jvs 6-Feb-2004:  See comments at top of file for why
+        // hint is necessary here.
+        LOOKAHEAD(2)
+        <COMMA> AddExpression(list, ExprContext.ACCEPT_SUB_QUERY)
+    )*
+}
+
+/** Parses a HAVING clause for SELECT. */
+SqlNode Having() :
+{
+    SqlNode e;
+}
+{
+    <HAVING> e = Expression(ExprContext.ACCEPT_SUB_QUERY) { return e; }
+}
+
+/** Parses a WINDOW clause for SELECT. */
+SqlNodeList Window() :
+{
+    final List<SqlNode> list = new ArrayList<SqlNode>();
+    final Span s;
+}
+{
+    <WINDOW> { s = span(); }
+    AddWindowSpec(list)
+    (
+        LOOKAHEAD(2)
+        <COMMA> AddWindowSpec(list)
+    )*
+    {
+        return new SqlNodeList(list, s.addAll(list).pos());
+    }
+}
+
+void AddWindowSpec(List<SqlNode> list) :
+{
+    final SqlIdentifier id;
+    final SqlWindow e;
+}
+{
+    id = SimpleIdentifier() <AS> e = WindowSpecification() {
+        e.setDeclName(id);
+        list.add(e);
+    }
+}
+
+/**
+ * Parses a window specification.
+ */
+SqlWindow WindowSpecification() :
+{
+    final SqlIdentifier id;
+    final SqlNodeList partitionList;
+    final SqlNodeList orderList;
+    final SqlLiteral isRows;
+    final SqlNode lowerBound, upperBound;
+    final Span s, s1, s2;
+    final SqlLiteral allowPartial;
+}
+{
+    <LPAREN> { s = span(); }
+    (
+        id = SimpleIdentifier()
+    |   { id = null; }
+    )
+    (
+        <PARTITION> { s1 = span(); }
+        <BY>
+        partitionList = ExpressionCommaList(s1, ExprContext.ACCEPT_NON_QUERY)
+    |   { partitionList = SqlNodeList.EMPTY; }
+    )
+    (
+        orderList = OrderBy(true)
+    |   { orderList = SqlNodeList.EMPTY; }
+    )
+    (
+        (
+            <ROWS> { isRows = SqlLiteral.createBoolean(true, getPos()); }
+        |
+            <RANGE> { isRows = SqlLiteral.createBoolean(false, getPos()); }
+        )
+        (
+            <BETWEEN> lowerBound = WindowRange()
+            <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));
+        }
+    |
+        <DISALLOW> { s2 = span(); } <PARTIAL> {
+            allowPartial = SqlLiteral.createBoolean(false, s2.end(this));
+        }
+    |   { allowPartial = null; }
+    )
+    <RPAREN>
+    {
+        return SqlWindow.create(null, id, partitionList, orderList,
+            isRows, lowerBound, upperBound, allowPartial, s.end(this));
+    }
+}
+
+SqlNode WindowRange() :
+{
+    final SqlNode e;
+    final Span s;
+}
+{
+    LOOKAHEAD(2)
+    <CURRENT> { s = span(); } <ROW> {
+        return SqlWindow.createCurrentRow(s.end(this));
+    }
+|
+    LOOKAHEAD(2)
+    <UNBOUNDED> { s = span(); }
+    (
+        <PRECEDING> {
+            return SqlWindow.createUnboundedPreceding(s.end(this));
+        }
+    |
+        <FOLLOWING> {
+            return SqlWindow.createUnboundedFollowing(s.end(this));
+        }
+    )
+|
+    e = Expression(ExprContext.ACCEPT_NON_QUERY)
+    (
+        <PRECEDING> {
+            return SqlWindow.createPreceding(e, getPos());
+        }
+    |
+        <FOLLOWING> {
+            return SqlWindow.createFollowing(e, getPos());
+        }
+    )
+}
+
+/** 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) :
+{
+    final List<SqlNode> list = new ArrayList<SqlNode>();
+    final Span s;
+}
+{
+    <ORDER> {
+        s = span();
+        if (!accept) {
+            // Someone told us ORDER BY wasn't allowed here.  So why
+            // did they bother calling us?  To get the correct
+            // parser position for error reporting.
+            throw SqlUtil.newContextException(s.pos(), RESOURCE.illegalOrderBy());
+        }
+    }
+    <BY> AddOrderItem(list)
+    (
+        // NOTE jvs 6-Feb-2004:  See comments at top of file for why
+        // hint is necessary here.
+        LOOKAHEAD(2) <COMMA> AddOrderItem(list)
+    )*
+    {
+        return new SqlNodeList(list, s.addAll(list).pos());
+    }
+}
+
+/**
+ * Parses one item in an ORDER BY clause, and adds it to a list.
+ */
+void AddOrderItem(List<SqlNode> list) :
+{
+    SqlNode e;
+}
+{
+    e = Expression(ExprContext.ACCEPT_SUB_QUERY)
+    (
+        <ASC>
+    |   <DESC> {
+            e = SqlStdOperatorTable.DESC.createCall(getPos(), e);
+        }
+    )?
+    (
+        LOOKAHEAD(2)
+        <NULLS> <FIRST> {
+            e = SqlStdOperatorTable.NULLS_FIRST.createCall(getPos(), e);
+        }
+    |
+        <NULLS> <LAST> {
+            e = SqlStdOperatorTable.NULLS_LAST.createCall(getPos(), 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.
+ */
+SqlSnapshot Snapshot(SqlNode tableRef) :
+{
+    final Span s;
+    final SqlNode e;
+}
+{
+    { s = span(); } <FOR> <SYSTEM_TIME> <AS> <OF>
+    // Syntax for temporal table in
+    // standard SQL 2011 IWD 9075-2:201?(E) 7.6 <table reference>
+    // supports grammar as following:
+    // 1. datetime literal
+    // 2. datetime value function, i.e. CURRENT_TIMESTAMP
+    // 3. datetime term in 1 or 2 +(or -) interval term
+
+    // We extend to support column reference, use Expression
+    // to simplify the parsing code.
+    e = Expression(ExprContext.ACCEPT_NON_QUERY) {
+        return new SqlSnapshot(s.end(this), tableRef, e);
+    }
+}
+
+/** Parses a PIVOT clause following a table expression. */
+SqlNode Pivot(SqlNode tableRef) :
+{
+    final Span s;
+    final Span s2;
+    final List<SqlNode> aggList = new ArrayList<SqlNode>();
+    final List<SqlNode> valueList = new ArrayList<SqlNode>();
+    final SqlNodeList axisList;
+    final SqlNodeList inList;
+}
+{
+    <PIVOT> { s = span(); checkNotJoin(tableRef); }
+    <LPAREN>
+    AddPivotAgg(aggList) ( <COMMA> AddPivotAgg(aggList) )*
+    <FOR> axisList = SimpleIdentifierOrList()
+    <IN> <LPAREN> { s2 = span(); }
+    [ AddPivotValue(valueList) ( <COMMA> AddPivotValue(valueList) )* ]
+    <RPAREN> {
+        inList = new SqlNodeList(valueList, s2.end(this));
+    }
+    <RPAREN>
+    {
+        return new SqlPivot(s.end(this), tableRef,
+            new SqlNodeList(aggList, SqlParserPos.sum(aggList)),
+            axisList, inList);
+    }
+}
+
+void AddPivotAgg(List<SqlNode> list) :
+{
+    final SqlNode e;
+    final SqlIdentifier alias;
+}
+{
+    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,
+                    alias));
+        }
+    |
+        { list.add(e); }
+    )
+}
+
+void AddPivotValue(List<SqlNode> list) :
+{
+    final SqlNode e;
+    final SqlNodeList tuple;
+    final SqlIdentifier alias;
+}
+{
+    e = RowConstructor() { tuple = SqlParserUtil.stripRow(e); }
+    (
+        [ <AS> ] alias = SimpleIdentifier() {
+            list.add(
+                SqlStdOperatorTable.AS.createCall(Span.of(tuple).end(this),
+                    tuple, alias));
+        }
+    |
+        { list.add(tuple); }
+    )
+}
+
+/** Parses an UNPIVOT clause following a table expression. */
+SqlNode Unpivot(SqlNode tableRef) :
+{
+    final Span s;
+    final boolean includeNulls;
+    final SqlNodeList measureList;
+    final SqlNodeList axisList;
+    final Span s2;
+    final List<SqlNode> values = new ArrayList<SqlNode>();
+    final SqlNodeList inList;
+}
+{
+    <UNPIVOT> { s = span(); checkNotJoin(tableRef); }
+    (
+        <INCLUDE> <NULLS> { includeNulls = true; }
+    |   <EXCLUDE> <NULLS> { includeNulls = false; }
+    |   { includeNulls = false; }
+    )
+    <LPAREN>
+    measureList = SimpleIdentifierOrList()
+    <FOR> axisList = SimpleIdentifierOrList()
+    <IN>
+    <LPAREN> { s2 = span(); }
+    AddUnpivotValue(values) ( <COMMA> AddUnpivotValue(values) )*
+    <RPAREN>
+    { inList = new SqlNodeList(values, s2.end(this)); }
+    <RPAREN> {
+        return new SqlUnpivot(s.end(this), tableRef, includeNulls, measureList,
+            axisList, inList);
+    }
+}
+
+void AddUnpivotValue(List<SqlNode> list) :
+{
+    final SqlNodeList columnList;
+    final SqlNode values;
+}
+{
+    columnList = SimpleIdentifierOrList()
+    (
+        <AS> values = RowConstructor() {
+            final SqlNodeList valueList = SqlParserUtil.stripRow(values);
+            list.add(
+                SqlStdOperatorTable.AS.createCall(Span.of(columnList).end(this),
+                    columnList, valueList));
+        }
+    |
+        { list.add(columnList); }
+    )
+}
+
+/**
+ * Parses a MATCH_RECOGNIZE clause following a table expression.
+ */
+SqlMatchRecognize MatchRecognize(SqlNode tableRef) :
+{
+    final Span s, s0, s1, s2;
+    final SqlNodeList measureList;
+    final SqlNodeList partitionList;
+    final SqlNodeList orderList;
+    final SqlNode pattern;
+    final SqlLiteral interval;
+    final SqlNodeList patternDefList;
+    final SqlNode after;
+    final SqlNode var;
+    final SqlLiteral rowsPerMatch;
+    final SqlNodeList subsetList;
+    final SqlLiteral isStrictStarts;
+    final SqlLiteral isStrictEnds;
+}
+{
+    <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));
+        }
+    |
+        <ALL> { s0 = span(); } <ROWS> <PER> <MATCH> {
+            rowsPerMatch = SqlMatchRecognize.RowsPerMatchOption.ALL_ROWS.symbol(s0.end(this));
+        }
+    |   { rowsPerMatch = null; }
+    )
+    (
+        <AFTER> { s1 = span(); } <MATCH> <SKIP_>
+        (
+            <TO>
+            (
+                LOOKAHEAD(2)
+                <NEXT> <ROW> {
+                    after = SqlMatchRecognize.AfterOption.SKIP_TO_NEXT_ROW
+                        .symbol(s1.end(this));
+                }
+            |
+                LOOKAHEAD(2)
+                <FIRST> var = SimpleIdentifier() {
+                    after = SqlMatchRecognize.SKIP_TO_FIRST.createCall(
+                        s1.end(var), var);
+                }
+            |
+                // This "LOOKAHEAD({true})" is a workaround for Babel.
+                // Because of babel parser uses option "LOOKAHEAD=2" globally,
+                // JavaCC generates something like "LOOKAHEAD(2, [<LAST>] SimpleIdentifier())"
+                // here. But the correct LOOKAHEAD should be
+                // "LOOKAHEAD(2, [ LOOKAHEAD(2, <LAST> SimpleIdentifier()) <LAST> ]
+                // SimpleIdentifier())" which have the syntactic lookahead for <LAST> considered.
+                //
+                // Overall LOOKAHEAD({true}) is even better as this is the last branch in the
+                // choice.
+                LOOKAHEAD({true})
+                [ LOOKAHEAD(2, <LAST> SimpleIdentifier()) <LAST> ] var = SimpleIdentifier() {
+                    after = SqlMatchRecognize.SKIP_TO_LAST.createCall(
+                        s1.end(var), var);
+                }
+            )
+        |
+            <PAST> <LAST> <ROW> {
+                 after = SqlMatchRecognize.AfterOption.SKIP_PAST_LAST_ROW
+                     .symbol(s1.end(this));
+            }
+        )
+    |   { after = null; }
+    )
+    <PATTERN>
+    <LPAREN>
+    (
+        <CARET> { isStrictStarts = SqlLiteral.createBoolean(true, getPos()); }
+    |   { isStrictStarts = SqlLiteral.createBoolean(false, getPos()); }
+    )
+    pattern = PatternExpression()
+    (
+        <DOLLAR> { isStrictEnds = SqlLiteral.createBoolean(true, getPos()); }
+    |   { isStrictEnds = SqlLiteral.createBoolean(false, getPos()); }
+    )
+    <RPAREN>
+    (
+        <WITHIN> interval = IntervalLiteral()
+    |   { interval = null; }
+    )
+    (
+        <SUBSET> subsetList = SubsetDefinitionCommaList(span())
+    |   { subsetList = SqlNodeList.EMPTY; }
+    )
+    <DEFINE>
+    patternDefList = PatternDefinitionCommaList(span())
+    <RPAREN> {
+        return new SqlMatchRecognize(s.end(this), tableRef,
+            pattern, isStrictStarts, isStrictEnds, patternDefList, measureList,
+            after, subsetList, rowsPerMatch, partitionList, orderList, interval);
+    }
+}
+
+SqlNodeList MeasureColumnCommaList(Span s) :
+{
+    final List<SqlNode> list = new ArrayList<SqlNode>();
+}
+{
+    AddMeasureColumn(list)
+    ( <COMMA> AddMeasureColumn(list) )*
+    { return new SqlNodeList(list, s.addAll(list).pos()); }
+}
+
+void AddMeasureColumn(List<SqlNode> list) :
+{
+    final SqlNode e;
+    final SqlIdentifier alias;
+}
+{
+    e = Expression(ExprContext.ACCEPT_NON_QUERY)
+    <AS>
+    alias = SimpleIdentifier() {
+        list.add(SqlStdOperatorTable.AS.createCall(Span.of(e).end(this), e, alias));
+    }
+}
+
+SqlNode PatternExpression() :
+{
+    SqlNode left;
+    SqlNode right;
+}
+{
+    left = PatternTerm()
+    (
+        <VERTICAL_BAR>
+        right = PatternTerm() {
+            left = SqlStdOperatorTable.PATTERN_ALTER.createCall(
+                Span.of(left).end(right), left, right);
+        }
+    )*
+    {
+        return left;
+    }
+}
+
+SqlNode PatternTerm() :
+{
+    SqlNode left;
+    SqlNode right;
+}
+{
+    left = PatternFactor()
+    (
+        right = PatternFactor() {
+            left = SqlStdOperatorTable.PATTERN_CONCAT.createCall(
+                Span.of(left).end(right), left, right);
+        }
+    )*
+    {
+        return left;
+    }
+}
+
+SqlNode PatternFactor() :
+{
+    final SqlNode e;
+    final SqlNode extra;
+    final SqlLiteral startNum;
+    final SqlLiteral endNum;
+    final SqlLiteral reluctant;
+}
+{
+    e = PatternPrimary()
+    (
+        LOOKAHEAD(1)
+        (
+            <STAR> {
+                startNum = LITERAL_ZERO;
+                endNum = LITERAL_MINUS_ONE;
+            }
+        |
+            <PLUS> {
+                startNum = LITERAL_ONE;
+                endNum = LITERAL_MINUS_ONE;
+            }
+        |
+            <HOOK> {
+                startNum = LITERAL_ZERO;
+                endNum = LITERAL_ONE;
+            }
+        |
+            <LBRACE>
+            (
+                startNum = UnsignedNumericLiteral()
+                (
+                    <COMMA>
+                    (
+                        endNum = UnsignedNumericLiteral()
+                    |
+                        { endNum = LITERAL_MINUS_ONE; }
+                    )
+                |
+                     { endNum = startNum; }
+                )
+                <RBRACE>
+            |
+                <COMMA>
+                endNum = UnsignedNumericLiteral()
+                <RBRACE>
+                { startNum = LITERAL_MINUS_ONE; }
+            |
+                <MINUS> extra = PatternExpression() <MINUS> <RBRACE> {
+                    return SqlStdOperatorTable.PATTERN_CONCAT.createCall(
+                        Span.of(e).end(this), e,
+                        SqlStdOperatorTable.PATTERN_EXCLUDE.createCall(
+                            Span.of(extra).end(this), extra));
+                }
+            )
+        )
+        (
+            <HOOK> {
+                reluctant = SqlLiteral.createBoolean(
+                    startNum.intValue(true) != endNum.intValue(true),
+                    SqlParserPos.ZERO);
+            }
+        |
+            { reluctant = SqlLiteral.createBoolean(false, SqlParserPos.ZERO); }
+        )
+    |
+        { return e; }
+    )
+    {
+        return SqlStdOperatorTable.PATTERN_QUANTIFIER.createCall(
+            span().end(e), e, startNum, endNum, reluctant);
+    }
+}
+
+SqlNode PatternPrimary() :
+{
+    final Span s;
+    SqlNode e;
+    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);
+    }
+|
+    (
+        <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);
+        }
+    )
+}
+
+SqlNodeList SubsetDefinitionCommaList(Span s) :
+{
+    final List<SqlNode> list = new ArrayList<SqlNode>();
+}
+{
+    AddSubsetDefinition(list)
+    ( <COMMA> AddSubsetDefinition(list) )*
+    { return new SqlNodeList(list, s.addAll(list).pos()); }
+}
+
+void AddSubsetDefinition(List<SqlNode> list) :
+{
+    final SqlNode var;
+    final SqlNodeList varList;
+}
+{
+    var = SimpleIdentifier()
+    <EQ>
+    <LPAREN>
+    varList = ExpressionCommaList(span(), ExprContext.ACCEPT_NON_QUERY)
+    <RPAREN> {
+        list.add(
+            SqlStdOperatorTable.EQUALS.createCall(span().end(var), var,
+                varList));
+    }
+}
+
+SqlNodeList PatternDefinitionCommaList(Span s) :
+{
+    SqlNode e;
+    final List<SqlNode> eList = new ArrayList<SqlNode>();
+}
+{
+    e = PatternDefinition() {
+        eList.add(e);
+    }
+    (
+        <COMMA>
+        e = PatternDefinition() {
+            eList.add(e);
+        }
+    )*
+    {
+        return new SqlNodeList(eList, s.addAll(eList).pos());
+    }
+}
+
+SqlNode PatternDefinition() :
+{
+    final SqlNode var;
+    final SqlNode e;
+}
+{
+    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)); }
+}
+
+JAVACODE SqlNode addWith(SqlNodeList withList, SqlNode e) {
+    return withList == null
+        ? e
+        : new SqlWith(withList.getParserPosition(), withList, e);
+}
+
+/** 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) :
+{
+    final SqlOperator op;
+    final SqlParserPos pos;
+    final SqlNode 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 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) :
+{
+    final SqlOperator op;
+    final SqlParserPos pos;
+    final SqlNode 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);
+    }
+}
+
+SqlNodeList WithList() :
+{
+    final Span s;
+    final List<SqlWithItem> list = new ArrayList<SqlWithItem>();
+    boolean recursive = false;
+}
+{
+    <WITH> [ <RECURSIVE> { recursive = true; } ]{ s = span(); }
+    AddWithItem(list, SqlLiteral.createBoolean(recursive, getPos()))
+    ( <COMMA> AddWithItem(list, SqlLiteral.createBoolean(recursive, getPos())) )*
+    { return new SqlNodeList(list, s.end(this)); }
+}
+
+void AddWithItem(List<SqlWithItem> list, SqlLiteral recursive) :
+{
+    final SqlIdentifier id;
+    final SqlNodeList columnList;
+    final SqlNode definition;
+}
+{
+    id = SimpleIdentifier()
+    ( columnList = ParenthesizedSimpleIdentifierList() | { columnList = null; } )
+    <AS>
+    definition = ParenthesizedExpression(ExprContext.ACCEPT_QUERY)
+    { list.add(new SqlWithItem(id.getParserPosition(), id, columnList, definition, recursive)); }
+}
+
+/**
+ * Parses either a row expression, a leaf query expression, or
+ * a parenthesized expression of any kind.
+ */
+SqlNode LeafQueryOrExpr(ExprContext exprContext) :
+{
+    SqlNode 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); }
+}
+
+/**
+ * Parses a row expression or a parenthesized expression of any kind.
+ */
+SqlNode Expression(ExprContext exprContext) :
+{
+    final List<Object> list;
+}
+{
+    list = Expression2(exprContext) { return SqlParserUtil.toTree(list); }
+}
+
+void AddExpression2b(List<Object> list, ExprContext exprContext) :
+{
+    SqlNode e;
+    SqlOperator op;
+    SqlNode ext;
+}
+{
+    (
+        LOOKAHEAD(1)
+        op = PrefixRowOperator() {
+            checkNonQueryExpression(exprContext);
+            list.add(new SqlParserUtil.ToTreeListItem(op, getPos()));
+        }
+    )*
+    e = Expression3(exprContext) {
+        list.add(e);
+    }
+    (
+        LOOKAHEAD(2) <DOT>
+        ext = RowExpressionExtension() {
+            list.add(
+                new SqlParserUtil.ToTreeListItem(
+                    SqlStdOperatorTable.DOT, getPos()));
+            list.add(ext);
+        }
+    )*
+}
+
+/**
+ * Parses a binary row expression, or a parenthesized expression of any
+ * kind.
+ *
+ * <p>The result is as a flat list of operators and operands. The top-level
+ * call to get an expression should call {@link #Expression}, but lower-level
+ * calls should call this, to give the parser the opportunity to associate
+ * operator calls.
+ *
+ * <p>For example 'a = b like c = d' should come out '((a = b) like c) = d'
+ * because LIKE and '=' have the same precedence, but tends to come out as '(a
+ * = b) like (c = d)' because (a = b) and (c = d) are parsed as separate
+ * expressions.
+ */
+List<Object> Expression2(ExprContext exprContext) :
+{
+    final List<Object> list = new ArrayList();
+    List<Object> list2;
+    final List<Object> list3 = new ArrayList();
+    SqlNodeList nodeList;
+    SqlNode e;
+    SqlOperator itemOp;
+    SqlOperator op;
+    SqlIdentifier p;
+    final Span s = span();
+}
+{
+    AddExpression2b(list, exprContext)
+    (
+        LOOKAHEAD(2)
+        (
+            LOOKAHEAD(2)
+            (
+                // Special case for "IN", because RHS of "IN" is the only place
+                // that an expression-list is allowed ("exp IN (exp1, exp2)").
+                LOOKAHEAD(2) {
+                    checkNonQueryExpression(exprContext);
+                }
+                (
+                    <NOT> <IN> { op = SqlStdOperatorTable.NOT_IN; }
+                |
+                    <IN> { op = SqlStdOperatorTable.IN; }
+                |
+                    { final SqlKind k; }
+                    k = comp()
+                    (
+                        <SOME> { op = SqlStdOperatorTable.some(k); }
+                    |
+                        <ANY> { op = SqlStdOperatorTable.some(k); }
+                    |
+                        <ALL> { op = SqlStdOperatorTable.all(k); }
+                    )
+                )
+                { s.clear().add(this); }
+                nodeList = ParenthesizedQueryOrCommaList(ExprContext.ACCEPT_NONCURSOR)
+                {
+                    list.add(new SqlParserUtil.ToTreeListItem(op, s.pos()));
+                    s.add(nodeList);
+                    // special case for stuff like IN (s1 UNION s2)
+                    if (nodeList.size() == 1) {
+                        SqlNode item = nodeList.get(0);
+                        if (item.isA(SqlKind.QUERY)) {
+                            list.add(item);
+                        } else {
+                            list.add(nodeList);
+                        }
+                    } else {
+                        list.add(nodeList);
+                    }
+                }
+            |
+                LOOKAHEAD(2) {
+                    checkNonQueryExpression(exprContext);
+                }
+                (
+                    <NOT> <BETWEEN> {
+                        op = SqlStdOperatorTable.NOT_BETWEEN;
+                        s.clear().add(this);
+                    }
+                    [
+                        <SYMMETRIC> { op = SqlStdOperatorTable.SYMMETRIC_NOT_BETWEEN; }
+                    |
+                        <ASYMMETRIC>
+                    ]
+                |
+                    <BETWEEN>
+                    {
+                        op = SqlStdOperatorTable.BETWEEN;
+                        s.clear().add(this);
+                    }
+                    [
+                        <SYMMETRIC> { op = SqlStdOperatorTable.SYMMETRIC_BETWEEN; }
+                    |
+                        <ASYMMETRIC>
+                    ]
+                )
+                AddExpression2b(list3, ExprContext.ACCEPT_SUB_QUERY) {
+                    list.add(new SqlParserUtil.ToTreeListItem(op, s.pos()));
+                    list.addAll(list3);
+                    list3.clear();
+                }
+            |
+                LOOKAHEAD(2) {
+                    checkNonQueryExpression(exprContext);
+                    s.clear().add(this);
+                }
+                (
+                    (
+                        <NOT>
+                        (
+                            <LIKE> { op = SqlStdOperatorTable.NOT_LIKE; }
+                        |
+                            <ILIKE> { op = SqlLibraryOperators.NOT_ILIKE; }
+                        |
+                            <RLIKE> { op = SqlLibraryOperators.NOT_RLIKE; }
+                        |
+                            <SIMILAR> <TO> { op = SqlStdOperatorTable.NOT_SIMILAR_TO; }
+                        )
+                    |
+                        <LIKE> { op = SqlStdOperatorTable.LIKE; }
+                    |
+                        <ILIKE> { op = SqlLibraryOperators.ILIKE; }
+                    |
+                        <RLIKE> { op = SqlLibraryOperators.RLIKE; }
+                    |
+                        <SIMILAR> <TO> { op = SqlStdOperatorTable.SIMILAR_TO; }
+                    )
+                <#if (parser.includePosixOperators!default.parser.includePosixOperators)>
+                |
+                    <NEGATE> <TILDE> { op = SqlStdOperatorTable.NEGATED_POSIX_REGEX_CASE_SENSITIVE; }
+                    [ <STAR> { op = SqlStdOperatorTable.NEGATED_POSIX_REGEX_CASE_INSENSITIVE; } ]
+                |
+                    <TILDE> { op = SqlStdOperatorTable.POSIX_REGEX_CASE_SENSITIVE; }
+                    [ <STAR> { op = SqlStdOperatorTable.POSIX_REGEX_CASE_INSENSITIVE; } ]
+                </#if>
+                )
+                list2 = Expression2(ExprContext.ACCEPT_SUB_QUERY) {
+                    list.add(new SqlParserUtil.ToTreeListItem(op, s.pos()));
+                    list.addAll(list2);
+                }
+                [
+                    LOOKAHEAD(2)
+                    <ESCAPE> e = Expression3(ExprContext.ACCEPT_SUB_QUERY) {
+                        s.clear().add(this);
+                        list.add(
+                            new SqlParserUtil.ToTreeListItem(
+                                SqlStdOperatorTable.ESCAPE, s.pos()));
+                        list.add(e);
+                    }
+                ]
+            |
+            <#list (parser.extraBinaryExpressions!default.parser.extraBinaryExpressions) as extra >
+                ${extra}(list, exprContext, s)
+            |
+            </#list>
+                LOOKAHEAD(3) op = BinaryRowOperator() {
+                    checkNonQueryExpression(exprContext);
+                    list.add(new SqlParserUtil.ToTreeListItem(op, getPos()));
+                }
+                AddExpression2b(list, ExprContext.ACCEPT_SUB_QUERY)
+            |
+                <LBRACKET>
+                itemOp = getItemOp()
+                e = Expression(ExprContext.ACCEPT_SUB_QUERY)
+                <RBRACKET> {
+                    list.add(
+                        new SqlParserUtil.ToTreeListItem(
+                            itemOp, getPos()));
+                    list.add(e);
+                }
+                (
+                    LOOKAHEAD(2) <DOT>
+                    p = SimpleIdentifier() {
+                        list.add(
+                            new SqlParserUtil.ToTreeListItem(
+                                SqlStdOperatorTable.DOT, getPos()));
+                        list.add(p);
+                    }
+                )*
+            |
+                {
+                    checkNonQueryExpression(exprContext);
+                }
+                op = PostfixRowOperator() {
+                    list.add(new SqlParserUtil.ToTreeListItem(op, getPos()));
+                }
+            )
+        )+
+        {
+            return list;
+        }
+    |
+        {
+            return list;
+        }
+    )
+}
+
+/** Returns the appropriate ITEM operator for indexing arrays. */
+SqlOperator getItemOp() :
+{
+}
+{
+    <OFFSET> { return SqlLibraryOperators.OFFSET; }
+|
+    <ORDINAL> { return SqlLibraryOperators.ORDINAL; }
+|
+    <SAFE_OFFSET> { return SqlLibraryOperators.SAFE_OFFSET; }
+|
+    <SAFE_ORDINAL> { return SqlLibraryOperators.SAFE_ORDINAL; }
+|
+    { return SqlStdOperatorTable.ITEM; }
+}
+
+/** Parses a comparison operator inside a SOME / ALL predicate. */
+SqlKind comp() :
+{
+}
+{
+    <LT> { return SqlKind.LESS_THAN; }
+|
+    <LE> { return SqlKind.LESS_THAN_OR_EQUAL; }
+|
+    <GT> { return SqlKind.GREATER_THAN; }
+|
+    <GE> { return SqlKind.GREATER_THAN_OR_EQUAL; }
+|
+    <EQ> { return SqlKind.EQUALS; }
+|
+    <NE> { return SqlKind.NOT_EQUALS; }
+|
+    <NE2> {
+        if (!this.conformance.isBangEqualAllowed()) {
+            throw SqlUtil.newContextException(getPos(), RESOURCE.bangEqualNotAllowed());
+        }
+        return SqlKind.NOT_EQUALS;
+    }
+}
+
+/**
+ * Parses a unary row expression, or a parenthesized expression of any
+ * kind.
+ */
+SqlNode Expression3(ExprContext exprContext) :
+{
+    final SqlNode e;
+    final SqlNodeList list;
+    final SqlNodeList list1;
+    final Span s;
+    final Span rowSpan;
+}
+{
+    LOOKAHEAD(2)
+    e = AtomicRowExpression()
+    {
+        checkNonQueryExpression(exprContext);
+        return e;
+    }
+|
+    e = CursorExpression(exprContext) { return e; }
+|
+    LOOKAHEAD(3)
+    <ROW> {
+        s = span();
+    }
+    list = ParenthesizedQueryOrCommaList(exprContext) {
+        if (exprContext != ExprContext.ACCEPT_ALL
+            && exprContext != ExprContext.ACCEPT_CURSOR
+            && !this.conformance.allowExplicitRowValueConstructor())
+        {
+            throw SqlUtil.newContextException(s.end(list),
+                RESOURCE.illegalRowExpression());
+        }
+        return SqlStdOperatorTable.ROW.createCall(list);
+    }
+|
+    (
+        <ROW> { rowSpan = span(); }
+    |   { rowSpan = null; }
+    )
+    list1 = ParenthesizedQueryOrCommaList(exprContext) {
+        if (rowSpan != null) {
+            // interpret as row constructor
+            return SqlStdOperatorTable.ROW.createCall(rowSpan.end(list1),
+                (List<SqlNode>) list1);
+        }
+    }
+    [
+        LOOKAHEAD(2)
+        /* TODO:
+        (
+            op = periodOperator()
+            list2 = ParenthesizedQueryOrCommaList(exprContext)
+            {
+                if (list1.size() != 2 || list2.size() != 2) {
+                    throw SqlUtil.newContextException(
+                        list1.getParserPosition().plus(
+                            list2.getParserPosition()),
+                        RESOURCE.illegalOverlaps());
+                }
+                for (SqlNode node : list2) {
+                    list1.add(node);
+                }
+                return op.createCall(
+                    list1.getParserPosition().plus(list2.getParserPosition()),
+                    list1.toArray());
+            }
+        )
+    |
+        */
+        (
+            e = IntervalQualifier()
+            {
+                if ((list1.size() == 1)
+                    && list1.get(0) instanceof SqlCall)
+                {
+                    final SqlCall call = (SqlCall) list1.get(0);
+                    if (call.getKind() == SqlKind.MINUS
+                            && call.operandCount() == 2) {
+                        return SqlStdOperatorTable.MINUS_DATE.createCall(
+                            Span.of(list1).end(this), call.operand(0),
+                            call.operand(1), e);
+                     }
+                }
+                throw SqlUtil.newContextException(span().end(list1),
+                    RESOURCE.illegalMinusDate());
+            }
+        )
+    ]
+    {
+        if (list1.size() == 1) {
+            // interpret as single value or query
+            return list1.get(0);
+        } else {
+            // interpret as row constructor
+            return SqlStdOperatorTable.ROW.createCall(span().end(list1),
+                (List<SqlNode>) list1);
+        }
+    }
+}
+
+/**
+ * Parses a lambda expression.
+ */
+SqlNode LambdaExpression() :
+{
+    final SqlNodeList parameters;
+    final SqlNode expression;
+    final Span s;
+}
+{
+    parameters = SimpleIdentifierOrListOrEmpty()
+    <LAMBDA> { s = span(); }
+    expression = Expression(ExprContext.ACCEPT_NON_QUERY)
+    {
+        return new SqlLambda(s.end(this), parameters, expression);
+    }
+}
+
+/**
+ * List of simple identifiers in parentheses or empty parentheses or one simple identifier.
+ * <ul>Examples:
+ * <li>{@code ()}
+ * <li>{@code DEPTNO}
+ * <li>{@code (EMPNO, DEPTNO)}
+ * </ul>
+ */
+SqlNodeList SimpleIdentifierOrListOrEmpty() :
+{
+    SqlNodeList list;
+}
+{
+    LOOKAHEAD(2)
+    <LPAREN> <RPAREN> { return SqlNodeList.EMPTY; }
+|
+    list = SimpleIdentifierOrList() { return list; }
+}
+
+SqlOperator periodOperator() :
+{
+}
+{
+     <OVERLAPS> { return SqlStdOperatorTable.OVERLAPS; }
+|
+     LOOKAHEAD(2)
+     <IMMEDIATELY> <PRECEDES> { return SqlStdOperatorTable.IMMEDIATELY_PRECEDES; }
+|
+     <PRECEDES> { return SqlStdOperatorTable.PRECEDES; }
+|
+     <IMMEDIATELY> <SUCCEEDS> { return SqlStdOperatorTable.IMMEDIATELY_SUCCEEDS; }
+|
+     <SUCCEEDS> { return SqlStdOperatorTable.SUCCEEDS; }
+|
+     <EQUALS> { return SqlStdOperatorTable.PERIOD_EQUALS; }
+}
+
+/**
+ * Parses a COLLATE clause
+ */
+SqlCollation CollateClause() :
+{
+}
+{
+    <COLLATE> <COLLATION_ID>
+    {
+        return new SqlCollation(
+            getToken(0).image, SqlCollation.Coercibility.EXPLICIT);
+    }
+}
+
+/**
+ * Numeric literal or parameter; used in LIMIT, OFFSET and FETCH clauses.
+ */
+SqlNode UnsignedNumericLiteralOrParam() :
+{
+    final SqlNode e;
+}
+{
+    (
+        e = UnsignedNumericLiteral()
+    |
+        e = DynamicParam()
+    )
+    { return e; }
+}
+
+/**
+ * Parses a row expression extension, it can be either an identifier,
+ * or a call to a named function.
+ */
+SqlNode RowExpressionExtension() :
+{
+    final SqlFunctionCategory funcType = SqlFunctionCategory.USER_DEFINED_FUNCTION;
+    final SqlIdentifier p;
+    final Span s;
+    final List<SqlNode> args;
+    final SqlLiteral quantifier;
+}
+{
+    p = SimpleIdentifier()
+    (
+        LOOKAHEAD( <LPAREN> ) { s = span(); }
+        (
+            LOOKAHEAD(2) <LPAREN> <STAR> {
+                quantifier = null;
+                args = ImmutableList.of(SqlIdentifier.star(getPos()));
+            }
+            <RPAREN>
+        |
+            LOOKAHEAD(2) <LPAREN> <RPAREN> {
+                quantifier = null;
+                args = ImmutableList.of();
+            }
+        |
+            args = FunctionParameterList(ExprContext.ACCEPT_SUB_QUERY) {
+                quantifier = (SqlLiteral) args.get(0);
+                args.remove(0);
+            }
+        )
+        { return createCall(p, s.end(this), funcType, quantifier, args); }
+    |
+        { return p; }
+    )
+}
+
+/**
+ * Parses a call to the STRING_AGG aggregate function (or to an aggregate
+ * function with similar syntax: ARRAY_AGG, ARRAY_CONCAT_AGG, GROUP_CONCAT).
+ */
+SqlCall StringAggFunctionCall() :
+{
+    final Span s, s2;
+    final SqlOperator op;
+    final List<SqlNode> args = new ArrayList<SqlNode>();
+    final SqlLiteral qualifier;
+    final SqlNodeList orderBy;
+    final Pair<SqlParserPos, SqlOperator> nullTreatment;
+    final SqlNode separator;
+}
+{
+    (
+        <ARRAY_AGG> { s = span(); op = SqlLibraryOperators.ARRAY_AGG; }
+    |   <ARRAY_CONCAT_AGG> { s = span(); op = SqlLibraryOperators.ARRAY_CONCAT_AGG; }
+    |   <GROUP_CONCAT> { s = span(); op = SqlLibraryOperators.GROUP_CONCAT; }
+    |   <STRING_AGG> { s = span(); op = SqlLibraryOperators.STRING_AGG; }
+    )
+    <LPAREN>
+    (
+        qualifier = AllOrDistinct()
+    |   { qualifier = null; }
+    )
+    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);
+        }
+        AddArg(args, ExprContext.ACCEPT_SUB_QUERY)
+    )*
+    (
+        nullTreatment = NullTreatment()
+    |   { nullTreatment = null; }
+    )
+    [
+        orderBy = OrderBy(true) {
+            args.add(orderBy);
+        }
+    ]
+    [
+        <SEPARATOR> { s2 = span(); } separator = StringLiteral() {
+            args.add(SqlInternalOperators.SEPARATOR.createCall(s2.end(this), separator));
+        }
+    ]
+    <RPAREN>
+    {
+        SqlCall call = op.createCall(qualifier, s.end(this), args);
+        if (nullTreatment != null) {
+            // Wrap in RESPECT_NULLS or IGNORE_NULLS.
+            call = nullTreatment.right.createCall(nullTreatment.left, call);
+        }
+        return call;
+    }
+}
+
+/**
+ * Parses both the standard and the BigQuery PERCENTILE_CONT/PERCENTILE_DISC
+ * functions.
+ *
+ * <p>The standard is of the form "PERCENTILE_CONT(fraction)" while BigQuery is
+ * of the form "PERCENTILE_CONT(value, fraction [ {RESPECT | IGNORE} NULLS ] )".
+ * Handles the parsing of the operator and its operands but not the WITHIN GROUP
+ * (for the standard) or OVER (for BigQuery) clauses.
+ */
+SqlCall PercentileFunctionCall() :
+{
+   final Span s;
+   SqlOperator op;
+   final SqlNode e;
+   final List<SqlNode> args = new ArrayList<SqlNode>();
+   final Pair<SqlParserPos, SqlOperator> nullTreatment;
+}
+{
+   (
+       <PERCENTILE_CONT> { op = SqlStdOperatorTable.PERCENTILE_CONT; }
+   |   <PERCENTILE_DISC> { op = SqlStdOperatorTable.PERCENTILE_DISC; }
+   )
+   { s = span(); }
+   <LPAREN>
+   AddArg(args, ExprContext.ACCEPT_SUB_QUERY)
+   (
+       <RPAREN> {
+           return op.createCall(s.end(this), args);
+       }
+   |
+       <COMMA>
+       e = NumericLiteral() { args.add(e); }
+       (
+           nullTreatment = NullTreatment()
+       |   { nullTreatment = null; }
+       )
+       <RPAREN>
+       {
+           op =
+               op == SqlStdOperatorTable.PERCENTILE_CONT
+                   ? SqlLibraryOperators.PERCENTILE_CONT2
+                   : SqlLibraryOperators.PERCENTILE_DISC2;
+           SqlCall call = op.createCall(s.end(this), args);
+           if (nullTreatment != null) {
+               // Wrap in RESPECT_NULLS or IGNORE_NULLS.
+               call = nullTreatment.right.createCall(nullTreatment.left, call);
+           }
+           return call;
+       }
+   )
+}
+
+
+/**
+ * Parses an atomic row expression.
+ */
+SqlNode AtomicRowExpression() :
+{
+    final SqlNode e;
+}
+{
+    (
+        LOOKAHEAD(2)
+        e = LiteralOrIntervalExpression()
+    |
+        e = DynamicParam()
+    |
+        LOOKAHEAD(2)
+        e = BuiltinFunctionCall()
+    |
+        e = JdbcFunctionCall()
+    |
+        e = MultisetConstructor()
+    |
+        e = ArrayConstructor()
+    |
+        LOOKAHEAD(3)
+        e = MapConstructor()
+    |
+        e = PeriodConstructor()
+    |
+        // NOTE jvs 18-Jan-2005:  use syntactic lookahead to discriminate
+        // compound identifiers from function calls in which the function
+        // name is a compound identifier
+        LOOKAHEAD( [<SPECIFIC>] FunctionName() <LPAREN>)
+        e = NamedFunctionCall()
+    |
+        e = ContextVariable()
+    |
+        e = CompoundIdentifier()
+    |
+        e = NewSpecification()
+    |
+        e = CaseExpression()
+    |
+        e = SequenceExpression()
+    )
+    { return e; }
+}
+
+SqlNode CaseExpression() :
+{
+    final Span whenSpan = Span.of();
+    final Span thenSpan = Span.of();
+    final Span s;
+    SqlNode e;
+    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) {
+            if (((SqlNodeList) e).size() == 1) {
+                e = ((SqlNodeList) e).get(0);
+            }
+            whenList.add(e);
+        }
+        <THEN> { thenSpan.add(this); }
+        e = Expression(ExprContext.ACCEPT_SUB_QUERY) {
+            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()),
+            new SqlNodeList(thenList, thenSpan.addAll(thenList).pos()),
+            elseClause);
+    }
+}
+
+SqlCall SequenceExpression() :
+{
+    final Span s;
+    final SqlOperator f;
+    final SqlNode sequenceRef;
+}
+{
+    (
+        <NEXT> { f = SqlStdOperatorTable.NEXT_VALUE; s = span(); }
+    |
+        LOOKAHEAD(3)
+        <CURRENT> { f = SqlStdOperatorTable.CURRENT_VALUE; s = span(); }
+    )
+    <VALUE> <FOR> sequenceRef = CompoundIdentifier() {
+        return f.createCall(s.end(sequenceRef), sequenceRef);
+    }
+}
+
+/**
+ * Parses "SET &lt;NAME&gt; = VALUE" or "RESET &lt;NAME&gt;", without a leading
+ * "ALTER &lt;SCOPE&gt;".
+ */
+SqlSetOption SqlSetOption(Span s, String scope) :
+{
+    SqlIdentifier name;
+    final SqlNode val;
+}
+{
+    (
+        <SET> {
+            s.add(this);
+        }
+        name = CompoundIdentifier()
+        <EQ>
+        (
+            val = Literal()
+        |
+            val = SimpleIdentifier()
+        |
+            <ON> {
+                // OFF is handled by SimpleIdentifier, ON handled here.
+                val = new SqlIdentifier(token.image.toUpperCase(Locale.ROOT),
+                    getPos());
+            }
+        )
+        {
+            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);
+        }
+    )
+}
+
+/**
+ * Parses an expression for setting or resetting an option in SQL, such as QUOTED_IDENTIFIERS,
+ * or explain plan level (physical/logical).
+ */
+SqlAlter SqlAlter() :
+{
+    final Span s;
+    final String scope;
+    final SqlAlter alterNode;
+}
+{
+    <ALTER> { s = span(); }
+    scope = Scope()
+    (
+<#-- additional literal parser methods are included here -->
+<#list (parser.alterStatementParserMethods!default.parser.alterStatementParserMethods) as method>
+        alterNode = ${method}(s, scope)
+    |
+</#list>
+
+        alterNode = SqlSetOption(s, scope)
+    )
+    {
+        return alterNode;
+    }
+}
+
+String Scope() :
+{
+}
+{
+    ( <SYSTEM> | <SESSION> ) { return token.image.toUpperCase(Locale.ROOT); }
+}
+
+<#if (parser.createStatementParserMethods!default.parser.createStatementParserMethods)?size != 0>
+/**
+ * Parses a CREATE statement.
+ */
+SqlCreate SqlCreate() :
+{
+    final Span s;
+    boolean replace = false;
+    final SqlCreate create;
+}
+{
+    <CREATE> { s = span(); }
+    [
+        <OR> <REPLACE> {
+            replace = true;
+        }
+    ]
+    (
+<#-- additional literal parser methods are included here -->
+<#list (parser.createStatementParserMethods!default.parser.createStatementParserMethods) as method>
+        create = ${method}(s, replace)
+        <#sep>| LOOKAHEAD(2) </#sep>
+</#list>
+    )
+    {
+        return create;
+    }
+}
+</#if>
+
+<#if (parser.dropStatementParserMethods!default.parser.dropStatementParserMethods)?size != 0>
+/**
+ * Parses a DROP statement.
+ */
+SqlDrop SqlDrop() :
+{
+    final Span s;
+    boolean replace = false;
+    final SqlDrop drop;
+}
+{
+    <DROP> { s = span(); }
+    (
+<#-- additional literal parser methods are included here -->
+<#list (parser.dropStatementParserMethods!default.parser.dropStatementParserMethods) as method>
+        drop = ${method}(s, replace)
+        <#sep>|</#sep>
+</#list>
+    )
+    {
+        return drop;
+    }
+}
+</#if>
+
+<#if (parser.truncateStatementParserMethods!default.parser.truncateStatementParserMethods)?size != 0>
+/**
+ * Parses a TRUNCATE statement.
+ */
+SqlTruncate SqlTruncate() :
+{
+    final Span s;
+    final SqlTruncate truncate;
+}
+{
+    <TRUNCATE> { s = span(); }
+    (
+<#-- additional literal parser methods are included here -->
+<#list (parser.truncateStatementParserMethods!default.parser.truncateStatementParserMethods) as method>
+        truncate = ${method}(s)
+        <#sep>|</#sep>
+</#list>
+    )
+    {
+        return truncate;
+    }
+}
+</#if>
+
+/**
+ * Parses a literal expression, allowing continued string literals.
+ * Usually returns an SqlLiteral, but a continued string literal
+ * is an SqlCall expression, which concatenates 2 or more string
+ * literals; the validator reduces this.
+ *
+ * <p>If the context allows both literals and expressions,
+ * use {@link #LiteralOrIntervalExpression}, which requires less
+ * lookahead.
+ */
+SqlNode Literal() :
+{
+    SqlNode e;
+}
+{
+    (
+        e = NonIntervalLiteral()
+    |
+        e = IntervalLiteral()
+    )
+    { return e; }
+}
+
+/** Parses a literal that is not an interval literal. */
+SqlNode NonIntervalLiteral() :
+{
+    final SqlNode e;
+}
+{
+    (
+        e = NumericLiteral()
+    |
+        e = StringLiteral()
+    |
+        e = SpecialLiteral()
+    |
+        e = DateTimeLiteral()
+<#-- additional literal parser methods are included here -->
+<#list (parser.literalParserMethods!default.parser.literalParserMethods) as method>
+    |
+        e = ${method}
+</#list>
+    )
+    {
+        return e;
+    }
+}
+
+/** Parses a literal or an interval expression.
+ *
+ * <p>We include them in the same production because it is difficult to
+ * distinguish interval literals from interval expression (both of which
+ * start with the {@code INTERVAL} keyword); this way, we can use less
+ * LOOKAHEAD. */
+SqlNode LiteralOrIntervalExpression() :
+{
+    final SqlNode e;
+}
+{
+    (
+        e = IntervalLiteralOrExpression()
+    |
+        e = NonIntervalLiteral()
+    )
+    { return e; }
+}
+
+/** Parses a unsigned numeric literal */
+SqlNumericLiteral UnsignedNumericLiteral() :
+{
+final String p;
+}
+{
+    <UNSIGNED_INTEGER_LITERAL> {
+        return SqlLiteral.createExactNumeric(token.image, getPos());
+    }
+|
+    <DECIMAL_NUMERIC_LITERAL> {
+        return SqlLiteral.createExactNumeric(token.image, getPos());
+    }
+|
+    <DECIMAL>
+    p = SimpleStringLiteral() {
+        return SqlParserUtil.parseDecimalLiteral(SqlParserUtil.trim(p, " "), getPos());
+    }
+|
+    <APPROX_NUMERIC_LITERAL> {
+        return SqlLiteral.createApproxNumeric(token.image, getPos());
+    }
+}
+
+/** Parses a numeric literal (can be signed) */
+SqlLiteral NumericLiteral() :
+{
+    final SqlNumericLiteral num;
+    final Span s;
+}
+{
+    <PLUS> num = UnsignedNumericLiteral() {
+        return num;
+    }
+|
+    <MINUS> { s = span(); } num = UnsignedNumericLiteral() {
+        return SqlLiteral.createNegative(num, s.end(this));
+    }
+|
+    num = UnsignedNumericLiteral() {
+        return num;
+    }
+}
+
+/** Parse a special literal keyword */
+SqlLiteral SpecialLiteral() :
+{
+}
+{
+    <TRUE> { return SqlLiteral.createBoolean(true, getPos()); }
+|
+    <FALSE> { return SqlLiteral.createBoolean(false, getPos()); }
+|
+    <UNKNOWN> { return SqlLiteral.createUnknown(getPos()); }
+|
+    <NULL> { return SqlLiteral.createNull(getPos()); }
+}
+
+/**
+ * Parses a string literal. The literal may be continued onto several
+ * lines.  For a simple literal, the result is an SqlLiteral.  For a continued
+ * literal, the result is an SqlCall expression, which concatenates 2 or more
+ * string literals; the validator reduces this.
+ *
+ * @see SqlLiteral#unchain(SqlNode)
+ * @see SqlLiteral#stringValue(SqlNode)
+ *
+ * @return a literal expression
+ */
+SqlNode StringLiteral() :
+{
+    String p;
+    final List<SqlLiteral> frags;
+    char unicodeEscapeChar = 0;
+    String charSet = null;
+    SqlCharStringLiteral literal;
+}
+{
+    // A continued string literal consists of a head fragment and one or more
+    // tail fragments. Since comments may occur between the fragments, and
+    // comments are special tokens, each fragment is a token. But since spaces
+    // or comments may not occur between the prefix and the first quote, the
+    // head fragment, with any prefix, is one token.
+
+    <BINARY_STRING_LITERAL>
+    {
+        frags = new ArrayList<SqlLiteral>();
+        try {
+            p = SqlParserUtil.trim(token.image, "xX'");
+            frags.add(SqlLiteral.createBinaryString(p, getPos()));
+        } catch (NumberFormatException ex) {
+            throw SqlUtil.newContextException(getPos(),
+                RESOURCE.illegalBinaryString(token.image));
+        }
+    }
+    (
+        // The grammar is ambiguous when a continued literals and a character
+        // string alias are both possible. For example, in
+        //   SELECT x'01'\n'ab'
+        // we prefer that 'ab' continues the literal, and is not an alias.
+        // The following LOOKAHEAD mutes the warning about ambiguity.
+        LOOKAHEAD(1)
+        <QUOTED_STRING>
+        {
+            try {
+                p = SqlParserUtil.trim(token.image, "'"); // no embedded quotes
+                frags.add(SqlLiteral.createBinaryString(p, getPos()));
+            } catch (NumberFormatException ex) {
+                throw SqlUtil.newContextException(getPos(),
+                    RESOURCE.illegalBinaryString(token.image));
+            }
+        }
+    )*
+    {
+        assert !frags.isEmpty();
+        if (frags.size() == 1) {
+            return frags.get(0); // just the head fragment
+        } else {
+            SqlParserPos pos2 = SqlParserPos.sum(frags);
+            return SqlStdOperatorTable.LITERAL_CHAIN.createCall(pos2, frags);
+        }
+    }
+|
+    (
+        <PREFIXED_STRING_LITERAL>
+        { charSet = SqlParserUtil.getCharacterSet(token.image); }
+    |   <QUOTED_STRING>
+    |   <UNICODE_STRING_LITERAL> {
+            // TODO jvs 2-Feb-2009:  support the explicit specification of
+            // a character set for Unicode string literals, per SQL:2003
+            unicodeEscapeChar = BACKSLASH;
+            charSet = "UTF16";
+        }
+    )
+    {
+        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));
+        }
+    }
+    (
+        // The grammar is ambiguous when a continued literals and a character
+        // string alias are both possible. For example, in
+        //   SELECT 'taxi'\n'cab'
+        // we prefer that 'cab' continues the literal, and is not an alias.
+        // The following LOOKAHEAD mutes the warning about ambiguity.
+        LOOKAHEAD(1)
+        <QUOTED_STRING>
+        {
+            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));
+            }
+        }
+    )*
+    [
+        <UESCAPE> <QUOTED_STRING>
+        {
+            if (unicodeEscapeChar == 0) {
+                throw SqlUtil.newContextException(getPos(),
+                    RESOURCE.unicodeEscapeUnexpected());
+            }
+            String s = SqlParserUtil.parseString(token.image);
+            unicodeEscapeChar = SqlParserUtil.checkUnicodeEscapeChar(s);
+        }
+    ]
+    {
+        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[0]);
+            for (int i = 0; i < rands.length; ++i) {
+                rands[i] = ((SqlLiteral) rands[i]).unescapeUnicode(
+                    unicodeEscapeChar);
+            }
+            SqlParserPos pos2 = SqlParserPos.sum(rands);
+            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>
+    {
+        p = SqlParserUtil.stripQuotes(getToken(0).image, DQ, DQ, "\\\"",
+            Casing.UNCHANGED);
+        try {
+            return SqlLiteral.createCharString(p, charSet, getPos());
+        } catch (java.nio.charset.UnsupportedCharsetException e) {
+            throw SqlUtil.newContextException(getPos(),
+                RESOURCE.unknownCharacterSet(charSet));
+        }
+    }
+|
+    <BIG_QUERY_QUOTED_STRING>
+    {
+        p = SqlParserUtil.stripQuotes(getToken(0).image, "'", "'", "\\'",
+            Casing.UNCHANGED);
+        try {
+            return SqlLiteral.createCharString(p, charSet, getPos());
+        } catch (java.nio.charset.UnsupportedCharsetException e) {
+            throw SqlUtil.newContextException(getPos(),
+                RESOURCE.unknownCharacterSet(charSet));
+        }
+    }
+}
+
+/** 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 Span s;
+    boolean local = false;
+}
+{
+    <LBRACE_D> <QUOTED_STRING> {
+        p = SqlParserUtil.parseString(token.image);
+    }
+    <RBRACE> {
+        return SqlParserUtil.parseDateLiteral(p, getPos());
+    }
+|
+    <LBRACE_T> <QUOTED_STRING> {
+        p = SqlParserUtil.parseString(token.image);
+    }
+    <RBRACE> {
+        return SqlParserUtil.parseTimeLiteral(p, getPos());
+    }
+|
+    <LBRACE_TS> { s = span(); } <QUOTED_STRING> {
+        p = SqlParserUtil.parseString(token.image);
+    }
+    <RBRACE> {
+        return SqlParserUtil.parseTimestampLiteral(p, 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));
+    }
+|
+    LOOKAHEAD(2)
+    <TIME> { s = span(); } p = SimpleStringLiteral() {
+      return SqlLiteral.createUnknown("TIME", p, s.end(this));
+    }
+|
+    LOOKAHEAD(2)
+    <TIMESTAMP> { s = span(); } p = SimpleStringLiteral() {
+        return SqlLiteral.createUnknown("TIMESTAMP", p, s.end(this));
+    }
+|
+    LOOKAHEAD(2)
+    <TIME> { s = span(); } <WITH> ( <LOCAL> { local = true; } )? <TIME> <ZONE> p = SimpleStringLiteral() {
+        return SqlLiteral.createUnknown("TIME WITH " + (local ? "LOCAL " : "") + "TIME ZONE", p, s.end(this));
+    }
+|
+    LOOKAHEAD(2)
+    <TIMESTAMP> { s = span(); } <WITH> ( <LOCAL> { local = true; } )? <TIME> <ZONE> p = SimpleStringLiteral() {
+        return SqlLiteral.createUnknown("TIMESTAMP WITH " + (local ? "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() :
+{
+    final List<SqlNode> args = new ArrayList<SqlNode>();
+    SqlNode e;
+    final Span s;
+}
+{
+    <MULTISET> { s = span(); }
+    (
+        LOOKAHEAD(2)
+        <LPAREN>
+        // by sub query "MULTISET(SELECT * FROM T)"
+        e = LeafQueryOrExpr(ExprContext.ACCEPT_QUERY)
+        <RPAREN> {
+            return SqlStdOperatorTable.MULTISET_QUERY.createCall(
+                s.end(this), e);
+        }
+    |
+        // by enumeration "MULTISET[e0, e1, ..., eN]"
+        <LBRACKET> // TODO: do trigraph as well ??( ??)
+        AddExpression(args, ExprContext.ACCEPT_NON_QUERY)
+        ( <COMMA> AddExpression(args, ExprContext.ACCEPT_NON_QUERY) )*
+        <RBRACKET>
+        {
+            return SqlStdOperatorTable.MULTISET_VALUE.createCall(
+                s.end(this), args);
+        }
+    )
+}
+
+/** Parses an ARRAY constructor */
+SqlNode ArrayConstructor() :
+{
+    final SqlNodeList args;
+    SqlNode e;
+    final Span s;
+    final String p;
+}
+{
+    <ARRAY> { s = span(); }
+    (
+        (
+            // nullary array function call: "array()" (Apache Spark)
+            LOOKAHEAD(2)
+            <LPAREN> <RPAREN> { args = SqlNodeList.EMPTY; }
+        |
+            args = ParenthesizedQueryOrCommaList(ExprContext.ACCEPT_ALL)
+        )
+        {
+            if (args.size() == 1 && args.get(0).isA(SqlKind.QUERY)) {
+                // Array query constructor, 'ARRAY (SELECT * FROM t)'
+                return SqlStdOperatorTable.ARRAY_QUERY.createCall(s.end(this), args.get(0));
+            } else {
+                // Spark ARRAY function, 'ARRAY(1, 2)',
+                // equivalent to standard 'ARRAY [1, 2]'
+                return SqlLibraryOperators.ARRAY.createCall(s.end(this), args.getList());
+            }
+        }
+    |
+        // by enumeration "ARRAY[e0, e1, ..., eN]"
+        <LBRACKET> // TODO: do trigraph as well ??( ??)
+        (
+            args = ExpressionCommaList(s, ExprContext.ACCEPT_NON_QUERY)
+        |
+            { args = SqlNodeList.EMPTY; }
+        )
+        <RBRACKET>
+        {
+            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() :
+{
+    SqlNodeList args;
+    final Span s;
+}
+{
+    <MAP> { s = span(); }
+    (
+        (
+            // empty map function call: "map()"
+            LOOKAHEAD(2)
+            <LPAREN> <RPAREN> { args = SqlNodeList.EMPTY; }
+        |
+            args = ParenthesizedQueryOrCommaList(ExprContext.ACCEPT_ALL)
+        )
+        {
+            if (args.size() == 1 && args.get(0).isA(SqlKind.QUERY)) {
+                // MAP query constructor e.g. "MAP (SELECT empno, deptno FROM emps)"
+                return SqlStdOperatorTable.MAP_QUERY.createCall(s.end(this), args.get(0));
+            } else {
+                // MAP function e.g. "MAP(1, 2)" equivalent to standard "MAP[1, 2]"
+                return SqlLibraryOperators.MAP.createCall(s.end(this), args.getList());
+            }
+        }
+    |
+        // by enumeration "MAP[k0, v0, ..., kN, vN]"
+        <LBRACKET> // TODO: do trigraph as well ??( ??)
+        (
+            args = ExpressionCommaList(s, ExprContext.ACCEPT_NON_QUERY)
+        |
+            { args = SqlNodeList.EMPTY; }
+        )
+        <RBRACKET>
+        {
+            return SqlStdOperatorTable.MAP_VALUE_CONSTRUCTOR.createCall(
+                s.end(this), args.getList());
+        }
+    )
+}
+
+/** Parses a PERIOD constructor */
+SqlNode PeriodConstructor() :
+{
+    final List<SqlNode> args = new ArrayList<SqlNode>();
+    final Span s;
+}
+{
+    <PERIOD> { s = span(); }
+    <LPAREN>
+    AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+    <COMMA>
+    AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+    <RPAREN> {
+        return SqlStdOperatorTable.ROW.createCall(s.end(this), args);
+    }
+}
+
+/**
+ * Parses an interval literal.
+ */
+SqlLiteral IntervalLiteral() :
+{
+    final String p;
+    final SqlIntervalQualifier intervalQualifier;
+    int sign = 1;
+    final Span s;
+}
+{
+    <INTERVAL> { s = span(); }
+    [
+        <MINUS> { sign = -1; }
+    |
+        <PLUS> { sign = 1; }
+    ]
+    p = SimpleStringLiteral()
+    intervalQualifier = IntervalQualifier() {
+        return SqlParserUtil.parseIntervalLiteral(s.end(intervalQualifier),
+            sign, p, intervalQualifier);
+    }
+}
+
+/** Parses an interval literal (e.g. {@code INTERVAL '2:3' HOUR TO MINUTE})
+ * or an interval expression (e.g. {@code INTERVAL emp.empno MINUTE}
+ * or {@code INTERVAL 3 MONTHS}). */
+SqlNode IntervalLiteralOrExpression() :
+{
+    final String p;
+    final SqlIntervalQualifier intervalQualifier;
+    int sign = 1;
+    final Span s;
+    SqlNode e;
+}
+{
+    <INTERVAL> { s = span(); }
+    [
+        <MINUS> { sign = -1; }
+    |
+        <PLUS> { sign = 1; }
+    ]
+    (
+        // literal (with quoted string)
+        p = SimpleStringLiteral()
+        intervalQualifier = IntervalQualifier() {
+            return SqlParserUtil.parseIntervalLiteral(s.end(intervalQualifier),
+                sign, p, intervalQualifier);
+        }
+    |
+        // To keep parsing simple, any expressions besides numeric literal and
+        // identifiers must be enclosed in parentheses.
+        (
+            <LPAREN>
+            e = Expression(ExprContext.ACCEPT_SUB_QUERY)
+            <RPAREN>
+        |
+            e = UnsignedNumericLiteral()
+        |
+            e = CompoundIdentifier()
+        )
+        intervalQualifier = IntervalQualifierStart() {
+            if (sign == -1) {
+                e = SqlStdOperatorTable.UNARY_MINUS.createCall(e.getParserPosition(), e);
+            }
+            return SqlStdOperatorTable.INTERVAL.createCall(s.end(this), e,
+                intervalQualifier);
+        }
+    )
+}
+
+TimeUnit Year() :
+{
+}
+{
+    <YEAR> { return TimeUnit.YEAR; }
+|
+    <YEARS> { return warn(TimeUnit.YEAR); }
+}
+
+TimeUnit Quarter() :
+{
+}
+{
+    <QUARTER> { return TimeUnit.QUARTER; }
+|
+    <QUARTERS> { return warn(TimeUnit.QUARTER); }
+}
+
+TimeUnit Month() :
+{
+}
+{
+    <MONTH> { return TimeUnit.MONTH; }
+|
+    <MONTHS> { return warn(TimeUnit.MONTH); }
+}
+
+TimeUnit Week() :
+{
+}
+{
+    <WEEK> { return TimeUnit.WEEK; }
+|
+    <WEEKS> { return warn(TimeUnit.WEEK); }
+}
+
+TimeUnit Day() :
+{
+}
+{
+    <DAY> { return TimeUnit.DAY; }
+|
+    <DAYS> { return warn(TimeUnit.DAY); }
+}
+
+TimeUnit Hour() :
+{
+}
+{
+    <HOUR> { return TimeUnit.HOUR; }
+|
+    <HOURS> { return warn(TimeUnit.HOUR); }
+}
+
+TimeUnit Minute() :
+{
+}
+{
+    <MINUTE> { return TimeUnit.MINUTE; }
+|
+    <MINUTES> { return warn(TimeUnit.MINUTE); }
+}
+
+TimeUnit Second() :
+{
+}
+{
+    <SECOND> { return TimeUnit.SECOND; }
+|
+    <SECONDS> { return warn(TimeUnit.SECOND); }
+}
+
+SqlIntervalQualifier IntervalQualifier() :
+{
+    final Span s;
+    final TimeUnit start;
+    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()
+            |
+                end = Minute()
+            |
+                end = Second() secondFracPrec = PrecisionOpt()
+            )
+        |   { end = null; }
+        )
+    |
+        start = Hour() { s = span(); } startPrec = PrecisionOpt()
+        (
+            LOOKAHEAD(2) <TO>
+            (
+                end = Minute()
+            |
+                end = Second()
+                [ <LPAREN> secondFracPrec = UnsignedIntLiteral() <RPAREN> ]
+            )
+        |   { end = null; }
+        )
+    |
+        start = Minute() { s = span(); } startPrec = PrecisionOpt()
+        (
+            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,
+            s.end(this));
+    }
+}
+
+/** Interval qualifier without 'TO unit'. */
+SqlIntervalQualifier IntervalQualifierStart() :
+{
+    final Span s;
+    final TimeUnit start;
+    int startPrec = RelDataType.PRECISION_NOT_SPECIFIED;
+    int secondFracPrec = RelDataType.PRECISION_NOT_SPECIFIED;
+}
+{
+    (
+        (
+            start = Year()
+        |   start = Quarter()
+        |   start = Month()
+        |   start = Week()
+        |   start = Day()
+        |   start = Hour()
+        |   start = Minute()
+        )
+        { s = span(); }
+        startPrec = PrecisionOpt()
+    |
+        start = Second() { s = span(); }
+        [   <LPAREN> startPrec = UnsignedIntLiteral()
+            [ <COMMA> secondFracPrec = UnsignedIntLiteral() ]
+            <RPAREN>
+        ]
+    )
+    {
+        return new SqlIntervalQualifier(start, startPrec, null, secondFracPrec,
+            s.end(this));
+    }
+}
+
+/** 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.
+ */
+SqlIntervalQualifier TimeUnitOrName() : {
+    final SqlIdentifier unitName;
+    final SqlIntervalQualifier intervalQualifier;
+}
+{
+    // 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.
+ */
+SqlDynamicParam DynamicParam() :
+{
+}
+{
+    <HOOK> {
+        return new SqlDynamicParam(nDynamicParams++, getPos());
+    }
+}
+
+/**
+ * Parses one segment of an identifier that may be composite.
+ *
+ * <p>Each time it reads an identifier it writes one element to each list;
+ * the entry in {@code positions} records its position and whether the
+ * segment was quoted.
+ */
+void AddIdentifierSegment(List<String> names, List<SqlParserPos> positions) :
+{
+    final String id;
+    char unicodeEscapeChar = BACKSLASH;
+    final SqlParserPos pos;
+    final Span span;
+}
+{
+    (
+        <IDENTIFIER> {
+            id = unquotedIdentifier();
+            pos = getPos();
+        }
+    |
+        <HYPHENATED_IDENTIFIER> {
+            id = unquotedIdentifier();
+            pos = getPos();
+        }
+    |
+        <QUOTED_IDENTIFIER> {
+            id = SqlParserUtil.stripQuotes(getToken(0).image, DQ, DQ, DQDQ,
+                quotedCasing);
+            pos = getPos().withQuoting(true);
+        }
+    |
+        <BACK_QUOTED_IDENTIFIER> {
+            id = SqlParserUtil.stripQuotes(getToken(0).image, "`", "`", "``",
+                quotedCasing);
+            pos = getPos().withQuoting(true);
+        }
+    |
+        <BIG_QUERY_BACK_QUOTED_IDENTIFIER> {
+            id = SqlParserUtil.stripQuotes(getToken(0).image, "`", "`", "\\`",
+                quotedCasing);
+            pos = getPos().withQuoting(true);
+        }
+    |
+        <BRACKET_QUOTED_IDENTIFIER> {
+            id = SqlParserUtil.stripQuotes(getToken(0).image, "[", "]", "]]",
+                quotedCasing);
+            pos = getPos().withQuoting(true);
+        }
+    |
+        <UNICODE_QUOTED_IDENTIFIER> {
+            span = span();
+            String image = getToken(0).image;
+            image = image.substring(image.indexOf('"'));
+            image = SqlParserUtil.stripQuotes(image, DQ, DQ, DQDQ, quotedCasing);
+        }
+        [
+            <UESCAPE> <QUOTED_STRING> {
+                String s = SqlParserUtil.parseString(token.image);
+                unicodeEscapeChar = SqlParserUtil.checkUnicodeEscapeChar(s);
+            }
+        ]
+        {
+            pos = span.end(this).withQuoting(true);
+            SqlLiteral lit = SqlLiteral.createCharString(image, "UTF16", pos);
+            lit = lit.unescapeUnicode(unicodeEscapeChar);
+            id = lit.toValue();
+        }
+    |
+        id = NonReservedKeyWord() {
+            pos = getPos();
+        }
+    )
+    {
+        if (id.length() > this.identifierMaxLength) {
+            throw SqlUtil.newContextException(pos,
+                RESOURCE.identifierTooLong(id, this.identifierMaxLength));
+        }
+        names.add(id);
+        if (positions != null) {
+            positions.add(pos);
+        }
+    }
+}
+
+/** 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 AddTableIdentifierSegment(List<String> names, List<SqlParserPos> positions) :
+{
+}
+{
+    AddIdentifierSegment(names, positions) {
+        final int n = names.size();
+        if (n > 0
+                && positions.size() == n
+                && names.get(n - 1).contains(".")
+                && positions.get(n - 1).isQuoted()
+                && this.conformance.splitQuotedTableName()) {
+            final String name = names.remove(n - 1);
+            final SqlParserPos pos = positions.remove(n - 1);
+            final String[] splitNames = name.split("\\.");
+            for (String splitName : splitNames) {
+                names.add(splitName);
+                positions.add(pos);
+            }
+        }
+    }
+}
+
+/**
+ * Parses a simple identifier as a String.
+ */
+String Identifier() :
+{
+    final List<String> names = new ArrayList<String>();
+}
+{
+    AddIdentifierSegment(names, null) {
+        return names.get(0);
+    }
+}
+
+/**
+ * Parses a simple identifier as an SqlIdentifier.
+ */
+SqlIdentifier SimpleIdentifier() :
+{
+    final List<String> names = new ArrayList<String>();
+    final List<SqlParserPos> positions = new ArrayList<SqlParserPos>();
+}
+{
+    AddIdentifierSegment(names, positions) {
+        return new SqlIdentifier(names.get(0), positions.get(0));
+    }
+}
+
+/**
+ * Parses a character literal as an SqlIdentifier.
+ * Only valid for column aliases in certain dialects.
+ */
+SqlIdentifier SimpleIdentifierFromStringLiteral() :
+{
+}
+{
+    <QUOTED_STRING> {
+        if (!this.conformance.allowCharLiteralAlias()) {
+            throw SqlUtil.newContextException(getPos(), RESOURCE.charLiteralAliasNotValid());
+        }
+        final String s = SqlParserUtil.parseString(token.image);
+        return new SqlIdentifier(s, getPos());
+    }
+}
+
+/**
+ * Parses a comma-separated list of simple identifiers.
+ */
+void AddSimpleIdentifiers(List<SqlNode> list) :
+{
+    SqlIdentifier id;
+}
+{
+    id = SimpleIdentifier() {list.add(id);}
+    (
+        <COMMA> id = SimpleIdentifier() {
+            list.add(id);
+        }
+    )*
+}
+
+/**
+  * List of simple identifiers in parentheses. The position extends from the
+  * open parenthesis to the close parenthesis.
+  */
+SqlNodeList ParenthesizedSimpleIdentifierList() :
+{
+    final Span s;
+    final List<SqlNode> list = new ArrayList<SqlNode>();
+}
+{
+    <LPAREN> { s = span(); }
+    AddSimpleIdentifiers(list)
+    <RPAREN> {
+        return new SqlNodeList(list, s.end(this));
+    }
+}
+
+/** List of simple identifiers in parentheses or one simple identifier.
+ *
+ * <ul>Examples:
+ * <li>{@code DEPTNO}
+ * <li>{@code (EMPNO, DEPTNO)}
+ * </ul>
+ */
+SqlNodeList SimpleIdentifierOrList() :
+{
+    SqlIdentifier id;
+    SqlNodeList list;
+}
+{
+    id = SimpleIdentifier() {
+        return new SqlNodeList(Collections.singletonList(id), id.getParserPosition());
+    }
+|
+    list = ParenthesizedSimpleIdentifierList() {
+        return list;
+    }
+}
+
+<#if (parser.includeCompoundIdentifier!default.parser.includeCompoundIdentifier) >
+/**
+ * Parses a compound identifier.
+ */
+SqlIdentifier CompoundIdentifier() :
+{
+    final List<String> nameList = new ArrayList<String>();
+    final List<SqlParserPos> posList = new ArrayList<SqlParserPos>();
+    boolean star = false;
+}
+{
+    AddIdentifierSegment(nameList, posList)
+    (
+        LOOKAHEAD(2)
+        <DOT>
+        AddIdentifierSegment(nameList, posList)
+    )*
+    (
+        LOOKAHEAD(2)
+        <DOT>
+        <STAR> {
+            star = true;
+            nameList.add("");
+            posList.add(getPos());
+        }
+    )?
+    {
+        SqlParserPos pos = SqlParserPos.sum(posList);
+        if (star) {
+            return SqlIdentifier.star(nameList, pos, posList);
+        }
+        return new SqlIdentifier(nameList, null, pos, posList);
+    }
+}
+
+/**
+ * Parses a compound identifier in the FROM clause.
+ */
+SqlIdentifier CompoundTableIdentifier() :
+{
+    final List<String> nameList = new ArrayList<String>();
+    final List<SqlParserPos> posList = new ArrayList<SqlParserPos>();
+}
+{
+    AddTableIdentifierSegment(nameList, posList)
+    (
+        LOOKAHEAD(2)
+        <DOT>
+        AddTableIdentifierSegment(nameList, posList)
+    )*
+    {
+        SqlParserPos pos = SqlParserPos.sum(posList);
+        return new SqlIdentifier(nameList, null, pos, posList);
+    }
+}
+
+/**
+ * Parses a comma-separated list of compound identifiers.
+ */
+void AddCompoundIdentifierTypes(List<SqlNode> list, List<SqlNode> extendList) :
+{
+}
+{
+    AddCompoundIdentifierType(list, extendList)
+    (<COMMA> AddCompoundIdentifierType(list, extendList))*
+}
+
+/**
+ * List of compound identifiers in parentheses. The position extends from the
+ * open parenthesis to the close parenthesis.
+ */
+Pair<SqlNodeList, SqlNodeList> ParenthesizedCompoundIdentifierList() :
+{
+    final Span s;
+    final List<SqlNode> list = new ArrayList<SqlNode>();
+    final List<SqlNode> extendList = new ArrayList<SqlNode>();
+}
+{
+    <LPAREN> { s = span(); }
+    AddCompoundIdentifierTypes(list, extendList)
+    <RPAREN> {
+        return Pair.of(new SqlNodeList(list, s.end(this)), new SqlNodeList(extendList, s.end(this)));
+    }
+}
+<#else>
+  <#include "/@includes/compoundIdentifier.ftl" />
+</#if>
+
+/**
+ * Parses a NEW UDT(...) expression.
+ */
+SqlNode NewSpecification() :
+{
+    final Span s;
+    final SqlNode routineCall;
+}
+{
+    <NEW> { s = span(); }
+    routineCall =
+        NamedRoutineCall(SqlFunctionCategory.USER_DEFINED_CONSTRUCTOR,
+            ExprContext.ACCEPT_SUB_QUERY) {
+        return SqlStdOperatorTable.NEW.createCall(s.end(routineCall), routineCall);
+    }
+}
+
+//TODO: real parse errors.
+int UnsignedIntLiteral() :
+{
+    Token t;
+}
+{
+    t = <UNSIGNED_INTEGER_LITERAL>
+    {
+        try {
+            return Integer.parseInt(t.image);
+        } catch (NumberFormatException ex) {
+            throw SqlUtil.newContextException(getPos(),
+                RESOURCE.invalidLiteral(t.image, Integer.class.getCanonicalName()));
+        }
+    }
+}
+
+int IntLiteral() :
+{
+    Token t;
+}
+{
+    (
+        t = <UNSIGNED_INTEGER_LITERAL>
+    |
+        <PLUS> t = <UNSIGNED_INTEGER_LITERAL>
+    )
+    {
+        try {
+            return Integer.parseInt(t.image);
+        } catch (NumberFormatException ex) {
+            throw SqlUtil.newContextException(getPos(),
+                RESOURCE.invalidLiteral(t.image, Integer.class.getCanonicalName()));
+        }
+    }
+|
+    <MINUS> t = <UNSIGNED_INTEGER_LITERAL> {
+        try {
+            return -Integer.parseInt(t.image);
+        } catch (NumberFormatException ex) {
+            throw SqlUtil.newContextException(getPos(),
+                RESOURCE.invalidLiteral(t.image, Integer.class.getCanonicalName()));
+        }
+    }
+}
+
+// Type name with optional scale and precision.
+SqlDataTypeSpec DataType() :
+{
+    SqlTypeNameSpec typeName;
+    final Span s;
+}
+{
+    typeName = TypeName() {
+        s = Span.of(typeName.getParserPos());
+    }
+    (
+        typeName = CollectionsTypeName(typeName)
+    )*
+    {
+        return new SqlDataTypeSpec(typeName, s.add(typeName.getParserPos()).pos());
+    }
+}
+
+// Some SQL type names need special handling due to the fact that they have
+// spaces in them but are not quoted.
+SqlTypeNameSpec TypeName() :
+{
+    final SqlTypeNameSpec typeNameSpec;
+    final SqlIdentifier typeName;
+    final Span s = Span.of();
+}
+{
+    (
+<#-- additional types are included here -->
+<#-- put custom data types in front of Calcite core data types -->
+<#list (parser.dataTypeParserMethods!default.parser.dataTypeParserMethods) as method>
+        LOOKAHEAD(2)
+        typeNameSpec = ${method}
+    |
+</#list>
+        LOOKAHEAD(2)
+        typeNameSpec = SqlTypeName(s)
+    |
+        typeNameSpec = RowTypeName()
+    |
+        LOOKAHEAD(2)
+        typeNameSpec = MapTypeName()
+    |
+        typeName = CompoundIdentifier() {
+            typeNameSpec = new SqlUserDefinedTypeNameSpec(typeName, s.end(this));
+        }
+    )
+    {
+        return typeNameSpec;
+    }
+}
+
+// Types used for JDBC and ODBC scalar conversion function
+SqlTypeNameSpec SqlTypeName(Span s) :
+{
+    final SqlTypeNameSpec sqlTypeNameSpec;
+}
+{
+    (
+        sqlTypeNameSpec = SqlTypeName1(s)
+    |
+        sqlTypeNameSpec = SqlTypeName2(s)
+    |
+        sqlTypeNameSpec = SqlTypeName3(s)
+    |
+        sqlTypeNameSpec = CharacterTypeName(s)
+    |
+        sqlTypeNameSpec = DateTimeTypeName()
+    )
+    {
+        return sqlTypeNameSpec;
+    }
+}
+
+// Parse sql type name that don't allow any extra specifications except the type name.
+// For extra specification, we mean precision, scale, charSet, etc.
+SqlTypeNameSpec SqlTypeName1(Span s) :
+{
+    final SqlTypeName sqlTypeName;
+}
+{
+    (
+        <GEOMETRY> {
+            if (!this.conformance.allowGeometry()) {
+                throw SqlUtil.newContextException(getPos(), RESOURCE.geometryDisabled());
+            }
+            s.add(this);
+            sqlTypeName = SqlTypeName.GEOMETRY;
+        }
+    |
+        <BOOLEAN> { s.add(this); sqlTypeName = SqlTypeName.BOOLEAN; }
+    |
+        ( <INTEGER> | <INT> ) { s.add(this); sqlTypeName = SqlTypeName.INTEGER; }
+    |
+        <TINYINT> { s.add(this); sqlTypeName = SqlTypeName.TINYINT; }
+    |
+        <SMALLINT> { s.add(this); sqlTypeName = SqlTypeName.SMALLINT; }
+    |
+        <BIGINT> { s.add(this); sqlTypeName = SqlTypeName.BIGINT; }
+    |
+        <REAL> { s.add(this); sqlTypeName = SqlTypeName.REAL; }
+    |
+        <DOUBLE> { s.add(this); }
+        [ <PRECISION> ] { sqlTypeName = SqlTypeName.DOUBLE; }
+    |
+        <FLOAT> { s.add(this); sqlTypeName = SqlTypeName.FLOAT; }
+    )
+    {
+        return new SqlBasicTypeNameSpec(sqlTypeName, s.end(this));
+    }
+}
+
+// Parse sql type name that allows precision specification.
+SqlTypeNameSpec SqlTypeName2(Span s) :
+{
+    final SqlTypeName sqlTypeName;
+    int precision = -1;
+}
+{
+    (
+        <BINARY> { s.add(this); }
+        (
+            <VARYING> { sqlTypeName = SqlTypeName.VARBINARY; }
+        |
+            { sqlTypeName = SqlTypeName.BINARY; }
+        )
+    |
+        <VARBINARY> { s.add(this); sqlTypeName = SqlTypeName.VARBINARY; }
+    )
+    precision = PrecisionOpt()
+    {
+        return new SqlBasicTypeNameSpec(sqlTypeName, precision, s.end(this));
+    }
+}
+
+// Parse sql type name that allows precision and scale specifications.
+SqlTypeNameSpec SqlTypeName3(Span s) :
+{
+    final SqlTypeName sqlTypeName;
+    int precision = -1;
+    int scale = -1;
+}
+{
+    (
+        (<DECIMAL> | <DEC> | <NUMERIC>) { s.add(this); sqlTypeName = SqlTypeName.DECIMAL; }
+    |
+        <ANY> { s.add(this); sqlTypeName = SqlTypeName.ANY; }
+    )
+    [
+        <LPAREN>
+        precision = UnsignedIntLiteral()
+        [
+            <COMMA>
+            scale = UnsignedIntLiteral()
+        ]
+        <RPAREN>
+    ]
+    {
+        return new SqlBasicTypeNameSpec(sqlTypeName, precision, scale, s.end(this));
+    }
+}
+
+// Types used for for JDBC and ODBC scalar conversion function
+SqlJdbcDataTypeName JdbcOdbcDataTypeName() :
+{
+}
+{
+    (<SQL_CHAR> | <CHAR>) { return SqlJdbcDataTypeName.SQL_CHAR; }
+|   (<SQL_VARCHAR> | <VARCHAR>) { return SqlJdbcDataTypeName.SQL_VARCHAR; }
+|   (<SQL_DATE> | <DATE>) { return SqlJdbcDataTypeName.SQL_DATE; }
+|   (<SQL_TIME> | <TIME>) { return SqlJdbcDataTypeName.SQL_TIME; }
+|   (<SQL_TIMESTAMP> | <TIMESTAMP>) { return SqlJdbcDataTypeName.SQL_TIMESTAMP; }
+|   (<SQL_DECIMAL> | <DECIMAL>) { return SqlJdbcDataTypeName.SQL_DECIMAL; }
+|   (<SQL_NUMERIC> | <NUMERIC>) { return SqlJdbcDataTypeName.SQL_NUMERIC; }
+|   (<SQL_BOOLEAN> | <BOOLEAN>) { return SqlJdbcDataTypeName.SQL_BOOLEAN; }
+|   (<SQL_INTEGER> | <INTEGER>) { return SqlJdbcDataTypeName.SQL_INTEGER; }
+|   (<SQL_BINARY> | <BINARY>) { return SqlJdbcDataTypeName.SQL_BINARY; }
+|   (<SQL_VARBINARY> | <VARBINARY>) { return SqlJdbcDataTypeName.SQL_VARBINARY; }
+|   (<SQL_TINYINT> | <TINYINT>) { return SqlJdbcDataTypeName.SQL_TINYINT; }
+|   (<SQL_SMALLINT> | <SMALLINT>) { return SqlJdbcDataTypeName.SQL_SMALLINT; }
+|   (<SQL_BIGINT> | <BIGINT>) { return SqlJdbcDataTypeName.SQL_BIGINT; }
+|   (<SQL_REAL>| <REAL>) { return SqlJdbcDataTypeName.SQL_REAL; }
+|   (<SQL_DOUBLE> | <DOUBLE>) { return SqlJdbcDataTypeName.SQL_DOUBLE; }
+|   (<SQL_FLOAT> | <FLOAT>) { return SqlJdbcDataTypeName.SQL_FLOAT; }
+|   <SQL_INTERVAL_YEAR> { return SqlJdbcDataTypeName.SQL_INTERVAL_YEAR; }
+|   <SQL_INTERVAL_YEAR_TO_MONTH> { return SqlJdbcDataTypeName.SQL_INTERVAL_YEAR_TO_MONTH; }
+|   <SQL_INTERVAL_MONTH> { return SqlJdbcDataTypeName.SQL_INTERVAL_MONTH; }
+|   <SQL_INTERVAL_DAY> { return SqlJdbcDataTypeName.SQL_INTERVAL_DAY; }
+|   <SQL_INTERVAL_DAY_TO_HOUR> { return SqlJdbcDataTypeName.SQL_INTERVAL_DAY_TO_HOUR; }
+|   <SQL_INTERVAL_DAY_TO_MINUTE> { return SqlJdbcDataTypeName.SQL_INTERVAL_DAY_TO_MINUTE; }
+|   <SQL_INTERVAL_DAY_TO_SECOND> { return SqlJdbcDataTypeName.SQL_INTERVAL_DAY_TO_SECOND; }
+|   <SQL_INTERVAL_HOUR> { return SqlJdbcDataTypeName.SQL_INTERVAL_HOUR; }
+|   <SQL_INTERVAL_HOUR_TO_MINUTE> { return SqlJdbcDataTypeName.SQL_INTERVAL_HOUR_TO_MINUTE; }
+|   <SQL_INTERVAL_HOUR_TO_SECOND> { return SqlJdbcDataTypeName.SQL_INTERVAL_HOUR_TO_SECOND; }
+|   <SQL_INTERVAL_MINUTE> { return SqlJdbcDataTypeName.SQL_INTERVAL_MINUTE; }
+|   <SQL_INTERVAL_MINUTE_TO_SECOND> { return SqlJdbcDataTypeName.SQL_INTERVAL_MINUTE_TO_SECOND; }
+|   <SQL_INTERVAL_SECOND> { return SqlJdbcDataTypeName.SQL_INTERVAL_SECOND; }
+}
+
+SqlLiteral JdbcOdbcDataType() :
+{
+    SqlJdbcDataTypeName typeName;
+}
+{
+    typeName = JdbcOdbcDataTypeName() {
+        return typeName.symbol(getPos());
+    }
+}
+
+/**
+* Parse a collection type name, the input element type name may
+* also be a collection type.
+*/
+SqlTypeNameSpec CollectionsTypeName(SqlTypeNameSpec elementTypeName) :
+{
+    final SqlTypeName collectionTypeName;
+}
+{
+    (
+        <MULTISET> { collectionTypeName = SqlTypeName.MULTISET; }
+    |
+        <ARRAY> { collectionTypeName = SqlTypeName.ARRAY; }
+    )
+    {
+        return new SqlCollectionTypeNameSpec(elementTypeName,
+                collectionTypeName, getPos());
+    }
+}
+
+/**
+* Parse a nullable option, default is true.
+*/
+boolean NullableOptDefaultTrue() :
+{
+}
+{
+    <NULL> { return true; }
+|
+    <NOT> <NULL> { return false; }
+|
+    { return true; }
+}
+
+/**
+* Parse a nullable option, default is false.
+*/
+boolean NullableOptDefaultFalse() :
+{
+}
+{
+    <NULL> { return true; }
+|
+    <NOT> <NULL> { return false; }
+|
+    { 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 AddFieldNameTypes(List<SqlIdentifier> fieldNames,
+    List<SqlDataTypeSpec> fieldTypes) :
+{
+}
+{
+    AddFieldNameType(fieldNames, fieldTypes)
+    ( <COMMA> AddFieldNameType(fieldNames, fieldTypes) )*
+}
+
+void AddFieldNameType(List<SqlIdentifier> fieldNames,
+    List<SqlDataTypeSpec> fieldTypes) :
+{
+    final SqlIdentifier fName;
+    final SqlDataTypeSpec fType;
+    final boolean nullable;
+}
+{
+    fName = SimpleIdentifier()
+    fType = DataType()
+    nullable = NullableOptDefaultFalse()
+    {
+        fieldNames.add(fName);
+        fieldTypes.add(fType.withNullable(nullable, getPos()));
+    }
+}
+
+/**
+* Parse Row type with format: Row(name1 type1, name2 type2).
+* Every field type can have suffix of `NULL` or `NOT NULL` to indicate if this type is nullable.
+* i.e. Row(f0 int not null, f1 varchar null).
+*/
+SqlTypeNameSpec RowTypeName() :
+{
+    List<SqlIdentifier> fieldNames = new ArrayList<SqlIdentifier>();
+    List<SqlDataTypeSpec> fieldTypes = new ArrayList<SqlDataTypeSpec>();
+}
+{
+    <ROW>
+    <LPAREN> AddFieldNameTypes(fieldNames, fieldTypes) <RPAREN>
+    {
+        return new SqlRowTypeNameSpec(getPos(), fieldNames, fieldTypes);
+    }
+}
+
+SqlTypeNameSpec MapTypeName() :
+{
+    SqlDataTypeSpec keyType = null;
+    SqlDataTypeSpec valType = null;
+}
+{
+    <MAP>
+    <LT>
+    keyType = DataType()
+    <COMMA>
+    valType = DataType()
+    <GT>
+    {
+        return new SqlMapTypeNameSpec(keyType, valType, getPos());
+    }
+}
+
+/**
+* Parse character types: char, varchar.
+*/
+SqlTypeNameSpec CharacterTypeName(Span s) :
+{
+    int precision = -1;
+    final SqlTypeName sqlTypeName;
+    String charSetName = null;
+}
+{
+    (
+        (<CHARACTER> | <CHAR>) { s.add(this); }
+        (
+            <VARYING> { sqlTypeName = SqlTypeName.VARCHAR; }
+        |
+            { sqlTypeName = SqlTypeName.CHAR; }
+        )
+    |
+        <VARCHAR> { s.add(this); sqlTypeName = SqlTypeName.VARCHAR; }
+    )
+    precision = PrecisionOpt()
+    [
+        <CHARACTER> <SET>
+        charSetName = Identifier()
+    ]
+    {
+        return new SqlBasicTypeNameSpec(sqlTypeName, precision, charSetName, s.end(this));
+    }
+}
+
+/**
+* Parse datetime types: date, time, timestamp.
+*/
+SqlTypeNameSpec DateTimeTypeName() :
+{
+    int precision = -1;
+    SqlTypeName typeName;
+    final Span s;
+}
+{
+    <DATE> {
+        typeName = SqlTypeName.DATE;
+        return new SqlBasicTypeNameSpec(typeName, getPos());
+    }
+|
+    LOOKAHEAD(2)
+    <TIME> { s = span(); }
+    precision = PrecisionOpt()
+    typeName = TimeZoneOpt(true)
+    {
+        return new SqlBasicTypeNameSpec(typeName, precision, s.end(this));
+    }
+|
+    <TIMESTAMP> { s = span(); }
+    precision = PrecisionOpt()
+    typeName = TimeZoneOpt(false)
+    {
+        return new SqlBasicTypeNameSpec(typeName, precision, s.end(this));
+    }
+}
+
+// Parse an optional data type precision, default is -1.
+int PrecisionOpt() :
+{
+    int precision = -1;
+}
+{
+    <LPAREN>
+    precision = UnsignedIntLiteral()
+    <RPAREN>
+    { return precision; }
+|
+    { return -1; }
+}
+
+/**
+* Parse a time zone suffix for DateTime types. According to SQL-2011,
+* "with time zone" and "without time zone" belong to standard SQL.
+* We also support "with local time zone".
+*/
+SqlTypeName TimeZoneOpt(boolean timeType) :
+{
+    boolean local = false;
+}
+{
+    LOOKAHEAD(3)
+    <WITHOUT> <TIME> <ZONE> { return timeType ? SqlTypeName.TIME : SqlTypeName.TIMESTAMP;  }
+|
+    <WITH> ( <LOCAL> { local = true; } )? <TIME> <ZONE> {
+        return timeType ? (local ? SqlTypeName.TIME_WITH_LOCAL_TIME_ZONE : SqlTypeName.TIME_TZ)
+                        : (local ? SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE : SqlTypeName.TIMESTAMP_TZ); }
+|
+    { return timeType ? SqlTypeName.TIME : SqlTypeName.TIMESTAMP; }
+}
+
+/**
+ * Parses a CURSOR(query) expression.  The parser allows these
+ * anywhere, but the validator restricts them to appear only as
+ * arguments to table functions.
+ */
+SqlNode CursorExpression(ExprContext exprContext) :
+{
+    final SqlNode e;
+    final Span s;
+}
+{
+    <CURSOR> {
+        s = span();
+        if (exprContext != ExprContext.ACCEPT_ALL
+                && exprContext != ExprContext.ACCEPT_CURSOR) {
+            throw SqlUtil.newContextException(s.end(this),
+                RESOURCE.illegalCursorExpression());
+        }
+    }
+    e = Expression(ExprContext.ACCEPT_QUERY) {
+        return SqlStdOperatorTable.CURSOR.createCall(s.end(e), e);
+    }
+}
+
+/**
+ * Parses a call to a builtin function with special syntax.
+ */
+SqlNode BuiltinFunctionCall() :
+{
+    final SqlIdentifier name;
+    final List<SqlNode> args = new ArrayList<SqlNode>();
+    SqlNode e;
+    final Span s;
+    SqlDataTypeSpec dt;
+    final SqlIntervalQualifier unit;
+    final SqlNode node;
+    final SqlLiteral style; // mssql convert 'style' operand
+    final SqlFunction f;
+    final SqlNode format;
+}
+{
+    //~ FUNCTIONS WITH SPECIAL SYNTAX ---------------------------------------
+    (
+        (  <CAST> { f = SqlStdOperatorTable.CAST; }
+        | <SAFE_CAST> { f = SqlLibraryOperators.SAFE_CAST; }
+        | <TRY_CAST> { f = SqlLibraryOperators.TRY_CAST; }
+        )
+        { s = span(); }
+        <LPAREN> AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+        <AS>
+        (
+            dt = DataType() { args.add(dt); }
+        |
+            <INTERVAL> e = IntervalQualifier() { args.add(e); }
+        )
+        [ <FORMAT> format = StringLiteral() { args.add(format); } ]
+        <RPAREN> {
+            return f.createCall(s.end(this), args);
+        }
+    |
+        <EXTRACT> { s = span(); }
+        <LPAREN> unit = TimeUnitOrName() {
+            args.add(unit);
+        }
+        <FROM>
+        AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+        <RPAREN> {
+            return SqlStdOperatorTable.EXTRACT.createCall(s.end(this), args);
+        }
+    |
+        <POSITION> { s = span(); }
+        <LPAREN>
+        // 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.add(e); }
+        <IN>
+        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>
+        (
+            // 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.TRANSLATE.createCall(s.end(this), args);
+                }
+            |
+                <COMMA> e = SimpleIdentifier() { args.add(e); }
+                <COMMA> e = SimpleIdentifier() { args.add(e); }
+                <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>
+        AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+        (
+            <USING> name = SimpleIdentifier() { args.add(name); }
+            <RPAREN> {
+                return SqlStdOperatorTable.TRANSLATE.createCall(s.end(this),
+                    args);
+            }
+        |
+            ( <COMMA> AddExpression(args, ExprContext.ACCEPT_SUB_QUERY) )*
+            <RPAREN> {
+                return SqlLibraryOperators.TRANSLATE3.createCall(s.end(this),
+                    args);
+            }
+        )
+    |
+        <OVERLAY> { s = span(); }
+        <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);
+        }
+    |
+        <FLOOR> { s = span(); }
+        e = FloorCeilOptions(s, true) {
+            return e;
+        }
+    |
+        ( <CEIL> | <CEILING>) { s = span(); }
+        e = FloorCeilOptions(s, false) {
+            return e;
+        }
+    |
+        <SUBSTRING> { s = span(); }
+        <LPAREN>
+        AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+        ( <FROM> | <COMMA>)
+        AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+        [
+            (<FOR> | <COMMA>)
+            AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+        ]
+        <RPAREN> {
+            return SqlStdOperatorTable.SUBSTRING.createCall(
+                s.end(this), args);
+        }
+    |
+        <TRIM> {
+            SqlLiteral flag = null;
+            SqlNode trimChars = null;
+            s = span();
+        }
+        <LPAREN>
+        [
+            LOOKAHEAD(2)
+            [
+                <BOTH> {
+                    s.add(this);
+                    flag = SqlTrimFunction.Flag.BOTH.symbol(getPos());
+                }
+            |
+                <TRAILING> {
+                    s.add(this);
+                    flag = SqlTrimFunction.Flag.TRAILING.symbol(getPos());
+                }
+            |
+                <LEADING> {
+                    s.add(this);
+                    flag = SqlTrimFunction.Flag.LEADING.symbol(getPos());
+                }
+            ]
+            [ trimChars = Expression(ExprContext.ACCEPT_SUB_QUERY) ]
+            (
+                <FROM> {
+                    if (null == flag && null == trimChars) {
+                        throw SqlUtil.newContextException(getPos(),
+                            RESOURCE.illegalFromEmpty());
+                    }
+                }
+            |
+                <RPAREN> {
+                    // This is to handle the case of TRIM(x)
+                    // (FRG-191).
+                    if (flag == null) {
+                        flag = SqlTrimFunction.Flag.BOTH.symbol(SqlParserPos.ZERO);
+                    }
+                    args.add(flag);
+                    args.add(null); // no trim chars
+                    args.add(trimChars); // reinterpret trimChars as source
+                    return SqlStdOperatorTable.TRIM.createCall(s.end(this),
+                        args);
+                }
+            )
+        ]
+        e = Expression(ExprContext.ACCEPT_SUB_QUERY) {
+            if (flag == null) {
+                flag = SqlTrimFunction.Flag.BOTH.symbol(SqlParserPos.ZERO);
+            }
+            args.add(flag);
+            args.add(trimChars);
+            args.add(e);
+        }
+        <RPAREN> {
+            return SqlStdOperatorTable.TRIM.createCall(s.end(this), args);
+        }
+    |
+        node = ContainsSubstrFunctionCall() { return node; }
+    |
+        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; }
+    |
+</#list>
+        node = MatchRecognizeFunctionCall() { return node; }
+    |
+        node = JsonExistsFunctionCall() { return node; }
+    |
+        node = JsonValueFunctionCall() { return node; }
+    |
+        node = JsonQueryFunctionCall() { return node; }
+    |
+        node = JsonObjectFunctionCall() { return node; }
+    |
+        node = JsonObjectAggFunctionCall() { return node; }
+    |
+        node = JsonArrayFunctionCall() { return node; }
+    |
+        node = JsonArrayAggFunctionCall() { return node; }
+    |
+        node = GroupByWindowingCall() { return node; }
+    )
+}
+
+SqlJsonEncoding JsonRepresentation() :
+{
+}
+{
+    <JSON>
+    [
+        // Encoding is currently ignored.
+        LOOKAHEAD(2) <ENCODING>
+        (
+            <UTF8> { return SqlJsonEncoding.UTF8; }
+        |
+            <UTF16> { return SqlJsonEncoding.UTF16; }
+        |
+            <UTF32> { return SqlJsonEncoding.UTF32; }
+        )
+    ]
+    {
+        return SqlJsonEncoding.UTF8;
+    }
+}
+
+void JsonInputClause() :
+{
+}
+{
+    <FORMAT> JsonRepresentation()
+}
+
+SqlDataTypeSpec JsonReturningClause() :
+{
+    SqlDataTypeSpec dt;
+}
+{
+    <RETURNING> dt = DataType() { return dt; }
+}
+
+SqlDataTypeSpec JsonOutputClause() :
+{
+    SqlDataTypeSpec dataType;
+}
+{
+    dataType = JsonReturningClause()
+    [
+        <FORMAT> JsonRepresentation()
+    ]
+    {
+        return dataType;
+    }
+}
+
+SqlNode JsonPathSpec() :
+{
+    SqlNode e;
+}
+{
+    e = StringLiteral() {
+        return e;
+    }
+}
+
+List<SqlNode> JsonApiCommonSyntax() :
+{
+    SqlNode e;
+    final List<SqlNode> args = new ArrayList<SqlNode>();
+}
+{
+    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) {
+            // no-op
+        }
+        <AS> e = SimpleIdentifier() {
+            // no-op
+        }
+        (
+            <COMMA>
+            e = Expression(ExprContext.ACCEPT_NON_QUERY) {
+                // no-op
+            }
+            <AS> e = SimpleIdentifier() {
+                // no-op
+            }
+        )*
+    ]
+    {
+        return args;
+    }
+}
+
+SqlJsonExistsErrorBehavior JsonExistsErrorBehavior() :
+{
+
+}
+{
+    <TRUE> { return SqlJsonExistsErrorBehavior.TRUE; }
+    |
+    <FALSE> { return SqlJsonExistsErrorBehavior.FALSE; }
+    |
+    <UNKNOWN> { return SqlJsonExistsErrorBehavior.UNKNOWN; }
+    |
+    <ERROR> { return SqlJsonExistsErrorBehavior.ERROR; }
+}
+
+SqlCall JsonExistsFunctionCall() :
+{
+    List<SqlNode> args = new ArrayList<SqlNode>();
+    List<SqlNode> commonSyntax;
+    final Span span;
+    SqlJsonExistsErrorBehavior errorBehavior;
+}
+{
+    <JSON_EXISTS> { span = span(); }
+    <LPAREN> commonSyntax = JsonApiCommonSyntax() {
+        args.addAll(commonSyntax);
+    }
+    [
+        errorBehavior = JsonExistsErrorBehavior() { args.add(errorBehavior.symbol(getPos())); }
+        <ON> <ERROR>
+    ]
+    <RPAREN> {
+        return SqlStdOperatorTable.JSON_EXISTS.createCall(span.end(this), args);
+    }
+}
+
+List<SqlNode> JsonValueEmptyOrErrorBehavior() :
+{
+    final List<SqlNode> list = new ArrayList<SqlNode>();
+}
+{
+    (
+        <ERROR> {
+            list.add(SqlJsonValueEmptyOrErrorBehavior.ERROR.symbol(getPos()));
+        }
+    |
+        <NULL> {
+            list.add(SqlJsonValueEmptyOrErrorBehavior.NULL.symbol(getPos()));
+        }
+    |
+        <DEFAULT_> {
+            list.add(SqlJsonValueEmptyOrErrorBehavior.DEFAULT.symbol(getPos()));
+        }
+        AddExpression(list, ExprContext.ACCEPT_NON_QUERY)
+    )
+    <ON>
+    (
+        <EMPTY> {
+            list.add(SqlJsonEmptyOrError.EMPTY.symbol(getPos()));
+        }
+    |
+        <ERROR> {
+            list.add(SqlJsonEmptyOrError.ERROR.symbol(getPos()));
+        }
+    )
+    { return list; }
+}
+
+SqlCall JsonValueFunctionCall() :
+{
+    final List<SqlNode> args = new ArrayList<SqlNode>(7);
+    SqlNode e;
+    List<SqlNode> commonSyntax;
+    final Span span;
+    List<SqlNode> behavior;
+}
+{
+    <JSON_VALUE> { span = span(); }
+    <LPAREN> commonSyntax = JsonApiCommonSyntax() {
+        args.addAll(commonSyntax);
+    }
+    [
+        e = JsonReturningClause() {
+            args.add(SqlJsonValueReturning.RETURNING.symbol(getPos()));
+            args.add(e);
+        }
+    ]
+    (
+        behavior = JsonValueEmptyOrErrorBehavior() {
+            args.addAll(behavior);
+        }
+    )*
+    <RPAREN> {
+        return SqlStdOperatorTable.JSON_VALUE.createCall(span.end(this), args);
+    }
+}
+
+List<SqlNode> JsonQueryEmptyOrErrorBehavior() :
+{
+    final List<SqlNode> list = new ArrayList<SqlNode>();
+}
+{
+    (
+        <ERROR> {
+            list.add(SqlLiteral.createSymbol(SqlJsonQueryEmptyOrErrorBehavior.ERROR, getPos()));
+        }
+    |
+        <NULL> {
+            list.add(SqlLiteral.createSymbol(SqlJsonQueryEmptyOrErrorBehavior.NULL, getPos()));
+        }
+    |
+        LOOKAHEAD(2)
+        <EMPTY> <ARRAY> {
+            list.add(SqlLiteral.createSymbol(SqlJsonQueryEmptyOrErrorBehavior.EMPTY_ARRAY, getPos()));
+        }
+    |
+        <EMPTY> <OBJECT> {
+            list.add(SqlLiteral.createSymbol(SqlJsonQueryEmptyOrErrorBehavior.EMPTY_OBJECT, getPos()));
+        }
+    )
+    <ON>
+    (
+        <EMPTY> {
+            list.add(SqlLiteral.createSymbol(SqlJsonEmptyOrError.EMPTY, getPos()));
+        }
+    |
+        <ERROR> {
+            list.add(SqlLiteral.createSymbol(SqlJsonEmptyOrError.ERROR, getPos()));
+        }
+    )
+    { return list; }
+}
+
+SqlNode JsonQueryWrapperBehavior() :
+{
+}
+{
+    <WITHOUT> [<ARRAY>] {
+        return SqlLiteral.createSymbol(SqlJsonQueryWrapperBehavior.WITHOUT_ARRAY, getPos());
+    }
+|
+    LOOKAHEAD(2)
+    <WITH> <CONDITIONAL> [<ARRAY>] {
+        return SqlLiteral.createSymbol(SqlJsonQueryWrapperBehavior.WITH_CONDITIONAL_ARRAY, getPos());
+    }
+|
+    <WITH> [<UNCONDITIONAL>] [<ARRAY>] {
+        return SqlLiteral.createSymbol(SqlJsonQueryWrapperBehavior.WITH_UNCONDITIONAL_ARRAY, getPos());
+    }
+}
+
+SqlCall JsonQueryFunctionCall() :
+{
+    final SqlNode[] args = new SqlNode[5];
+    SqlNode e;
+    List<SqlNode> commonSyntax;
+    final Span span;
+    List<SqlNode> behavior;
+}
+{
+    <JSON_QUERY> { span = span(); }
+    <LPAREN> commonSyntax = JsonApiCommonSyntax() {
+        args[0] = commonSyntax.get(0);
+        args[1] = commonSyntax.get(1);
+    }
+    [
+        e = JsonQueryWrapperBehavior() <WRAPPER> {
+            args[2] = e;
+        }
+    ]
+    (
+        behavior = JsonQueryEmptyOrErrorBehavior() {
+            final SqlJsonEmptyOrError symbol =
+                ((SqlLiteral) behavior.get(1)).getValueAs(SqlJsonEmptyOrError.class);
+            switch (symbol) {
+            case EMPTY:
+                args[3] = behavior.get(0);
+                break;
+            case ERROR:
+                args[4] = behavior.get(0);
+                break;
+            }
+        }
+    )*
+    <RPAREN> {
+        return SqlStdOperatorTable.JSON_QUERY.createCall(span.end(this), args);
+    }
+}
+
+SqlNode JsonName() :
+{
+    final SqlNode e;
+}
+{
+     e = Expression(ExprContext.ACCEPT_NON_QUERY) {
+        return e;
+     }
+}
+
+List<SqlNode> JsonNameAndValue() :
+{
+    final List<SqlNode> list = new ArrayList<SqlNode>();
+    final SqlNode e;
+    boolean kvMode = false;
+}
+{
+    [
+        LOOKAHEAD(2, <KEY> JsonName())
+        <KEY> { kvMode = true; }
+    ]
+    e = JsonName() {
+        list.add(e);
+    }
+    (
+        <VALUE>
+    |
+        <COMMA> {
+            if (kvMode) {
+                throw SqlUtil.newContextException(getPos(), RESOURCE.illegalComma());
+            }
+        }
+    |
+        <COLON> {
+            if (kvMode) {
+                throw SqlUtil.newContextException(getPos(), RESOURCE.illegalColon());
+            }
+        }
+    )
+    AddExpression(list, ExprContext.ACCEPT_NON_QUERY)
+    {
+        return list;
+    }
+}
+
+SqlNode JsonConstructorNullClause() :
+{
+}
+{
+    <NULL> <ON> <NULL> {
+        return SqlLiteral.createSymbol(SqlJsonConstructorNullClause.NULL_ON_NULL, getPos());
+    }
+|
+    <ABSENT> <ON> <NULL> {
+        return SqlLiteral.createSymbol(SqlJsonConstructorNullClause.ABSENT_ON_NULL, getPos());
+    }
+}
+
+SqlCall JsonObjectFunctionCall() :
+{
+    final List<SqlNode> nvArgs = new ArrayList<SqlNode>();
+    final SqlNode[] otherArgs = new SqlNode[1];
+    SqlNode e;
+    List<SqlNode> list;
+    final Span span;
+}
+{
+    <JSON_OBJECT> { span = span(); }
+    <LPAREN> [
+        LOOKAHEAD(2)
+        list = JsonNameAndValue() {
+            nvArgs.addAll(list);
+        }
+        (
+            <COMMA>
+            list = JsonNameAndValue() {
+                nvArgs.addAll(list);
+            }
+        )*
+    ]
+    [
+        e = JsonConstructorNullClause() {
+            otherArgs[0] = e;
+        }
+    ]
+    <RPAREN> {
+        final List<SqlNode> args = new ArrayList();
+        args.addAll(Arrays.asList(otherArgs));
+        args.addAll(nvArgs);
+        return SqlStdOperatorTable.JSON_OBJECT.createCall(span.end(this), args);
+    }
+}
+
+SqlCall JsonObjectAggFunctionCall() :
+{
+    final SqlNode[] args = new SqlNode[2];
+    List<SqlNode> list;
+    final Span span;
+    SqlJsonConstructorNullClause nullClause =
+        SqlJsonConstructorNullClause.NULL_ON_NULL;
+    final SqlNode e;
+}
+{
+    <JSON_OBJECTAGG> { span = span(); }
+    <LPAREN> list = JsonNameAndValue() {
+        args[0] = list.get(0);
+        args[1] = list.get(1);
+    }
+    [
+        e = JsonConstructorNullClause() {
+            nullClause = (SqlJsonConstructorNullClause) ((SqlLiteral) e).getValue();
+        }
+    ]
+    <RPAREN> {
+        return SqlStdOperatorTable.JSON_OBJECTAGG.with(nullClause)
+            .createCall(span.end(this), args);
+    }
+}
+
+SqlCall JsonArrayFunctionCall() :
+{
+    final List<SqlNode> elements = new ArrayList<SqlNode>();
+    final SqlNode[] otherArgs = new SqlNode[1];
+    SqlNode e;
+    final Span span;
+}
+{
+    <JSON_ARRAY> { span = span(); }
+    <LPAREN> [
+        LOOKAHEAD(2)
+        AddExpression(elements, ExprContext.ACCEPT_NON_QUERY)
+        ( <COMMA> AddExpression(elements, ExprContext.ACCEPT_NON_QUERY) )*
+    ]
+    [
+        e = JsonConstructorNullClause() {
+            otherArgs[0] = e;
+        }
+    ]
+    <RPAREN> {
+        final List<SqlNode> args = new ArrayList();
+        args.addAll(Arrays.asList(otherArgs));
+        args.addAll(elements);
+        return SqlStdOperatorTable.JSON_ARRAY.createCall(span.end(this), args);
+    }
+}
+
+SqlNodeList JsonArrayAggOrderByClause() :
+{
+    final SqlNodeList orderList;
+}
+{
+    orderList = OrderBy(true)
+    { return orderList; }
+}
+
+SqlCall JsonArrayAggFunctionCall() :
+{
+    final SqlNode valueExpr;
+    final SqlNodeList orderList;
+    final Span span;
+    final SqlJsonConstructorNullClause nullClause;
+    SqlNode e;
+    final SqlNode aggCall;
+}
+{
+    <JSON_ARRAYAGG> { span = span(); }
+    <LPAREN> e = Expression(ExprContext.ACCEPT_NON_QUERY) {
+        valueExpr = e;
+    }
+    ( orderList = JsonArrayAggOrderByClause() | { orderList = null; } )
+    (
+        e = JsonConstructorNullClause() {
+            nullClause = (SqlJsonConstructorNullClause) ((SqlLiteral) e).getValue();
+        }
+    |   { nullClause = SqlJsonConstructorNullClause.ABSENT_ON_NULL; }
+    )
+    <RPAREN>
+    {
+        aggCall = SqlStdOperatorTable.JSON_ARRAYAGG.with(nullClause)
+            .createCall(span.end(this), valueExpr, orderList);
+    }
+    [
+        e = withinGroup(aggCall) {
+            if (orderList != null) {
+                throw SqlUtil.newContextException(span.pos().plus(e.getParserPosition()),
+                    RESOURCE.ambiguousSortOrderInJsonArrayAggFunc());
+            }
+            return (SqlCall) e;
+        }
+    ]
+    {
+        if (orderList == null) {
+            return SqlStdOperatorTable.JSON_ARRAYAGG.with(nullClause)
+                .createCall(span.end(this), valueExpr);
+        }
+        return SqlStdOperatorTable.JSON_ARRAYAGG.with(nullClause)
+            .createCall(span.end(this), valueExpr, orderList);
+    }
+}
+
+ /**
+ * Parses the CONTAINS_SUBSTR function, which has a unique optional third argument "JSON_SCOPE"
+ * that specifies what scope to search if the first argument is a JSON string.
+ */
+ SqlCall ContainsSubstrFunctionCall() :
+ {
+    final List<SqlNode> args = new ArrayList<SqlNode>();
+    final Span s;
+    SqlNode e;
+ }
+ {
+     <CONTAINS_SUBSTR> { s = span(); }
+     <LPAREN>
+     AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+     <COMMA>
+     AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+     (
+        <RPAREN>
+     |
+        <COMMA>
+        <JSON_SCOPE>
+        <NAMED_ARGUMENT_ASSIGNMENT> e = Expression(ExprContext.ACCEPT_SUB_QUERY)  { args.add(e); }
+        <RPAREN>
+     ) { return SqlLibraryOperators.CONTAINS_SUBSTR.createCall(s.end(this), args); }
+ }
+
+/**
+ * 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() :
+{
+    final List<SqlNode> args = new ArrayList<SqlNode>();
+    final Span s;
+    final SqlIntervalQualifier unit;
+}
+{
+    <TIMESTAMPADD> { s = span(); }
+    <LPAREN>
+    unit = TimeUnitOrName() { args.add(unit); }
+    <COMMA>
+    AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+    <COMMA>
+    AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+    <RPAREN> {
+        return SqlStdOperatorTable.TIMESTAMP_ADD.createCall(
+            s.end(this), args);
+    }
+}
+
+/**
+ * Parses a call to TIMESTAMPDIFF.
+ */
+SqlCall TimestampDiffFunctionCall() :
+{
+    final List<SqlNode> args = new ArrayList<SqlNode>();
+    final Span s;
+    final SqlIntervalQualifier unit;
+}
+{
+    <TIMESTAMPDIFF> { s = span(); }
+    <LPAREN>
+    unit = TimeUnitOrName() { args.add(unit); }
+    <COMMA>
+    AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+    <COMMA>
+    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() :
+{
+    final Span s;
+    final List<SqlNode> args;
+    final SqlOperator op;
+}
+{
+    (
+        <TUMBLE> { op = SqlStdOperatorTable.TUMBLE_OLD; }
+    |
+        <HOP> { op = SqlStdOperatorTable.HOP_OLD; }
+    |
+        <SESSION> { op = SqlStdOperatorTable.SESSION_OLD; }
+    )
+    { s = span(); }
+    args = UnquantifiedFunctionParameterList(ExprContext.ACCEPT_SUB_QUERY) {
+        return op.createCall(s.end(this), args);
+    }
+}
+
+SqlCall MatchRecognizeFunctionCall() :
+{
+    final SqlCall func;
+    final Span s;
+}
+{
+    (
+        <CLASSIFIER> { s = span(); } <LPAREN> <RPAREN> {
+            func = SqlStdOperatorTable.CLASSIFIER.createCall(s.end(this));
+        }
+    |
+        <MATCH_NUMBER> { s = span(); } <LPAREN> <RPAREN> {
+            func = SqlStdOperatorTable.MATCH_NUMBER.createCall(s.end(this));
+        }
+    |
+        LOOKAHEAD(3)
+        func = MatchRecognizeNavigationLogical()
+    |
+        LOOKAHEAD(2)
+        func = MatchRecognizeNavigationPhysical()
+    |
+        func = MatchRecognizeCallWithModifier()
+    )
+    { return func; }
+}
+
+SqlCall MatchRecognizeCallWithModifier() :
+{
+    final Span s;
+    final SqlOperator runningOp;
+    final SqlNode func;
+}
+{
+    (
+        <RUNNING> { runningOp = SqlStdOperatorTable.RUNNING; }
+    |
+        <FINAL> { runningOp = SqlStdOperatorTable.FINAL; }
+    )
+    { s = span(); }
+    func = NamedFunctionCall() {
+        return runningOp.createCall(s.end(func), func);
+    }
+}
+
+SqlCall MatchRecognizeNavigationLogical() :
+{
+    final Span s = Span.of();
+    SqlCall func;
+    final SqlOperator funcOp;
+    final SqlOperator runningOp;
+    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; }
+    )
+    (
+        <FIRST> { funcOp = SqlStdOperatorTable.FIRST; }
+    |
+        <LAST> { funcOp = SqlStdOperatorTable.LAST; }
+    )
+    { s.add(this); }
+    <LPAREN>
+    AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+    (
+        <COMMA> e = NumericLiteral() { args.add(e); }
+    |
+        { args.add(LITERAL_ZERO); }
+    )
+    <RPAREN> {
+        func = funcOp.createCall(s.end(this), args);
+        if (runningOp != null) {
+            return runningOp.createCall(s.end(this), func);
+        } else {
+            return func;
+        }
+    }
+}
+
+SqlCall MatchRecognizeNavigationPhysical() :
+{
+    final Span s;
+    final SqlOperator funcOp;
+    final List<SqlNode> args = new ArrayList<SqlNode>();
+    SqlNode e;
+}
+{
+    (
+        <PREV> { funcOp = SqlStdOperatorTable.PREV; }
+    |
+        <NEXT> { funcOp = SqlStdOperatorTable.NEXT; }
+    )
+    { s = span(); }
+    <LPAREN>
+    AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+    (
+        <COMMA> e = NumericLiteral() { args.add(e); }
+    |
+        { args.add(LITERAL_ONE); }
+    )
+    <RPAREN> {
+        return funcOp.createCall(s.end(this), args);
+    }
+}
+
+SqlCall withinDistinct(SqlNode arg) :
+{
+    final Span s;
+    final SqlNodeList distinctList;
+}
+{
+    <WITHIN> { s = span(); }
+    <DISTINCT>
+    <LPAREN>
+    distinctList = ExpressionCommaList(s, ExprContext.ACCEPT_SUB_QUERY)
+    <RPAREN> {
+        return SqlStdOperatorTable.WITHIN_DISTINCT.createCall(
+            s.end(this), arg, distinctList);
+    }
+}
+
+SqlCall withinGroup(SqlNode arg) :
+{
+    final Span s;
+    final SqlNodeList orderList;
+}
+{
+    <WITHIN> { s = span(); }
+    <GROUP>
+    <LPAREN>
+    orderList = OrderBy(true)
+    <RPAREN> {
+        return SqlStdOperatorTable.WITHIN_GROUP.createCall(
+            s.end(this), arg, orderList);
+    }
+}
+
+Pair<SqlParserPos, SqlOperator> NullTreatment() :
+{
+    final Span span;
+}
+{
+    <IGNORE> { span = span(); } <NULLS> {
+        return Pair.of(span.end(this), SqlStdOperatorTable.IGNORE_NULLS);
+    }
+|
+    <RESPECT> { span = span(); } <NULLS> {
+        return Pair.of(span.end(this), SqlStdOperatorTable.RESPECT_NULLS);
+    }
+}
+
+SqlCall nullTreatment(SqlCall arg) :
+{
+    final Pair<SqlParserPos, SqlOperator> pair;
+}
+{
+    pair = NullTreatment() { return pair.right.createCall(pair.left, arg); }
+}
+
+/**
+ * Parses a call to a named function (could be a builtin with regular
+ * syntax, or else a UDF).
+ *
+ * <p>NOTE: every UDF has two names: an <em>invocation name</em> and a
+ * <em>specific name</em>.  Normally, function calls are resolved via overload
+ * resolution and invocation names.  The SPECIFIC prefix allows overload
+ * resolution to be bypassed.  Note that usage of the SPECIFIC prefix in
+ * queries is non-standard; it is used internally by Farrago, e.g. in stored
+ * view definitions to permanently bind references to a particular function
+ * after the overload resolution performed by view creation.
+ *
+ * <p>TODO jvs 25-Mar-2005:  Once we have SQL-Flagger support, flag SPECIFIC
+ * as non-standard.
+ */
+SqlNode NamedFunctionCall() :
+{
+    SqlCall call;
+    final Span filterSpan;
+    final SqlNode filter;
+    final Span overSpan;
+    final SqlNode over;
+}
+{
+    (
+        LOOKAHEAD(2)
+        call = StringAggFunctionCall()
+    |
+        LOOKAHEAD(1)
+        call = PercentileFunctionCall()
+    |
+        call = NamedCall()
+    )
+    [
+        LOOKAHEAD(2) call = nullTreatment(call)
+    ]
+    [
+        LOOKAHEAD(2) // decide between WITHIN DISTINCT and WITHIN GROUP
+        call = withinDistinct(call)
+    ]
+    [
+        call = withinGroup(call)
+    ]
+    [
+        <FILTER> { filterSpan = span(); }
+        <LPAREN>
+        <WHERE>
+        filter = Expression(ExprContext.ACCEPT_SUB_QUERY)
+        <RPAREN> {
+            call = SqlStdOperatorTable.FILTER.createCall(
+                filterSpan.end(this), call, filter);
+        }
+    ]
+    [
+        <OVER> { overSpan = span(); }
+        (
+            over = SimpleIdentifier()
+        |
+            over = WindowSpecification()
+        )
+        {
+            call = SqlStdOperatorTable.OVER.createCall(overSpan.end(over), call, over);
+        }
+    ]
+    {
+        return call;
+    }
+}
+
+SqlCall NamedCall() :
+{
+    final SqlFunctionCategory funcType;
+    final SqlIdentifier qualifiedName;
+    final Span s;
+    final List<SqlNode> args;
+    SqlLiteral quantifier = null;
+}
+{
+    (
+        <SPECIFIC> {
+            funcType = SqlFunctionCategory.USER_DEFINED_SPECIFIC_FUNCTION;
+        }
+    |
+        { funcType = SqlFunctionCategory.USER_DEFINED_FUNCTION; }
+    )
+    qualifiedName = FunctionName() {
+        s = span();
+    }
+    (
+        LOOKAHEAD(2) <LPAREN> <STAR> {
+            args = ImmutableList.of(SqlIdentifier.star(getPos()));
+        }
+        <RPAREN>
+    |
+        LOOKAHEAD(2) <LPAREN> <RPAREN> {
+            args = ImmutableList.of();
+        }
+    |
+        args = FunctionParameterList(ExprContext.ACCEPT_SUB_QUERY) {
+            quantifier = (SqlLiteral) args.get(0);
+            args.remove(0);
+        }
+    )
+    {
+        return createCall(qualifiedName, s.end(this), funcType, quantifier, args);
+    }
+}
+
+/*
+* Parse Floor/Ceil function parameters
+*/
+SqlNode StandardFloorCeilOptions(Span s, boolean floorFlag) :
+{
+    SqlNode e;
+    final List<SqlNode> args = new ArrayList<SqlNode>();
+    final SqlIntervalQualifier unit;
+    SqlCall function;
+    final Span s1;
+}
+{
+    <LPAREN> AddExpression(args, ExprContext.ACCEPT_SUB_QUERY)
+    (
+        <TO> unit = TimeUnitOrName() {
+            args.add(unit);
+        }
+    )?
+    <RPAREN> {
+        SqlOperator op = SqlStdOperatorTable.floorCeil(floorFlag, this.conformance);
+        function =  op.createCall(s.end(this), args);
+    }
+    (
+        <OVER> { s1 = span(); }
+        (
+            e = SimpleIdentifier()
+        |
+            e = WindowSpecification()
+        )
+        {
+            return SqlStdOperatorTable.OVER.createCall(s1.end(this), function, e);
+        }
+    |
+        { return function; }
+    )
+}
+
+/**
+ * Parses the name of a JDBC function that is a token but is not reserved.
+ */
+String NonReservedJdbcFunctionName() :
+{
+}
+{
+    (
+        <SUBSTRING>
+    )
+    {
+        return unquotedIdentifier();
+    }
+}
+
+/**
+ * Parses the name of a function (either a compound identifier or
+ * a reserved word which can be used as a function name).
+ */
+SqlIdentifier FunctionName() :
+{
+    SqlIdentifier qualifiedName;
+}
+{
+    (
+        qualifiedName = CompoundIdentifier()
+    |
+        qualifiedName = ReservedFunctionName()
+    )
+    {
+        return qualifiedName;
+    }
+}
+
+/**
+ * Parses a reserved word which is used as the name of a function.
+ */
+SqlIdentifier ReservedFunctionName() :
+{
+}
+{
+    (
+        <ABS>
+    |   <AVG>
+    |   <CARDINALITY>
+    |   <CEILING>
+    |   <CHAR>
+    |   <CHAR_LENGTH>
+    |   <CHARACTER_LENGTH>
+    |   <COALESCE>
+    |   <COLLECT>
+    |   <COVAR_POP>
+    |   <COVAR_SAMP>
+    |   <CUME_DIST>
+    |   <COUNT>
+    |   <CURRENT_DATE>
+    |   <CURRENT_TIME>
+    |   <CURRENT_TIMESTAMP>
+    |   <DENSE_RANK>
+    |   <ELEMENT>
+    |   <EVERY>
+    |   <EXP>
+    |   <FIRST_VALUE>
+    |   <FLOOR>
+    |   <FUSION>
+    |   <INTERSECTION>
+    |   <GROUPING>
+    |   <HOUR>
+    |   <LAG>
+    |   <LEAD>
+    |   <LEFT>
+    |   <LAST_VALUE>
+    |   <LN>
+    |   <LOCALTIME>
+    |   <LOCALTIMESTAMP>
+    |   <LOWER>
+    |   <MAX>
+    |   <MIN>
+    |   <MINUTE>
+    |   <MOD>
+    |   <MONTH>
+    |   <NTH_VALUE>
+    |   <NTILE>
+    |   <NULLIF>
+    |   <OCTET_LENGTH>
+    |   <PERCENTILE_CONT>
+    |   <PERCENTILE_DISC>
+    |   <PERCENT_RANK>
+    |   <POWER>
+    |   <RANK>
+    |   <REGR_COUNT>
+    |   <REGR_SXX>
+    |   <REGR_SYY>
+    |   <RIGHT>
+    |   <ROW_NUMBER>
+    |   <SECOND>
+    |   <SOME>
+    |   <SQRT>
+    |   <STDDEV_POP>
+    |   <STDDEV_SAMP>
+    |   <SUM>
+    |   <UPPER>
+    |   <TRUNCATE>
+    |   <USER>
+    |   <VAR_POP>
+    |   <VAR_SAMP>
+    |   <YEAR>
+    )
+    {
+        return new SqlIdentifier(unquotedIdentifier(), getPos());
+    }
+}
+
+SqlIdentifier ContextVariable() :
+{
+}
+{
+    (
+        <CURRENT_CATALOG>
+    |   <CURRENT_DATE>
+    |   <CURRENT_DEFAULT_TRANSFORM_GROUP>
+    |   <CURRENT_PATH>
+    |   <CURRENT_ROLE>
+    |   <CURRENT_SCHEMA>
+    |   <CURRENT_TIME>
+    |   <CURRENT_TIMESTAMP>
+    |   <CURRENT_USER>
+    |   <LOCALTIME>
+    |   <LOCALTIMESTAMP>
+    |   <SESSION_USER>
+    |   <SYSTEM_USER>
+    |   <USER>
+    )
+    {
+        return new SqlIdentifier(unquotedIdentifier(), getPos());
+    }
+}
+
+/**
+ * Parses a function call expression with JDBC syntax.
+ */
+SqlNode JdbcFunctionCall() :
+{
+    String name;
+    SqlIdentifier id;
+    SqlNode e;
+    SqlLiteral tl;
+    SqlNodeList args;
+    SqlCall call;
+    final Span s, s1;
+}
+{
+    <LBRACE_FN> {
+        s = span();
+    }
+    (
+        LOOKAHEAD(1)
+        call = ContainsSubstrFunctionCall() {
+            name = call.getOperator().getName();
+            args = new SqlNodeList(call.getOperandList(), getPos());
+        }
+    |
+        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() {
+            name = call.getOperator().getName();
+            args = new SqlNodeList(call.getOperandList(), getPos());
+        }
+    |
+        <CONVERT> { name = unquotedIdentifier(); }
+        <LPAREN>
+        e = Expression(ExprContext.ACCEPT_SUB_QUERY) {
+            args = new SqlNodeList(getPos());
+            args.add(e);
+        }
+        <COMMA>
+        tl = JdbcOdbcDataType() { args.add(tl); }
+        <RPAREN>
+    |
+        (
+            // INSERT is a reserved word, but we need to handle {fn insert}
+            // Similarly LEFT, RIGHT, TRUNCATE
+            LOOKAHEAD(1)
+            ( <INSERT> | <LEFT> | <RIGHT> | <TRUNCATE> ) { name = unquotedIdentifier(); }
+        |
+            // For cases like {fn power(1,2)} and {fn lower('a')}
+            id = ReservedFunctionName() { name = id.getSimple(); }
+        |
+            // For cases like {fn substring('foo', 1,2)}
+            name = NonReservedJdbcFunctionName()
+        |
+            name = Identifier()
+        )
+        (
+            LOOKAHEAD(2) <LPAREN> <STAR> { s1 = span(); } <RPAREN>
+            {
+                args = new SqlNodeList(s1.pos());
+                args.add(SqlIdentifier.star(s1.pos()));
+            }
+        |
+            LOOKAHEAD(2) <LPAREN> <RPAREN> { args = SqlNodeList.EMPTY; }
+        |
+            args = ParenthesizedQueryOrCommaList(ExprContext.ACCEPT_SUB_QUERY)
+        )
+    )
+    <RBRACE> {
+        return new SqlJdbcFunctionCall(name).createCall(s.end(this),
+            args.getList());
+    }
+}
+
+/**
+ * Parses a binary query operator like UNION.
+ */
+SqlBinaryOperator BinaryQueryOperator() :
+{
+}
+{
+    // If both the ALL or DISTINCT keywords are missing, DISTINCT is implicit.
+    (
+        <UNION>
+        (
+            <ALL> { return SqlStdOperatorTable.UNION_ALL; }
+        |   <DISTINCT> { return SqlStdOperatorTable.UNION; }
+        |   { return SqlStdOperatorTable.UNION; }
+        )
+    |
+        <INTERSECT>
+        (
+            <ALL> { return SqlStdOperatorTable.INTERSECT_ALL; }
+        |   <DISTINCT> { return SqlStdOperatorTable.INTERSECT; }
+        |   { return SqlStdOperatorTable.INTERSECT; }
+        )
+    |
+        (
+            <EXCEPT>
+        |
+            <SET_MINUS> {
+                if (!this.conformance.isMinusAllowed()) {
+                    throw SqlUtil.newContextException(getPos(), RESOURCE.minusNotAllowed());
+                }
+            }
+        )
+        (
+            <ALL> { return SqlStdOperatorTable.EXCEPT_ALL; }
+        |   <DISTINCT> { return SqlStdOperatorTable.EXCEPT; }
+        |   { return SqlStdOperatorTable.EXCEPT; }
+        )
+    )
+}
+
+/**
+ * Parses a binary multiset operator.
+ */
+SqlBinaryOperator BinaryMultisetOperator() :
+{
+}
+{
+    // If both the ALL or DISTINCT keywords are missing, DISTINCT is implicit
+    <MULTISET>
+    (
+        <UNION>
+        [
+            <ALL>
+        |   <DISTINCT> { return SqlStdOperatorTable.MULTISET_UNION_DISTINCT; }
+        ]
+        { return SqlStdOperatorTable.MULTISET_UNION; }
+    |
+        <INTERSECT>
+        [
+            <ALL>
+        |   <DISTINCT> { return SqlStdOperatorTable.MULTISET_INTERSECT_DISTINCT; }
+        ]
+        { return SqlStdOperatorTable.MULTISET_INTERSECT; }
+    |
+        <EXCEPT>
+        [
+            <ALL>
+        |   <DISTINCT> { return SqlStdOperatorTable.MULTISET_EXCEPT_DISTINCT; }
+        ]
+        { return SqlStdOperatorTable.MULTISET_EXCEPT; }
+    )
+}
+
+/**
+ * Parses a binary row operator like AND.
+ */
+SqlBinaryOperator BinaryRowOperator() :
+{
+    SqlBinaryOperator op;
+}
+{
+    // <IN> is handled as a special case
+    <EQ> { return SqlStdOperatorTable.EQUALS; }
+|   <GT> { return SqlStdOperatorTable.GREATER_THAN; }
+|   <LT> { return SqlStdOperatorTable.LESS_THAN; }
+|   <LE> { return SqlStdOperatorTable.LESS_THAN_OR_EQUAL; }
+|   <GE> { return SqlStdOperatorTable.GREATER_THAN_OR_EQUAL; }
+|   <NE> { return SqlStdOperatorTable.NOT_EQUALS; }
+|   <NE2> {
+        if (!this.conformance.isBangEqualAllowed()) {
+            throw SqlUtil.newContextException(getPos(), RESOURCE.bangEqualNotAllowed());
+        }
+        return SqlStdOperatorTable.NOT_EQUALS;
+    }
+|   <PLUS> { return SqlStdOperatorTable.PLUS; }
+|   <MINUS> { return SqlStdOperatorTable.MINUS; }
+|   <STAR> { return SqlStdOperatorTable.MULTIPLY; }
+|   <SLASH> { return SqlStdOperatorTable.DIVIDE; }
+|   <PERCENT_REMAINDER> {
+        if (!this.conformance.isPercentRemainderAllowed()) {
+            throw SqlUtil.newContextException(getPos(), RESOURCE.percentRemainderNotAllowed());
+        }
+        return SqlStdOperatorTable.PERCENT_REMAINDER;
+    }
+|   <CONCAT> { return SqlStdOperatorTable.CONCAT; }
+|   <AND> { return SqlStdOperatorTable.AND; }
+|   <OR> { return SqlStdOperatorTable.OR; }
+|   LOOKAHEAD(2) <IS> <DISTINCT> <FROM> { return SqlStdOperatorTable.IS_DISTINCT_FROM; }
+|   <IS> <NOT> <DISTINCT> <FROM> { return SqlStdOperatorTable.IS_NOT_DISTINCT_FROM; }
+|   <MEMBER> <OF> { return SqlStdOperatorTable.MEMBER_OF; }
+|   LOOKAHEAD(2) <SUBMULTISET> <OF> { return SqlStdOperatorTable.SUBMULTISET_OF; }
+|   <NOT> <SUBMULTISET> <OF> { return SqlStdOperatorTable.NOT_SUBMULTISET_OF; }
+|   <CONTAINS> { return SqlStdOperatorTable.CONTAINS; }
+|   <OVERLAPS> { return SqlStdOperatorTable.OVERLAPS; }
+|   <EQUALS> { return SqlStdOperatorTable.PERIOD_EQUALS; }
+|   <PRECEDES> { return SqlStdOperatorTable.PRECEDES; }
+|   <SUCCEEDS> { return SqlStdOperatorTable.SUCCEEDS; }
+|   LOOKAHEAD(2) <IMMEDIATELY> <PRECEDES> { return SqlStdOperatorTable.IMMEDIATELY_PRECEDES; }
+|   <IMMEDIATELY> <SUCCEEDS> { return SqlStdOperatorTable.IMMEDIATELY_SUCCEEDS; }
+|   op = BinaryMultisetOperator() { return op; }
+}
+
+/**
+ * Parses a prefix row operator like NOT.
+ */
+SqlPrefixOperator PrefixRowOperator() :
+{}
+{
+    <PLUS> { return SqlStdOperatorTable.UNARY_PLUS; }
+|   <MINUS> { return SqlStdOperatorTable.UNARY_MINUS; }
+|   <NOT> { return SqlStdOperatorTable.NOT; }
+|   <EXISTS> { return SqlStdOperatorTable.EXISTS; }
+|   <UNIQUE> { return SqlStdOperatorTable.UNIQUE; }
+}
+
+/**
+ * Parses a postfix row operator like IS NOT NULL.
+ */
+SqlPostfixOperator PostfixRowOperator() :
+{}
+{
+    <IS>
+    (
+        <A> <SET> { return SqlStdOperatorTable.IS_A_SET; }
+    |
+        <NOT>
+        (
+            <NULL> { return SqlStdOperatorTable.IS_NOT_NULL; }
+        |   <TRUE> { return SqlStdOperatorTable.IS_NOT_TRUE; }
+        |   <FALSE> { return SqlStdOperatorTable.IS_NOT_FALSE; }
+        |   <UNKNOWN> { return SqlStdOperatorTable.IS_NOT_UNKNOWN; }
+        |   <A> <SET> { return SqlStdOperatorTable.IS_NOT_A_SET; }
+        |   <EMPTY> { return SqlStdOperatorTable.IS_NOT_EMPTY; }
+        |   LOOKAHEAD(2) <JSON> <VALUE> { return SqlStdOperatorTable.IS_NOT_JSON_VALUE; }
+        |   LOOKAHEAD(2) <JSON> <OBJECT> { return SqlStdOperatorTable.IS_NOT_JSON_OBJECT; }
+        |   LOOKAHEAD(2) <JSON> <ARRAY> { return SqlStdOperatorTable.IS_NOT_JSON_ARRAY; }
+        |   LOOKAHEAD(2) <JSON> <SCALAR> { return SqlStdOperatorTable.IS_NOT_JSON_SCALAR; }
+        |   <JSON> { return SqlStdOperatorTable.IS_NOT_JSON_VALUE; }
+        )
+    |
+        (
+            <NULL> { return SqlStdOperatorTable.IS_NULL; }
+        |   <TRUE> { return SqlStdOperatorTable.IS_TRUE; }
+        |   <FALSE> { return SqlStdOperatorTable.IS_FALSE; }
+        |   <UNKNOWN> { return SqlStdOperatorTable.IS_UNKNOWN; }
+        |   <EMPTY> { return SqlStdOperatorTable.IS_EMPTY; }
+        |   LOOKAHEAD(2) <JSON> <VALUE> { return SqlStdOperatorTable.IS_JSON_VALUE; }
+        |   LOOKAHEAD(2) <JSON> <OBJECT> { return SqlStdOperatorTable.IS_JSON_OBJECT; }
+        |   LOOKAHEAD(2) <JSON> <ARRAY> { return SqlStdOperatorTable.IS_JSON_ARRAY; }
+        |   LOOKAHEAD(2) <JSON> <SCALAR> { return SqlStdOperatorTable.IS_JSON_SCALAR; }
+        |   <JSON> { return SqlStdOperatorTable.IS_JSON_VALUE; }
+        )
+    )
+|
+    <FORMAT>
+    (
+        JsonRepresentation() {
+            return SqlStdOperatorTable.JSON_VALUE_EXPRESSION;
+        }
+    )
+}
+
+
+/* KEYWORDS:  anything in this list is a reserved word unless it appears
+   in the NonReservedKeyWord() production. */
+
+<DEFAULT, DQID, BTID, BQID, BQHID> TOKEN :
+{
+    < A: "A" >
+|   < ABS: "ABS" >
+|   < ABSENT: "ABSENT" >
+|   < ABSOLUTE: "ABSOLUTE" >
+|   < ACTION: "ACTION" >
+|   < ADA: "ADA" >
+|   < ADD: "ADD" >
+|   < ADMIN: "ADMIN" >
+|   < AFTER: "AFTER" >
+|   < ALL: "ALL" >
+|   < ALLOCATE: "ALLOCATE" >
+|   < ALLOW: "ALLOW" >
+|   < ALTER: "ALTER" >
+|   < ALWAYS: "ALWAYS" >
+|   < AND: "AND" >
+|   < ANY: "ANY" >
+|   < APPLY: "APPLY" >
+|   < ARE: "ARE" >
+|   < ARRAY: "ARRAY" >
+|   < ARRAY_AGG: "ARRAY_AGG" >
+|   < ARRAY_CONCAT_AGG: "ARRAY_CONCAT_AGG" >
+|   < ARRAY_MAX_CARDINALITY: "ARRAY_MAX_CARDINALITY" >
+|   < AS: "AS" >
+|   < ASC: "ASC" >
+|   < ASENSITIVE: "ASENSITIVE" >
+|   < ASSERTION: "ASSERTION" >
+|   < ASSIGNMENT: "ASSIGNMENT" >
+|   < ASYMMETRIC: "ASYMMETRIC" >
+|   < AT: "AT" >
+|   < ATOMIC: "ATOMIC" >
+|   < ATTRIBUTE: "ATTRIBUTE" >
+|   < ATTRIBUTES: "ATTRIBUTES" >
+|   < AUTHORIZATION: "AUTHORIZATION" >
+|   < AVG: "AVG" >
+|   < BEFORE: "BEFORE" >
+|   < BEGIN: "BEGIN" >
+|   < BEGIN_FRAME: "BEGIN_FRAME" >
+|   < BEGIN_PARTITION: "BEGIN_PARTITION" >
+|   < BERNOULLI: "BERNOULLI" >
+|   < BETWEEN: "BETWEEN" >
+|   < BIGINT: "BIGINT" >
+|   < BINARY: "BINARY" >
+|   < BIT: "BIT" >
+|   < BLOB: "BLOB" >
+|   < BOOLEAN: "BOOLEAN" >
+|   < BOTH: "BOTH" >
+|   < BREADTH: "BREADTH" >
+|   < BY: "BY" >
+|   < C: "C" >
+|   < CALL: "CALL" >
+|   < CALLED: "CALLED" >
+|   < CARDINALITY: "CARDINALITY" >
+|   < CASCADE: "CASCADE" >
+|   < CASCADED: "CASCADED" >
+|   < CASE: "CASE" >
+|   < CAST: "CAST" >
+|   < CATALOG: "CATALOG" >
+|   < CATALOG_NAME: "CATALOG_NAME" >
+|   < CEIL: "CEIL" >
+|   < CEILING: "CEILING" >
+|   < CENTURY: "CENTURY" >
+|   < CHAIN: "CHAIN" >
+|   < CHAR: "CHAR" >
+|   < CHAR_LENGTH: "CHAR_LENGTH" >
+|   < CHARACTER: "CHARACTER" >
+|   < CHARACTER_LENGTH: "CHARACTER_LENGTH" >
+|   < CHARACTER_SET_CATALOG: "CHARACTER_SET_CATALOG" >
+|   < CHARACTER_SET_NAME: "CHARACTER_SET_NAME" >
+|   < CHARACTER_SET_SCHEMA: "CHARACTER_SET_SCHEMA" >
+|   < CHARACTERISTICS: "CHARACTERISTICS" >
+|   < CHARACTERS: "CHARACTERS" >
+|   < CHECK: "CHECK" >
+|   < CLASSIFIER: "CLASSIFIER" >
+|   < CLASS_ORIGIN: "CLASS_ORIGIN" >
+|   < CLOB: "CLOB" >
+|   < CLOSE: "CLOSE" >
+|   < COALESCE: "COALESCE" >
+|   < COBOL: "COBOL" >
+|   < COLLATE: "COLLATE" >
+|   < COLLATION: "COLLATION" >
+|   < COLLATION_CATALOG: "COLLATION_CATALOG" >
+|   < COLLATION_NAME: "COLLATION_NAME" >
+|   < COLLATION_SCHEMA: "COLLATION_SCHEMA" >
+|   < COLLECT: "COLLECT" >
+|   < COLUMN: "COLUMN" >
+|   < COLUMN_NAME: "COLUMN_NAME" >
+|   < COMMAND_FUNCTION: "COMMAND_FUNCTION" >
+|   < COMMAND_FUNCTION_CODE: "COMMAND_FUNCTION_CODE" >
+|   < COMMIT: "COMMIT" >
+|   < COMMITTED: "COMMITTED" >
+|   < CONDITION: "CONDITION" >
+|   < CONDITIONAL: "CONDITIONAL" >
+|   < CONDITION_NUMBER: "CONDITION_NUMBER" >
+|   < CONNECT: "CONNECT" >
+|   < CONNECTION: "CONNECTION" >
+|   < CONNECTION_NAME: "CONNECTION_NAME" >
+|   < CONSTRAINT: "CONSTRAINT" >
+|   < CONSTRAINT_CATALOG: "CONSTRAINT_CATALOG" >
+|   < CONSTRAINT_NAME: "CONSTRAINT_NAME" >
+|   < CONSTRAINT_SCHEMA: "CONSTRAINT_SCHEMA" >
+|   < CONSTRAINTS: "CONSTRAINTS" >
+|   < CONSTRUCTOR: "CONSTRUCTOR" >
+|   < CONTAINS: "CONTAINS" >
+|   < CONTAINS_SUBSTR: "CONTAINS_SUBSTR" >
+|   < CONTINUE: "CONTINUE" >
+|   < CONVERT: "CONVERT" >
+|   < CORR: "CORR" >
+|   < CORRESPONDING: "CORRESPONDING" >
+|   < COUNT: "COUNT" >
+|   < COVAR_POP: "COVAR_POP" >
+|   < COVAR_SAMP: "COVAR_SAMP" >
+|   < CREATE: "CREATE" >
+|   < CROSS: "CROSS" >
+|   < CUBE: "CUBE" >
+|   < CUME_DIST: "CUME_DIST" >
+|   < CURRENT: "CURRENT" >
+|   < CURRENT_CATALOG: "CURRENT_CATALOG" >
+|   < CURRENT_DATE: "CURRENT_DATE" >
+|   < CURRENT_DEFAULT_TRANSFORM_GROUP: "CURRENT_DEFAULT_TRANSFORM_GROUP" >
+|   < CURRENT_PATH: "CURRENT_PATH" >
+|   < CURRENT_ROLE: "CURRENT_ROLE" >
+|   < CURRENT_ROW: "CURRENT_ROW" >
+|   < CURRENT_SCHEMA: "CURRENT_SCHEMA" >
+|   < CURRENT_TIME: "CURRENT_TIME" >
+|   < CURRENT_TIMESTAMP: "CURRENT_TIMESTAMP" >
+|   < CURRENT_TRANSFORM_GROUP_FOR_TYPE: "CURRENT_TRANSFORM_GROUP_FOR_TYPE" >
+|   < CURRENT_USER: "CURRENT_USER" >
+|   < CURSOR: "CURSOR" >
+|   < CURSOR_NAME: "CURSOR_NAME" >
+|   < CYCLE: "CYCLE" >
+|   < 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" >
+|   < DECADE: "DECADE" >
+|   < DECIMAL: "DECIMAL" >
+|   < DECLARE: "DECLARE" >
+|   < DEFAULT_: "DEFAULT" >
+|   < DEFAULTS: "DEFAULTS" >
+|   < DEFERRABLE: "DEFERRABLE" >
+|   < DEFERRED: "DEFERRED" >
+|   < DEFINE: "DEFINE" >
+|   < DEFINED: "DEFINED" >
+|   < DEFINER: "DEFINER" >
+|   < DEGREE: "DEGREE" >
+|   < DELETE: "DELETE" > { beforeTableName(); }
+|   < DENSE_RANK: "DENSE_RANK" >
+|   < DEPTH: "DEPTH" >
+|   < DEREF: "DEREF" >
+|   < DERIVED: "DERIVED" >
+|   < DESC: "DESC" >
+|   < DESCRIBE: "DESCRIBE" > { beforeTableName(); }
+|   < DESCRIPTION: "DESCRIPTION" >
+|   < DESCRIPTOR: "DESCRIPTOR" >
+|   < DETERMINISTIC: "DETERMINISTIC" >
+|   < DIAGNOSTICS: "DIAGNOSTICS" >
+|   < DISALLOW: "DISALLOW" >
+|   < DISCONNECT: "DISCONNECT" >
+|   < DISPATCH: "DISPATCH" >
+|   < DISTINCT: "DISTINCT" >
+|   < DOMAIN: "DOMAIN" >
+|   < DOT_FORMAT: "DOT" >
+|   < DOUBLE: "DOUBLE" >
+|   < DOW: "DOW" >
+|   < DOY: "DOY" >
+|   < DROP: "DROP" >
+|   < DYNAMIC: "DYNAMIC" >
+|   < DYNAMIC_FUNCTION: "DYNAMIC_FUNCTION" >
+|   < DYNAMIC_FUNCTION_CODE: "DYNAMIC_FUNCTION_CODE" >
+|   < EACH: "EACH" >
+|   < ELEMENT: "ELEMENT" >
+|   < ELSE: "ELSE" >
+|   < EMPTY: "EMPTY" >
+|   < ENCODING: "ENCODING">
+|   < END: "END" >
+|   < END_EXEC: "END-EXEC" >
+|   < END_FRAME: "END_FRAME" >
+|   < END_PARTITION: "END_PARTITION" >
+|   < EPOCH: "EPOCH" >
+|   < EQUALS: "EQUALS" >
+|   < ERROR: "ERROR" >
+|   < ESCAPE: "ESCAPE" >
+|   < EVERY: "EVERY" >
+|   < EXCEPT: "EXCEPT" >
+|   < EXCEPTION: "EXCEPTION" >
+|   < EXCLUDE: "EXCLUDE" >
+|   < EXCLUDING: "EXCLUDING" >
+|   < EXEC: "EXEC" >
+|   < EXECUTE: "EXECUTE" >
+|   < EXISTS: "EXISTS" >
+|   < EXP: "EXP" >
+|   < EXPLAIN: "EXPLAIN" >
+|   < EXTEND: "EXTEND" >
+|   < EXTERNAL: "EXTERNAL" >
+|   < EXTRACT: "EXTRACT" >
+|   < FALSE: "FALSE" >
+|   < FETCH: "FETCH" >
+|   < FILTER: "FILTER" >
+|   < FINAL: "FINAL" >
+|   < FIRST: "FIRST" >
+|   < FIRST_VALUE: "FIRST_VALUE">
+|   < FLOAT: "FLOAT" >
+|   < FLOOR: "FLOOR" >
+|   < FOLLOWING: "FOLLOWING" >
+|   < FOR: "FOR" >
+|   < FORMAT: "FORMAT" >
+|   < FOREIGN: "FOREIGN" >
+|   < FORTRAN: "FORTRAN" >
+|   < FOUND: "FOUND" >
+|   < FRAC_SECOND: "FRAC_SECOND" >
+|   < FRAME_ROW: "FRAME_ROW" >
+|   < FREE: "FREE" >
+|   < FRIDAY: "FRIDAY" >
+|   < FROM: "FROM" > { beforeTableName(); }
+|   < FULL: "FULL" >
+|   < FUNCTION: "FUNCTION" >
+|   < FUSION: "FUSION" >
+|   < G: "G" >
+|   < GENERAL: "GENERAL" >
+|   < GENERATED: "GENERATED" >
+|   < GEOMETRY: "GEOMETRY" >
+|   < GET: "GET" >
+|   < GLOBAL: "GLOBAL" >
+|   < GO: "GO" >
+|   < GOTO: "GOTO" >
+|   < GRANT: "GRANT" >
+|   < GRANTED: "GRANTED" >
+|   < GROUP: "GROUP" >
+|   < GROUP_CONCAT: "GROUP_CONCAT" >
+|   < GROUPING: "GROUPING" >
+|   < GROUPS: "GROUPS" >
+|   < HAVING: "HAVING" >
+|   < HIERARCHY: "HIERARCHY" >
+|   < HOLD: "HOLD" >
+|   < HOP: "HOP" >
+|   < HOUR: "HOUR" >
+|   < HOURS: "HOURS" >
+|   < IDENTITY: "IDENTITY" >
+|   < IGNORE: "IGNORE" >
+|   < ILIKE: "ILIKE" >
+|   < IMMEDIATE: "IMMEDIATE" >
+|   < IMMEDIATELY: "IMMEDIATELY" >
+|   < IMPLEMENTATION: "IMPLEMENTATION" >
+|   < IMPORT: "IMPORT" >
+|   < IN: "IN" >
+|   < INCLUDE: "INCLUDE" >
+|   < INCLUDING: "INCLUDING" >
+|   < INCREMENT: "INCREMENT" >
+|   < INDICATOR: "INDICATOR" >
+|   < INITIAL: "INITIAL" >
+|   < INITIALLY: "INITIALLY" >
+|   < INNER: "INNER" >
+|   < INOUT: "INOUT" >
+|   < INPUT: "INPUT" >
+|   < INSENSITIVE: "INSENSITIVE" >
+|   < INSERT: "INSERT" > { beforeTableName(); }
+|   < INSTANCE: "INSTANCE" >
+|   < INSTANTIABLE: "INSTANTIABLE" >
+|   < INT: "INT" >
+|   < INTEGER: "INTEGER" >
+|   < INTERSECT: "INTERSECT" >
+|   < INTERSECTION: "INTERSECTION" >
+|   < INTERVAL: "INTERVAL" >
+|   < INTO: "INTO" >
+|   < INVOKER: "INVOKER" >
+|   < IS: "IS" >
+|   < ISODOW: "ISODOW" >
+|   < ISOYEAR: "ISOYEAR" >
+|   < ISOLATION: "ISOLATION" >
+|   < JAVA: "JAVA" >
+|   < JOIN: "JOIN" > { beforeTableName(); }
+|   < JSON: "JSON" >
+|   < JSON_ARRAY: "JSON_ARRAY">
+|   < JSON_ARRAYAGG: "JSON_ARRAYAGG">
+|   < JSON_EXISTS: "JSON_EXISTS" >
+|   < JSON_OBJECT: "JSON_OBJECT">
+|   < JSON_OBJECTAGG: "JSON_OBJECTAGG">
+|   < JSON_QUERY: "JSON_QUERY" >
+|   < JSON_SCOPE: "JSON_SCOPE" >
+|   < JSON_VALUE: "JSON_VALUE" >
+|   < K: "K" >
+|   < KEY: "KEY" >
+|   < KEY_MEMBER: "KEY_MEMBER" >
+|   < KEY_TYPE: "KEY_TYPE" >
+|   < LABEL: "LABEL" >
+|   < LAG: "LAG" >
+|   < LANGUAGE: "LANGUAGE" >
+|   < LARGE: "LARGE" >
+|   < LAST: "LAST" >
+|   < LAST_VALUE: "LAST_VALUE" >
+|   < LATERAL: "LATERAL" >
+|   < LEAD: "LEAD" >
+|   < LEADING: "LEADING" >
+|   < LEFT: "LEFT" >
+|   < LENGTH: "LENGTH" >
+|   < LEVEL: "LEVEL" >
+|   < LIBRARY: "LIBRARY" >
+|   < LIKE: "LIKE" >
+|   < LIKE_REGEX: "LIKE_REGEX" >
+|   < LIMIT: "LIMIT" >
+|   < LN: "LN" >
+|   < LOCAL: "LOCAL" >
+|   < LOCALTIME: "LOCALTIME" >
+|   < LOCALTIMESTAMP: "LOCALTIMESTAMP" >
+|   < LOCATOR: "LOCATOR" >
+|   < LOWER: "LOWER" >
+|   < M: "M" >
+|   < MAP: "MAP" >
+|   < MATCH: "MATCH" >
+|   < MATCHED: "MATCHED" >
+|   < MATCHES: "MATCHES" >
+|   < MATCH_NUMBER: "MATCH_NUMBER">
+|   < MATCH_RECOGNIZE: "MATCH_RECOGNIZE">
+|   < MAX: "MAX" >
+|   < MAXVALUE: "MAXVALUE" >
+|   < MEASURES: "MEASURES" >
+|   < MEMBER: "MEMBER" >
+|   < MERGE: "MERGE" > { beforeTableName(); }
+|   < MESSAGE_LENGTH: "MESSAGE_LENGTH" >
+|   < MESSAGE_OCTET_LENGTH: "MESSAGE_OCTET_LENGTH" >
+|   < MESSAGE_TEXT: "MESSAGE_TEXT" >
+|   < METHOD: "METHOD" >
+|   < MICROSECOND: "MICROSECOND" >
+|   < MILLISECOND: "MILLISECOND" >
+|   < MILLENNIUM: "MILLENNIUM" >
+|   < MIN: "MIN" >
+|   < MINUTE: "MINUTE" >
+|   < MINUTES: "MINUTES" >
+|   < MINVALUE: "MINVALUE" >
+|   < MOD: "MOD" >
+|   < MODIFIES: "MODIFIES" >
+|   < MODULE: "MODULE" >
+|   < MONDAY: "MONDAY" >
+|   < MONTH: "MONTH" >
+|   < MONTHS: "MONTHS" >
+|   < MORE_: "MORE" >
+|   < MULTISET: "MULTISET" >
+|   < MUMPS: "MUMPS" >
+|   < NAME: "NAME" >
+|   < NAMES: "NAMES" >
+|   < NANOSECOND: "NANOSECOND" >
+|   < NATIONAL: "NATIONAL" >
+|   < NATURAL: "NATURAL" >
+|   < NCHAR: "NCHAR" >
+|   < NCLOB: "NCLOB" >
+|   < NESTING: "NESTING" >
+|   < NEW: "NEW" >
+|   < NEXT: "NEXT" >
+|   < NO: "NO" >
+|   < NONE: "NONE" >
+|   < NORMALIZE: "NORMALIZE" >
+|   < NORMALIZED: "NORMALIZED" >
+|   < NOT: "NOT" >
+|   < NTH_VALUE: "NTH_VALUE" >
+|   < NTILE: "NTILE" >
+|   < NULL: "NULL" >
+|   < NULLABLE: "NULLABLE" >
+|   < NULLIF: "NULLIF" >
+|   < NULLS: "NULLS" >
+|   < NUMBER: "NUMBER" >
+|   < NUMERIC: "NUMERIC" >
+|   < OBJECT: "OBJECT" >
+|   < OCCURRENCES_REGEX: "OCCURRENCES_REGEX" >
+|   < OCTET_LENGTH: "OCTET_LENGTH" >
+|   < OCTETS: "OCTETS" >
+|   < OF: "OF" >
+|   < OFFSET: "OFFSET" >
+|   < OLD: "OLD" >
+|   < OMIT: "OMIT" >
+|   < ON: "ON" >
+|   < ONE: "ONE" >
+|   < ONLY: "ONLY" >
+|   < OPEN: "OPEN" >
+|   < OPTION: "OPTION" >
+|   < OPTIONS: "OPTIONS" >
+|   < OR: "OR" >
+|   < ORDER: "ORDER" >
+|   < ORDERING: "ORDERING" >
+|   < ORDINAL: "ORDINAL" >
+|   < ORDINALITY: "ORDINALITY" >
+|   < OTHERS: "OTHERS" >
+|   < OUT: "OUT" >
+|   < OUTER: "OUTER" >
+|   < OUTPUT: "OUTPUT" >
+|   < OVER: "OVER" >
+|   < OVERLAPS: "OVERLAPS" >
+|   < OVERLAY: "OVERLAY" >
+|   < OVERRIDING: "OVERRIDING" >
+|   < PAD: "PAD" >
+|   < PARAMETER: "PARAMETER" >
+|   < PARAMETER_MODE: "PARAMETER_MODE" >
+|   < PARAMETER_NAME: "PARAMETER_NAME" >
+|   < PARAMETER_ORDINAL_POSITION: "PARAMETER_ORDINAL_POSITION" >
+|   < PARAMETER_SPECIFIC_CATALOG: "PARAMETER_SPECIFIC_CATALOG" >
+|   < PARAMETER_SPECIFIC_NAME: "PARAMETER_SPECIFIC_NAME" >
+|   < PARAMETER_SPECIFIC_SCHEMA: "PARAMETER_SPECIFIC_SCHEMA" >
+|   < PARTIAL: "PARTIAL" >
+|   < PARTITION: "PARTITION" >
+|   < PASCAL: "PASCAL" >
+|   < PASSING: "PASSING" >
+|   < PASSTHROUGH: "PASSTHROUGH" >
+|   < PAST: "PAST" >
+|   < PATH: "PATH" >
+|   < PATTERN: "PATTERN" >
+|   < PER: "PER" >
+|   < PERCENT: "PERCENT" >
+|   < PERCENTILE_CONT: "PERCENTILE_CONT" >
+|   < PERCENTILE_DISC: "PERCENTILE_DISC" >
+|   < PERCENT_RANK: "PERCENT_RANK" >
+|   < PERIOD: "PERIOD" >
+|   < PERMUTE: "PERMUTE" >
+|   < PIVOT: "PIVOT" >
+|   < PLACING: "PLACING" >
+|   < PLAN: "PLAN" >
+|   < PLI: "PLI" >
+|   < PORTION: "PORTION" >
+|   < POSITION: "POSITION" >
+|   < POSITION_REGEX: "POSITION_REGEX" >
+|   < POWER: "POWER" >
+|   < PRECEDES: "PRECEDES" >
+|   < PRECEDING: "PRECEDING" >
+|   < PRECISION: "PRECISION" >
+|   < PREPARE: "PREPARE" >
+|   < PRESERVE: "PRESERVE" >
+|   < PREV: "PREV" >
+|   < PRIMARY: "PRIMARY" >
+|   < PRIOR: "PRIOR" >
+|   < PRIVILEGES: "PRIVILEGES" >
+|   < PROCEDURE: "PROCEDURE" >
+|   < PUBLIC: "PUBLIC" >
+|   < QUALIFY: "QUALIFY" >
+|   < QUARTER: "QUARTER" >
+|   < QUARTERS: "QUARTERS" >
+|   < RANGE: "RANGE" >
+|   < RANK: "RANK" >
+|   < READ: "READ" >
+|   < READS: "READS" >
+|   < REAL: "REAL" >
+|   < RECURSIVE: "RECURSIVE" >
+|   < REF: "REF" >
+|   < REFERENCES: "REFERENCES" >
+|   < REFERENCING: "REFERENCING" >
+|   < REGR_AVGX: "REGR_AVGX" >
+|   < REGR_AVGY: "REGR_AVGY" >
+|   < REGR_COUNT: "REGR_COUNT" >
+|   < REGR_INTERCEPT: "REGR_INTERCEPT" >
+|   < REGR_R2: "REGR_R2" >
+|   < REGR_SLOPE: "REGR_SLOPE" >
+|   < REGR_SXX: "REGR_SXX" >
+|   < REGR_SXY: "REGR_SXY" >
+|   < REGR_SYY: "REGR_SYY" >
+|   < RELATIVE: "RELATIVE" >
+|   < RELEASE: "RELEASE" >
+|   < REPEATABLE: "REPEATABLE" >
+|   < REPLACE: "REPLACE" >
+|   < RESET: "RESET" >
+|   < RESPECT: "RESPECT" >
+|   < RESTART: "RESTART" >
+|   < RESTRICT: "RESTRICT" >
+|   < RESULT: "RESULT" >
+|   < RETURN: "RETURN" >
+|   < RETURNED_CARDINALITY: "RETURNED_CARDINALITY" >
+|   < RETURNED_LENGTH: "RETURNED_LENGTH" >
+|   < RETURNED_OCTET_LENGTH: "RETURNED_OCTET_LENGTH" >
+|   < RETURNED_SQLSTATE: "RETURNED_SQLSTATE" >
+|   < RETURNING: "RETURNING" >
+|   < RETURNS: "RETURNS" >
+|   < REVOKE: "REVOKE" >
+|   < RIGHT: "RIGHT" >
+|   < RLIKE: "RLIKE" >
+|   < ROLE: "ROLE" >
+|   < ROLLBACK: "ROLLBACK" >
+|   < ROLLUP: "ROLLUP" >
+|   < ROUTINE: "ROUTINE" >
+|   < ROUTINE_CATALOG: "ROUTINE_CATALOG" >
+|   < ROUTINE_NAME: "ROUTINE_NAME" >
+|   < ROUTINE_SCHEMA: "ROUTINE_SCHEMA" >
+|   < ROW: "ROW" >
+|   < ROW_COUNT: "ROW_COUNT" >
+|   < ROW_NUMBER: "ROW_NUMBER" >
+|   < ROWS: "ROWS" >
+|   < RUNNING: "RUNNING" >
+|   < SAFE_CAST: "SAFE_CAST" >
+|   < SAFE_OFFSET: "SAFE_OFFSET" >
+|   < SAFE_ORDINAL: "SAFE_ORDINAL" >
+|   < SATURDAY: "SATURDAY" >
+|   < SAVEPOINT: "SAVEPOINT" >
+|   < SCALAR: "SCALAR" >
+|   < SCALE: "SCALE" >
+|   < SCHEMA: "SCHEMA" >
+|   < SCHEMA_NAME: "SCHEMA_NAME" >
+|   < SCOPE: "SCOPE" >
+|   < SCOPE_CATALOGS: "SCOPE_CATALOGS" >
+|   < SCOPE_NAME: "SCOPE_NAME" >
+|   < SCOPE_SCHEMA: "SCOPE_SCHEMA" >
+|   < SCROLL: "SCROLL" >
+|   < SEARCH: "SEARCH" >
+|   < SECOND: "SECOND" >
+|   < SECONDS: "SECONDS" >
+|   < SECTION: "SECTION" >
+|   < SECURITY: "SECURITY" >
+|   < SEEK: "SEEK" >
+|   < SELECT: "SELECT" > { afterTableName(); }
+|   < SELF: "SELF" >
+|   < SENSITIVE: "SENSITIVE" >
+|   < SEPARATOR: "SEPARATOR" >
+|   < SEQUENCE: "SEQUENCE" >
+|   < SERIALIZABLE: "SERIALIZABLE" >
+|   < SERVER: "SERVER" >
+|   < SERVER_NAME: "SERVER_NAME" >
+|   < SESSION: "SESSION" >
+|   < SESSION_USER: "SESSION_USER" >
+|   < SET: "SET" > { afterTableName(); }
+|   < SETS: "SETS" >
+|   < SET_MINUS: "MINUS">
+|   < SHOW: "SHOW" >
+|   < SIMILAR: "SIMILAR" >
+|   < SIMPLE: "SIMPLE" >
+|   < SIZE: "SIZE" >
+|   < SKIP_: "SKIP" >
+|   < SMALLINT: "SMALLINT" >
+|   < SOME: "SOME" >
+|   < SOURCE: "SOURCE" >
+|   < SPACE: "SPACE" >
+|   < SPECIFIC: "SPECIFIC" >
+|   < SPECIFIC_NAME: "SPECIFIC_NAME" >
+|   < SPECIFICTYPE: "SPECIFICTYPE" >
+|   < SQL: "SQL" >
+|   < SQLEXCEPTION: "SQLEXCEPTION" >
+|   < SQLSTATE: "SQLSTATE" >
+|   < SQLWARNING: "SQLWARNING" >
+|   < SQL_BIGINT: "SQL_BIGINT" >
+|   < SQL_BINARY: "SQL_BINARY" >
+|   < SQL_BIT: "SQL_BIT" >
+|   < SQL_BLOB: "SQL_BLOB" >
+|   < SQL_BOOLEAN: "SQL_BOOLEAN" >
+|   < SQL_CHAR: "SQL_CHAR" >
+|   < SQL_CLOB: "SQL_CLOB" >
+|   < SQL_DATE: "SQL_DATE" >
+|   < SQL_DECIMAL: "SQL_DECIMAL" >
+|   < SQL_DOUBLE: "SQL_DOUBLE" >
+|   < SQL_FLOAT: "SQL_FLOAT" >
+|   < SQL_INTEGER: "SQL_INTEGER" >
+|   < SQL_INTERVAL_DAY: "SQL_INTERVAL_DAY" >
+|   < SQL_INTERVAL_DAY_TO_HOUR: "SQL_INTERVAL_DAY_TO_HOUR" >
+|   < SQL_INTERVAL_DAY_TO_MINUTE: "SQL_INTERVAL_DAY_TO_MINUTE" >
+|   < SQL_INTERVAL_DAY_TO_SECOND: "SQL_INTERVAL_DAY_TO_SECOND" >
+|   < SQL_INTERVAL_HOUR: "SQL_INTERVAL_HOUR" >
+|   < SQL_INTERVAL_HOUR_TO_MINUTE: "SQL_INTERVAL_HOUR_TO_MINUTE" >
+|   < SQL_INTERVAL_HOUR_TO_SECOND: "SQL_INTERVAL_HOUR_TO_SECOND" >
+|   < SQL_INTERVAL_MINUTE: "SQL_INTERVAL_MINUTE" >
+|   < SQL_INTERVAL_MINUTE_TO_SECOND: "SQL_INTERVAL_MINUTE_TO_SECOND" >
+|   < SQL_INTERVAL_MONTH: "SQL_INTERVAL_MONTH" >
+|   < SQL_INTERVAL_SECOND: "SQL_INTERVAL_SECOND" >
+|   < SQL_INTERVAL_YEAR: "SQL_INTERVAL_YEAR" >
+|   < SQL_INTERVAL_YEAR_TO_MONTH: "SQL_INTERVAL_YEAR_TO_MONTH" >
+|   < SQL_LONGVARBINARY: "SQL_LONGVARBINARY" >
+|   < SQL_LONGVARCHAR: "SQL_LONGVARCHAR" >
+|   < SQL_LONGVARNCHAR: "SQL_LONGVARNCHAR" >
+|   < SQL_NCHAR: "SQL_NCHAR" >
+|   < SQL_NCLOB: "SQL_NCLOB" >
+|   < SQL_NUMERIC: "SQL_NUMERIC" >
+|   < SQL_NVARCHAR: "SQL_NVARCHAR" >
+|   < SQL_REAL: "SQL_REAL" >
+|   < SQL_SMALLINT: "SQL_SMALLINT" >
+|   < SQL_TIME: "SQL_TIME" >
+|   < SQL_TIMESTAMP: "SQL_TIMESTAMP" >
+|   < SQL_TINYINT: "SQL_TINYINT" >
+|   < SQL_TSI_DAY: "SQL_TSI_DAY" >
+|   < SQL_TSI_FRAC_SECOND: "SQL_TSI_FRAC_SECOND" >
+|   < SQL_TSI_HOUR: "SQL_TSI_HOUR" >
+|   < SQL_TSI_MICROSECOND: "SQL_TSI_MICROSECOND" >
+|   < SQL_TSI_MINUTE: "SQL_TSI_MINUTE" >
+|   < SQL_TSI_MONTH: "SQL_TSI_MONTH" >
+|   < SQL_TSI_QUARTER: "SQL_TSI_QUARTER" >
+|   < SQL_TSI_SECOND: "SQL_TSI_SECOND" >
+|   < SQL_TSI_WEEK: "SQL_TSI_WEEK" >
+|   < SQL_TSI_YEAR: "SQL_TSI_YEAR" >
+|   < SQL_VARBINARY: "SQL_VARBINARY" >
+|   < SQL_VARCHAR: "SQL_VARCHAR" >
+|   < SQRT: "SQRT" >
+|   < START: "START" >
+|   < STATE: "STATE" >
+|   < STATEMENT: "STATEMENT" >
+|   < STATIC: "STATIC" >
+|   < STDDEV_POP: "STDDEV_POP" >
+|   < STDDEV_SAMP: "STDDEV_SAMP" >
+|   < STREAM: "STREAM" >
+|   < STRING_AGG: "STRING_AGG" >
+|   < STRUCTURE: "STRUCTURE" >
+|   < STYLE: "STYLE" >
+|   < SUBCLASS_ORIGIN: "SUBCLASS_ORIGIN" >
+|   < SUBMULTISET: "SUBMULTISET" >
+|   < SUBSET: "SUBSET" >
+|   < SUBSTITUTE: "SUBSTITUTE" >
+|   < SUBSTRING: "SUBSTRING" >
+|   < SUBSTRING_REGEX: "SUBSTRING_REGEX" >
+|   < SUCCEEDS: "SUCCEEDS" >
+|   < SUM: "SUM" >
+|   < SUNDAY: "SUNDAY" >
+|   < SYMMETRIC: "SYMMETRIC" >
+|   < SYSTEM: "SYSTEM" >
+|   < SYSTEM_TIME: "SYSTEM_TIME" >
+|   < SYSTEM_USER: "SYSTEM_USER" >
+|   < TABLE: "TABLE" > { beforeTableName(); }
+|   < TABLE_NAME: "TABLE_NAME" >
+|   < 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" >
+|   < TO: "TO" >
+|   < TOP_LEVEL_COUNT: "TOP_LEVEL_COUNT" >
+|   < TRAILING: "TRAILING" >
+|   < TRANSACTION: "TRANSACTION" >
+|   < TRANSACTIONS_ACTIVE: "TRANSACTIONS_ACTIVE" >
+|   < TRANSACTIONS_COMMITTED: "TRANSACTIONS_COMMITTED" >
+|   < TRANSACTIONS_ROLLED_BACK: "TRANSACTIONS_ROLLED_BACK" >
+|   < TRANSFORM: "TRANSFORM" >
+|   < TRANSFORMS: "TRANSFORMS" >
+|   < TRANSLATE: "TRANSLATE" >
+|   < TRANSLATE_REGEX: "TRANSLATE_REGEX" >
+|   < TRANSLATION: "TRANSLATION" >
+|   < TREAT: "TREAT" >
+|   < TRIGGER: "TRIGGER" >
+|   < TRIGGER_CATALOG: "TRIGGER_CATALOG" >
+|   < TRIGGER_NAME: "TRIGGER_NAME" >
+|   < TRIGGER_SCHEMA: "TRIGGER_SCHEMA" >
+|   < TRIM: "TRIM" >
+|   < TRIM_ARRAY: "TRIM_ARRAY" >
+|   < TRUE: "TRUE" >
+|   < TRUNCATE: "TRUNCATE" >
+|   < TRY_CAST: "TRY_CAST" >
+|   < TUESDAY: "TUESDAY" >
+|   < TUMBLE: "TUMBLE" >
+|   < TYPE: "TYPE" >
+|   < UESCAPE: "UESCAPE" >
+|   < UNBOUNDED: "UNBOUNDED" >
+|   < UNCOMMITTED: "UNCOMMITTED" >
+|   < UNCONDITIONAL: "UNCONDITIONAL" >
+|   < UNDER: "UNDER" >
+|   < UNION: "UNION" >
+|   < UNIQUE: "UNIQUE" >
+|   < UNKNOWN: "UNKNOWN" >
+|   < UNPIVOT: "UNPIVOT" >
+|   < UNNAMED: "UNNAMED" >
+|   < UNNEST: "UNNEST" >
+|   < UPDATE: "UPDATE" > { beforeTableName(); }
+|   < UPPER: "UPPER" >
+|   < UPSERT: "UPSERT" >
+|   < USAGE: "USAGE" >
+|   < USER: "USER" >
+|   < USER_DEFINED_TYPE_CATALOG: "USER_DEFINED_TYPE_CATALOG" >
+|   < USER_DEFINED_TYPE_CODE: "USER_DEFINED_TYPE_CODE" >
+|   < USER_DEFINED_TYPE_NAME: "USER_DEFINED_TYPE_NAME" >
+|   < USER_DEFINED_TYPE_SCHEMA: "USER_DEFINED_TYPE_SCHEMA" >
+|   < USING: "USING" >
+|   < UTF8: "UTF8" >
+|   < UTF16: "UTF16" >
+|   < UTF32: "UTF32" >
+|   < VALUE: "VALUE" >
+|   < VALUES: "VALUES" > { afterTableName(); }
+|   < VALUE_OF: "VALUE_OF" >
+|   < VAR_POP: "VAR_POP" >
+|   < VAR_SAMP: "VAR_SAMP" >
+|   < VARBINARY: "VARBINARY" >
+|   < VARCHAR: "VARCHAR" >
+|   < VARYING: "VARYING" >
+|   < VERSION: "VERSION" >
+|   < VERSIONING: "VERSIONING" >
+|   < VIEW: "VIEW" >
+|   < WEDNESDAY: "WEDNESDAY" >
+|   < WEEK: "WEEK" >
+|   < WEEKS: "WEEKS" >
+|   < WHEN: "WHEN" >
+|   < WHENEVER: "WHENEVER" >
+|   < WHERE: "WHERE" >
+|   < WIDTH_BUCKET: "WIDTH_BUCKET" >
+|   < WINDOW: "WINDOW" >
+|   < WITH: "WITH" >
+|   < WITHIN: "WITHIN" >
+|   < WITHOUT: "WITHOUT" >
+|   < WORK: "WORK" >
+|   < WRAPPER: "WRAPPER" >
+|   < WRITE: "WRITE" >
+|   < XML: "XML" >
+|   < YEAR: "YEAR" >
+|   < YEARS: "YEARS" >
+|   < ZONE: "ZONE" >
+<#-- additional parser keywords are included here -->
+<#list (parser.keywords!default.parser.keywords) as keyword>
+|   < ${keyword}: "${keyword}" >
+</#list>
+}
+
+/**
+ * Parses a non-reserved keyword for use as an identifier.
+ *
+ * <p>The method is broken up into several sub-methods; without this
+ * decomposition, parsers such as Babel with more than ~1,000 non-reserved
+ * keywords would generate such deeply nested 'if' statements that javac would
+ * fail with a {@link StackOverflowError}.
+ *
+ * <p>The list is generated from the FMPP config data. To add or remove
+ * keywords, modify config.fmpp. For parsers except Babel, make sure that
+ * keywords are not reserved by the SQL standard.
+ *
+ * @see Glossary#SQL2003 SQL:2003 Part 2 Section 5.2
+ */
+String NonReservedKeyWord() :
+{
+}
+{
+    (
+        NonReservedKeyWord0of3()
+    |   NonReservedKeyWord1of3()
+    |   NonReservedKeyWord2of3()
+    )
+    {
+        return unquotedIdentifier();
+    }
+}
+
+/** @see #NonReservedKeyWord */
+void NonReservedKeyWord0of3() :
+{
+}
+{
+    (
+<#list (parser.nonReservedKeywords!default.parser.nonReservedKeywords) + (parser.nonReservedKeywordsToAdd!default.parser.nonReservedKeywordsToAdd) as keyword>
+<#if keyword?index == 0>
+        <${keyword}>
+<#elseif keyword?index % 3 == 0>
+    |   <${keyword}>
+</#if>
+</#list>
+    )
+}
+
+/** @see #NonReservedKeyWord */
+void NonReservedKeyWord1of3() :
+{
+}
+{
+    (
+<#list (parser.nonReservedKeywords!default.parser.nonReservedKeywords) + (parser.nonReservedKeywordsToAdd!default.parser.nonReservedKeywordsToAdd) as keyword>
+<#if keyword?index == 1>
+        <${keyword}>
+<#elseif keyword?index % 3 == 1>
+    |   <${keyword}>
+</#if>
+</#list>
+    )
+}
+
+/** @see #NonReservedKeyWord */
+void NonReservedKeyWord2of3() :
+{
+}
+{
+    (
+<#list (parser.nonReservedKeywords!default.parser.nonReservedKeywords) + (parser.nonReservedKeywordsToAdd!default.parser.nonReservedKeywordsToAdd) as keyword>
+<#if keyword?index == 2>
+        <${keyword}>
+<#elseif keyword?index % 3 == 2>
+    |   <${keyword}>
+</#if>
+</#list>
+    )
+}
+
+/* LITERALS */
+
+<DEFAULT, DQID, BTID, BQID, BQHID> TOKEN :
+{
+    < UNSIGNED_INTEGER_LITERAL: (["0"-"9"])+ >
+|
+    < APPROX_NUMERIC_LITERAL:
+    (<UNSIGNED_INTEGER_LITERAL> | <DECIMAL_NUMERIC_LITERAL>) <EXPONENT> >
+|
+    < DECIMAL_NUMERIC_LITERAL:
+    (["0"-"9"])+(".")?(["0"-"9"])*
+    | "."(["0"-"9"])+
+    >
+|
+    < #EXPONENT: ["e","E"] (["+","-"])? (["0"-"9"])+ >
+|
+    < #HEXDIGIT: ["0"-"9","a"-"f","A"-"F"] >
+|
+    < #WHITESPACE:
+    [ " ","\t","\n","\r","\f" ]
+    >
+|
+    /* To improve error reporting, we allow all kinds of characters,
+     * not just hexits, in a binary string literal. */
+    < BINARY_STRING_LITERAL: ["x","X"] <QUOTE> ( (~["'"]) | ("''"))* <QUOTE> >
+}
+
+// All databases except BigQuery support standard single-quoted literals,
+// which use single-quote as the escape character.
+<DEFAULT, DQID, BTID> TOKEN :
+{
+    < QUOTED_STRING: <QUOTE> ( (~["'"]) | ("''"))* <QUOTE> >
+|
+    < 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",":",".","-","_"])*
+    >
+}
+
+// BigQuery supports single- and double-quoted literals with back-slash
+// as the escape character.
+<BQID, BQHID> TOKEN :
+{
+    // BigQuery-style double-quoted string, escaped using backslash
+    < BIG_QUERY_DOUBLE_QUOTED_STRING:
+      <DOUBLE_QUOTE> ( (~["\\", "\""]) | ("\\" ~[]) )* <DOUBLE_QUOTE>
+    >
+|
+    // BigQuery-style single-quoted string, escaped using backslash
+    < BIG_QUERY_QUOTED_STRING:
+      <QUOTE> ( (~["\\", "'"]) | ("\\" ~[]) )* <QUOTE>
+    >
+}
+
+<DEFAULT, DQID, BTID, BQID, BQHID> TOKEN :
+{
+    < UNICODE_QUOTED_ESCAPE_CHAR:
+    <QUOTE>
+    (~["0"-"9","a"-"f","A"-"F","+","\""," ","\t","\n","\r","\f"])
+    <QUOTE>
+    >
+}
+
+/* SEPARATORS */
+
+<DEFAULT, DQID, BTID, BQID, BQHID> TOKEN :
+{
+    < LPAREN: "(">
+|   < RPAREN: ")">
+<#if (parser.includeBraces!default.parser.includeBraces) >
+|   < LBRACE_D: "{" (" ")* ["d","D"] >
+|   < LBRACE_T: "{" (" ")* ["t","T"] >
+|   < LBRACE_TS: "{" (" ")* ["t","T"] ["s","S"] >
+|   < LBRACE_FN: "{" (" ")* ["f","F"] ["n","N"] >
+|   < LBRACE: "{" >
+|   < RBRACE: "}" >
+<#else>
+<#include "/@includes/braces.ftl" />
+</#if>
+|   < LBRACKET: "[" >
+|   < RBRACKET: "]" >
+|   < SEMICOLON: ";" >
+|   < DOT: "." >
+|   < COMMA: "," >
+}
+
+/* OPERATORS */
+
+<DEFAULT, DQID, BTID, BQID, BQHID> TOKEN :
+{
+    < EQ: "=" >
+|   < GT: ">" >
+|   < LT: "<" >
+|   < HOOK: "?" >
+|   < COLON: ":" >
+|   < LE: "<=" >
+|   < GE: ">=" >
+|   < NE: "<>" >
+|   < NE2: "!=" >
+|   < PLUS: "+" >
+|   < MINUS: "-" >
+|   < LAMBDA: "->" >
+|   < STAR: "*" >
+|   < SLASH: "/" >
+|   < PERCENT_REMAINDER: "%" >
+|   < CONCAT: "||" >
+|   < NAMED_ARGUMENT_ASSIGNMENT: "=>" >
+|   < DOUBLE_PERIOD: ".." >
+|   < QUOTE: "'" >
+|   < DOUBLE_QUOTE: "\"" >
+|   < VERTICAL_BAR: "|" >
+|   < CARET: "^" >
+|   < DOLLAR: "$" >
+<#list (parser.binaryOperatorsTokens!default.parser.binaryOperatorsTokens) as operator>
+|   ${operator}
+</#list>
+}
+
+
+/*****************************************
+ * Lexical Descriptions                  *
+ *****************************************/
+
+TOKEN_MGR_DECLS : {
+    final List<Integer> lexicalStateStack = new ArrayList<Integer>();
+
+    void pushState() {
+      lexicalStateStack.add(curLexState);
+    }
+
+    void popState() {
+      SwitchTo(lexicalStateStack.remove(lexicalStateStack.size() - 1));
+    }
+
+    void beforeTableName() {
+      if (curLexState == BQID) {
+        pushState();
+        SwitchTo(BQHID);
+      }
+    }
+
+    void afterTableName() {
+      if (curLexState == BQHID) {
+        popState();
+      }
+    }
+
+<#if (parser.includeAdditionalDeclarations!default.parser.includeAdditionalDeclarations)>
+  <#include "/@includes/tokenManagerDeclarations.ftl" />
+</#if>
+}
+
+/*
+Lexical states:
+
+DEFAULT: Identifiers are quoted in brackets, e.g. [My Identifier]
+DQID:    Identifiers are double-quoted, e.g. "My Identifier"
+BTID:    Identifiers are enclosed in back-ticks, escaped using back-ticks,
+         e.g. `My ``Quoted`` Identifier`
+BQID:    Identifiers are enclosed in back-ticks, escaped using backslash,
+         e.g. `My \`Quoted\` Identifier`,
+         and with the potential to shift into BQHID in contexts where table
+         names are expected, and thus allow hyphen-separated identifiers as
+         part of table names
+BQHID:   Identifiers are enclosed in back-ticks, escaped using backslash,
+         e.g. `My \`Quoted\` Identifier`
+         and unquoted identifiers may contain hyphens, e.g. foo-bar
+IN_SINGLE_LINE_COMMENT:
+IN_FORMAL_COMMENT:
+IN_MULTI_LINE_COMMENT:
+
+DEFAULT, DQID, BTID, BQID are the 4 'normal states'. Behavior is identical
+except for how quoted identifiers are recognized.
+
+The BQHID state exists only at the start of a table name (e.g. immediately after
+FROM or INSERT INTO). As soon as an identifier is seen, the state shifts back
+to BTID.
+
+After a comment has completed, the lexer returns to the previous state, one
+of the 'normal states'.
+*/
+
+/* WHITE SPACE */
+
+<DEFAULT, DQID, BTID, BQID, BQHID> SKIP :
+{
+    " "
+|   "\t"
+|   "\n"
+|   "\r"
+|   "\f"
+}
+
+/* COMMENTS */
+
+<DEFAULT, DQID, BTID, BQID, BQHID> TOKEN :
+{
+    < HINT_BEG: "/*+">
+|   < COMMENT_END: "*/" >
+}
+
+<DEFAULT, DQID, BTID, BQID, BQHID> MORE :
+{
+    <"/**" ~["/"]> { pushState(); } : IN_FORMAL_COMMENT
+}
+
+<DEFAULT, DQID, BTID, BQID, BQHID> MORE :
+{
+    "/*" { pushState(); } : IN_MULTI_LINE_COMMENT
+}
+
+<DEFAULT, DQID, BTID, BQID, BQHID> SKIP :
+{
+    <SINGLE_LINE_COMMENT: ("//"|"--")(~["\n","\r"])* ("\n"|"\r"|"\r\n")? >
+}
+
+<IN_FORMAL_COMMENT>
+SPECIAL_TOKEN :
+{
+    <FORMAL_COMMENT: <COMMENT_END> > { popState(); }
+}
+
+<IN_MULTI_LINE_COMMENT>
+SPECIAL_TOKEN :
+{
+    <MULTI_LINE_COMMENT: <COMMENT_END> > { popState(); }
+}
+
+<IN_FORMAL_COMMENT,IN_MULTI_LINE_COMMENT>
+MORE :
+{
+    < ~[] >
+}
+
+
+/* IDENTIFIERS */
+
+<DEFAULT> TOKEN :
+{
+    < BRACKET_QUOTED_IDENTIFIER:
+    "["
+    (
+        (~["]","\n","\r"])
+    |
+        ("]]")
+    )+
+    "]"
+    >
+}
+
+<DQID> TOKEN :
+{
+    < QUOTED_IDENTIFIER:
+    "\""
+    (
+        (~["\"","\n","\r"])
+    |
+        ("\"\"")
+    )+
+    "\""
+    >
+}
+
+<BTID> TOKEN :
+{
+    < BACK_QUOTED_IDENTIFIER:
+    "`"
+    (
+        (~["`","\n","\r"])
+    |
+        ("``")
+    )+
+    "`"
+    >
+}
+
+<BQID, BQHID> TOKEN :
+{
+    // BigQuery-style backtick-quoted identifier, escaped using backslash
+    < BIG_QUERY_BACK_QUOTED_IDENTIFIER:
+    "`"
+    (
+        (~["\\", "`"])
+    |
+        ("\\" ~[])
+    )*
+    "`"
+    >
+}
+
+<BQHID> TOKEN :
+{
+    // Per BigQuery: "Project IDs must contain 6-63 lowercase letters, digits,
+    // or dashes. IDs must start with a letter and may not end with a dash."
+    // We do not restrict length, or prevent identifiers from ending in a dash.
+    < HYPHENATED_IDENTIFIER: <LETTER> (<LETTER>|<DIGIT>|"-")* > { popState(); }
+}
+
+<DEFAULT, DQID, BTID, BQID> TOKEN :
+{
+    <#if parser.customIdentifierToken?has_content>
+        ${parser.customIdentifierToken}
+    <#else>
+        < IDENTIFIER: <LETTER> (<LETTER>|<DIGIT>)* >
+    </#if>
+}
+
+<DEFAULT, DQID, BTID, BQID, BQHID> TOKEN :
+{
+    < COLLATION_ID:
+    (<LETTER>|<DIGIT>)+ (<LETTER>|<DIGIT>|":"|"."|"-"|"_")*
+    "$"
+    (<LETTER>|"_")+
+    ("$" (<LETTER>|<DIGIT>|"_")+)?
+    >
+|
+    < UNICODE_QUOTED_IDENTIFIER: "U" "&" <QUOTED_IDENTIFIER> >
+|
+    < #LETTER:
+    [
+        "\u0024",
+        "\u0041"-"\u005a",
+        "\u005f",
+        "\u0061"-"\u007a",
+        "\u00c0"-"\u00d6",
+        "\u00d8"-"\u00f6",
+        "\u00f8"-"\u00ff",
+        "\u0100"-"\u1fff",
+        "\u3040"-"\u318f",
+        "\u3300"-"\u337f",
+        "\u3400"-"\u3d2d",
+        "\u4e00"-"\u9fff",
+        "\uf900"-"\ufaff"
+    ]
+    >
+|
+    < #DIGIT:
+    [
+        "\u0030"-"\u0039",
+        "\u0660"-"\u0669",
+        "\u06f0"-"\u06f9",
+        "\u0966"-"\u096f",
+        "\u09e6"-"\u09ef",
+        "\u0a66"-"\u0a6f",
+        "\u0ae6"-"\u0aef",
+        "\u0b66"-"\u0b6f",
+        "\u0be7"-"\u0bef",
+        "\u0c66"-"\u0c6f",
+        "\u0ce6"-"\u0cef",
+        "\u0d66"-"\u0d6f",
+        "\u0e50"-"\u0e59",
+        "\u0ed0"-"\u0ed9",
+        "\u1040"-"\u1049"
+    ]
+    >
+}
+
+/* Special token to throw a wrench in the works. It is never valid in SQL,
+   and so when it occurs, it causes the parser to print which tokens would
+   have been valid at that point. Used by SqlAdvisor. */
+<DEFAULT, DQID, BTID, BQID, BQHID> TOKEN :
+{
+    < BEL:
+    [
+        "\u0007"
+    ]
+    >
+}
+
+/**
+ * Defines a production which can never be accepted by the parser.
+ * In effect, it tells the parser, "If you got here, you've gone too far."
+ * It is used as the default production for parser extension points;
+ * derived parsers replace it with a real production when they want to
+ * implement a particular extension point.
+ */
+void UnusedExtension() :
+{
+}
+{
+    (
+        LOOKAHEAD({false}) <ZONE>
+    )
+}
diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/expression/AliasedOperatorConversion.java b/sql/src/main/java/org/apache/druid/sql/calcite/expression/AliasedOperatorConversion.java
index 9e42ba411c0f..a93853bcf99b 100644
--- a/sql/src/main/java/org/apache/druid/sql/calcite/expression/AliasedOperatorConversion.java
+++ b/sql/src/main/java/org/apache/druid/sql/calcite/expression/AliasedOperatorConversion.java
@@ -21,9 +21,7 @@
 
 import org.apache.calcite.rex.RexNode;
 import org.apache.calcite.sql.SqlFunction;
-import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.SqlOperator;
-import org.apache.druid.java.util.common.IAE;
 import org.apache.druid.query.aggregation.PostAggregator;
 import org.apache.druid.query.filter.DimFilter;
 import org.apache.druid.segment.column.RowSignature;
@@ -39,10 +37,6 @@ public class AliasedOperatorConversion implements SqlOperatorConversion
 
   public AliasedOperatorConversion(final SqlOperatorConversion baseConversion, final String name)
   {
-    if (!SqlKind.FUNCTION.contains(baseConversion.calciteOperator().getKind())) {
-      throw new IAE("Base operator must be a function but was[%s]", baseConversion.calciteOperator().getKind());
-    }
-
     final SqlFunction baseFunction = (SqlFunction) baseConversion.calciteOperator();
 
     this.baseConversion = baseConversion;
diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/parser/DruidSqlParserUtils.java b/sql/src/main/java/org/apache/druid/sql/calcite/parser/DruidSqlParserUtils.java
index d81907ef1443..38909ec91877 100644
--- a/sql/src/main/java/org/apache/druid/sql/calcite/parser/DruidSqlParserUtils.java
+++ b/sql/src/main/java/org/apache/druid/sql/calcite/parser/DruidSqlParserUtils.java
@@ -38,7 +38,6 @@
 import org.apache.calcite.sql.dialect.CalciteSqlDialect;
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
 import org.apache.calcite.sql.type.SqlTypeName;
-import org.apache.calcite.util.Pair;
 import org.apache.druid.error.DruidException;
 import org.apache.druid.error.InvalidSqlInput;
 import org.apache.druid.java.util.common.granularity.Granularity;
@@ -68,6 +67,7 @@
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Map.Entry;
 import java.util.stream.Collectors;
 
 public class DruidSqlParserUtils
@@ -414,7 +414,7 @@ public static SqlOrderBy convertClusterByToOrderBy(SqlNode query, SqlNodeList cl
   @Nullable
   public static List<String> resolveClusteredByColumnsToOutputColumns(
       final SqlNodeList clusteredByNodes,
-      final ImmutableList<Pair<Integer, String>> sourceFieldMappings
+      final List<Entry<Integer, String>> sourceFieldMappings
   )
   {
     // CLUSTERED BY is an optional clause
@@ -429,7 +429,7 @@ public static List<String> resolveClusteredByColumnsToOutputColumns(
       if (clusteredByNode instanceof SqlNumericLiteral) {
         // The node is a literal number -- an ordinal in the CLUSTERED BY clause. Lookup the ordinal in field mappings.
         final int ordinal = ((SqlNumericLiteral) clusteredByNode).getValueAs(Integer.class);
-        retClusteredByNames.add(sourceFieldMappings.get(ordinal - 1).right);
+        retClusteredByNames.add(sourceFieldMappings.get(ordinal - 1).getValue());
       } else if (clusteredByNode instanceof SqlBasicCall) {
         // The node is an expression/operator.
         retClusteredByNames.add(getColumnNameFromSqlCall((SqlBasicCall) clusteredByNode));
diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/planner/QueryUtils.java b/sql/src/main/java/org/apache/druid/sql/calcite/planner/QueryUtils.java
index 33ea126e74d5..e0a5cce94187 100644
--- a/sql/src/main/java/org/apache/druid/sql/calcite/planner/QueryUtils.java
+++ b/sql/src/main/java/org/apache/druid/sql/calcite/planner/QueryUtils.java
@@ -19,11 +19,11 @@
 
 package org.apache.druid.sql.calcite.planner;
 
-import org.apache.calcite.util.Pair;
 import org.apache.druid.sql.calcite.rel.DruidQuery;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map.Entry;
 
 /**
  * Utility class for queries
@@ -42,12 +42,12 @@ private QueryUtils()
    * @return Mappings for queryColumn to outputColumn
    */
   public static List<ColumnMapping> buildColumnMappings(
-      final List<Pair<Integer, String>> fieldMapping,
+      final List<Entry<Integer, String>> fieldMapping,
       final DruidQuery druidQuery
   )
   {
     final List<ColumnMapping> columnMappings = new ArrayList<>();
-    for (final Pair<Integer, String> entry : fieldMapping) {
+    for (final Entry<Integer, String> entry : fieldMapping) {
       final String queryColumn = druidQuery.getOutputRowSignature().getColumnName(entry.getKey());
       final String outputColumn = entry.getValue();
       columnMappings.add(new ColumnMapping(queryColumn, outputColumn));
diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/rel/logical/DruidWindow.java b/sql/src/main/java/org/apache/druid/sql/calcite/rel/logical/DruidWindow.java
index 0e47970d9571..c0fbf5b5df85 100644
--- a/sql/src/main/java/org/apache/druid/sql/calcite/rel/logical/DruidWindow.java
+++ b/sql/src/main/java/org/apache/druid/sql/calcite/rel/logical/DruidWindow.java
@@ -55,4 +55,10 @@ public RelOptCost computeSelfCost(RelOptPlanner planner, RelMetadataQuery mq)
   {
     return planner.getCostFactory().makeCost(mq.getRowCount(this), 0, 0);
   }
+
+  @Override
+  public Window copy(List<RexLiteral> constants)
+  {
+    return new DruidWindow(getCluster(), traitSet, hints, input, constants, rowType, groups);
+  }
 }
diff --git a/sql/src/main/java/org/apache/druid/sql/calcite/run/NativeQueryMaker.java b/sql/src/main/java/org/apache/druid/sql/calcite/run/NativeQueryMaker.java
index 62d235e5dcd0..2035bca53878 100644
--- a/sql/src/main/java/org/apache/druid/sql/calcite/run/NativeQueryMaker.java
+++ b/sql/src/main/java/org/apache/druid/sql/calcite/run/NativeQueryMaker.java
@@ -26,7 +26,6 @@
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeField;
 import org.apache.calcite.runtime.Hook;
-import org.apache.calcite.util.Pair;
 import org.apache.druid.java.util.common.ISE;
 import org.apache.druid.java.util.common.Intervals;
 import org.apache.druid.java.util.common.StringUtils;
@@ -56,6 +55,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map.Entry;
 import java.util.UUID;
 import java.util.stream.Collectors;
 
@@ -64,13 +64,13 @@ public class NativeQueryMaker implements QueryMaker
   private final QueryLifecycleFactory queryLifecycleFactory;
   private final PlannerContext plannerContext;
   private final ObjectMapper jsonMapper;
-  private final List<Pair<Integer, String>> fieldMapping;
+  private final List<Entry<Integer, String>> fieldMapping;
 
   public NativeQueryMaker(
       final QueryLifecycleFactory queryLifecycleFactory,
       final PlannerContext plannerContext,
       final ObjectMapper jsonMapper,
-      final List<Pair<Integer, String>> fieldMapping
+      final List<Entry<Integer, String>> fieldMapping
   )
   {
     this.queryLifecycleFactory = queryLifecycleFactory;
@@ -257,11 +257,11 @@ private <T> QueryResponse<Object[]> mapResultSequence(
     );
   }
 
-  private static <T> List<T> mapColumnList(final List<T> in, final List<Pair<Integer, String>> fieldMapping)
+  private static <T> List<T> mapColumnList(final List<T> in, final List<Entry<Integer, String>> fieldMapping)
   {
     final List<T> out = new ArrayList<>(fieldMapping.size());
 
-    for (final Pair<Integer, String> entry : fieldMapping) {
+    for (final Entry<Integer, String> entry : fieldMapping) {
       out.add(in.get(entry.getKey()));
     }
 
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteNestedDataQueryTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteNestedDataQueryTest.java
index 08c25a43d4ff..95a4d0c1c327 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteNestedDataQueryTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteNestedDataQueryTest.java
@@ -1648,8 +1648,8 @@ public void testGroupByRootSingleTypeArrayLongNullsFilteredArrayEquality()
                             .setGranularity(Granularities.ALL)
                             .setDimFilter(
                                 or(
-                                    isNull("arrayLongNulls"),
-                                    equality("arrayLongNulls", new Object[]{null, 2L, 9L}, ColumnType.LONG_ARRAY)
+                                    equality("arrayLongNulls", new Object[]{null, 2L, 9L}, ColumnType.LONG_ARRAY),
+                                    isNull("arrayLongNulls")
                                 )
                             )
                             .setDimensions(
@@ -1689,27 +1689,25 @@ public void testGroupByRootSingleTypeArrayLongNullsUnnest()
             + "FROM druid.arrays, UNNEST(arrayLongNulls) as u (longs) GROUP BY 1"
         )
         .queryContext(QUERY_CONTEXT_NO_STRINGIFY_ARRAY)
-        .expectedQueries(
-            ImmutableList.of(
-                GroupByQuery.builder()
-                            .setDataSource(
-                                UnnestDataSource.create(
-                                    TableDataSource.create(DATA_SOURCE_ARRAYS),
-                                    expressionVirtualColumn("j0.unnest", "\"arrayLongNulls\"", ColumnType.LONG_ARRAY),
-                                    null
-                                )
-                            )
-                            .setInterval(querySegmentSpec(Filtration.eternity()))
-                            .setGranularity(Granularities.ALL)
-                            .setDimensions(
-                                dimensions(
-                                    new DefaultDimensionSpec("j0.unnest", "d0", ColumnType.LONG)
-                                )
-                            )
-                            .setAggregatorSpecs(aggregators(new LongSumAggregatorFactory("a0", "cnt")))
-                            .setContext(QUERY_CONTEXT_NO_STRINGIFY_ARRAY)
-                            .build()
-            )
+        .expectedQuery(
+            GroupByQuery.builder()
+                .setDataSource(
+                    UnnestDataSource.create(
+                        TableDataSource.create(DATA_SOURCE_ARRAYS),
+                        expressionVirtualColumn("j0.unnest", "\"arrayLongNulls\"", ColumnType.LONG_ARRAY),
+                        null
+                    )
+                )
+                .setInterval(querySegmentSpec(Filtration.eternity()))
+                .setGranularity(Granularities.ALL)
+                .setDimensions(
+                    dimensions(
+                        new DefaultDimensionSpec("j0.unnest", "d0", ColumnType.LONG)
+                    )
+                )
+                .setAggregatorSpecs(aggregators(new LongSumAggregatorFactory("a0", "cnt")))
+                .setContext(QUERY_CONTEXT_NO_STRINGIFY_ARRAY)
+                .build()
         )
         .expectedResults(
             ImmutableList.of(
@@ -6681,39 +6679,52 @@ public void testFilterJsonIsNull()
   @Test
   public void testCoalesceOnNestedColumns()
   {
-    // jo.unnest is first entry in coalesce
-    // so Calcite removes the coalesce to be used here
-    testQuery(
-        "select coalesce(c,long) as col "
-        + " from druid.all_auto, unnest(json_value(arrayNestedLong, '$[1]' returning bigint array)) as u(c) ",
-        ImmutableList.of(
-            Druids.newScanQueryBuilder()
-                  .dataSource(UnnestDataSource.create(
-                      new TableDataSource(DATA_SOURCE_ALL),
-                      new NestedFieldVirtualColumn("arrayNestedLong", "$[1]", "j0.unnest", ColumnType.LONG_ARRAY),
-                      null
-                  ))
-                  .intervals(querySegmentSpec(Filtration.eternity()))
-                  .columns("j0.unnest")
-                  .resultFormat(ScanQuery.ResultFormat.RESULT_FORMAT_COMPACTED_LIST)
-                  .legacy(false)
-                  .context(QUERY_CONTEXT_DEFAULT)
-                  .build()
-        ),
-        ImmutableList.of(
-            new Object[]{null},
-            new Object[]{3L},
-            new Object[]{4L},
-            new Object[]{3L},
-            new Object[]{4L},
-            new Object[]{1L},
-            new Object[]{2L},
-            new Object[]{null}
-        ),
-        RowSignature.builder()
-                    .add("col", ColumnType.LONG)
+    testBuilder()
+        .sql(
+            "select c,long,coalesce(c,long) as col "
+                + " from druid.all_auto, unnest(json_value(arrayNestedLong, '$[1]' returning bigint array)) as u(c) "
+        )
+        .expectedQueries(
+            ImmutableList.of(
+                Druids.newScanQueryBuilder()
+                    .dataSource(
+                        UnnestDataSource.create(
+                            new TableDataSource(DATA_SOURCE_ALL),
+                            new NestedFieldVirtualColumn("arrayNestedLong", "$[1]", "j0.unnest", ColumnType.LONG_ARRAY),
+                            null
+                        )
+                    )
+                    .virtualColumns(expressionVirtualColumn("v0", "nvl(\"j0.unnest\",\"long\")", ColumnType.LONG))
+                    .intervals(querySegmentSpec(Filtration.eternity()))
+                    .columns("j0.unnest", "long", "v0")
+                    .resultFormat(ScanQuery.ResultFormat.RESULT_FORMAT_COMPACTED_LIST)
+                    .legacy(false)
+                    .context(QUERY_CONTEXT_DEFAULT)
                     .build()
-    );
+            )
+        )
+        .expectedResults(
+            ImmutableList.of(
+                // with NullHandling.replaceWithDefault; isNull is not handled
+                // so COALESCE may never see `null`
+                new Object[]{null, 2L, NullHandling.sqlCompatible() ? 2L : 0L},
+                new Object[]{3L, 1L, 3L},
+                new Object[]{4L, 1L, 4L},
+                new Object[]{3L, 4L, 3L},
+                new Object[]{4L, 4L, 4L},
+                new Object[]{1L, 5L, 1L},
+                new Object[]{2L, 5L, 2L},
+                new Object[]{null, 5L, NullHandling.sqlCompatible() ? 5L : 0L}
+            )
+        )
+        .expectedSignature(
+            RowSignature.builder()
+                .add("c", ColumnType.LONG)
+                .add("long", ColumnType.LONG)
+                .add("col", ColumnType.LONG)
+                .build()
+        )
+        .run();
   }
 
   @Test
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteQueryTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteQueryTest.java
index 0b6dd10e3c9e..7e4675efc74e 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteQueryTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteQueryTest.java
@@ -2613,23 +2613,31 @@ public void testExactCountDistinctWithFilter()
   {
     msqIncompatible();
     final String sqlQuery = "SELECT COUNT(DISTINCT foo.dim1) FILTER(WHERE foo.cnt = 1), SUM(foo.cnt) FROM druid.foo";
-    // When useApproximateCountDistinct=false and useGroupingSetForExactDistinct=false, planning fails due
-    // to a bug in the Calcite's rule (AggregateExpandDistinctAggregatesRule)
-    assertThrows(
-        RuntimeException.class,
-        () -> testQuery(
+
+    testBuilder()
+        .plannerConfig(
             PLANNER_CONFIG_NO_HLL.withOverrides(
                 ImmutableMap.of(
                     PlannerConfig.CTX_KEY_USE_GROUPING_SET_FOR_EXACT_DISTINCT, "false",
                     PlannerConfig.CTX_KEY_USE_APPROXIMATE_COUNT_DISTINCT, false
                 )
-            ), // Enable exact count distinct
-            sqlQuery,
-            CalciteTests.REGULAR_USER_AUTH_RESULT,
-            ImmutableList.of(),
-            ImmutableList.of()
+            )
         )
-    );
+        .sql(sqlQuery)
+        .authResult(CalciteTests.REGULAR_USER_AUTH_RESULT)
+        .expectedResults(
+            ImmutableList.of(
+                new Object[] {NullHandling.replaceWithDefault() ? 5L : 6L, 6L}
+            )
+        )
+        .run();
+  }
+
+  @SqlTestFrameworkConfig.NumMergeBuffers(3)
+  @Test
+  public void testExactCountDistinctWithFilter2()
+  {
+    final String sqlQuery = "SELECT COUNT(DISTINCT foo.dim1) FILTER(WHERE foo.cnt = 1), SUM(foo.cnt) FROM druid.foo";
 
     testQuery(
         PLANNER_CONFIG_NO_HLL.withOverrides(
@@ -5028,7 +5036,19 @@ public void testFilteredAggregations()
               .granularity(Granularities.ALL)
               .context(QUERY_CONTEXT_DEFAULT);
     if (NullHandling.sqlCompatible()) {
-      builder = builder.virtualColumns(expressionVirtualColumn("v0", "substring(\"dim1\", 0, 1)", ColumnType.STRING))
+      builder = builder.virtualColumns(
+                          expressionVirtualColumn("v0", "substring(\"dim1\", 0, 1)", ColumnType.STRING),
+                          expressionVirtualColumn(
+                              "v1",
+                              "case_searched((\"dim1\" != '1'),1,0)",
+                              ColumnType.LONG
+                          ),
+                          expressionVirtualColumn(
+                              "v2",
+                              "case_searched((\"dim1\" != '1'),\"cnt\",0)",
+                              ColumnType.LONG
+                          )
+                        )
                        .aggregators(
                            aggregators(
                                new FilteredAggregatorFactory(
@@ -5054,10 +5074,7 @@ public void testFilteredAggregations()
                                    new CountAggregatorFactory("a4"),
                                    not(equality("dim1", "1", ColumnType.STRING))
                                ),
-                               new FilteredAggregatorFactory(
-                                   new CountAggregatorFactory("a5"),
-                                   not(equality("dim1", "1", ColumnType.STRING))
-                               ),
+                               new LongSumAggregatorFactory("a5", "v1"),
                                new FilteredAggregatorFactory(
                                    new LongSumAggregatorFactory("a6", "cnt"),
                                    equality("dim2", "a", ColumnType.STRING)
@@ -5069,10 +5086,7 @@ public void testFilteredAggregations()
                                        not(equality("dim1", "1", ColumnType.STRING))
                                    )
                                ),
-                               new FilteredAggregatorFactory(
-                                   new LongSumAggregatorFactory("a8", "cnt"),
-                                   not(equality("dim1", "1", ColumnType.STRING))
-                               ),
+                               new LongSumAggregatorFactory("a8", "v2"),
                                new FilteredAggregatorFactory(
                                    new LongMaxAggregatorFactory("a9", "cnt"),
                                    not(equality("dim1", "1", ColumnType.STRING))
@@ -5097,8 +5111,19 @@ public void testFilteredAggregations()
                            )
                        );
     } else {
-      builder = builder.aggregators(
-          aggregators(
+      builder = builder.virtualColumns(
+              expressionVirtualColumn(
+              "v0",
+              "case_searched((\"dim1\" != '1'),1,0)",
+              ColumnType.LONG
+          ),
+          expressionVirtualColumn(
+              "v1",
+              "case_searched((\"dim1\" != '1'),\"cnt\",0)",
+              ColumnType.LONG
+          ))
+          .aggregators(
+              aggregators(
               new FilteredAggregatorFactory(
                   new LongSumAggregatorFactory("a0", "cnt"),
                   equality("dim1", "abc", ColumnType.STRING)
@@ -5110,7 +5135,6 @@ public void testFilteredAggregations()
               new FilteredAggregatorFactory(
                   new LongSumAggregatorFactory("a2", "cnt"),
                   selector("dim1", "a", new SubstringDimExtractionFn(0, 1))
-
               ),
               new FilteredAggregatorFactory(
                   new CountAggregatorFactory("a3"),
@@ -5123,10 +5147,7 @@ public void testFilteredAggregations()
                   new CountAggregatorFactory("a4"),
                   not(equality("dim1", "1", ColumnType.STRING))
               ),
-              new FilteredAggregatorFactory(
-                  new CountAggregatorFactory("a5"),
-                  not(equality("dim1", "1", ColumnType.STRING))
-              ),
+              new LongSumAggregatorFactory("a5", "v0"),
               new FilteredAggregatorFactory(
                   new LongSumAggregatorFactory("a6", "cnt"),
                   equality("dim2", "a", ColumnType.STRING)
@@ -5138,10 +5159,7 @@ public void testFilteredAggregations()
                       not(equality("dim1", "1", ColumnType.STRING))
                   )
               ),
-              new FilteredAggregatorFactory(
-                  new LongSumAggregatorFactory("a8", "cnt"),
-                  not(equality("dim1", "1", ColumnType.STRING))
-              ),
+              new LongSumAggregatorFactory("a8", "v1"),
               new FilteredAggregatorFactory(
                   new LongMaxAggregatorFactory("a9", "cnt"),
                   not(equality("dim1", "1", ColumnType.STRING))
@@ -5207,11 +5225,15 @@ public void testCaseFilteredAggregationWithGroupBy()
                         .setInterval(querySegmentSpec(Filtration.eternity()))
                         .setGranularity(Granularities.ALL)
                         .setDimensions(dimensions(new DefaultDimensionSpec("cnt", "d0", ColumnType.LONG)))
+                        .setVirtualColumns(
+                            expressionVirtualColumn(
+                                "v0",
+                                "case_searched((\"dim1\" != '1'),1,0)",
+                                ColumnType.LONG
+                            )
+                        )
                         .setAggregatorSpecs(aggregators(
-                            new FilteredAggregatorFactory(
-                                new CountAggregatorFactory("a0"),
-                                not(equality("dim1", "1", ColumnType.STRING))
-                            ),
+                            new LongSumAggregatorFactory("a0", "v0"),
                             new LongSumAggregatorFactory("a1", "cnt")
                         ))
                         .setPostAggregatorSpecs(
@@ -9247,27 +9269,22 @@ public void testQueryWithSelectProjectAndIdentityProjectDoesNotRename()
                                                     "v0",
                                                     "((\"__time\" >= 947005200000) && (\"__time\" < 1641402000000))",
                                                     ColumnType.LONG
+                                                ),
+                                                expressionVirtualColumn(
+                                                    "v1",
+                                                    "case_searched(((\"__time\" >= 947005200000) && (\"__time\" < 1641402000000)),1,0)",
+                                                    ColumnType.LONG
                                                 )
                                             )
                                             .setDimensions(
                                                 dimensions(
-                                                    new DefaultDimensionSpec("v0", "d0", ColumnType.LONG),
-                                                    new DefaultDimensionSpec("dim1", "d1", ColumnType.STRING)
+                                                    new DefaultDimensionSpec("dim1", "d0", ColumnType.STRING),
+                                                    new DefaultDimensionSpec("v0", "d1", ColumnType.LONG)
                                                 )
                                             )
                                             .setAggregatorSpecs(
                                                 aggregators(
-                                                    new FilteredAggregatorFactory(
-                                                        new CountAggregatorFactory("a0"),
-                                                        range(
-                                                            "__time",
-                                                            ColumnType.LONG,
-                                                            timestamp("2000-01-04T17:00:00"),
-                                                            timestamp("2022-01-05T17:00:00"),
-                                                            false,
-                                                            true
-                                                        )
-                                                    ),
+                                                    new LongSumAggregatorFactory("a0", "v1"),
                                                     new GroupingAggregatorFactory(
                                                         "a1",
                                                         ImmutableList.of("dim1", "v0")
@@ -9295,9 +9312,9 @@ public void testQueryWithSelectProjectAndIdentityProjectDoesNotRename()
                                 new FilteredAggregatorFactory(
                                     new CountAggregatorFactory("_a1"),
                                     and(
-                                        notNull("d1"),
+                                        notNull("d0"),
                                         equality("a1", 0L, ColumnType.LONG),
-                                        expressionFilter("\"d0\"")
+                                        expressionFilter("\"d1\"")
                                     )
                                 )
                             )
@@ -14906,7 +14923,6 @@ public void testGreatestFunctionForStringWithIsNull()
     );
   }
 
-  @DecoupledTestConfig(quidemReason = QuidemTestCaseReason.AGGREGATE_REMOVE_NOT_FIRED, separateDefaultModeTest = true)
   @Test
   public void testSubqueryTypeMismatchWithLiterals()
   {
@@ -14953,6 +14969,7 @@ public void testSubqueryTypeMismatchWithLiterals()
     );
   }
 
+  @NotYetSupported(Modes.SORT_REMOVE_CONSTANT_KEYS_CONFLICT)
   @Test
   public void testTimeseriesQueryWithEmptyInlineDatasourceAndGranularity()
   {
@@ -14979,7 +14996,6 @@ public void testTimeseriesQueryWithEmptyInlineDatasourceAndGranularity()
                         .setDataSource(InlineDataSource.fromIterable(
                             ImmutableList.of(
                                 new Object[]{timestamp("2000-01-01"), 1.0},
-
                                 // Floor to month is applied while creating inline source, so this is
                                 // 2000-01-01, not 2000-01-02.
                                 new Object[]{timestamp("2000-01-01"), 2.0}
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteSelectQueryTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteSelectQueryTest.java
index 9f81962d1a0a..3203ae9915e5 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteSelectQueryTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteSelectQueryTest.java
@@ -710,20 +710,11 @@ public void testSelectDistinctWithStrlenFilter()
                 .setInterval(querySegmentSpec(Filtration.eternity()))
                 .setGranularity(Granularities.ALL)
                 .setVirtualColumns(
-                    expressionVirtualColumn("v0", "strlen(\"dim1\")", ColumnType.LONG),
-                    // The two layers of CASTs here are unusual, they should really be collapsed into one
-                    expressionVirtualColumn(
-                        "v1",
-                        "CAST(CAST(strlen(\"dim1\"), 'STRING'), 'LONG')",
-                        ColumnType.LONG
-                    )
+                    expressionVirtualColumn("v0", "strlen(\"dim1\")", ColumnType.LONG)
                 )
                 .setDimensions(dimensions(new DefaultDimensionSpec("dim1", "d0")))
                 .setDimFilter(
-                    or(
-                        equality("v0", 3L, ColumnType.LONG),
-                        equality("v1", 3L, ColumnType.LONG)
-                    )
+                    equality("v0", 3L, ColumnType.LONG)
                 )
                 .setContext(QUERY_CONTEXT_DEFAULT)
                 .build()
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteSubqueryTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteSubqueryTest.java
index 3ad1217f84d3..808ab5c36630 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/CalciteSubqueryTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/CalciteSubqueryTest.java
@@ -49,7 +49,6 @@
 import org.apache.druid.query.extraction.SubstringDimExtractionFn;
 import org.apache.druid.query.groupby.GroupByQuery;
 import org.apache.druid.query.groupby.orderby.DefaultLimitSpec;
-import org.apache.druid.query.groupby.orderby.NoopLimitSpec;
 import org.apache.druid.query.groupby.orderby.OrderByColumnSpec;
 import org.apache.druid.query.ordering.StringComparators;
 import org.apache.druid.query.scan.ScanQuery;
@@ -1075,57 +1074,43 @@ public void testJoinWithSubqueries(String testName, Map<String, Object> queryCon
   public void testSingleValueFloatAgg(String testName, Map<String, Object> queryContext)
   {
     cannotVectorize();
-    testQuery(
-        "SELECT count(*) FROM foo where m1 <= (select min(m1) + 4 from foo)",
-        ImmutableList.of(
+    testBuilder()
+        .sql("SELECT count(*) FROM foo where m1 <= (select min(m1) + 4 from foo)")
+        .expectedQuery(
             Druids.newTimeseriesQueryBuilder()
-                  .dataSource(join(
-                      new TableDataSource(CalciteTests.DATASOURCE1),
-                      new QueryDataSource(GroupByQuery.builder()
-                                                      .setDataSource(new QueryDataSource(
-                                                          Druids.newTimeseriesQueryBuilder()
-                                                                .dataSource(CalciteTests.DATASOURCE1)
-                                                                .intervals(querySegmentSpec(Filtration.eternity()))
-                                                                .granularity(Granularities.ALL)
-                                                                .aggregators(new FloatMinAggregatorFactory("a0", "m1"))
-                                                                .build()
-                                                      ))
-                                                      .setInterval(querySegmentSpec(Filtration.eternity()))
-                                                      .setGranularity(Granularities.ALL)
-                                                      .setVirtualColumns(expressionVirtualColumn(
-                                                                             "v0",
-                                                                             "(\"a0\" + 4)",
-                                                                             ColumnType.FLOAT
-                                                                         )
-                                                      )
-                                                      .setAggregatorSpecs(
-                                                          aggregators(
-                                                              new SingleValueAggregatorFactory(
-                                                                  "_a0",
-                                                                  "v0",
-                                                                  ColumnType.FLOAT
-                                                              )
-                                                          )
-                                                      )
-                                                      .setLimitSpec(NoopLimitSpec.instance())
-                                                      .setContext(QUERY_CONTEXT_DEFAULT)
-                                                      .build()
-                      ),
-                      "j0.",
-                      "1",
-                      NullHandling.replaceWithDefault() ? JoinType.LEFT : JoinType.INNER
-                  ))
-                  .intervals(querySegmentSpec(Filtration.eternity()))
-                  .granularity(Granularities.ALL)
-                  .aggregators(aggregators(new CountAggregatorFactory("a0")))
-                  .filters(expressionFilter("(\"m1\" <= \"j0._a0\")"))
-                  .context(QUERY_CONTEXT_DEFAULT)
-                  .build()
-        ),
-        ImmutableList.of(
-            new Object[]{5L}
+                .dataSource(
+                    join(
+                        new TableDataSource(CalciteTests.DATASOURCE1),
+                        new QueryDataSource(
+                            Druids.newTimeseriesQueryBuilder()
+                                .dataSource(CalciteTests.DATASOURCE1)
+                                .intervals(querySegmentSpec(Filtration.eternity()))
+                                .granularity(Granularities.ALL)
+                                .aggregators(new FloatMinAggregatorFactory("a0", "m1"))
+                                .postAggregators(
+                                    expressionPostAgg("p0", "(\"a0\" + 4)", ColumnType.FLOAT)
+                                )
+
+                                .build()
+                        ),
+                        "j0.",
+                        "1",
+                        NullHandling.replaceWithDefault() ? JoinType.LEFT : JoinType.INNER
+                    )
+                )
+                .intervals(querySegmentSpec(Filtration.eternity()))
+                .granularity(Granularities.ALL)
+                .aggregators(aggregators(new CountAggregatorFactory("a0")))
+                .filters(expressionFilter("(\"m1\" <= \"j0.p0\")"))
+                .context(QUERY_CONTEXT_DEFAULT)
+                .build()
         )
-    );
+        .expectedResults(
+            ImmutableList.of(
+                new Object[] {5L}
+            )
+        )
+        .run();
   }
 
   @MethodSource("constructorFeeder")
@@ -1133,57 +1118,46 @@ public void testSingleValueFloatAgg(String testName, Map<String, Object> queryCo
   public void testSingleValueDoubleAgg(String testName, Map<String, Object> queryContext)
   {
     cannotVectorize();
-    testQuery(
-        "SELECT count(*) FROM foo where m1 >= (select max(m1) - 3.5 from foo)",
-        ImmutableList.of(
+    testBuilder()
+        .sql("SELECT count(*) FROM foo where m1 >= (select max(m1) - 3.5 from foo)")
+        .expectedQuery(
             Druids.newTimeseriesQueryBuilder()
-                  .dataSource(join(
-                      new TableDataSource(CalciteTests.DATASOURCE1),
-                      new QueryDataSource(GroupByQuery.builder()
-                                                      .setDataSource(new QueryDataSource(
-                                                          Druids.newTimeseriesQueryBuilder()
-                                                                .dataSource(CalciteTests.DATASOURCE1)
-                                                                .intervals(querySegmentSpec(Filtration.eternity()))
-                                                                .granularity(Granularities.ALL)
-                                                                .aggregators(new FloatMaxAggregatorFactory("a0", "m1"))
-                                                                .build()
-                                                      ))
-                                                      .setInterval(querySegmentSpec(Filtration.eternity()))
-                                                      .setGranularity(Granularities.ALL)
-                                                      .setVirtualColumns(expressionVirtualColumn(
-                                                                             "v0",
-                                                                             "(\"a0\" - 3.5)",
-                                                                             ColumnType.DOUBLE
-                                                                         )
-                                                      )
-                                                      .setAggregatorSpecs(
-                                                          aggregators(
-                                                              new SingleValueAggregatorFactory(
-                                                                  "_a0",
-                                                                  "v0",
-                                                                  ColumnType.DOUBLE
-                                                              )
-                                                          )
-                                                      )
-                                                      .setLimitSpec(NoopLimitSpec.instance())
-                                                      .setContext(QUERY_CONTEXT_DEFAULT)
-                                                      .build()
-                      ),
-                      "j0.",
-                      "1",
-                      NullHandling.replaceWithDefault() ? JoinType.LEFT : JoinType.INNER
-                  ))
-                  .intervals(querySegmentSpec(Filtration.eternity()))
-                  .granularity(Granularities.ALL)
-                  .aggregators(aggregators(new CountAggregatorFactory("a0")))
-                  .filters(expressionFilter("(\"m1\" >= \"j0._a0\")"))
-                  .context(QUERY_CONTEXT_DEFAULT)
-                  .build()
-        ),
-        ImmutableList.of(
-            new Object[]{4L}
+                .dataSource(
+                    join(
+                        new TableDataSource(CalciteTests.DATASOURCE1),
+                        new QueryDataSource(
+                            Druids.newTimeseriesQueryBuilder()
+                                .dataSource(CalciteTests.DATASOURCE1)
+                                .intervals(querySegmentSpec(Filtration.eternity()))
+                                .granularity(Granularities.ALL)
+                                .aggregators(new FloatMaxAggregatorFactory("a0", "m1"))
+                                .postAggregators(
+                                    expressionPostAgg(
+                                        "p0",
+                                        "(\"a0\" - 3.5)",
+                                        ColumnType.DOUBLE
+                                    )
+                                )
+                                .build()
+                        ),
+                        "j0.",
+                        "1",
+                        NullHandling.replaceWithDefault() ? JoinType.LEFT : JoinType.INNER
+                    )
+                )
+                .intervals(querySegmentSpec(Filtration.eternity()))
+                .granularity(Granularities.ALL)
+                .aggregators(aggregators(new CountAggregatorFactory("a0")))
+                .filters(expressionFilter("(\"m1\" >= \"j0.p0\")"))
+                .context(QUERY_CONTEXT_DEFAULT)
+                .build()
         )
-    );
+        .expectedResults(
+            ImmutableList.of(
+                new Object[] {4L}
+            )
+        )
+        .run();
   }
 
   @MethodSource("constructorFeeder")
@@ -1191,122 +1165,97 @@ public void testSingleValueDoubleAgg(String testName, Map<String, Object> queryC
   public void testSingleValueLongAgg(String testName, Map<String, Object> queryContext)
   {
     cannotVectorize();
-    testQuery(
-        "SELECT count(*) FROM wikipedia where __time >= (select max(__time) - INTERVAL '10' MINUTE from wikipedia)",
-        ImmutableList.of(
+    testBuilder()
+        .sql(
+            "SELECT count(*) FROM wikipedia where __time >= (select max(__time) - INTERVAL '10' MINUTE from wikipedia)"
+        )
+        .expectedQuery(
             Druids.newTimeseriesQueryBuilder()
-                  .dataSource(join(
-                      new TableDataSource(CalciteTests.WIKIPEDIA),
-                      new QueryDataSource(GroupByQuery.builder()
-                                                      .setDataSource(new QueryDataSource(
-                                                          Druids.newTimeseriesQueryBuilder()
-                                                                .dataSource(CalciteTests.WIKIPEDIA)
-                                                                .intervals(querySegmentSpec(Filtration.eternity()))
-                                                                .granularity(Granularities.ALL)
-                                                                .aggregators(new LongMaxAggregatorFactory(
-                                                                    "a0",
-                                                                    "__time"
-                                                                ))
-                                                                .build()
-                                                      ))
-                                                      .setInterval(querySegmentSpec(Filtration.eternity()))
-                                                      .setGranularity(Granularities.ALL)
-                                                      .setVirtualColumns(expressionVirtualColumn(
-                                                                             "v0",
-                                                                             "(\"a0\" - 600000)",
-                                                                             ColumnType.LONG
-                                                                         )
-                                                      )
-                                                      .setAggregatorSpecs(
-                                                          aggregators(
-                                                              new SingleValueAggregatorFactory(
-                                                                  "_a0",
-                                                                  "v0",
-                                                                  ColumnType.LONG
-                                                              )
-                                                          )
-                                                      )
-                                                      .setLimitSpec(NoopLimitSpec.instance())
-                                                      .setContext(QUERY_CONTEXT_DEFAULT)
-                                                      .build()
-                      ),
-                      "j0.",
-                      "1",
-                      NullHandling.replaceWithDefault() ? JoinType.LEFT : JoinType.INNER
-                  ))
-                  .intervals(querySegmentSpec(Filtration.eternity()))
-                  .granularity(Granularities.ALL)
-                  .aggregators(aggregators(new CountAggregatorFactory("a0")))
-                  .filters(expressionFilter("(\"__time\" >= \"j0._a0\")"))
-                  .context(QUERY_CONTEXT_DEFAULT)
-                  .build()
-        ),
-        ImmutableList.of(
-            new Object[]{220L}
+                .dataSource(
+                    join(
+                        new TableDataSource(CalciteTests.WIKIPEDIA),
+                        new QueryDataSource(
+                            Druids.newTimeseriesQueryBuilder()
+                                .dataSource(CalciteTests.WIKIPEDIA)
+                                .intervals(querySegmentSpec(Filtration.eternity()))
+                                .granularity(Granularities.ALL)
+                                .aggregators(
+                                    new LongMaxAggregatorFactory(
+                                        "a0",
+                                        "__time"
+                                    )
+                                )
+                                .postAggregators(
+                                    expressionPostAgg(
+                                        "p0", "(\"a0\" - 600000)",
+                                        ColumnType.LONG
+                                    )
+                                )
+                                .build()
+                        ),
+                        "j0.",
+                        "1",
+                        NullHandling.replaceWithDefault() ? JoinType.LEFT : JoinType.INNER
+                    )
+                )
+                .intervals(querySegmentSpec(Filtration.eternity()))
+                .granularity(Granularities.ALL)
+                .aggregators(aggregators(new CountAggregatorFactory("a0")))
+                .filters(expressionFilter("(\"__time\" >= \"j0.p0\")"))
+                .context(QUERY_CONTEXT_DEFAULT)
+                .build()
         )
-    );
+        .expectedResults(
+            ImmutableList.of(
+                new Object[] {220L}
+            )
+        )
+        .run();
   }
 
   @MethodSource("constructorFeeder")
   @ParameterizedTest(name = "{0}")
   public void testSingleValueStringAgg(String testName, Map<String, Object> queryContext)
   {
-    cannotVectorize();
-    testQuery(
-        "SELECT  count(*) FROM wikipedia where channel = (select channel from wikipedia order by __time desc LIMIT 1 OFFSET 6)",
-        ImmutableList.of(
+    testBuilder()
+        .sql(
+            "SELECT count(*) FROM wikipedia where channel = (select channel from wikipedia order by __time desc LIMIT 1 OFFSET 6)"
+        )
+        .expectedQuery(
             Druids.newTimeseriesQueryBuilder()
-                  .dataSource(join(
-                      new TableDataSource(CalciteTests.WIKIPEDIA),
-                      new QueryDataSource(GroupByQuery.builder()
-                                                      .setDataSource(new QueryDataSource(
-                                                          Druids.newScanQueryBuilder()
-                                                                .dataSource(CalciteTests.WIKIPEDIA)
-                                                                .intervals(querySegmentSpec(Filtration.eternity()))
-                                                                .resultFormat(ScanQuery.ResultFormat.RESULT_FORMAT_COMPACTED_LIST)
-                                                                .offset(6L)
-                                                                .limit(1L)
-                                                                .order(ScanQuery.Order.DESCENDING)
-                                                                .columns("__time", "channel")
-                                                                .legacy(false)
-                                                                .context(QUERY_CONTEXT_DEFAULT)
-                                                                .build()
-                                                      ))
-                                                      .setInterval(querySegmentSpec(Filtration.eternity()))
-                                                      .setGranularity(Granularities.ALL)
-                                                      .setVirtualColumns(expressionVirtualColumn(
-                                                                             "v0",
-                                                                             "\"channel\"",
-                                                                             ColumnType.STRING
-                                                                         )
-                                                      )
-                                                      .setAggregatorSpecs(
-                                                          aggregators(
-                                                              new SingleValueAggregatorFactory(
-                                                                  "a0",
-                                                                  "v0",
-                                                                  ColumnType.STRING
-                                                              )
-                                                          )
-                                                      )
-                                                      .setLimitSpec(NoopLimitSpec.instance())
-                                                      .setContext(QUERY_CONTEXT_DEFAULT)
-                                                      .build()
-                      ),
-                      "j0.",
-                      "(\"channel\" == \"j0.a0\")",
-                      JoinType.INNER
-                  ))
-                  .intervals(querySegmentSpec(Filtration.eternity()))
-                  .granularity(Granularities.ALL)
-                  .aggregators(aggregators(new CountAggregatorFactory("a0")))
-                  .context(QUERY_CONTEXT_DEFAULT)
-                  .build()
-        ),
-        ImmutableList.of(
-            new Object[]{1256L}
+                .dataSource(
+                    join(
+                        new TableDataSource(CalciteTests.WIKIPEDIA),
+                        new QueryDataSource(
+                            Druids.newScanQueryBuilder()
+                                .dataSource(CalciteTests.WIKIPEDIA)
+                                .intervals(querySegmentSpec(Filtration.eternity()))
+                                .resultFormat(ScanQuery.ResultFormat.RESULT_FORMAT_COMPACTED_LIST)
+                                .offset(6L)
+                                .limit(1L)
+                                .order(ScanQuery.Order.DESCENDING)
+                                .columns("__time", "channel")
+                                .legacy(false)
+                                .context(QUERY_CONTEXT_DEFAULT)
+                                .build()
+                        ),
+                        "j0.",
+                        "(\"channel\" == \"j0.channel\")",
+                        JoinType.INNER
+                    )
+                )
+                .intervals(querySegmentSpec(Filtration.eternity()))
+                .granularity(Granularities.ALL)
+                .aggregators(aggregators(new CountAggregatorFactory("a0")))
+                .context(QUERY_CONTEXT_DEFAULT)
+                .build()
         )
-    );
+        .expectedResults(
+            ImmutableList.of(
+                new Object[] {1256L}
+            )
+        )
+        .run();
   }
 
   @MethodSource("constructorFeeder")
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/NotYetSupported.java b/sql/src/test/java/org/apache/druid/sql/calcite/NotYetSupported.java
index de94a2649766..d1a0c4ec883c 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/NotYetSupported.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/NotYetSupported.java
@@ -99,7 +99,8 @@ enum Modes
     CORRELATE_CONVERSION(DruidException.class, "Missing conversion( is|s are) LogicalCorrelate"),
     SORT_REMOVE_TROUBLE(DruidException.class, "Calcite assertion violated.*Sort\\.<init>"),
     STACK_OVERFLOW(StackOverflowError.class, ""),
-    CANNOT_JOIN_LOOKUP_NON_KEY(RuntimeException.class, "Cannot join lookup with condition referring to non-key");
+    CANNOT_JOIN_LOOKUP_NON_KEY(RuntimeException.class, "Cannot join lookup with condition referring to non-key"),
+    SORT_REMOVE_CONSTANT_KEYS_CONFLICT(DruidException.class, "not enough rules");
     // @formatter:on
 
     public Class<? extends Throwable> throwableClass;
diff --git a/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlParserUtilsTest.java b/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlParserUtilsTest.java
index bc9d6997536a..b51a106aef93 100644
--- a/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlParserUtilsTest.java
+++ b/sql/src/test/java/org/apache/druid/sql/calcite/parser/DruidSqlParserUtilsTest.java
@@ -22,6 +22,7 @@
 import com.google.common.collect.ImmutableList;
 import org.apache.calcite.avatica.util.TimeUnit;
 import org.apache.calcite.avatica.util.TimeUnitRange;
+import org.apache.calcite.runtime.PairList;
 import org.apache.calcite.sql.SqlAsOperator;
 import org.apache.calcite.sql.SqlBasicCall;
 import org.apache.calcite.sql.SqlIdentifier;
@@ -34,7 +35,6 @@
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
 import org.apache.calcite.sql.parser.SqlParserPos;
 import org.apache.calcite.sql.type.SqlTypeName;
-import org.apache.calcite.util.Pair;
 import org.apache.druid.error.DruidException;
 import org.apache.druid.error.DruidExceptionMatcher;
 import org.apache.druid.java.util.common.DateTimes;
@@ -185,11 +185,12 @@ public void testNullClusteredByAndSource()
     @Test
     public void testNullClusteredBy()
     {
-      final ImmutableList<Pair<Integer, String>> fields = ImmutableList.of(
-          Pair.of(1, "__time"),
-          Pair.of(2, "foo"),
-          Pair.of(3, "bar")
-      );
+      PairList<Integer, String> fields = PairList.<Integer, String>builder()
+          .add(1, "__time")
+          .add(2, "foo")
+          .add(3, "bar")
+          .build();
+
       Assert.assertNull(
           DruidSqlParserUtils.resolveClusteredByColumnsToOutputColumns(
               null,
@@ -222,11 +223,11 @@ public void testSimpledClusteredByWithNullSource()
     @Test
     public void testSimpleClusteredBy()
     {
-      final ImmutableList<Pair<Integer, String>> sourceFieldMappings = ImmutableList.of(
-          Pair.of(1, "__time"),
-          Pair.of(2, "FOO"),
-          Pair.of(3, "BOO")
-      );
+      PairList<Integer, String> sourceFieldMappings = PairList.<Integer, String>builder()
+          .add(1, "__time")
+          .add(2, "FOO")
+          .add(3, "BOO")
+          .build();
 
       final SqlNodeList clusteredByArgs = new SqlNodeList(SqlParserPos.ZERO);
       clusteredByArgs.add(new SqlIdentifier("__time", SqlParserPos.ZERO));
@@ -243,15 +244,15 @@ public void testSimpleClusteredBy()
     @Test
     public void testClusteredByOrdinalsAndAliases()
     {
-      final ImmutableList<Pair<Integer, String>> sourceFieldMappings = ImmutableList.of(
-          Pair.of(1, "__time"),
-          Pair.of(2, "DIM3"),
-          Pair.of(3, "DIM3_ALIAS"),
-          Pair.of(4, "floor_dim4_time"),
-          Pair.of(5, "DIM5"),
-          Pair.of(5, "DIM6"),
-          Pair.of(7, "TIME_FLOOR(\"timestamps\", 'PT1H')")
-      );
+      PairList<Integer, String> sourceFieldMappings = PairList.<Integer, String>builder()
+          .add(1, "__time")
+          .add(2, "DIM3")
+          .add(3, "DIM3_ALIAS")
+          .add(4, "floor_dim4_time")
+          .add(5, "DIM5")
+          .add(5, "DIM6")
+          .add(7, "TIME_FLOOR(\"timestamps\", 'PT1H')")
+          .build();
 
       // Construct the clustered by args
       final SqlNodeList clusteredByArgs = new SqlNodeList(SqlParserPos.ZERO);
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@all_disabled@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@all_disabled@NullHandling=default.iq
index b673cb7d7224..1c97bb7ee961 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@all_disabled@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@all_disabled@NullHandling=default.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 INNER JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@all_disabled@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@all_disabled@NullHandling=sql.iq
index eecc02c743b2..d3cf5105a913 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@all_disabled@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@all_disabled@NullHandling=sql.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 INNER JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@all_enabled@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@all_enabled@NullHandling=default.iq
index 4067edb5bcbe..bd8b49ead4e9 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@all_enabled@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@all_enabled@NullHandling=default.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 INNER JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@all_enabled@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@all_enabled@NullHandling=sql.iq
index 1996db4d5d07..3fdf39476ee4 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@all_enabled@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@all_enabled@NullHandling=sql.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 INNER JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@default@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@default@NullHandling=default.iq
index 6062daaf9a6b..2f80224ec77c 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@default@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@default@NullHandling=default.iq
@@ -15,11 +15,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 INNER JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@default@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@default@NullHandling=sql.iq
index 538c16122552..5dafdf1cb581 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@default@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@default@NullHandling=sql.iq
@@ -15,11 +15,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 INNER JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=default.iq
index 5c905acff34e..94526e1ddb29 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=default.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 INNER JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=sql.iq
index 3fb25cee4120..dd795fb1c510 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=sql.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 INNER JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=default.iq
index 273ab55d1a06..9db67c9d7331 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=default.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 INNER JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=sql.iq
index 92e569b8a862..e60075a65746 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=sql.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 INNER JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-rewrites@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-rewrites@NullHandling=default.iq
index fb0b6d4fa2a6..b07e13731bba 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-rewrites@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-rewrites@NullHandling=default.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 INNER JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-rewrites@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-rewrites@NullHandling=sql.iq
index 3f7bf11759ce..cb5807a26930 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-rewrites@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-rewrites@NullHandling=sql.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 INNER JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@join-to-filter@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@join-to-filter@NullHandling=default.iq
index c8718ddff9be..6ebe59515c8a 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@join-to-filter@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@join-to-filter@NullHandling=default.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 INNER JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@join-to-filter@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@join-to-filter@NullHandling=sql.iq
index afdb2ecd8892..935f19e21a60 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@join-to-filter@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@join-to-filter@NullHandling=sql.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 INNER JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@all_disabled@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@all_disabled@NullHandling=default.iq
index bb7b19ce9db0..a644d80a90d6 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@all_disabled@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@all_disabled@NullHandling=default.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 INNER JOIN abc as t2 on t1.dim1 = t2.dim1
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@all_disabled@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@all_disabled@NullHandling=sql.iq
index 585ba59b372a..d77f13502a37 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@all_disabled@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@all_disabled@NullHandling=sql.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 INNER JOIN abc as t2 on t1.dim1 = t2.dim1
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@all_enabled@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@all_enabled@NullHandling=default.iq
index 589d7222a598..f905ad0706e6 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@all_enabled@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@all_enabled@NullHandling=default.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 INNER JOIN abc as t2 on t1.dim1 = t2.dim1
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@all_enabled@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@all_enabled@NullHandling=sql.iq
index 83c9355ff1b7..64d4eddf4885 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@all_enabled@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@all_enabled@NullHandling=sql.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 INNER JOIN abc as t2 on t1.dim1 = t2.dim1
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@default@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@default@NullHandling=default.iq
index 7df3873f942f..b7c64a788479 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@default@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@default@NullHandling=default.iq
@@ -15,11 +15,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 INNER JOIN abc as t2 on t1.dim1 = t2.dim1
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@default@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@default@NullHandling=sql.iq
index 51c017fa0888..11994dcdafb8 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@default@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@default@NullHandling=sql.iq
@@ -15,11 +15,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 INNER JOIN abc as t2 on t1.dim1 = t2.dim1
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=default.iq
index a5611b67b169..0410dbbc2dd3 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=default.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 INNER JOIN abc as t2 on t1.dim1 = t2.dim1
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=sql.iq
index a30b72faf1a4..81b0a62d042d 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=sql.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 INNER JOIN abc as t2 on t1.dim1 = t2.dim1
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=default.iq
index a9dc43455726..5335021cba1e 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=default.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 INNER JOIN abc as t2 on t1.dim1 = t2.dim1
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=sql.iq
index b068148f553c..8be64f51fc34 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=sql.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 INNER JOIN abc as t2 on t1.dim1 = t2.dim1
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-rewrites@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-rewrites@NullHandling=default.iq
index 2b4c57c3931f..7c7b15456377 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-rewrites@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-rewrites@NullHandling=default.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 INNER JOIN abc as t2 on t1.dim1 = t2.dim1
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-rewrites@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-rewrites@NullHandling=sql.iq
index 7671fed30ede..2750b09b2ad1 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-rewrites@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-rewrites@NullHandling=sql.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 INNER JOIN abc as t2 on t1.dim1 = t2.dim1
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@join-to-filter@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@join-to-filter@NullHandling=default.iq
index 90f380fbc429..8bf56ebc4761 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@join-to-filter@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@join-to-filter@NullHandling=default.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 INNER JOIN abc as t2 on t1.dim1 = t2.dim1
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@join-to-filter@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@join-to-filter@NullHandling=sql.iq
index 03bf0675958e..8190f45efafd 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@join-to-filter@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testInnerJoinOnTwoInlineDataSources_withLeftDirectAccess@join-to-filter@NullHandling=sql.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 INNER JOIN abc as t2 on t1.dim1 = t2.dim1
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@all_disabled@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@all_disabled@NullHandling=default.iq
index 8eded902facc..d4dfbd0ad1d2 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@all_disabled@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@all_disabled@NullHandling=default.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@all_disabled@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@all_disabled@NullHandling=sql.iq
index a0843c687b57..bcefbd4c4ebd 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@all_disabled@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@all_disabled@NullHandling=sql.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@all_enabled@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@all_enabled@NullHandling=default.iq
index 876e3754f560..daa8e4e768f8 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@all_enabled@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@all_enabled@NullHandling=default.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@all_enabled@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@all_enabled@NullHandling=sql.iq
index 9522671d9987..9645a60b0073 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@all_enabled@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@all_enabled@NullHandling=sql.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@default@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@default@NullHandling=default.iq
index 62ceac66ee5b..33c10207f8f1 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@default@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@default@NullHandling=default.iq
@@ -15,11 +15,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@default@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@default@NullHandling=sql.iq
index aef0110abb0a..d9d19e39d772 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@default@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@default@NullHandling=sql.iq
@@ -15,11 +15,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=default.iq
index a7a738f3b553..5b7547275fa2 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=default.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=sql.iq
index 77ef79c876d8..a15a61f877c6 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=sql.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=default.iq
index 4efc038a380d..12362cdaaaab 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=default.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=sql.iq
index 854f0e04cab8..91b4312973ed 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=sql.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-rewrites@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-rewrites@NullHandling=default.iq
index 4a656b3bc077..e7dc799ba595 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-rewrites@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-rewrites@NullHandling=default.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-rewrites@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-rewrites@NullHandling=sql.iq
index 4689ba669150..b1d869fc0083 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-rewrites@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@filter-rewrites@NullHandling=sql.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@join-to-filter@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@join-to-filter@NullHandling=default.iq
index 0a10654bbdc1..9d917f9bc973 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@join-to-filter@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@join-to-filter@NullHandling=default.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@join-to-filter@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@join-to-filter@NullHandling=sql.iq
index f102203a9797..8df872ddb8a0 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@join-to-filter@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithOuterWhere_withLeftDirectAccess@join-to-filter@NullHandling=sql.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@all_disabled@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@all_disabled@NullHandling=default.iq
index c899ca42f506..18d5b2c281ec 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@all_disabled@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@all_disabled@NullHandling=default.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@all_disabled@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@all_disabled@NullHandling=sql.iq
index b72648d4ba38..223cf55e124a 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@all_disabled@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@all_disabled@NullHandling=sql.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@all_enabled@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@all_enabled@NullHandling=default.iq
index ae82abfaed84..38c060edc25b 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@all_enabled@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@all_enabled@NullHandling=default.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@all_enabled@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@all_enabled@NullHandling=sql.iq
index efd79e345320..399581bceb52 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@all_enabled@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@all_enabled@NullHandling=sql.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@default@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@default@NullHandling=default.iq
index 04d616a090ae..e151ac97f52c 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@default@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@default@NullHandling=default.iq
@@ -15,11 +15,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@default@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@default@NullHandling=sql.iq
index 43ac841557c0..6fb8344b350a 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@default@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@default@NullHandling=sql.iq
@@ -15,11 +15,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=default.iq
index d39d77e3a821..0005b6f21996 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=default.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=sql.iq
index 4b96abc1555d..b58ccfb74421 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=sql.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=default.iq
index 7bf6fa02d00d..1b66e080ef2f 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=default.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=sql.iq
index 0803b4279825..466504c9ee49 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=sql.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@filter-rewrites@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@filter-rewrites@NullHandling=default.iq
index 4068aa57724c..dfc9e307dcaf 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@filter-rewrites@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@filter-rewrites@NullHandling=default.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@filter-rewrites@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@filter-rewrites@NullHandling=sql.iq
index 949d14d853d9..a9678e70060f 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@filter-rewrites@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@filter-rewrites@NullHandling=sql.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@join-to-filter@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@join-to-filter@NullHandling=default.iq
index 9c1d562f6824..583c592d3960 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@join-to-filter@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@join-to-filter@NullHandling=default.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@join-to-filter@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@join-to-filter@NullHandling=sql.iq
index 9bd4ecafd97b..689bf3b8562f 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@join-to-filter@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSourcesWithTimeFilter_withLeftDirectAccess@join-to-filter@NullHandling=sql.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1 WHERE t1.dim1 = '10.1'
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@all_disabled@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@all_disabled@NullHandling=default.iq
index d3f88c965504..bbde46874f6e 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@all_disabled@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@all_disabled@NullHandling=default.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@all_disabled@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@all_disabled@NullHandling=sql.iq
index 1c91a6ca4d4b..27682661b4c6 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@all_disabled@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@all_disabled@NullHandling=sql.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@all_enabled@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@all_enabled@NullHandling=default.iq
index 8674874c92a4..28a80ff003c3 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@all_enabled@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@all_enabled@NullHandling=default.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@all_enabled@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@all_enabled@NullHandling=sql.iq
index efff7d664056..c27a4b7a1200 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@all_enabled@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@all_enabled@NullHandling=sql.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@default@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@default@NullHandling=default.iq
index 9302fc9bb4ff..697888623332 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@default@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@default@NullHandling=default.iq
@@ -15,11 +15,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@default@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@default@NullHandling=sql.iq
index cf60b23d50c0..a4342bed6590 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@default@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@default@NullHandling=sql.iq
@@ -15,11 +15,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=default.iq
index 935e4701f1ec..a18be661b59c 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=default.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=sql.iq
index c74ae449b9e4..6f2c0cfa4764 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-on-value-column_disabled@NullHandling=sql.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=default.iq
index 9acd3ab46557..bad3fea5e407 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=default.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=sql.iq
index 0294f2a6027f..c4ee8dcac084 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-rewrites-disabled@NullHandling=sql.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-rewrites@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-rewrites@NullHandling=default.iq
index 6e0f9288ca25..a69dfe749f68 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-rewrites@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-rewrites@NullHandling=default.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-rewrites@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-rewrites@NullHandling=sql.iq
index a5119dd551af..69f6925ce7e1 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-rewrites@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@filter-rewrites@NullHandling=sql.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@join-to-filter@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@join-to-filter@NullHandling=default.iq
index 128b3ddfa23d..c6de594d4ba9 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@join-to-filter@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@join-to-filter@NullHandling=default.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@join-to-filter@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@join-to-filter@NullHandling=sql.iq
index 2562afd6020d..63131da8ae3e 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@join-to-filter@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteJoinQueryTest/testLeftJoinOnTwoInlineDataSources_withLeftDirectAccess@join-to-filter@NullHandling=sql.iq
@@ -18,11 +18,11 @@ with abc as
 )
 SELECT t1.dim1, t1."__time" from abc as t1 LEFT JOIN abc as t2 on t1.dim1 = t2.dim1
 ;
-+------+---------------------+
-| dim1 | __time              |
-+------+---------------------+
-| 10.1 | 2000-01-02 00:00:00 |
-+------+---------------------+
++------+-------------------------+
+| dim1 | __time                  |
++------+-------------------------+
+| 10.1 | 2000-01-02 00:00:00.000 |
++------+-------------------------+
 (1 row)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByTimeFloorAndDimOnGroupByTimeFloorAndDim@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByTimeFloorAndDimOnGroupByTimeFloorAndDim@NullHandling=default.iq
index bd5bb765dedd..eb4bdee0c2fc 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByTimeFloorAndDimOnGroupByTimeFloorAndDim@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByTimeFloorAndDimOnGroupByTimeFloorAndDim@NullHandling=default.iq
@@ -12,14 +12,14 @@ SELECT dim2, time_floor(gran, 'P1M') gran, sum(s)
 FROM (SELECT time_floor(__time, 'P1D') AS gran, dim2, sum(m1) as s FROM druid.foo GROUP BY 1, 2 HAVING sum(m1) > 1) AS x
 GROUP BY 1, 2
 ORDER BY dim2, gran desc;
-+------+---------------------+--------+
-| dim2 | gran                | EXPR$2 |
-+------+---------------------+--------+
-|      | 2001-01-01 00:00:00 |    6.0 |
-|      | 2000-01-01 00:00:00 |    5.0 |
-| a    | 2001-01-01 00:00:00 |    4.0 |
-| abc  | 2001-01-01 00:00:00 |    5.0 |
-+------+---------------------+--------+
++------+-------------------------+--------+
+| dim2 | gran                    | EXPR$2 |
++------+-------------------------+--------+
+|      | 2001-01-01 00:00:00.000 |    6.0 |
+|      | 2000-01-01 00:00:00.000 |    5.0 |
+| a    | 2001-01-01 00:00:00.000 |    4.0 |
+| abc  | 2001-01-01 00:00:00.000 |    5.0 |
++------+-------------------------+--------+
 (4 rows)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByTimeFloorAndDimOnGroupByTimeFloorAndDim@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByTimeFloorAndDimOnGroupByTimeFloorAndDim@NullHandling=sql.iq
index fb4b5cd8dfb4..5105e214557d 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByTimeFloorAndDimOnGroupByTimeFloorAndDim@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByTimeFloorAndDimOnGroupByTimeFloorAndDim@NullHandling=sql.iq
@@ -12,15 +12,15 @@ SELECT dim2, time_floor(gran, 'P1M') gran, sum(s)
 FROM (SELECT time_floor(__time, 'P1D') AS gran, dim2, sum(m1) as s FROM druid.foo GROUP BY 1, 2 HAVING sum(m1) > 1) AS x
 GROUP BY 1, 2
 ORDER BY dim2, gran desc;
-+------+---------------------+--------+
-| dim2 | gran                | EXPR$2 |
-+------+---------------------+--------+
-|      | 2001-01-01 00:00:00 |    6.0 |
-|      | 2000-01-01 00:00:00 |    2.0 |
-|      | 2000-01-01 00:00:00 |    3.0 |
-| a    | 2001-01-01 00:00:00 |    4.0 |
-| abc  | 2001-01-01 00:00:00 |    5.0 |
-+------+---------------------+--------+
++------+-------------------------+--------+
+| dim2 | gran                    | EXPR$2 |
++------+-------------------------+--------+
+|      | 2001-01-01 00:00:00.000 |    6.0 |
+|      | 2000-01-01 00:00:00.000 |    2.0 |
+|      | 2000-01-01 00:00:00.000 |    3.0 |
+| a    | 2001-01-01 00:00:00.000 |    4.0 |
+| abc  | 2001-01-01 00:00:00.000 |    5.0 |
++------+-------------------------+--------+
 (5 rows)
 
 !ok
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByWithLiteralInSubqueryGrouping.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByWithLiteralInSubqueryGrouping.iq
index 85c1b392c49a..b5d2c682643b 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByWithLiteralInSubqueryGrouping.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testGroupByWithLiteralInSubqueryGrouping.iq
@@ -30,8 +30,8 @@ SELECT
 +-------+----+
 | t1    | t2 |
 +-------+----+
-| dummy | b  |
 | dummy |    |
+| dummy | b  |
 +-------+----+
 (2 rows)
 
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testQueryWithSelectProjectAndIdentityProjectDoesNotRename@NullHandling=default.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testQueryWithSelectProjectAndIdentityProjectDoesNotRename@NullHandling=default.iq
index dd7cb19cb201..8dff354a6cbb 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testQueryWithSelectProjectAndIdentityProjectDoesNotRename@NullHandling=default.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testQueryWithSelectProjectAndIdentityProjectDoesNotRename@NullHandling=default.iq
@@ -25,16 +25,16 @@ GROUP BY ();
 LogicalProject(EXPR$0=[/(CAST($0):DECIMAL(19, 1), $1)])
   LogicalAggregate(group=[{}], agg#0=[MIN($1) FILTER $3], agg#1=[COUNT($0) FILTER $2])
     LogicalProject($f1=[$0], $f0=[$1], $g_0=[=($2, 0)], $g_1=[=($2, 1)])
-      LogicalAggregate(group=[{0}], groups=[[{0}, {}]], $f0=[COUNT() FILTER $1], $g=[GROUPING($0)])
-        LogicalProject($f1=[CASE(SEARCH($0, Sarg[[2000-01-04 17:00:00..2022-01-05 17:00:00)]), $1, null:VARCHAR)], $f2=[SEARCH($0, Sarg[[2000-01-04 17:00:00..2022-01-05 17:00:00)])])
+      LogicalAggregate(group=[{1}], groups=[[{1}, {}]], $f0=[SUM($0)], $g=[GROUPING($1)])
+        LogicalProject($f0=[CASE(SEARCH($0, Sarg[[2000-01-04 17:00:00..2022-01-05 17:00:00)]), 1, 0)], $f1=[CASE(SEARCH($0, Sarg[[2000-01-04 17:00:00..2022-01-05 17:00:00)]), $1, null:VARCHAR)])
           LogicalTableScan(table=[[druid, foo]])
 
 !logicalPlan
 DruidProject(EXPR$0=[/(CAST($0):DECIMAL(19, 1), $1)], druid=[logical])
   DruidAggregate(group=[{}], agg#0=[MIN($1) FILTER $3], agg#1=[COUNT($0) FILTER $2], druid=[logical])
     DruidProject($f1=[$0], $f0=[$1], $g_0=[=($2, 0)], $g_1=[=($2, 1)], druid=[logical])
-      DruidAggregate(group=[{0}], groups=[[{0}, {}]], $f0=[COUNT() FILTER $1], $g=[GROUPING($0)], druid=[logical])
-        DruidProject($f1=[CASE(SEARCH($0, Sarg[[2000-01-04 17:00:00..2022-01-05 17:00:00)]), $1, null:VARCHAR)], $f2=[SEARCH($0, Sarg[[2000-01-04 17:00:00..2022-01-05 17:00:00)])], druid=[logical])
+      DruidAggregate(group=[{1}], groups=[[{1}, {}]], $f0=[SUM($0)], $g=[GROUPING($1)], druid=[logical])
+        DruidProject($f0=[CASE(SEARCH($0, Sarg[[2000-01-04 17:00:00..2022-01-05 17:00:00)]), 1, 0)], $f1=[CASE(SEARCH($0, Sarg[[2000-01-04 17:00:00..2022-01-05 17:00:00)]), $1, null:VARCHAR)], druid=[logical])
           DruidTableScan(table=[[druid, foo]], druid=[logical])
 
 !druidPlan
@@ -57,6 +57,11 @@ DruidProject(EXPR$0=[/(CAST($0):DECIMAL(19, 1), $1)], druid=[logical])
         "name" : "v0",
         "expression" : "case_searched(((\"__time\" >= 947005200000) && (\"__time\" < 1641402000000)),\"dim1\",null)",
         "outputType" : "STRING"
+      }, {
+        "type" : "expression",
+        "name" : "v1",
+        "expression" : "case_searched(((\"__time\" >= 947005200000) && (\"__time\" < 1641402000000)),1,0)",
+        "outputType" : "LONG"
       } ],
       "granularity" : {
         "type" : "all"
@@ -68,22 +73,9 @@ DruidProject(EXPR$0=[/(CAST($0):DECIMAL(19, 1), $1)], druid=[logical])
         "outputType" : "STRING"
       } ],
       "aggregations" : [ {
-        "type" : "filtered",
-        "aggregator" : {
-          "type" : "count",
-          "name" : "a0"
-        },
-        "filter" : {
-          "type" : "bound",
-          "dimension" : "__time",
-          "lower" : "947005200000",
-          "upper" : "1641402000000",
-          "upperStrict" : true,
-          "ordering" : {
-            "type" : "numeric"
-          }
-        },
-        "name" : "a0"
+        "type" : "longSum",
+        "name" : "a0",
+        "fieldName" : "v1"
       }, {
         "type" : "grouping",
         "name" : "a1",
diff --git a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testQueryWithSelectProjectAndIdentityProjectDoesNotRename@NullHandling=sql.iq b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testQueryWithSelectProjectAndIdentityProjectDoesNotRename@NullHandling=sql.iq
index f110fbad512b..0a1c54da595f 100644
--- a/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testQueryWithSelectProjectAndIdentityProjectDoesNotRename@NullHandling=sql.iq
+++ b/sql/src/test/quidem/org.apache.druid.sql.calcite.DecoupledPlanningCalciteQueryTest/testQueryWithSelectProjectAndIdentityProjectDoesNotRename@NullHandling=sql.iq
@@ -25,16 +25,16 @@ GROUP BY ();
 LogicalProject(EXPR$0=[/(CAST($0):DECIMAL(19, 1), $1)])
   LogicalAggregate(group=[{}], agg#0=[MIN($1) FILTER $3], agg#1=[COUNT($0) FILTER $2])
     LogicalProject($f1=[$0], $f0=[$1], $g_0=[=($2, 0)], $g_1=[=($2, 1)])
-      LogicalAggregate(group=[{0}], groups=[[{0}, {}]], $f0=[COUNT() FILTER $1], $g=[GROUPING($0)])
-        LogicalProject($f1=[CASE(SEARCH($0, Sarg[[2000-01-04 17:00:00..2022-01-05 17:00:00)]), $1, null:VARCHAR)], $f2=[SEARCH($0, Sarg[[2000-01-04 17:00:00..2022-01-05 17:00:00)])])
+      LogicalAggregate(group=[{1}], groups=[[{1}, {}]], $f0=[SUM($0)], $g=[GROUPING($1)])
+        LogicalProject($f0=[CASE(SEARCH($0, Sarg[[2000-01-04 17:00:00..2022-01-05 17:00:00)]), 1, 0)], $f1=[CASE(SEARCH($0, Sarg[[2000-01-04 17:00:00..2022-01-05 17:00:00)]), $1, null:VARCHAR)])
           LogicalTableScan(table=[[druid, foo]])
 
 !logicalPlan
 DruidProject(EXPR$0=[/(CAST($0):DECIMAL(19, 1), $1)], druid=[logical])
   DruidAggregate(group=[{}], agg#0=[MIN($1) FILTER $3], agg#1=[COUNT($0) FILTER $2], druid=[logical])
     DruidProject($f1=[$0], $f0=[$1], $g_0=[=($2, 0)], $g_1=[=($2, 1)], druid=[logical])
-      DruidAggregate(group=[{0}], groups=[[{0}, {}]], $f0=[COUNT() FILTER $1], $g=[GROUPING($0)], druid=[logical])
-        DruidProject($f1=[CASE(SEARCH($0, Sarg[[2000-01-04 17:00:00..2022-01-05 17:00:00)]), $1, null:VARCHAR)], $f2=[SEARCH($0, Sarg[[2000-01-04 17:00:00..2022-01-05 17:00:00)])], druid=[logical])
+      DruidAggregate(group=[{1}], groups=[[{1}, {}]], $f0=[SUM($0)], $g=[GROUPING($1)], druid=[logical])
+        DruidProject($f0=[CASE(SEARCH($0, Sarg[[2000-01-04 17:00:00..2022-01-05 17:00:00)]), 1, 0)], $f1=[CASE(SEARCH($0, Sarg[[2000-01-04 17:00:00..2022-01-05 17:00:00)]), $1, null:VARCHAR)], druid=[logical])
           DruidTableScan(table=[[druid, foo]], druid=[logical])
 
 !druidPlan
@@ -57,6 +57,11 @@ DruidProject(EXPR$0=[/(CAST($0):DECIMAL(19, 1), $1)], druid=[logical])
         "name" : "v0",
         "expression" : "case_searched(((\"__time\" >= 947005200000) && (\"__time\" < 1641402000000)),\"dim1\",null)",
         "outputType" : "STRING"
+      }, {
+        "type" : "expression",
+        "name" : "v1",
+        "expression" : "case_searched(((\"__time\" >= 947005200000) && (\"__time\" < 1641402000000)),1,0)",
+        "outputType" : "LONG"
       } ],
       "granularity" : {
         "type" : "all"
@@ -68,20 +73,9 @@ DruidProject(EXPR$0=[/(CAST($0):DECIMAL(19, 1), $1)], druid=[logical])
         "outputType" : "STRING"
       } ],
       "aggregations" : [ {
-        "type" : "filtered",
-        "aggregator" : {
-          "type" : "count",
-          "name" : "a0"
-        },
-        "filter" : {
-          "type" : "range",
-          "column" : "__time",
-          "matchValueType" : "LONG",
-          "lower" : 947005200000,
-          "upper" : 1641402000000,
-          "upperOpen" : true
-        },
-        "name" : "a0"
+        "type" : "longSum",
+        "name" : "a0",
+        "fieldName" : "v1"
       }, {
         "type" : "grouping",
         "name" : "a1",