You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@calcite.apache.org by li...@apache.org on 2022/03/04 13:24:22 UTC

[calcite] 18/41: [CALCITE-4885] Fluent test fixtures so that dependent projects can write parser, validator and rules tests

This is an automated email from the ASF dual-hosted git repository.

liyafan pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/calcite.git

commit 909e134cc53738e9f78e53b998d27ab87227d958
Author: Julian Hyde <jh...@apache.org>
AuthorDate: Sat Nov 13 00:38:58 2021 -0800

    [CALCITE-4885] Fluent test fixtures so that dependent projects can write parser, validator and rules tests
    
    The goal is to be able to write tests from both inside and outside of
    Calcite, and without deriving from a particular test class.
    
    We achieve that goal by creating *fixture* objects for each kind of
    test. Test configuration (e.g. what SQL query to test) belongs in that
    fixture, and is set using wither methods.
    
    Inside the fixture is a *factory* that creates the objects necessary
    to run the test (parser, validator, and so forth). The factory
    necssarily contains the config for the parser, validator, etc. Tests
    configure the factory by calling methods in their fixture.
    
    Also inside a fixture is a *tester* that orchestrates the lifecycle
    (parse, validate, SQL-to-rel, check results). The tester is stateless
    (necessary state is provided by parameters to its methods, which often
    include a `SqlTestFactory`). There is one main implementation of the
    tester, but it can be substituted with an radically different
    implementations (say one that no-ops, or dumps all SQL expressions to
    a file).
    
    Tests that compare actual results with expected results may have a
    `DiffRepository` attached to their fixture.
    
    There follows descriptions of other refactorings included in this
    change.
    
    The code was deprecated in [CALCITE-4591], [CALCITE-4593],
    [CALCITE-4446] to be removed before release 1.28.
    
    Move classes `DiffRepository`, `MockRelOptPlanner`,
    `SqlToRelTestBase`, `RelOptTestBase`, `SqlRuntimeTester`,
    `SqlOperatorTest` (renaming to `CoreSqlOperatorTest`),
    `SqlOperatorBaseTest` (renaming to `SqlOperatorTest`).
    
    Class `Fixtures` is a single place to obtain fixtures to tests of the
    parser, validator, operators, planner rules, and more. These fixtures
    can be used within Calcite but also by any project that uses Calcite
    (the project just needs to use the `testkit` module).
    
    `class FixtureTest` tests `Fixtures` and contains examples.
    
    Add `fixture()` methods, to create fixtures without SQL, to many test
    classes including `RelToSqlConverterTest`, `InterpreterTest`,
    `SqlParserTest`, `SqlValidatorTest`, `DruidAdapter2IT`,
    `DruidAdapterIT`. (Previously many tests would write `sql("?")` to
    create tests with dummy SQL.
    
    In `class CalciteAssert`, move method `withRel` from `AssertQuery` to
    `AssertThat`, so that tests can provide a `RelNode` without first
    providing dummy SQL. Also make the list of hooks (used heavily by
    `AssertQuery`) immutable.
    
    In `SqlTester`, remove methods `checkFieldOrigin`, `checkResultType`,
    `checkCollation`, `checkCharset`, `checkIntervalConv`,
    `checkMonotonic`; all can now be implemented in terms of a new method
    `validateAndThen`, and similar methods `validateAndApply` and
    `forEachQueryValidateAndThen`.
    
    Obsolete `interface SqlToRelTestBase.Tester`; `SqlToRelFixture` now
    uses `SqlTester`.
    
    Move inner `class MockViewExpander` from `SqlToRelTestBase` to
    `SqlTestFactory`.
    
    Method `SqlToRelTestBase.assertValid` becomes `Matchers.relIsValid`.
    
    Refactor/rename a few methods, and change 'query' field to 'expression'.
    
    State is now in the fixture (`class SqlParserFixture`) or
    `SqlTestFactory`.
    
    Create a fixture (`class SqlParserListFixture`) for list-based parser
    tests.
    
    Remove fixture's `transform` field; config is now transformed
    immediately, not deferred.
    
    Remove field `LINUXIFY` (thread-local state).
    
    Fields `SqlToRelFixture.expression` and `SqlValidatorFixture.expression`
    were each previously called `query` and had the opposite sense;
    both are now consistent with `SqlParserFixture.expression`.
    
    Rename method `sql` to `withSql`, `config` to `withConfig`, etc.
    
    Rename method `withDecorrelation` to `withDecorrelate`,
    `withLateDecorrelation` to `withLateDecorrelate`
    `with(RelOptPlanner)` to `withPlanner`,
    `with(HepProgram)` to `withProgram`.
    
    `MaterializedViewTester` is now a utility class for materialized view
    tests but is no longer required to be a base class.
    
    Move `interface AbstractMaterializedViewTest.Sql` to top-level
    `class MaterializedViewFixture`.
    
    In `class MaterializedViewSubstitutionVisitorTest`, create a fixture
    for satisfiability tests.
    
    `RelSupplier` was previously an inner class of `class RelOptTestBase`.
    
    It is used in metadata tests (`RelMetadataFixture`) and planner rule
    tests (`RelOptFixture`) but could be used in other tests too.
    
    Add `class RelSuppliers` with utilities and implementations for
    `RelSupplier`.
    
    Move `assertXxx` methods into a fixture, `class
    SqlAdvisorTest.Fixture`.
    
    Remove inner `class LexConfiguration`; it relied on a mutable tester
    in each `SqlValidatorTest` instance, which is no longer there.
    
    Implement methods `toString`, `equals`, `hashCode`.
    
    Move inner `class Sql` to top-level `class SqlPrettyWriterFixture`.
    
    Add `class ConnectionFactories`, utilities for `ConnectionFactory` and
    `CalciteAssert.ConnectionPostProcessor`.
    
    Enumerates all possible 'xxx' in JDBC `ResultSet.getXxx` and
    `PreparedStatement.setXxx` methods.
    
    Utilities for `interface SqlTester.ResultChecker`.
    
    Move `interface SqlOperatorTest.Fixture` to `SqlOperatorFixture`.
    
    In `class SqlOperatorFixture`, remove `double delta` arguments from
    methods that test floating-point values; instead use a `ResultChecker`
    created using a `ResultCheckers` method such as `isWithin` or
    `isExactly`.
    
    Remove method `withLibrary2`.
    
    Move `class SqlToRelConverterTest.RelValidityChecker` to top-level.
    
    In class `SqlLimitsTest`, move method `checkTypes` to
    `class SqlTests`.
    
    In a few cases we would built complex transforms (instances of
    `UnaryOperator`) that were applied just before the test ran. Now we
    try to apply transforms early, storing a transformed config rather
    than a chained transform. It's easier to understand and debug.
    
    Remove method `RelDataTypeSystemImpl.allowExtendedTrim`, which was
    added in [CALCITE-2571] but was never used.
    
    Remove some uses of `assert` in `TypeCoercionTest`. (Never use
    `assert` in tests!)
    
    Use `Assertions.assertEquals`, `Objects.requireNonNull` via static import.
    
    In `class SqlValidator.Config`, rename method `sqlConformance()` to
    `conformance()`, to be consistent with conformance properties
    elsewhere.
    
    In `class TryThreadLocal`, add methods `letIn(T, Supplier)` and
    `letIn(T, Runnable)`.
    
    Close apache/calcite#2685
---
 .../org/apache/calcite/test/BabelParserTest.java   |    95 +-
 .../java/org/apache/calcite/test/BabelTest.java    |    32 +
 .../java/org/apache/calcite/test/package-info.java |    21 +-
 .../apache/calcite/jdbc/CalciteConnectionImpl.java |    23 +-
 .../java/org/apache/calcite/plan/RelOptUtil.java   |     4 +-
 .../apache/calcite/prepare/CalcitePrepareImpl.java |    13 +-
 .../org/apache/calcite/prepare/PlannerImpl.java    |     2 +-
 .../org/apache/calcite/rel/RelValidityChecker.java |    65 +
 .../calcite/rel/type/RelDataTypeSystemImpl.java    |     4 -
 .../java/org/apache/calcite/sql/SqlDialect.java    |    44 +-
 .../org/apache/calcite/sql/SqlUnnestOperator.java  |     2 +-
 .../apache/calcite/sql/parser/StringAndPos.java    |    18 +
 .../apache/calcite/sql/validate/OrderByScope.java  |     2 +-
 .../apache/calcite/sql/validate/SqlValidator.java  |    23 +-
 .../calcite/sql/validate/SqlValidatorImpl.java     |    28 +-
 .../apache/calcite/sql2rel/SqlToRelConverter.java  |    10 +-
 .../calcite/sql2rel/StandardConvertletTable.java   |     2 +-
 .../java/org/apache/calcite/tools/RelRunner.java   |     8 +-
 .../java/org/apache/calcite/util/JdbcType.java     |    53 +
 .../java/org/apache/calcite/util/JdbcTypeImpl.java |   118 +
 .../main/java/org/apache/calcite/util/Sarg.java    |    18 +-
 .../org/apache/calcite/util/TryThreadLocal.java    |    59 +-
 .../calcite/jdbc/CalciteRemoteDriverTest.java      |    46 +-
 .../org/apache/calcite/plan/RelWriterTest.java     |     2 +-
 .../plan/volcano/MultipleTraitConversionTest.java  |     2 +-
 .../calcite/plan/volcano/VolcanoPlannerTest.java   |     2 +-
 .../RelMetadataHandlerGeneratorUtilTest.java       |    55 +-
 .../calcite/rel/rel2sql/RelToSqlConverterTest.java |    22 +-
 .../apache/calcite/sql/parser/SqlUnParserTest.java |     9 +-
 .../ExtensionSqlParserTest.java                    |     7 +-
 .../apache/calcite/sql/test/DocumentationTest.java |     2 +-
 .../apache/calcite/sql/test/SqlAdvisorTest.java    |  1210 +--
 .../calcite/sql/test/SqlOperatorBaseTest.java      | 10490 -------------------
 .../apache/calcite/sql/test/SqlOperatorTest.java   |    36 -
 .../calcite/sql/test/SqlPrettyWriterFixture.java   |   185 +
 .../calcite/sql/test/SqlPrettyWriterTest.java      |   149 +-
 .../apache/calcite/sql/type/SqlTypeUtilTest.java   |     4 +-
 .../calcite/sql/validate/SqlValidatorUtilTest.java |    10 +-
 .../calcite/test/CalciteSqlOperatorTest.java       |    11 +-
 .../apache/calcite/test/CoreSqlOperatorTest.java   |    13 +-
 .../org/apache/calcite/test/HepPlannerTest.java    |    82 +-
 .../org/apache/calcite/test/InterpreterTest.java   |    18 +-
 .../org/apache/calcite/test/JdbcAdapterTest.java   |     2 +-
 .../java/org/apache/calcite/test/JdbcTest.java     |    45 +-
 .../calcite/test/MaterializedViewFixture.java      |   115 +
 .../test/MaterializedViewRelOptRulesTest.java      |   313 +-
 .../MaterializedViewSubstitutionVisitorTest.java   |   275 +-
 ...edViewTest.java => MaterializedViewTester.java} |   162 +-
 .../org/apache/calcite/test/MutableRelTest.java    |    19 +-
 ...ratorTest.java => ProxyingRelMetadataTest.java} |    14 +-
 .../org/apache/calcite/test/RelBuilderTest.java    |     1 -
 .../org/apache/calcite/test/RelMetadataTest.java   |  2956 ++----
 .../org/apache/calcite/test/RelOptRulesTest.java   |   758 +-
 .../org/apache/calcite/test/RelOptTestBase.java    |   345 -
 .../apache/calcite/test/RexTransformerTest.java    |     4 +-
 .../calcite/test/RuleMatchVisualizerTest.java      |    24 +-
 .../apache/calcite/test/ScannableTableTest.java    |     2 +-
 .../apache/calcite/test/SqlHintsConverterTest.java |   195 +-
 .../org/apache/calcite/test/SqlLimitsTest.java     |    35 +-
 .../java/org/apache/calcite/test/SqlTestGen.java   |   120 +-
 .../apache/calcite/test/SqlToRelConverterTest.java |   594 +-
 .../org/apache/calcite/test/SqlToRelTestBase.java  |  1107 --
 .../apache/calcite/test/SqlValidatorDynamicTest.kt |    21 +-
 .../calcite/test/SqlValidatorFeatureTest.java      |     8 +-
 .../org/apache/calcite/test/SqlValidatorTest.java  |  1024 +-
 .../org/apache/calcite/test/TCatalogReader.java    |    81 +
 .../org/apache/calcite/test/TopDownOptTest.java    |   601 +-
 .../calcite/test/TypeCoercionConverterTest.java    |    53 +-
 .../org/apache/calcite/test/TypeCoercionTest.java  |   956 +-
 .../EnumerableBatchNestedLoopJoinTest.java         |     6 +-
 .../test/enumerable/EnumerableCalcTest.java        |     2 -
 .../test/enumerable/EnumerableCorrelateTest.java   |     3 -
 .../test/enumerable/EnumerableHashJoinTest.java    |     3 +-
 .../test/enumerable/EnumerableJoinTest.java        |     8 +-
 .../EnumerableRepeatUnionHierarchyTest.java        |     1 -
 .../test/enumerable/EnumerableRepeatUnionTest.java |     6 -
 .../enumerable/EnumerableStringComparisonTest.java |     4 -
 .../java/org/apache/calcite/tools/PlannerTest.java |     2 +-
 .../java/org/apache/calcite/util/UtilTest.java     |    37 +
 core/src/test/resources/log4j2-test.xml            |     2 +-
 .../org/apache/calcite/test/RelOptRulesTest.xml    |    52 +-
 .../apache/calcite/test/SqlHintsConverterTest.xml  |    31 +
 .../apache/calcite/test/SqlToRelConverterTest.xml  |    38 +-
 .../org/apache/calcite/test/DruidAdapter2IT.java   |    39 +-
 .../org/apache/calcite/test/DruidAdapterIT.java    |    19 +-
 .../adapter/elasticsearch/AggregationTest.java     |   121 +-
 .../adapter/elasticsearch/BooleanLogicTest.java    |    41 +-
 .../elasticsearch/ElasticSearchAdapterTest.java    |    92 +-
 .../calcite/adapter/elasticsearch/MatchTest.java   |    42 +-
 .../adapter/elasticsearch/Projection2Test.java     |   112 +-
 .../adapter/elasticsearch/ProjectionTest.java      |    83 +-
 .../adapter/elasticsearch/ScrollingTest.java       |    22 +-
 .../adapter/geode/rel/GeodeAllDataTypesTest.java   |    27 +-
 .../adapter/geode/rel/GeodeBookstoreTest.java      |    24 +-
 .../calcite/adapter/geode/rel/GeodeZipsTest.java   |    34 +-
 .../org/apache/calcite/test/ServerParserTest.java  |     7 +-
 .../java/org/apache/calcite/test/ServerTest.java   |     2 +-
 .../apache/calcite/test/ServerUnParserTest.java    |    11 +-
 testkit/build.gradle.kts                           |     3 +
 .../calcite/sql/parser/SqlParserFixture.java       |   212 +
 .../calcite/sql/parser/SqlParserListFixture.java   |    62 +
 .../apache/calcite/sql/parser/SqlParserTest.java   |   857 +-
 .../apache/calcite/sql/test/AbstractSqlTester.java |   645 +-
 .../apache/calcite/sql/test/ResultCheckers.java    |   320 +
 .../calcite/sql/test/SqlOperatorFixture.java       |   644 ++
 .../apache/calcite/sql/test/SqlTestFactory.java    |   405 +-
 .../org/apache/calcite/sql/test/SqlTester.java     |   394 +-
 .../java/org/apache/calcite/sql/test/SqlTests.java |   267 +-
 .../calcite/sql/test/SqlValidatorTester.java       |    31 +-
 .../org/apache/calcite/test/CalciteAssert.java     |   417 +-
 .../apache/calcite/test/ConnectionFactories.java   |   222 +
 .../org/apache/calcite/test/ConnectionFactory.java |    51 +
 .../org/apache/calcite/test/DiffRepository.java    |    41 +-
 .../java/org/apache/calcite/test/Fixtures.java     |    59 +
 .../java/org/apache/calcite/test/Matchers.java     |    96 +-
 .../org/apache/calcite/test/MockRelOptPlanner.java |    35 +-
 .../apache/calcite/test/RelMetadataFixture.java    |   597 ++
 .../org/apache/calcite/test/RelOptFixture.java     |   438 +
 .../org/apache/calcite/test/RelOptTestBase.java    |    28 +-
 .../java/org/apache/calcite/test/RelSupplier.java  |   138 +
 .../calcite/test/SqlOperatorFixtureImpl.java       |   275 +
 .../org/apache/calcite/test/SqlOperatorTest.java   |  8839 ++++++++++++++++
 .../org/apache/calcite}/test/SqlRuntimeTester.java |    50 +-
 .../org/apache/calcite/test/SqlToRelFixture.java   |   206 +
 .../org/apache/calcite/test/SqlToRelTestBase.java  |   103 +
 .../apache/calcite/test/SqlValidatorFixture.java   |   435 +
 .../apache/calcite/test/SqlValidatorTestCase.java  |   427 +-
 .../calcite/test/catalog/MockCatalogReader.java    |     6 +-
 .../test/catalog/MockCatalogReaderDynamic.java     |    15 +-
 .../test/catalog/MockCatalogReaderExtended.java    |    15 +-
 .../test/catalog/MockCatalogReaderSimple.java      |    15 +-
 .../java/org/apache/calcite/test/FixtureTest.java  |   232 +
 .../org/apache/calcite/test/FixtureTest.xml        |    56 +
 133 files changed, 19965 insertions(+), 20371 deletions(-)

diff --git a/babel/src/test/java/org/apache/calcite/test/BabelParserTest.java b/babel/src/test/java/org/apache/calcite/test/BabelParserTest.java
index 8ad35d7..377b71b 100644
--- a/babel/src/test/java/org/apache/calcite/test/BabelParserTest.java
+++ b/babel/src/test/java/org/apache/calcite/test/BabelParserTest.java
@@ -20,7 +20,7 @@ import org.apache.calcite.sql.SqlDialect;
 import org.apache.calcite.sql.dialect.MysqlSqlDialect;
 import org.apache.calcite.sql.parser.SqlAbstractParserImpl;
 import org.apache.calcite.sql.parser.SqlParser;
-import org.apache.calcite.sql.parser.SqlParserImplFactory;
+import org.apache.calcite.sql.parser.SqlParserFixture;
 import org.apache.calcite.sql.parser.SqlParserTest;
 import org.apache.calcite.sql.parser.StringAndPos;
 import org.apache.calcite.sql.parser.babel.SqlBabelParserImpl;
@@ -28,6 +28,7 @@ import org.apache.calcite.tools.Hoist;
 
 import com.google.common.base.Throwables;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 
@@ -43,8 +44,10 @@ import static org.hamcrest.MatcherAssert.assertThat;
  */
 class BabelParserTest extends SqlParserTest {
 
-  @Override protected SqlParserImplFactory parserImplFactory() {
-    return SqlBabelParserImpl.FACTORY;
+  @Override public SqlParserFixture fixture() {
+    return super.fixture()
+        .withTester(new BabelTesterImpl())
+        .withConfig(c -> c.withParserFactory(SqlBabelParserImpl.FACTORY));
   }
 
   @Test void testReservedWords() {
@@ -56,7 +59,7 @@ class BabelParserTest extends SqlParserTest {
    * <p>Copy-pasted from base method, but with some key differences.
    */
   @Override @Test protected void testMetadata() {
-    SqlAbstractParserImpl.Metadata metadata = getSqlParser("").getMetadata();
+    SqlAbstractParserImpl.Metadata metadata = fixture().parser().getMetadata();
     assertThat(metadata.isReservedFunctionName("ABS"), is(true));
     assertThat(metadata.isReservedFunctionName("FOO"), is(false));
 
@@ -195,49 +198,6 @@ class BabelParserTest extends SqlParserTest {
             + "'yyyy-MM-dd HH:mm:ss'"); // PostgreSQL gives 1969-07-20 23:00:00
   }
 
-  /**
-   * Babel parser's global {@code LOOKAHEAD} is larger than the core
-   * parser's. This causes different parse error message between these two
-   * parsers. Here we define a looser error checker for Babel, so that we can
-   * reuse failure testing codes from {@link SqlParserTest}.
-   *
-   * <p>If a test case is written in this file -- that is, not inherited -- it
-   * is still checked by {@link SqlParserTest}'s checker.
-   */
-  @Override protected Tester getTester() {
-    return new TesterImpl() {
-      @Override protected void checkEx(String expectedMsgPattern,
-          StringAndPos sap, Throwable thrown) {
-        if (thrownByBabelTest(thrown)) {
-          super.checkEx(expectedMsgPattern, sap, thrown);
-        } else {
-          checkExNotNull(sap, thrown);
-        }
-      }
-
-      private boolean thrownByBabelTest(Throwable ex) {
-        Throwable rootCause = Throwables.getRootCause(ex);
-        StackTraceElement[] stackTrace = rootCause.getStackTrace();
-        for (StackTraceElement stackTraceElement : stackTrace) {
-          String className = stackTraceElement.getClassName();
-          if (Objects.equals(className, BabelParserTest.class.getName())) {
-            return true;
-          }
-        }
-        return false;
-      }
-
-      private void checkExNotNull(StringAndPos sap,
-          Throwable thrown) {
-        if (thrown == null) {
-          throw new AssertionError("Expected query to throw exception, "
-              + "but it did not; query [" + sap.sql
-              + "]");
-        }
-      }
-    };
-  }
-
   /** Tests parsing PostgreSQL-style "::" cast operator. */
   @Test void testParseInfixCast()  {
     checkParseInfixCast("integer");
@@ -320,4 +280,45 @@ class BabelParserTest extends SqlParserTest {
         + "and DATEADD(day, [4:DECIMAL:1], hiredate) > [5:DATE:2010-05-06]";
     assertThat(hoisted.substitute(SqlParserTest::varToStr), is(expected2));
   }
+
+  /**
+   * Babel parser's global {@code LOOKAHEAD} is larger than the core
+   * parser's. This causes different parse error message between these two
+   * parsers. Here we define a looser error checker for Babel, so that we can
+   * reuse failure testing codes from {@link SqlParserTest}.
+   *
+   * <p>If a test case is written in this file -- that is, not inherited -- it
+   * is still checked by {@link SqlParserTest}'s checker.
+   */
+  public static class BabelTesterImpl extends TesterImpl {
+    @Override protected void checkEx(String expectedMsgPattern,
+        StringAndPos sap, @Nullable Throwable thrown) {
+      if (thrown != null && thrownByBabelTest(thrown)) {
+        super.checkEx(expectedMsgPattern, sap, thrown);
+      } else {
+        checkExNotNull(sap, thrown);
+      }
+    }
+
+    private boolean thrownByBabelTest(Throwable ex) {
+      Throwable rootCause = Throwables.getRootCause(ex);
+      StackTraceElement[] stackTrace = rootCause.getStackTrace();
+      for (StackTraceElement stackTraceElement : stackTrace) {
+        String className = stackTraceElement.getClassName();
+        if (Objects.equals(className, BabelParserTest.class.getName())) {
+          return true;
+        }
+      }
+      return false;
+    }
+
+    private void checkExNotNull(StringAndPos sap,
+        @Nullable Throwable thrown) {
+      if (thrown == null) {
+        throw new AssertionError("Expected query to throw exception, "
+            + "but it did not; query [" + sap.sql
+            + "]");
+      }
+    }
+  }
 }
diff --git a/babel/src/test/java/org/apache/calcite/test/BabelTest.java b/babel/src/test/java/org/apache/calcite/test/BabelTest.java
index b46a164..0d686f8 100644
--- a/babel/src/test/java/org/apache/calcite/test/BabelTest.java
+++ b/babel/src/test/java/org/apache/calcite/test/BabelTest.java
@@ -17,6 +17,7 @@
 package org.apache.calcite.test;
 
 import org.apache.calcite.config.CalciteConnectionProperty;
+import org.apache.calcite.sql.parser.SqlParserFixture;
 import org.apache.calcite.sql.parser.babel.SqlBabelParserImpl;
 
 import org.junit.jupiter.api.Test;
@@ -97,4 +98,35 @@ class BabelTest {
           is(sqlType));
     }
   }
+
+  /** Tests that you can run tests via {@link Fixtures}. */
+  @Test void testFixtures() {
+    final SqlValidatorFixture v = Fixtures.forValidator();
+    v.withSql("select ^1 + date '2002-03-04'^")
+        .fails("(?s).*Cannot apply '\\+' to arguments of"
+            + " type '<INTEGER> \\+ <DATE>'.*");
+
+    v.withSql("select 1 + 2 as three")
+        .type("RecordType(INTEGER NOT NULL THREE) NOT NULL");
+
+    // 'as' as identifier is invalid with Core parser
+    final SqlParserFixture p = Fixtures.forParser();
+    p.sql("select ^as^ from t")
+        .fails("(?s)Encountered \"as\".*");
+
+    // 'as' as identifier is invalid if you use Babel's tester and Core parser
+    p.sql("select ^as^ from t")
+        .withTester(new BabelParserTest.BabelTesterImpl())
+        .fails("(?s)Encountered \"as\".*");
+
+    // 'as' as identifier is valid with Babel parser
+    p.withConfig(c -> c.withParserFactory(SqlBabelParserImpl.FACTORY))
+        .sql("select as from t")
+        .ok("SELECT `AS`\n"
+            + "FROM `T`");
+
+    // Postgres cast is invalid with core parser
+    p.sql("select 1 ^:^: integer as x")
+        .fails("(?s).*Encountered \":\" at .*");
+  }
 }
diff --git a/server/src/test/java/org/apache/calcite/test/ServerUnParserTest.java b/babel/src/test/java/org/apache/calcite/test/package-info.java
similarity index 65%
copy from server/src/test/java/org/apache/calcite/test/ServerUnParserTest.java
copy to babel/src/test/java/org/apache/calcite/test/package-info.java
index 33c7dcf..c06f789 100644
--- a/server/src/test/java/org/apache/calcite/test/ServerUnParserTest.java
+++ b/babel/src/test/java/org/apache/calcite/test/package-info.java
@@ -14,20 +14,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.apache.calcite.test;
 
 /**
- * Extension to {@link ServerParserTest} that ensures that every expression can
- * un-parse successfully.
+ * Tests for Calcite.
  */
-class ServerUnParserTest extends ServerParserTest {
-  //~ Methods ----------------------------------------------------------------
-
-  @Override protected Tester getTester() {
-    return new UnparsingTesterImpl();
-  }
+@DefaultQualifier(value = NonNull.class, locations = TypeUseLocation.FIELD)
+@DefaultQualifier(value = NonNull.class, locations = TypeUseLocation.PARAMETER)
+@DefaultQualifier(value = NonNull.class, locations = TypeUseLocation.RETURN)
+package org.apache.calcite.test;
 
-  @Override protected boolean isUnparserTest() {
-    return true;
-  }
-}
+import org.checkerframework.checker.nullness.qual.NonNull;
+import org.checkerframework.framework.qual.DefaultQualifier;
+import org.checkerframework.framework.qual.TypeUseLocation;
diff --git a/core/src/main/java/org/apache/calcite/jdbc/CalciteConnectionImpl.java b/core/src/main/java/org/apache/calcite/jdbc/CalciteConnectionImpl.java
index 8cc030e..03deda3 100644
--- a/core/src/main/java/org/apache/calcite/jdbc/CalciteConnectionImpl.java
+++ b/core/src/main/java/org/apache/calcite/jdbc/CalciteConnectionImpl.java
@@ -46,7 +46,6 @@ import org.apache.calcite.materialize.Lattice;
 import org.apache.calcite.materialize.MaterializationService;
 import org.apache.calcite.plan.RelOptUtil;
 import org.apache.calcite.prepare.CalciteCatalogReader;
-import org.apache.calcite.rel.RelNode;
 import org.apache.calcite.rel.type.DelegatingTypeSystem;
 import org.apache.calcite.rel.type.RelDataTypeSystem;
 import org.apache.calcite.runtime.Hook;
@@ -75,7 +74,6 @@ import com.google.common.collect.ImmutableMap;
 import org.checkerframework.checker.nullness.qual.Nullable;
 
 import java.lang.reflect.Type;
-import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.HashMap;
@@ -182,23 +180,10 @@ abstract class CalciteConnectionImpl
 
   @Override public <T> T unwrap(Class<T> iface) throws SQLException {
     if (iface == RelRunner.class) {
-      return iface.cast(new RelRunner() {
-        @Override public PreparedStatement prepareStatement(RelNode rel)
-            throws SQLException {
-            return prepareStatement_(CalcitePrepare.Query.of(rel),
-                ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY,
-                getHoldability());
-        }
-
-        @SuppressWarnings("deprecation")
-        @Override public PreparedStatement prepare(RelNode rel) {
-          try {
-            return prepareStatement(rel);
-          } catch (SQLException e) {
-            throw Util.throwAsRuntime(e);
-          }
-        }
-      });
+      return iface.cast((RelRunner) rel ->
+          prepareStatement_(CalcitePrepare.Query.of(rel),
+              ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY,
+              getHoldability()));
     }
     return super.unwrap(iface);
   }
diff --git a/core/src/main/java/org/apache/calcite/plan/RelOptUtil.java b/core/src/main/java/org/apache/calcite/plan/RelOptUtil.java
index 39e55c4..f1e8b13 100644
--- a/core/src/main/java/org/apache/calcite/plan/RelOptUtil.java
+++ b/core/src/main/java/org/apache/calcite/plan/RelOptUtil.java
@@ -2052,14 +2052,14 @@ public abstract class RelOptUtil {
 
   @Experimental
   public static void registerDefaultRules(RelOptPlanner planner,
-      boolean enableMaterialziations, boolean enableBindable) {
+      boolean enableMaterializations, boolean enableBindable) {
     if (CalciteSystemProperty.ENABLE_COLLATION_TRAIT.value()) {
       registerAbstractRelationalRules(planner);
     }
     registerAbstractRules(planner);
     registerBaseRules(planner);
 
-    if (enableMaterialziations) {
+    if (enableMaterializations) {
       registerMaterializationRules(planner);
     }
     if (enableBindable) {
diff --git a/core/src/main/java/org/apache/calcite/prepare/CalcitePrepareImpl.java b/core/src/main/java/org/apache/calcite/prepare/CalcitePrepareImpl.java
index d73f7fb..774319e 100644
--- a/core/src/main/java/org/apache/calcite/prepare/CalcitePrepareImpl.java
+++ b/core/src/main/java/org/apache/calcite/prepare/CalcitePrepareImpl.java
@@ -127,12 +127,13 @@ import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
-import java.util.Objects;
 import java.util.Set;
 
 import static org.apache.calcite.linq4j.Nullness.castNonNull;
 import static org.apache.calcite.util.Static.RESOURCE;
 
+import static java.util.Objects.requireNonNull;
+
 /**
  * Shit just got real.
  *
@@ -727,7 +728,7 @@ public class CalcitePrepareImpl implements CalcitePrepare {
     final CalciteConnectionConfig connectionConfig = context.config();
     final SqlValidator.Config config = SqlValidator.Config.DEFAULT
         .withLenientOperatorLookup(connectionConfig.lenientOperatorLookup())
-        .withSqlConformance(connectionConfig.conformance())
+        .withConformance(connectionConfig.conformance())
         .withDefaultNullCollation(connectionConfig.defaultNullCollation())
         .withIdentifierExpansion(true);
     return new CalciteSqlValidator(opTab, catalogReader, typeFactory,
@@ -1129,7 +1130,7 @@ public class CalcitePrepareImpl implements CalcitePrepare {
           internalParameters.put("_conformance", conformance);
           bindable = EnumerableInterpretable.toBindable(internalParameters,
               context.spark(), enumerable,
-              Objects.requireNonNull(prefer, "EnumerableRel.Prefer prefer"));
+              requireNonNull(prefer, "EnumerableRel.Prefer prefer"));
         } finally {
           CatalogReader.THREAD_LOCAL.remove();
         }
@@ -1145,8 +1146,8 @@ public class CalcitePrepareImpl implements CalcitePrepare {
 
       return new PreparedResultImpl(
           resultType,
-          Objects.requireNonNull(parameterRowType, "parameterRowType"),
-          Objects.requireNonNull(fieldOrigins, "fieldOrigins"),
+          requireNonNull(parameterRowType, "parameterRowType"),
+          requireNonNull(fieldOrigins, "fieldOrigins"),
           root.collation.getFieldCollations().isEmpty()
               ? ImmutableList.of()
               : ImmutableList.of(root.collation),
@@ -1258,7 +1259,7 @@ public class CalcitePrepareImpl implements CalcitePrepare {
         // Case-sensitive name match because name was previously resolved.
         MemberExpression memberExpression = (MemberExpression) expression;
         PseudoField field = memberExpression.field;
-        Expression targetExpression = Objects.requireNonNull(memberExpression.expression,
+        Expression targetExpression = requireNonNull(memberExpression.expression,
             () -> "static field access is not implemented yet."
                 + " field.name=" + field.getName()
                 + ", field.declaringClass=" + field.getDeclaringClass());
diff --git a/core/src/main/java/org/apache/calcite/prepare/PlannerImpl.java b/core/src/main/java/org/apache/calcite/prepare/PlannerImpl.java
index 0960b74..a16c5a8 100644
--- a/core/src/main/java/org/apache/calcite/prepare/PlannerImpl.java
+++ b/core/src/main/java/org/apache/calcite/prepare/PlannerImpl.java
@@ -338,7 +338,7 @@ public class PlannerImpl implements Planner, ViewExpander {
         sqlValidatorConfig
             .withDefaultNullCollation(connectionConfig.defaultNullCollation())
             .withLenientOperatorLookup(connectionConfig.lenientOperatorLookup())
-            .withSqlConformance(connectionConfig.conformance())
+            .withConformance(connectionConfig.conformance())
             .withIdentifierExpansion(true));
   }
 
diff --git a/core/src/main/java/org/apache/calcite/rel/RelValidityChecker.java b/core/src/main/java/org/apache/calcite/rel/RelValidityChecker.java
new file mode 100644
index 0000000..f30fa32
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/rel/RelValidityChecker.java
@@ -0,0 +1,65 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.rel;
+
+import org.apache.calcite.rel.core.CorrelationId;
+import org.apache.calcite.util.Litmus;
+
+import com.google.common.collect.ImmutableSet;
+
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.Set;
+
+/**
+ * Visitor that checks that every {@link RelNode} in a tree is valid.
+ *
+ * @see RelNode#isValid(Litmus, RelNode.Context)
+ */
+public class RelValidityChecker extends RelVisitor
+    implements RelNode.Context {
+  private int invalidCount;
+  private final Deque<RelNode> stack = new ArrayDeque<>();
+
+  @Override public Set<CorrelationId> correlationIds() {
+    final ImmutableSet.Builder<CorrelationId> builder =
+        ImmutableSet.builder();
+    for (RelNode r : stack) {
+      builder.addAll(r.getVariablesSet());
+    }
+    return builder.build();
+  }
+
+  @Override public void visit(RelNode node, int ordinal,
+      @Nullable RelNode parent) {
+    try {
+      stack.push(node);
+      if (!node.isValid(Litmus.THROW, this)) {
+        ++invalidCount;
+      }
+      super.visit(node, ordinal, parent);
+    } finally {
+      stack.pop();
+    }
+  }
+
+  public int invalidCount() {
+    return invalidCount;
+  }
+}
diff --git a/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeSystemImpl.java b/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeSystemImpl.java
index d6954c6..a817293 100644
--- a/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeSystemImpl.java
+++ b/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeSystemImpl.java
@@ -266,8 +266,4 @@ public abstract class RelDataTypeSystemImpl implements RelDataTypeSystem {
     return false;
   }
 
-  public boolean allowExtendedTrim() {
-    return false;
-  }
-
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlDialect.java b/core/src/main/java/org/apache/calcite/sql/SqlDialect.java
index 362f4fb..a6a7357 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlDialect.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlDialect.java
@@ -19,6 +19,7 @@ package org.apache.calcite.sql;
 import org.apache.calcite.avatica.util.Casing;
 import org.apache.calcite.avatica.util.Quoting;
 import org.apache.calcite.avatica.util.TimeUnit;
+import org.apache.calcite.config.CharLiteralStyle;
 import org.apache.calcite.config.NullCollation;
 import org.apache.calcite.linq4j.function.Experimental;
 import org.apache.calcite.rel.RelFieldCollation;
@@ -53,12 +54,13 @@ import java.sql.Timestamp;
 import java.text.SimpleDateFormat;
 import java.util.List;
 import java.util.Locale;
-import java.util.Objects;
 import java.util.Set;
 import java.util.function.Supplier;
 
 import static org.apache.calcite.util.DateTimeStringUtils.getDateFormatter;
 
+import static java.util.Objects.requireNonNull;
+
 /**
  * <code>SqlDialect</code> encapsulates the differences between dialects of SQL.
  *
@@ -206,16 +208,13 @@ public class SqlDialect {
    * @param context All the information necessary to create a dialect
    */
   public SqlDialect(Context context) {
-    this.nullCollation = Objects.requireNonNull(context.nullCollation());
-    this.dataTypeSystem = Objects.requireNonNull(context.dataTypeSystem());
-    this.databaseProduct =
-        Objects.requireNonNull(context.databaseProduct());
-    this.literalQuoteString =
-        Objects.requireNonNull(context.literalQuoteString());
-    this.literalEndQuoteString =
-        Objects.requireNonNull(context.literalQuoteString());
+    this.nullCollation = requireNonNull(context.nullCollation());
+    this.dataTypeSystem = requireNonNull(context.dataTypeSystem());
+    this.databaseProduct = requireNonNull(context.databaseProduct());
+    this.literalQuoteString = requireNonNull(context.literalQuoteString());
+    this.literalEndQuoteString = requireNonNull(context.literalQuoteString());
     this.literalEscapedQuote =
-        Objects.requireNonNull(context.literalEscapedQuoteString());
+        requireNonNull(context.literalEscapedQuoteString());
     String identifierQuoteString = context.identifierQuoteString();
     if (identifierQuoteString != null) {
       identifierQuoteString = identifierQuoteString.trim();
@@ -234,8 +233,8 @@ public class SqlDialect {
                 ? null
                 : this.identifierEndQuoteString + this.identifierEndQuoteString
             : context.identifierEscapedQuoteString();
-    this.unquotedCasing = Objects.requireNonNull(context.unquotedCasing());
-    this.quotedCasing = Objects.requireNonNull(context.quotedCasing());
+    this.unquotedCasing = requireNonNull(context.unquotedCasing());
+    this.quotedCasing = requireNonNull(context.quotedCasing());
     this.caseSensitive = context.caseSensitive();
   }
 
@@ -1133,7 +1132,8 @@ public class SqlDialect {
     return config.withQuotedCasing(getQuotedCasing())
         .withUnquotedCasing(getUnquotedCasing())
         .withCaseSensitive(isCaseSensitive())
-        .withConformance(getConformance());
+        .withConformance(getConformance())
+        .withCharLiteralStyles(ImmutableSet.of(CharLiteralStyle.STANDARD));
   }
 
   @Deprecated // to be removed before 2.0
@@ -1321,8 +1321,8 @@ public class SqlDialect {
     @SuppressWarnings("argument.type.incompatible")
     DatabaseProduct(String databaseProductName, @Nullable String quoteString,
         NullCollation nullCollation) {
-      Objects.requireNonNull(databaseProductName, "databaseProductName");
-      Objects.requireNonNull(nullCollation, "nullCollation");
+      requireNonNull(databaseProductName, "databaseProductName");
+      requireNonNull(nullCollation, "nullCollation");
       // Note: below lambda accesses uninitialized DatabaseProduct.this, so it might be
       // worth refactoring
       dialect = Suppliers.memoize(() -> {
@@ -1425,7 +1425,7 @@ public class SqlDialect {
         SqlConformance conformance, NullCollation nullCollation,
         RelDataTypeSystem dataTypeSystem,
         JethroDataSqlDialect.JethroInfo jethroInfo) {
-      this.databaseProduct = Objects.requireNonNull(databaseProduct, "databaseProduct");
+      this.databaseProduct = requireNonNull(databaseProduct, "databaseProduct");
       this.databaseProductName = databaseProductName;
       this.databaseVersion = databaseVersion;
       this.databaseMajorVersion = databaseMajorVersion;
@@ -1434,13 +1434,13 @@ public class SqlDialect {
       this.literalEscapedQuoteString = literalEscapedQuoteString;
       this.identifierQuoteString = identifierQuoteString;
       this.identifierEscapedQuoteString = identifierEscapedQuoteString;
-      this.quotedCasing = Objects.requireNonNull(quotedCasing, "quotedCasing");
-      this.unquotedCasing = Objects.requireNonNull(unquotedCasing, "unquotedCasing");
+      this.quotedCasing = requireNonNull(quotedCasing, "quotedCasing");
+      this.unquotedCasing = requireNonNull(unquotedCasing, "unquotedCasing");
       this.caseSensitive = caseSensitive;
-      this.conformance = Objects.requireNonNull(conformance, "conformance");
-      this.nullCollation = Objects.requireNonNull(nullCollation, "nullCollation");
-      this.dataTypeSystem = Objects.requireNonNull(dataTypeSystem, "dataTypeSystem");
-      this.jethroInfo = Objects.requireNonNull(jethroInfo, "jethroInfo");
+      this.conformance = requireNonNull(conformance, "conformance");
+      this.nullCollation = requireNonNull(nullCollation, "nullCollation");
+      this.dataTypeSystem = requireNonNull(dataTypeSystem, "dataTypeSystem");
+      this.jethroInfo = requireNonNull(jethroInfo, "jethroInfo");
     }
 
     @Override public DatabaseProduct databaseProduct() {
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlUnnestOperator.java b/core/src/main/java/org/apache/calcite/sql/SqlUnnestOperator.java
index 20356e6..d92eafe 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlUnnestOperator.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlUnnestOperator.java
@@ -106,7 +106,7 @@ public class SqlUnnestOperator extends SqlFunctionalOperator {
         && ((SqlCallBinding) operatorBinding)
         .getValidator()
         .config()
-        .sqlConformance()
+        .conformance()
         .allowAliasUnnestItems();
   }
 
diff --git a/core/src/main/java/org/apache/calcite/sql/parser/StringAndPos.java b/core/src/main/java/org/apache/calcite/sql/parser/StringAndPos.java
index d791465..3aaa5c5 100644
--- a/core/src/main/java/org/apache/calcite/sql/parser/StringAndPos.java
+++ b/core/src/main/java/org/apache/calcite/sql/parser/StringAndPos.java
@@ -18,6 +18,8 @@ package org.apache.calcite.sql.parser;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 
+import java.util.Objects;
+
 /**
  * Contains a string, the offset of a token within the string, and a parser
  * position containing the beginning and end line number.
@@ -33,6 +35,22 @@ public class StringAndPos {
     this.pos = pos;
   }
 
+  @Override public String toString() {
+    return addCarets();
+  }
+
+  @Override public int hashCode() {
+    return Objects.hash(sql, cursor);
+  }
+
+  @Override public boolean equals(@Nullable Object o) {
+    return o == this
+        || o instanceof StringAndPos
+        && sql.equals(((StringAndPos) o).sql)
+        && cursor == ((StringAndPos) o).cursor
+        && Objects.equals(pos, ((StringAndPos) o).pos);
+  }
+
   /**
    * Looks for one or two carets in a SQL string, and if present, converts
    * them into a parser position.
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/OrderByScope.java b/core/src/main/java/org/apache/calcite/sql/validate/OrderByScope.java
index 61d73f3..2b48c7d 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/OrderByScope.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/OrderByScope.java
@@ -73,7 +73,7 @@ public class OrderByScope extends DelegatingScope {
   @Override public SqlQualified fullyQualify(SqlIdentifier identifier) {
     // If it's a simple identifier, look for an alias.
     if (identifier.isSimple()
-        && validator.config().sqlConformance().isSortByAlias()) {
+        && validator.config().conformance().isSortByAlias()) {
       final String name = identifier.names.get(0);
       final SqlValidatorNamespace selectNs =
           validator.getNamespaceOrThrow(select);
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/SqlValidator.java b/core/src/main/java/org/apache/calcite/sql/validate/SqlValidator.java
index c798361..1143e0a 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/SqlValidator.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/SqlValidator.java
@@ -913,12 +913,25 @@ public interface SqlValidator {
 
     /** Returns the dialect of SQL (SQL:2003, etc.) this validator recognizes.
      * Default is {@link SqlConformanceEnum#DEFAULT}. */
-    @SuppressWarnings("deprecation")
-    @Value.Default default SqlConformance sqlConformance() {
-      return SqlConformance.DEFAULT;
+    @Value.Default default SqlConformance conformance() {
+      return SqlConformanceEnum.DEFAULT;
     }
 
-    /** Sets up the sql conformance of the validator. */
-    Config withSqlConformance(SqlConformance conformance);
+    /** Returns the SQL conformance.
+     * @deprecated Use {@link #conformance()} */
+    @Deprecated // to be removed before 2.0
+    default SqlConformance sqlConformance() {
+      return conformance();
+    }
+
+    /** Sets the SQL conformance of the validator. */
+    Config withConformance(SqlConformance conformance);
+
+    /** Sets the SQL conformance of the validator.
+     * @deprecated Use {@link #conformance()} */
+    @Deprecated // to be removed before 2.0
+    default Config withSqlConformance(SqlConformance conformance) {
+      return withConformance(conformance);
+    }
   }
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java b/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
index 99eb9f9..01c13c9 100644
--- a/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
+++ b/core/src/main/java/org/apache/calcite/sql/validate/SqlValidatorImpl.java
@@ -318,7 +318,7 @@ public class SqlValidatorImpl implements SqlValidatorWithHints {
   //~ Methods ----------------------------------------------------------------
 
   public SqlConformance getConformance() {
-    return config.sqlConformance();
+    return config.conformance();
   }
 
   @Pure
@@ -549,7 +549,7 @@ public class SqlValidatorImpl implements SqlValidatorWithHints {
 
     final SqlIdentifier identifier = (SqlIdentifier) selectItem;
     if (!identifier.isSimple()) {
-      if (!validator.config().sqlConformance().allowQualifyingCommonColumn()) {
+      if (!validator.config().conformance().allowQualifyingCommonColumn()) {
         validateQualifiedCommonColumn((SqlJoin) from, identifier, scope, validator);
       }
       return selectItem;
@@ -3492,7 +3492,7 @@ public class SqlValidatorImpl implements SqlValidatorWithHints {
     // a NATURAL keyword?
     switch (joinType) {
     case LEFT_SEMI_JOIN:
-      if (!this.config.sqlConformance().isLiberal()) {
+      if (!this.config.conformance().isLiberal()) {
         throw newValidationError(join.getJoinTypeNode(),
             RESOURCE.dialectDoesNotSupportFeature("LEFT SEMI JOIN"));
       }
@@ -3632,7 +3632,7 @@ public class SqlValidatorImpl implements SqlValidatorWithHints {
     }
 
     if (select.getFrom() == null) {
-      if (this.config.sqlConformance().isFromRequired()) {
+      if (this.config.conformance().isFromRequired()) {
         throw newValidationError(select, RESOURCE.selectMissingFrom());
       }
     } else {
@@ -4357,7 +4357,7 @@ public class SqlValidatorImpl implements SqlValidatorWithHints {
     }
     final AggregatingScope havingScope =
         (AggregatingScope) getSelectScope(select);
-    if (config.sqlConformance().isHavingAlias()) {
+    if (config.conformance().isHavingAlias()) {
       SqlNode newExpr = expandGroupByOrHavingExpr(having, havingScope, select, true);
       if (having != newExpr) {
         having = newExpr;
@@ -4823,7 +4823,7 @@ public class SqlValidatorImpl implements SqlValidatorWithHints {
       RelDataType targetRowType,
       SqlInsert insert) {
     if (insert.getTargetColumnList() == null
-        && this.config.sqlConformance().isInsertSubsetColumnsAllowed()) {
+        && this.config.conformance().isInsertSubsetColumnsAllowed()) {
       // Target an implicit subset of columns.
       final SqlNode source = insert.getSource();
       final RelDataType sourceRowType = getNamespaceOrThrow(source).getRowType();
@@ -5139,7 +5139,7 @@ public class SqlValidatorImpl implements SqlValidatorWithHints {
       }
 
       SqlCall rowConstructor = (SqlCall) operand;
-      if (this.config.sqlConformance().isInsertSubsetColumnsAllowed()
+      if (this.config.conformance().isInsertSubsetColumnsAllowed()
           && targetRowType.isStruct()
           && rowConstructor.operandCount() < targetRowType.getFieldCount()) {
         targetRowType =
@@ -5742,7 +5742,7 @@ public class SqlValidatorImpl implements SqlValidatorWithHints {
     // What columns from the input are not referenced by a column in the IN
     // list?
     final SqlValidatorNamespace inputNs =
-        Objects.requireNonNull(getNamespace(unpivot.query));
+        requireNonNull(getNamespace(unpivot.query));
     final Set<String> unusedColumnNames =
         catalogReader.nameMatcher().createSet();
     unusedColumnNames.addAll(inputNs.getRowType().getFieldNames());
@@ -5950,7 +5950,7 @@ public class SqlValidatorImpl implements SqlValidatorWithHints {
     if ((call.operandCount() == 0)
         && (operator.getSyntax() == SqlSyntax.FUNCTION_ID)
         && !call.isExpanded()
-        && !this.config.sqlConformance().allowNiladicParentheses()) {
+        && !this.config.conformance().allowNiladicParentheses()) {
       // For example, "LOCALTIME()" is illegal. (It should be
       // "LOCALTIME", which would have been handled as a
       // SqlIdentifier.)
@@ -6479,7 +6479,7 @@ public class SqlValidatorImpl implements SqlValidatorWithHints {
       // Ordinal markers, e.g. 'select a, b from t order by 2'.
       // Only recognize them if they are the whole expression,
       // and if the dialect permits.
-      if (literal == root && config.sqlConformance().isSortByOrdinal()) {
+      if (literal == root && config.conformance().isSortByOrdinal()) {
         switch (literal.getTypeName()) {
         case DECIMAL:
         case DOUBLE:
@@ -6530,7 +6530,7 @@ public class SqlValidatorImpl implements SqlValidatorWithHints {
     @Override public SqlNode visit(SqlIdentifier id) {
       // Aliases, e.g. 'select a as x, b from t order by x'.
       if (id.isSimple()
-          && config.sqlConformance().isSortByAlias()) {
+          && config.conformance().isSortByAlias()) {
         String alias = id.getSimple();
         final SqlValidatorNamespace selectNs = getNamespaceOrThrow(select);
         final RelDataType rowType =
@@ -6602,8 +6602,8 @@ public class SqlValidatorImpl implements SqlValidatorWithHints {
     @Override public @Nullable SqlNode visit(SqlIdentifier id) {
       if (id.isSimple()
           && (havingExpr
-              ? validator.config().sqlConformance().isHavingAlias()
-              : validator.config().sqlConformance().isGroupByAlias())) {
+              ? validator.config().conformance().isHavingAlias()
+              : validator.config().conformance().isGroupByAlias())) {
         String name = id.getSimple();
         SqlNode expr = null;
         final SqlNameMatcher nameMatcher =
@@ -6645,7 +6645,7 @@ public class SqlValidatorImpl implements SqlValidatorWithHints {
     }
 
     @Override public @Nullable SqlNode visit(SqlLiteral literal) {
-      if (havingExpr || !validator.config().sqlConformance().isGroupByOrdinal()) {
+      if (havingExpr || !validator.config().conformance().isGroupByOrdinal()) {
         return super.visit(literal);
       }
       boolean isOrdinalLiteral = literal == root;
diff --git a/core/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java b/core/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java
index e6e79c7..673c6ac 100644
--- a/core/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java
+++ b/core/src/main/java/org/apache/calcite/sql2rel/SqlToRelConverter.java
@@ -224,7 +224,7 @@ public class SqlToRelConverter {
   //~ Static fields/initializers ---------------------------------------------
 
   /** Default configuration. */
-  private static final Config CONFIG =
+  public static final Config CONFIG =
       ImmutableSqlToRelConverter.Config.builder()
           .withRelBuilderFactory(RelFactories.LOGICAL_BUILDER)
           .withRelBuilderConfigTransform(c -> c.withPushJoinCondition(true))
@@ -244,7 +244,7 @@ public class SqlToRelConverter {
 
   //~ Instance fields --------------------------------------------------------
 
-  protected final @Nullable SqlValidator validator;
+  public final @Nullable SqlValidator validator;
   protected final RexBuilder rexBuilder;
   protected final Prepare.CatalogReader catalogReader;
   protected final RelOptCluster cluster;
@@ -536,7 +536,7 @@ public class SqlToRelConverter {
    */
   public RelNode trimUnusedFields(boolean ordered, RelNode rootRel) {
     // Trim fields that are not used by their consumer.
-    if (isTrimUnusedFields()) {
+    if (config.isTrimUnusedFields()) {
       final RelFieldTrimmer trimmer = newFieldTrimmer();
       final List<RelCollation> collations =
           rootRel.getTraitSet().getTraits(RelCollationTraitDef.INSTANCE);
@@ -2256,7 +2256,7 @@ public class SqlToRelConverter {
     RelNode child =
         (null != bb.root) ? bb.root : LogicalValues.createOneRow(cluster);
     RelNode uncollect;
-    if (validator().config().sqlConformance().allowAliasUnnestItems()) {
+    if (validator().config().conformance().allowAliasUnnestItems()) {
       uncollect = relBuilder
           .push(child)
           .project(exprs)
@@ -3897,7 +3897,7 @@ public class SqlToRelConverter {
     final RelDataType tableRowType = targetTable.getRowType();
     SqlNodeList targetColumnList = call.getTargetColumnList();
     if (targetColumnList == null) {
-      if (validator().config().sqlConformance().isInsertSubsetColumnsAllowed()) {
+      if (validator().config().conformance().isInsertSubsetColumnsAllowed()) {
         final RelDataType targetRowType =
             typeFactory.createStructType(
                 tableRowType.getFieldList()
diff --git a/core/src/main/java/org/apache/calcite/sql2rel/StandardConvertletTable.java b/core/src/main/java/org/apache/calcite/sql2rel/StandardConvertletTable.java
index 35be3ec..a899677 100644
--- a/core/src/main/java/org/apache/calcite/sql2rel/StandardConvertletTable.java
+++ b/core/src/main/java/org/apache/calcite/sql2rel/StandardConvertletTable.java
@@ -1143,7 +1143,7 @@ public class StandardConvertletTable extends ReflectiveConvertletTable {
       SqlSubstringFunction op,
       SqlCall call) {
     final SqlLibrary library =
-        cx.getValidator().config().sqlConformance().semantics();
+        cx.getValidator().config().conformance().semantics();
     final SqlBasicCall basicCall = (SqlBasicCall) call;
     switch (library) {
     case BIG_QUERY:
diff --git a/core/src/main/java/org/apache/calcite/tools/RelRunner.java b/core/src/main/java/org/apache/calcite/tools/RelRunner.java
index b1dad24..bd6e659 100644
--- a/core/src/main/java/org/apache/calcite/tools/RelRunner.java
+++ b/core/src/main/java/org/apache/calcite/tools/RelRunner.java
@@ -29,15 +29,9 @@ import java.sql.SQLException;
  * @see RelRunners
  */
 public interface RelRunner {
-  /** Prepares a statement based on a relational expression. */
-  @Deprecated // to be removed before 1.28
-  PreparedStatement prepare(RelNode rel);
-
   /** Prepares a statement based on a relational expression.
    *
    * @param rel Relational expression
    * @throws SQLException on error */
-  default PreparedStatement prepareStatement(RelNode rel) throws SQLException {
-    return prepare(rel);
-  }
+  PreparedStatement prepareStatement(RelNode rel) throws SQLException;
 }
diff --git a/core/src/main/java/org/apache/calcite/util/JdbcType.java b/core/src/main/java/org/apache/calcite/util/JdbcType.java
new file mode 100644
index 0000000..eb5d264
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/util/JdbcType.java
@@ -0,0 +1,53 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.util;
+
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+import java.math.BigDecimal;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+/**
+ * Maps Java types to their corresponding getters in JDBC.
+ *
+ * <p>In future we could add more types,
+ * and add more methods
+ * (e.g. {@link java.sql.PreparedStatement#setInt(int, int)}).
+ *
+ * @param <T> Value type
+ */
+@SuppressWarnings("unchecked")
+public interface JdbcType<T extends @Nullable Object> {
+  JdbcType<Boolean> BOOLEAN = JdbcTypeImpl.BOOLEAN;
+  JdbcType<@Nullable Boolean> BOOLEAN_NULLABLE = JdbcTypeImpl.BOOLEAN_NULLABLE;
+  JdbcType<BigDecimal> BIG_DECIMAL = JdbcTypeImpl.BIG_DECIMAL;
+  JdbcType<@Nullable BigDecimal> BIG_DECIMAL_NULLABLE =
+      JdbcTypeImpl.BIG_DECIMAL_NULLABLE;
+  JdbcType<Double> DOUBLE = JdbcTypeImpl.DOUBLE;
+  JdbcType<@Nullable Double> DOUBLE_NULLABLE = JdbcTypeImpl.DOUBLE_NULLABLE;
+  JdbcType<Integer> INTEGER = JdbcTypeImpl.INTEGER;
+  JdbcType<@Nullable Integer> INTEGER_NULLABLE = JdbcTypeImpl.INTEGER_NULLABLE;
+  JdbcType<String> STRING = JdbcTypeImpl.STRING;
+  JdbcType<@Nullable String> STRING_NULLABLE = JdbcTypeImpl.STRING_NULLABLE;
+
+  /** Returns the value of column {@code column} from a JDBC result set.
+   *
+   * <p>For example, {@code INTEGER.get(i, resultSet)} calls
+   * {@link ResultSet#getInt(int)}. */
+  T get(int column, ResultSet resultSet) throws SQLException;
+}
diff --git a/core/src/main/java/org/apache/calcite/util/JdbcTypeImpl.java b/core/src/main/java/org/apache/calcite/util/JdbcTypeImpl.java
new file mode 100644
index 0000000..6cff5d6
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/util/JdbcTypeImpl.java
@@ -0,0 +1,118 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.util;
+
+import com.google.common.base.Preconditions;
+
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+import java.math.BigDecimal;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+import static java.util.Objects.requireNonNull;
+
+/**
+ * Implementation of {@link JdbcType}.
+ *
+ * <p>It is frustrating that we can't use an {@code enum} to implement an
+ * interface with a type parameter. At times like this, we wish Java had
+ * Generalized Algebraic Data Types (GADTs). */
+@SuppressWarnings("rawtypes")
+enum JdbcTypeImpl implements JdbcType {
+  BIG_DECIMAL(BigDecimal.class, false) {
+    @Override public BigDecimal get(int column,
+        ResultSet resultSet) throws SQLException {
+      return requireNonNull(resultSet.getBigDecimal(column), "getBigDecimal");
+    }
+  },
+
+  BIG_DECIMAL_NULLABLE(BigDecimal.class, true) {
+    @Override public @Nullable BigDecimal get(int column,
+        ResultSet resultSet) throws SQLException {
+      return resultSet.getBigDecimal(column);
+    }
+  },
+
+  BOOLEAN(Boolean.class, false) {
+    @Override public Boolean get(int column,
+        ResultSet resultSet) throws SQLException {
+      boolean v = resultSet.getBoolean(column);
+      Preconditions.checkArgument(v || !resultSet.wasNull());
+      return v;
+    }
+  },
+
+  BOOLEAN_NULLABLE(Boolean.class, true) {
+    @Override public @Nullable Boolean get(int column,
+        ResultSet resultSet) throws SQLException {
+      boolean v = resultSet.getBoolean(column);
+      return !v && resultSet.wasNull() ? null : v;
+    }
+  },
+
+  DOUBLE(Double.class, false) {
+    @Override public Double get(int column,
+        ResultSet resultSet) throws SQLException {
+      double v = resultSet.getDouble(column);
+      Preconditions.checkArgument(v != 0 || !resultSet.wasNull());
+      return v;
+    }
+  },
+
+  DOUBLE_NULLABLE(Double.class, true) {
+    @Override public @Nullable Double get(int column,
+        ResultSet resultSet) throws SQLException {
+      double v = resultSet.getDouble(column);
+      return v == 0 && resultSet.wasNull() ? null : v;
+    }
+  },
+
+  INTEGER(Integer.class, false) {
+    @Override public Integer get(int column,
+        ResultSet resultSet) throws SQLException {
+      int v = resultSet.getInt(column);
+      Preconditions.checkArgument(v != 0 || !resultSet.wasNull());
+      return v;
+    }
+  },
+
+  INTEGER_NULLABLE(Integer.class, true) {
+    @Override public @Nullable Integer get(int column,
+        ResultSet resultSet) throws SQLException {
+      int v = resultSet.getInt(column);
+      return v == 0 && resultSet.wasNull() ? null : v;
+    }
+  },
+
+  STRING(String.class, false) {
+    @Override public String get(int column,
+        ResultSet resultSet) throws SQLException {
+      return requireNonNull(resultSet.getString(column), "getString");
+    }
+  },
+
+  STRING_NULLABLE(String.class, true) {
+    @Override public @Nullable String get(int column,
+        ResultSet resultSet) throws SQLException {
+      return resultSet.getString(column);
+    }
+  };
+
+  JdbcTypeImpl(Class<?> unusedClass, boolean unusedNullable) {
+  }
+}
diff --git a/core/src/main/java/org/apache/calcite/util/Sarg.java b/core/src/main/java/org/apache/calcite/util/Sarg.java
index ef3822c..93112cd 100644
--- a/core/src/main/java/org/apache/calcite/util/Sarg.java
+++ b/core/src/main/java/org/apache/calcite/util/Sarg.java
@@ -27,9 +27,10 @@ import com.google.common.collect.RangeSet;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 
-import java.util.Objects;
 import java.util.function.BiConsumer;
 
+import static java.util.Objects.requireNonNull;
+
 /** Set of values (or ranges) that are the target of a search.
  *
  * <p>The name is derived from <b>S</b>earch <b>arg</b>ument, an ancient
@@ -68,8 +69,6 @@ import java.util.function.BiConsumer;
 public class Sarg<C extends Comparable<C>> implements Comparable<Sarg<C>> {
   public final RangeSet<C> rangeSet;
   public final RexUnknownAs nullAs;
-  @Deprecated // to be removed before 1.28
-  public final boolean containsNull;
   public final int pointCount;
 
   /** Returns FALSE for all null and not-null values.
@@ -116,9 +115,8 @@ public class Sarg<C extends Comparable<C>> implements Comparable<Sarg<C>> {
           "Sarg[=]", 7);
 
   private Sarg(ImmutableRangeSet<C> rangeSet, RexUnknownAs nullAs) {
-    this.rangeSet = Objects.requireNonNull(rangeSet, "rangeSet");
-    this.nullAs = Objects.requireNonNull(nullAs, "nullAs");
-    this.containsNull = nullAs == RexUnknownAs.TRUE;
+    this.rangeSet = requireNonNull(rangeSet, "rangeSet");
+    this.nullAs = requireNonNull(nullAs, "nullAs");
     this.pointCount = RangeSets.countPoints(rangeSet);
   }
 
@@ -227,8 +225,9 @@ public class Sarg<C extends Comparable<C>> implements Comparable<Sarg<C>> {
     return false;
   }
 
-  /** Returns whether this Sarg is a collection of 1 or more points (and perhaps
-   * an {@code IS NULL} if {@link #containsNull}).
+  /** Returns whether this Sarg is a collection of 1 or more
+   * points (and perhaps an {@code IS NULL} if
+   * {@code nullAs == RexUnknownAs.TRUE}).
    *
    * <p>Such sargs could be translated as {@code ref = value}
    * or {@code ref IN (value1, ...)}. */
@@ -237,7 +236,8 @@ public class Sarg<C extends Comparable<C>> implements Comparable<Sarg<C>> {
   }
 
   /** Returns whether this Sarg, when negated, is a collection of 1 or more
-   * points (and perhaps an {@code IS NULL} if {@link #containsNull}).
+   * points (and perhaps an {@code IS NULL} if
+   * {@code nullAs == RexUnknownAs.TRUE}).
    *
    * <p>Such sargs could be translated as {@code ref <> value}
    * or {@code ref NOT IN (value1, ...)}. */
diff --git a/core/src/main/java/org/apache/calcite/util/TryThreadLocal.java b/core/src/main/java/org/apache/calcite/util/TryThreadLocal.java
index b8ff5d7..ac58e2b 100644
--- a/core/src/main/java/org/apache/calcite/util/TryThreadLocal.java
+++ b/core/src/main/java/org/apache/calcite/util/TryThreadLocal.java
@@ -18,6 +18,8 @@ package org.apache.calcite.util;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
 
+import java.util.function.Supplier;
+
 /**
  * Thread-local variable that returns a handle that can be closed.
  *
@@ -52,13 +54,58 @@ public class TryThreadLocal<@Nullable T> extends ThreadLocal<T> {
   public Memo push(T value) {
     final T previous = get();
     set(value);
-    return () -> {
-      if (previous == initialValue) {
-        remove();
-      } else {
-        set(previous);
+    return () -> restoreTo(previous);
+  }
+
+  /** Sets the value back to a previous value.
+   *
+   * <p>If the previous value was {@link #initialValue}, calls
+   * {@link #remove()}. There's no way to tell whether {@link #set} has
+   * been called previously, but the effect is the same. */
+  protected void restoreTo(T previous) {
+    if (previous == initialValue) {
+      remove();
+    } else {
+      set(previous);
+    }
+  }
+
+  /** Performs an action with this ThreadLocal set to a particular value
+   * in this thread, and restores the previous value afterwards.
+   *
+   * <p>This method is named after the Standard ML {@code let} construct,
+   * for example {@code let val x = 1 in x + 2 end}. */
+  public void letIn(T t, Runnable runnable) {
+    final T previous = get();
+    if (previous == t) {
+      runnable.run();
+    } else {
+      try {
+        set(t);
+        runnable.run();
+      } finally {
+        restoreTo(previous);
+      }
+    }
+  }
+
+  /** Calls a Supplier with this ThreadLocal set to a particular value,
+   * in this thread, and restores the previous value afterwards.
+   *
+   * <p>This method is named after the Standard ML {@code let} construct,
+   * for example {@code let val x = 1 in x + 2 end}. */
+  public <R> R letIn(T t, Supplier<R> supplier) {
+    final T previous = get();
+    if (previous == t) {
+      return supplier.get();
+    } else {
+      try {
+        set(t);
+        return supplier.get();
+      } finally {
+        restoreTo(previous);
       }
-    };
+    }
   }
 
   /** Remembers to set the value back. */
diff --git a/core/src/test/java/org/apache/calcite/jdbc/CalciteRemoteDriverTest.java b/core/src/test/java/org/apache/calcite/jdbc/CalciteRemoteDriverTest.java
index 7780809..6e7a3d2 100644
--- a/core/src/test/java/org/apache/calcite/jdbc/CalciteRemoteDriverTest.java
+++ b/core/src/test/java/org/apache/calcite/jdbc/CalciteRemoteDriverTest.java
@@ -34,6 +34,7 @@ import org.apache.calcite.util.Util;
 
 import com.google.common.collect.ImmutableList;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
 import org.hamcrest.CoreMatchers;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
@@ -83,6 +84,8 @@ import static org.hamcrest.CoreMatchers.nullValue;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
+import static java.util.Objects.requireNonNull;
+
 /**
  * Test for Calcite's remote JDBC driver.
  * Technically speaking, the test is thread safe, however Caclite/Avatica have thread-safety issues
@@ -96,13 +99,6 @@ class CalciteRemoteDriverTest {
       CalciteSystemProperty.DEBUG.value() ? Util.printWriter(System.out)
           : new PrintWriter(new StringWriter());
 
-  private static final CalciteAssert.ConnectionFactory REMOTE_CONNECTION_FACTORY =
-      new CalciteAssert.ConnectionFactory() {
-        public Connection createConnection() throws SQLException {
-          return getRemoteConnection();
-        }
-      };
-
   private static final Function<Connection, ResultSet> GET_SCHEMAS =
       connection -> {
         try {
@@ -148,8 +144,8 @@ class CalciteRemoteDriverTest {
         }
       };
 
-  private static Connection localConnection;
-  private static HttpServer start;
+  private static @Nullable Connection localConnection;
+  private static @Nullable HttpServer start;
 
   @BeforeAll public static void beforeClass() throws Exception {
     localConnection = CalciteAssert.hr().connect();
@@ -160,7 +156,7 @@ class CalciteRemoteDriverTest {
   }
 
   protected static Connection getRemoteConnection() throws SQLException {
-    final int port = start.getPort();
+    final int port = requireNonNull(start, "start").getPort();
     return DriverManager.getConnection(
         "jdbc:avatica:remote:url=http://localhost:" + port);
   }
@@ -247,14 +243,16 @@ class CalciteRemoteDriverTest {
     assertThat(connection.isClosed(), is(true));
   }
 
-  @Test void testRemoteCatalogs() throws Exception {
-    CalciteAssert.hr().with(REMOTE_CONNECTION_FACTORY)
+  @Test void testRemoteCatalogs() {
+    CalciteAssert.hr()
+        .with(CalciteRemoteDriverTest::getRemoteConnection)
         .metaData(GET_CATALOGS)
         .returns("TABLE_CAT=null\n");
   }
 
-  @Test void testRemoteSchemas() throws Exception {
-    CalciteAssert.hr().with(REMOTE_CONNECTION_FACTORY)
+  @Test void testRemoteSchemas() {
+    CalciteAssert.hr()
+        .with(CalciteRemoteDriverTest::getRemoteConnection)
         .metaData(GET_SCHEMAS)
         .returns("TABLE_SCHEM=POST; TABLE_CATALOG=null\n"
             + "TABLE_SCHEM=foodmart; TABLE_CATALOG=null\n"
@@ -262,28 +260,32 @@ class CalciteRemoteDriverTest {
             + "TABLE_SCHEM=metadata; TABLE_CATALOG=null\n");
   }
 
-  @Test void testRemoteColumns() throws Exception {
-    CalciteAssert.hr().with(REMOTE_CONNECTION_FACTORY)
+  @Test void testRemoteColumns() {
+    CalciteAssert.hr()
+        .with(CalciteRemoteDriverTest::getRemoteConnection)
         .metaData(GET_COLUMNS)
         .returns(CalciteAssert.checkResultContains("COLUMN_NAME=EMPNO"));
   }
 
   @Test void testRemoteTypeInfo() {
     // TypeInfo does not include internal types (NULL, SYMBOL, ANY, etc.)
-    CalciteAssert.hr().with(REMOTE_CONNECTION_FACTORY)
+    CalciteAssert.hr()
+        .with(CalciteRemoteDriverTest::getRemoteConnection)
         .metaData(GET_TYPEINFO)
         .returns(CalciteAssert.checkResultCount(is(41)));
   }
 
-  @Test void testRemoteTableTypes() throws Exception {
-    CalciteAssert.hr().with(REMOTE_CONNECTION_FACTORY)
+  @Test void testRemoteTableTypes() {
+    CalciteAssert.hr()
+        .with(CalciteRemoteDriverTest::getRemoteConnection)
         .metaData(GET_TABLE_TYPES)
         .returns("TABLE_TYPE=TABLE\n"
             + "TABLE_TYPE=VIEW\n");
   }
 
-  @Test void testRemoteExecuteQuery() throws Exception {
-    CalciteAssert.hr().with(REMOTE_CONNECTION_FACTORY)
+  @Test void testRemoteExecuteQuery() {
+    CalciteAssert.hr()
+        .with(CalciteRemoteDriverTest::getRemoteConnection)
         .query("values (1, 'a'), (cast(null as integer), 'b')")
         .returnsUnordered("EXPR$0=1; EXPR$1=a", "EXPR$0=null; EXPR$1=b");
   }
@@ -883,7 +885,7 @@ class CalciteRemoteDriverTest {
   /** Test case for
    * <a href="https://issues.apache.org/jira/browse/CALCITE-3338">[CALCITE-3338]
    * Error with executeBatch and preparedStatement when using RemoteMeta</a>. */
-  @Test public void testInsertBatchWithPreparedStatement() throws Exception {
+  @Test void testInsertBatchWithPreparedStatement() throws Exception {
     final Connection connection = DriverManager.getConnection(
         "jdbc:avatica:remote:factory="
             + LocalServiceModifiableFactory.class.getName());
diff --git a/core/src/test/java/org/apache/calcite/plan/RelWriterTest.java b/core/src/test/java/org/apache/calcite/plan/RelWriterTest.java
index 103ef55..7903c18 100644
--- a/core/src/test/java/org/apache/calcite/plan/RelWriterTest.java
+++ b/core/src/test/java/org/apache/calcite/plan/RelWriterTest.java
@@ -585,7 +585,7 @@ class RelWriterTest {
     assertThat(s, is(XX2));
   }
 
-  @Test public void testExchange() {
+  @Test void testExchange() {
     final FrameworkConfig config = RelBuilderTest.config().build();
     final RelBuilder builder = RelBuilder.create(config);
     final RelNode rel = builder
diff --git a/core/src/test/java/org/apache/calcite/plan/volcano/MultipleTraitConversionTest.java b/core/src/test/java/org/apache/calcite/plan/volcano/MultipleTraitConversionTest.java
index 5868664..a39e97f 100644
--- a/core/src/test/java/org/apache/calcite/plan/volcano/MultipleTraitConversionTest.java
+++ b/core/src/test/java/org/apache/calcite/plan/volcano/MultipleTraitConversionTest.java
@@ -46,7 +46,7 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
  */
 public class MultipleTraitConversionTest {
   @SuppressWarnings("ConstantConditions")
-  @Test public void testMultipleTraitConversion() {
+  @Test void testMultipleTraitConversion() {
     VolcanoPlanner planner = new VolcanoPlanner();
 
     planner.addRelTraitDef(ConventionTraitDef.INSTANCE);
diff --git a/core/src/test/java/org/apache/calcite/plan/volcano/VolcanoPlannerTest.java b/core/src/test/java/org/apache/calcite/plan/volcano/VolcanoPlannerTest.java
index ec61039..8aa2e1b 100644
--- a/core/src/test/java/org/apache/calcite/plan/volcano/VolcanoPlannerTest.java
+++ b/core/src/test/java/org/apache/calcite/plan/volcano/VolcanoPlannerTest.java
@@ -565,7 +565,7 @@ class VolcanoPlannerTest {
         isLinux(plan));
   }
 
-  @Test public void testPruneNode() {
+  @Test void testPruneNode() {
     VolcanoPlanner planner = new VolcanoPlanner();
     planner.addRelTraitDef(ConventionTraitDef.INSTANCE);
 
diff --git a/core/src/test/java/org/apache/calcite/rel/metadata/janino/RelMetadataHandlerGeneratorUtilTest.java b/core/src/test/java/org/apache/calcite/rel/metadata/janino/RelMetadataHandlerGeneratorUtilTest.java
index 7998ccb..d8fd5de 100644
--- a/core/src/test/java/org/apache/calcite/rel/metadata/janino/RelMetadataHandlerGeneratorUtilTest.java
+++ b/core/src/test/java/org/apache/calcite/rel/metadata/janino/RelMetadataHandlerGeneratorUtilTest.java
@@ -23,7 +23,6 @@ import org.apache.calcite.util.Sources;
 
 import com.google.common.io.CharStreams;
 
-import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 import java.io.IOException;
@@ -36,6 +35,8 @@ import java.nio.file.Paths;
 
 import static org.apache.calcite.linq4j.Nullness.castNonNull;
 
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
 /**
  * Test {@link RelMetadataHandlerGeneratorUtil}.
  */
@@ -43,105 +44,105 @@ class RelMetadataHandlerGeneratorUtilTest {
   private static final Path RESULT_DIR = Paths.get("build/metadata");
 
   @Test void testAllPredicatesGenerateHandler() {
-    testGenerateHandler(BuiltInMetadata.AllPredicates.Handler.class);
+    checkGenerateHandler(BuiltInMetadata.AllPredicates.Handler.class);
   }
 
   @Test void testCollationGenerateHandler() {
-    testGenerateHandler(BuiltInMetadata.Collation.Handler.class);
+    checkGenerateHandler(BuiltInMetadata.Collation.Handler.class);
   }
 
   @Test void testColumnOriginGenerateHandler() {
-    testGenerateHandler(BuiltInMetadata.ColumnOrigin.Handler.class);
+    checkGenerateHandler(BuiltInMetadata.ColumnOrigin.Handler.class);
   }
 
   @Test void testColumnUniquenessGenerateHandler() {
-    testGenerateHandler(BuiltInMetadata.ColumnUniqueness.Handler.class);
+    checkGenerateHandler(BuiltInMetadata.ColumnUniqueness.Handler.class);
   }
 
   @Test void testCumulativeCostGenerateHandler() {
-    testGenerateHandler(BuiltInMetadata.CumulativeCost.Handler.class);
+    checkGenerateHandler(BuiltInMetadata.CumulativeCost.Handler.class);
   }
 
   @Test void testDistinctRowCountGenerateHandler() {
-    testGenerateHandler(BuiltInMetadata.DistinctRowCount.Handler.class);
+    checkGenerateHandler(BuiltInMetadata.DistinctRowCount.Handler.class);
   }
 
   @Test void testDistributionGenerateHandler() {
-    testGenerateHandler(BuiltInMetadata.Distribution.Handler.class);
+    checkGenerateHandler(BuiltInMetadata.Distribution.Handler.class);
   }
 
   @Test void testExplainVisibilityGenerateHandler() {
-    testGenerateHandler(BuiltInMetadata.ExplainVisibility.Handler.class);
+    checkGenerateHandler(BuiltInMetadata.ExplainVisibility.Handler.class);
   }
 
   @Test void testExpressionLineageGenerateHandler() {
-    testGenerateHandler(BuiltInMetadata.ExpressionLineage.Handler.class);
+    checkGenerateHandler(BuiltInMetadata.ExpressionLineage.Handler.class);
   }
 
   @Test void testLowerBoundCostGenerateHandler() {
-    testGenerateHandler(BuiltInMetadata.LowerBoundCost.Handler.class);
+    checkGenerateHandler(BuiltInMetadata.LowerBoundCost.Handler.class);
   }
 
   @Test void testMaxRowCountGenerateHandler() {
-    testGenerateHandler(BuiltInMetadata.MaxRowCount.Handler.class);
+    checkGenerateHandler(BuiltInMetadata.MaxRowCount.Handler.class);
   }
 
   @Test void testMemoryGenerateHandler() {
-    testGenerateHandler(BuiltInMetadata.Memory.Handler.class);
+    checkGenerateHandler(BuiltInMetadata.Memory.Handler.class);
   }
 
   @Test void testMinRowCountGenerateHandler() {
-    testGenerateHandler(BuiltInMetadata.MinRowCount.Handler.class);
+    checkGenerateHandler(BuiltInMetadata.MinRowCount.Handler.class);
   }
 
   @Test void testNodeTypesGenerateHandler() {
-    testGenerateHandler(BuiltInMetadata.NodeTypes.Handler.class);
+    checkGenerateHandler(BuiltInMetadata.NodeTypes.Handler.class);
   }
 
   @Test void testNonCumulativeCostGenerateHandler() {
-    testGenerateHandler(BuiltInMetadata.NonCumulativeCost.Handler.class);
+    checkGenerateHandler(BuiltInMetadata.NonCumulativeCost.Handler.class);
   }
 
   @Test void testParallelismGenerateHandler() {
-    testGenerateHandler(BuiltInMetadata.Parallelism.Handler.class);
+    checkGenerateHandler(BuiltInMetadata.Parallelism.Handler.class);
   }
 
   @Test void testPercentageOriginalRowsGenerateHandler() {
-    testGenerateHandler(BuiltInMetadata.PercentageOriginalRows.Handler.class);
+    checkGenerateHandler(BuiltInMetadata.PercentageOriginalRows.Handler.class);
   }
 
   @Test void testPopulationSizeGenerateHandler() {
-    testGenerateHandler(BuiltInMetadata.PopulationSize.Handler.class);
+    checkGenerateHandler(BuiltInMetadata.PopulationSize.Handler.class);
   }
 
   @Test void testPredicatesGenerateHandler() {
-    testGenerateHandler(BuiltInMetadata.Predicates.Handler.class);
+    checkGenerateHandler(BuiltInMetadata.Predicates.Handler.class);
   }
 
   @Test void testRowCountGenerateHandler() {
-    testGenerateHandler(BuiltInMetadata.RowCount.Handler.class);
+    checkGenerateHandler(BuiltInMetadata.RowCount.Handler.class);
   }
 
   @Test void testSelectivityGenerateHandler() {
-    testGenerateHandler(BuiltInMetadata.Selectivity.Handler.class);
+    checkGenerateHandler(BuiltInMetadata.Selectivity.Handler.class);
   }
 
   @Test void testSizeGenerateHandler() {
-    testGenerateHandler(BuiltInMetadata.Size.Handler.class);
+    checkGenerateHandler(BuiltInMetadata.Size.Handler.class);
   }
 
   @Test void testTableReferencesGenerateHandler() {
-    testGenerateHandler(BuiltInMetadata.TableReferences.Handler.class);
+    checkGenerateHandler(BuiltInMetadata.TableReferences.Handler.class);
   }
 
   @Test void testUniqueKeysGenerateHandler() {
-    testGenerateHandler(BuiltInMetadata.UniqueKeys.Handler.class);
+    checkGenerateHandler(BuiltInMetadata.UniqueKeys.Handler.class);
   }
 
   /**
    * Performance a regression test on the generated code for a given handler.
    */
-  private void testGenerateHandler(Class<? extends MetadataHandler<?>> handlerClass) {
+  private void checkGenerateHandler(Class<? extends MetadataHandler<?>> handlerClass) {
     RelMetadataHandlerGeneratorUtil.HandlerNameAndGeneratedCode nameAndGeneratedCode =
         RelMetadataHandlerGeneratorUtil.generateHandler(handlerClass,
             DefaultRelMetadataProvider.INSTANCE.handlers(handlerClass));
@@ -153,7 +154,7 @@ class RelMetadataHandlerGeneratorUtilTest {
     assert !expected.contains("\r") : "Expected code should not contain \\r";
     assert !nameAndGeneratedCode.getGeneratedCode().equals("\r")
         : "Generated code should not contain \\r";
-    Assertions.assertEquals(expected, nameAndGeneratedCode.getGeneratedCode());
+    assertEquals(expected, nameAndGeneratedCode.getGeneratedCode());
   }
 
   private static String readResource(String resourceName) {
diff --git a/core/src/test/java/org/apache/calcite/rel/rel2sql/RelToSqlConverterTest.java b/core/src/test/java/org/apache/calcite/rel/rel2sql/RelToSqlConverterTest.java
index b181af8..7d0742c 100644
--- a/core/src/test/java/org/apache/calcite/rel/rel2sql/RelToSqlConverterTest.java
+++ b/core/src/test/java/org/apache/calcite/rel/rel2sql/RelToSqlConverterTest.java
@@ -92,7 +92,6 @@ import org.junit.jupiter.api.Test;
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
-import java.util.Objects;
 import java.util.Set;
 import java.util.function.Consumer;
 import java.util.function.Function;
@@ -108,21 +107,27 @@ import static org.hamcrest.MatcherAssert.assertThat;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
+import static java.util.Objects.requireNonNull;
+
 /**
  * Tests for {@link RelToSqlConverter}.
  */
 class RelToSqlConverterTest {
 
-  /** Initiates a test case with a given SQL query. */
-  private Sql sql(String sql) {
-    return new Sql(CalciteAssert.SchemaSpec.JDBC_FOODMART, sql,
+  private Sql fixture() {
+    return new Sql(CalciteAssert.SchemaSpec.JDBC_FOODMART, "?",
         CalciteSqlDialect.DEFAULT, SqlParser.Config.DEFAULT, ImmutableSet.of(),
         UnaryOperator.identity(), null, ImmutableList.of(), RelDataTypeSystem.DEFAULT);
   }
 
+  /** Initiates a test case with a given SQL query. */
+  private Sql sql(String sql) {
+    return fixture().withSql(sql);
+  }
+
   /** Initiates a test case with a given {@link RelNode} supplier. */
   private Sql relFn(Function<RelBuilder, RelNode> relFn) {
-    return sql("?")
+    return fixture()
         .schema(CalciteAssert.SchemaSpec.SCOTT_WITH_TEMPORAL)
         .relFn(relFn);
   }
@@ -6267,7 +6272,12 @@ class RelToSqlConverterTest {
       this.transforms = ImmutableList.copyOf(transforms);
       this.parserConfig = parserConfig;
       this.config = config;
-      this.typeSystem = Objects.requireNonNull(typeSystem, "typeSystem");
+      this.typeSystem = requireNonNull(typeSystem, "typeSystem");
+    }
+
+    Sql withSql(String sql) {
+      return new Sql(schemaSpec, sql, dialect, parserConfig, librarySet, config,
+          relFn, transforms, typeSystem);
     }
 
     Sql dialect(SqlDialect dialect) {
diff --git a/core/src/test/java/org/apache/calcite/sql/parser/SqlUnParserTest.java b/core/src/test/java/org/apache/calcite/sql/parser/SqlUnParserTest.java
index 0ac4f40..031e52e 100644
--- a/core/src/test/java/org/apache/calcite/sql/parser/SqlUnParserTest.java
+++ b/core/src/test/java/org/apache/calcite/sql/parser/SqlUnParserTest.java
@@ -21,11 +21,8 @@ package org.apache.calcite.sql.parser;
  * un-parse successfully.
  */
 class SqlUnParserTest extends SqlParserTest {
-  @Override protected Tester getTester() {
-    return new UnparsingTesterImpl();
-  }
-
-  @Override protected boolean isUnparserTest() {
-    return true;
+  @Override public SqlParserFixture fixture() {
+    return super.fixture()
+        .withTester(new UnparsingTesterImpl());
   }
 }
diff --git a/core/src/test/java/org/apache/calcite/sql/parser/parserextensiontesting/ExtensionSqlParserTest.java b/core/src/test/java/org/apache/calcite/sql/parser/parserextensiontesting/ExtensionSqlParserTest.java
index bd0068e..e9354db 100644
--- a/core/src/test/java/org/apache/calcite/sql/parser/parserextensiontesting/ExtensionSqlParserTest.java
+++ b/core/src/test/java/org/apache/calcite/sql/parser/parserextensiontesting/ExtensionSqlParserTest.java
@@ -17,7 +17,7 @@
 package org.apache.calcite.sql.parser.parserextensiontesting;
 
 import org.apache.calcite.sql.SqlNode;
-import org.apache.calcite.sql.parser.SqlParserImplFactory;
+import org.apache.calcite.sql.parser.SqlParserFixture;
 import org.apache.calcite.sql.parser.SqlParserTest;
 
 import org.hamcrest.core.IsNull;
@@ -31,8 +31,9 @@ import org.junit.jupiter.api.Test;
  */
 class ExtensionSqlParserTest extends SqlParserTest {
 
-  @Override protected SqlParserImplFactory parserImplFactory() {
-    return ExtensionSqlParserImpl.FACTORY;
+  @Override public SqlParserFixture fixture() {
+    return super.fixture()
+        .withConfig(c -> c.withParserFactory(ExtensionSqlParserImpl.FACTORY));
   }
 
   @Test void testAlterSystemExtension() {
diff --git a/core/src/test/java/org/apache/calcite/sql/test/DocumentationTest.java b/core/src/test/java/org/apache/calcite/sql/test/DocumentationTest.java
index 0a79f69..265531d 100644
--- a/core/src/test/java/org/apache/calcite/sql/test/DocumentationTest.java
+++ b/core/src/test/java/org/apache/calcite/sql/test/DocumentationTest.java
@@ -73,7 +73,7 @@ class DocumentationTest {
         if (line.equals("{% comment %} start {% endcomment %}")) {
           ++stage;
           SqlAbstractParserImpl.Metadata metadata =
-              new SqlParserTest().getSqlParser("").getMetadata();
+              new SqlParserTest().fixture().parser().getMetadata();
           int z = 0;
           for (String s : metadata.getTokens()) {
             if (z++ > 0) {
diff --git a/core/src/test/java/org/apache/calcite/sql/test/SqlAdvisorTest.java b/core/src/test/java/org/apache/calcite/sql/test/SqlAdvisorTest.java
index 802b9eb..82075d2 100644
--- a/core/src/test/java/org/apache/calcite/sql/test/SqlAdvisorTest.java
+++ b/core/src/test/java/org/apache/calcite/sql/test/SqlAdvisorTest.java
@@ -24,41 +24,48 @@ import org.apache.calcite.sql.parser.SqlParser;
 import org.apache.calcite.sql.parser.StringAndPos;
 import org.apache.calcite.sql.validate.SqlMoniker;
 import org.apache.calcite.sql.validate.SqlMonikerType;
+import org.apache.calcite.test.SqlValidatorFixture;
 import org.apache.calcite.test.SqlValidatorTestCase;
-import org.apache.calcite.testlib.annotations.WithLex;
 
 import com.google.common.collect.ImmutableMap;
 
-import org.junit.jupiter.api.Assertions;
+import org.checkerframework.checker.nullness.qual.Nullable;
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
-import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.TreeSet;
+import java.util.function.Consumer;
+import java.util.function.UnaryOperator;
 
 import static org.hamcrest.CoreMatchers.equalTo;
 import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.fail;
 
+import static java.util.Objects.requireNonNull;
+
 /**
  * Concrete child class of {@link SqlValidatorTestCase}, containing unit tests
  * for SqlAdvisor.
  */
-@ExtendWith(SqlValidatorTestCase.LexConfiguration.class)
+@SuppressWarnings({"unchecked", "ArraysAsListWithZeroOrOneArgument"})
 class SqlAdvisorTest extends SqlValidatorTestCase {
-  public static final SqlTestFactory ADVISOR_TEST_FACTORY =
+  public static final SqlTestFactory ADVISOR_NEW_TEST_FACTORY =
       SqlTestFactory.INSTANCE.withValidator(SqlAdvisorValidator::new);
 
+  static final Fixture LOCAL_FIXTURE =
+      new Fixture(SqlValidatorTester.DEFAULT, ADVISOR_NEW_TEST_FACTORY,
+          StringAndPos.of("?"), false, false);
+
   private static final List<String> STAR_KEYWORD =
       Collections.singletonList(
           "KEYWORD(*)");
@@ -383,6 +390,10 @@ class SqlAdvisorTest extends SqlValidatorTestCase {
       "COLUMN(EMPNO)\n"
           + "TABLE(EMP)\n";
 
+  @Override public Fixture fixture() {
+    return LOCAL_FIXTURE;
+  }
+
   protected List<String> getFromKeywords() {
     return FROM_KEYWORDS;
   }
@@ -405,248 +416,50 @@ class SqlAdvisorTest extends SqlValidatorTestCase {
     return JOIN_KEYWORDS;
   }
 
-  private void assertTokenizesTo(String sql, String expected) {
-    SqlSimpleParser.Tokenizer tokenizer =
-        new SqlSimpleParser.Tokenizer(sql, "xxxxx",
-            tester.getFactory().getParserConfig().quoting());
-    StringBuilder buf = new StringBuilder();
-    while (true) {
-      SqlSimpleParser.Token token = tokenizer.nextToken();
-      if (token == null) {
-        break;
-      }
-      buf.append(token).append("\n");
-    }
-    Assertions.assertEquals(expected, buf.toString());
-  }
-
-  protected void assertHint(
-      String sql,
-      List<String>... expectedLists) throws Exception {
-    List<String> expectedList = plus(expectedLists);
-    final String expected = toString(new TreeSet<>(expectedList));
-    assertHint(sql, expected);
-  }
-
-  /**
-   * Checks that a given SQL statement yields the expected set of completion
-   * hints.
-   *
-   * @param sql             SQL statement
-   * @param expectedResults Expected list of hints
-   * @throws Exception on error
-   */
-  protected void assertHint(
-      String sql,
-      String expectedResults) throws Exception {
-    SqlAdvisor advisor = tester.getFactory().createAdvisor();
-
-    StringAndPos sap = StringAndPos.of(sql);
-
-    List<SqlMoniker> results =
-        advisor.getCompletionHints(
-            sap.sql,
-            sap.pos);
-    Assertions.assertEquals(
-        expectedResults, convertCompletionHints(results));
-  }
-
-  /**
-   * Tests that a given SQL statement simplifies to the salesTables result.
-   *
-   * @param sql      SQL statement to simplify. The SQL statement must contain
-   *                 precisely one caret '^', which marks the location where
-   *                 completion is to occur.
-   * @param expected Expected result after simplification.
-   */
-  protected void assertSimplify(String sql, String expected) {
-    SqlAdvisor advisor = tester.getFactory().createAdvisor();
-
-    StringAndPos sap = StringAndPos.of(sql);
-    String actual = advisor.simplifySql(sap.sql, sap.cursor);
-    Assertions.assertEquals(expected, actual);
-  }
-
-  protected void assertComplete(
-      String sql,
-      List<String>... expectedResults) {
-    assertComplete(sql, null, expectedResults);
-  }
-
-  protected void assertComplete(
-      String sql,
-      Map<String, String> replacements,
-      List<String>... expectedResults) {
-    List<String> expectedList = plus(expectedResults);
-    String expected = toString(new TreeSet<>(expectedList));
-    assertComplete(sql, expected, null, replacements);
-  }
-
-  protected void assertComplete(
-      String sql,
-      String expectedResults,
-      String expectedWord) {
-    assertComplete(sql, expectedResults, expectedWord, null);
-  }
-  /**
-   * Tests that a given SQL which may be invalid or incomplete simplifies
-   * itself and yields the salesTables set of completion hints. This is an
-   * integration test of {@link #assertHint} and {@link #assertSimplify}.
-   *
-   * @param sql             SQL statement
-   * @param expectedResults Expected list of hints
-   * @param expectedWord    Word that we expect to be replaced, or null if we
-   *                        don't care
-   */
-  protected void assertComplete(
-      String sql,
-      String expectedResults,
-      String expectedWord,
-      Map<String, String> replacements) {
-    SqlAdvisor advisor = tester.getFactory().createAdvisor();
-
-    StringAndPos sap = StringAndPos.of(sql);
-    final String[] replaced = {null};
-    List<SqlMoniker> results =
-        advisor.getCompletionHints(sap.sql, sap.cursor, replaced);
-    Assertions.assertEquals(expectedResults, convertCompletionHints(results),
-        () -> "Completion hints for " + sql);
-    if (expectedWord != null) {
-      Assertions.assertEquals(expectedWord, replaced[0], "replaced[0] for " + sql);
-    } else {
-      assertNotNull(replaced[0]);
-    }
-    assertReplacements(sql, replacements, advisor, replaced[0], results);
-  }
-
-  private void assertReplacements(String sql, Map<String, String> replacements, SqlAdvisor advisor,
-      String word, List<SqlMoniker> results) {
-    if (replacements == null) {
-      return;
-    }
-    Set<String> missingReplacemenets = new HashSet<>(replacements.keySet());
-    for (SqlMoniker result : results) {
-      String id = result.id();
-      String expectedReplacement = replacements.get(id);
-      if (expectedReplacement == null) {
-        continue;
-      }
-      missingReplacemenets.remove(id);
-      String actualReplacement = advisor.getReplacement(result, word);
-      Assertions.assertEquals(expectedReplacement, actualReplacement,
-          () -> sql + ", replacement of " + word + " with " + id);
-    }
-    if (missingReplacemenets.isEmpty()) {
-      return;
-    }
-    fail("Sql " + sql + " did not produce replacement hints " + missingReplacemenets);
-
-  }
-
-  protected void assertEquals(
-      String[] actualResults,
-      List<String>... expectedResults) throws Exception {
-    List<String> expectedList = plus(expectedResults);
-    Map<String, String> uniqueResults = new HashMap<String, String>();
-    for (String actualResult : actualResults) {
-      uniqueResults.put(actualResult, actualResult);
-    }
-    if (!(expectedList.containsAll(uniqueResults.values())
-        && (expectedList.size() == uniqueResults.values().size()))) {
-      fail(
-          "SqlAdvisorTest: completion hints results not as salesTables:\n"
-              + uniqueResults.values() + "\nExpected:\n"
-              + expectedList);
-    }
-  }
-
-  private String convertCompletionHints(List<SqlMoniker> hints) {
-    if (hints == null) {
-      return "<<NULL>>";
-    }
-    List<String> list = new ArrayList<String>();
-    for (SqlMoniker hint : hints) {
-      if (hint.getType() != SqlMonikerType.FUNCTION) {
-        list.add(hint.id());
-      }
-    }
-    Collections.sort(list);
-    return toString(list);
-  }
-
-  /**
-   * Converts a list to a string, one item per line.
-   *
-   * @param list List
-   * @return String with one item of the list per line
-   */
-  private static <T> String toString(Collection<T> list) {
-    StringBuilder buf = new StringBuilder();
-    for (T t : list) {
-      buf.append(t).append("\n");
-    }
-    return buf.toString();
-  }
+  @Test void testFrom() {
+    final Fixture f = fixture();
 
-  @Override public SqlTester getTester() {
-    return new SqlValidatorTester(ADVISOR_TEST_FACTORY);
-  }
-
-  /**
-   * Concatenates several lists of the same type into a single list.
-   *
-   * @param lists Lists to concatenate
-   * @return Sum list
-   */
-  protected static <T> List<T> plus(List<T>... lists) {
-    final List<T> result = new ArrayList<T>();
-    for (List<T> list : lists) {
-      result.addAll(list);
-    }
-    return result;
-  }
-
-  @Test void testFrom() throws Exception {
-    String sql;
-
-    sql = "select a.empno, b.deptno from ^dummy a, sales.dummy b";
-    assertHint(sql, SCHEMAS, getSalesTables(), getFromKeywords()); // join
+    String sql = "select a.empno, b.deptno from ^dummy a, sales.dummy b";
+    f.withSql(sql)
+        .assertHint(SCHEMAS, getSalesTables(), getFromKeywords()); // join
 
     sql = "select a.empno, b.deptno from ^";
-    assertComplete(sql, SCHEMAS, getSalesTables(), getFromKeywords());
+    f.withSql(sql).assertComplete(SCHEMAS, getSalesTables(), getFromKeywords());
     sql = "select a.empno, b.deptno from ^, sales.dummy b";
-    assertComplete(sql, SCHEMAS, getSalesTables(), getFromKeywords());
+    f.withSql(sql).assertComplete(SCHEMAS, getSalesTables(), getFromKeywords());
     sql = "select a.empno, b.deptno from ^a";
-    assertComplete(sql, SCHEMAS, getSalesTables(), getFromKeywords());
+    f.withSql(sql).assertComplete(SCHEMAS, getSalesTables(), getFromKeywords());
 
     sql = "select a.empno, b.deptno from dummy a, ^sales.dummy b";
-    assertHint(sql, SCHEMAS, getSalesTables(), getFromKeywords()); // join
+    f.withSql(sql)
+        .assertHint(SCHEMAS, getSalesTables(), getFromKeywords()); // join
   }
 
   @Test void testFromComplete() {
     String sql = "select a.empno, b.deptno from dummy a, sales.^";
-    assertComplete(sql, getSalesTables());
+    fixture().withSql(sql).assertComplete(getSalesTables());
   }
 
   @Test void testGroup() {
     // This test is hard because the statement is not valid if you replace
     // '^' with a dummy identifier.
     String sql = "select a.empno, b.deptno from emp group ^";
-    assertComplete(sql, Arrays.asList("KEYWORD(BY)"));
+    fixture().withSql(sql).assertComplete(Arrays.asList("KEYWORD(BY)"));
   }
 
-  @Test void testJoin() throws Exception {
+  @Test void testJoin() {
+    final Fixture f = fixture();
     String sql;
 
     // from
     sql =
         "select a.empno, b.deptno from ^dummy a join sales.dummy b "
             + "on a.deptno=b.deptno where empno=1";
-    assertHint(sql, getFromKeywords(), SCHEMAS, getSalesTables());
+    f.withSql(sql).assertHint(getFromKeywords(), SCHEMAS, getSalesTables());
 
     // from
     sql = "select a.empno, b.deptno from ^ a join sales.dummy b";
-    assertComplete(sql, getFromKeywords(), SCHEMAS, getSalesTables());
+    f.withSql(sql).assertComplete(getFromKeywords(), SCHEMAS, getSalesTables());
 
     // REVIEW: because caret is before 'sales', should it ignore schema
     // name and present all schemas and all tables in the default schema?
@@ -654,268 +467,294 @@ class SqlAdvisorTest extends SqlValidatorTestCase {
     sql =
         "select a.empno, b.deptno from dummy a join ^sales.dummy b "
             + "on a.deptno=b.deptno where empno=1";
-    assertHint(sql, getFromKeywords(), SCHEMAS, getSalesTables());
+    f.withSql(sql).assertHint(getFromKeywords(), SCHEMAS, getSalesTables());
 
     sql = "select a.empno, b.deptno from dummy a join sales.^";
-    assertComplete(sql, getSalesTables()); // join
+    f.withSql(sql).assertComplete(getSalesTables()); // join
     sql = "select a.empno, b.deptno from dummy a join sales.^ on";
-    assertComplete(sql, getSalesTables()); // join
+    f.withSql(sql).assertComplete(getSalesTables()); // join
 
     // unfortunately cannot complete this case: syntax is too broken
     sql = "select a.empno, b.deptno from dummy a join sales.^ on a.deptno=";
-    assertComplete(sql, QUANTIFIERS, EXPR_KEYWORDS); // join
+    f.withSql(sql).assertComplete(QUANTIFIERS, EXPR_KEYWORDS); // join
   }
 
   @Test void testJoinKeywords() {
     // variety of keywords possible
     List<String> list = getJoinKeywords();
     String sql = "select * from dummy join sales.emp ^";
-    assertSimplify(sql, "SELECT * FROM dummy JOIN sales.emp _suggest_");
-    assertComplete(sql, list);
+    fixture().withSql(sql)
+        .assertSimplify("SELECT * FROM dummy JOIN sales.emp _suggest_")
+        .assertComplete(list);
   }
 
   @Test void testSimplifyStarAlias() {
-    String sql;
-    sql = "select ax^ from (select * from dummy a)";
-    assertSimplify(sql, "SELECT ax _suggest_ FROM ( SELECT * FROM dummy a )");
+    String sql = "select ax^ from (select * from dummy a)";
+    fixture().withSql(sql)
+        .assertSimplify("SELECT ax _suggest_ FROM ( SELECT * FROM dummy a )");
   }
 
   @Test void testSimplifySubQueryStar() {
+    final Fixture f = fixture();
     String sql;
-    sql = "select ax^ from (select (select * from dummy) axc from dummy a)";
-    assertSimplify(sql,
-        "SELECT ax _suggest_ FROM ( SELECT ( SELECT * FROM dummy ) axc FROM dummy a )");
-    assertComplete(sql, "COLUMN(AXC)\n", "ax");
 
-    sql =
-        "select ax^ from (select a.x+0 axa, b.x axb, (select * from dummy) axbc from dummy a, dummy b)";
-    assertSimplify(sql,
-        "SELECT ax _suggest_ FROM ( SELECT a.x+0 axa , b.x axb , ( SELECT * FROM dummy ) axbc FROM dummy a , dummy b )");
-    assertComplete(sql,
-        "COLUMN(AXA)\nCOLUMN(AXB)\nCOLUMN(AXBC)\n", "ax");
+    sql = "select ax^ from (select (select * from dummy) axc from dummy a)";
+    f.withSql(sql)
+        .assertSimplify("SELECT ax _suggest_ FROM ("
+            + " SELECT ( SELECT * FROM dummy ) axc FROM dummy a )")
+        .assertComplete("COLUMN(AXC)\n", "ax");
+
+    sql = "select ax^ from (select a.x+0 axa, b.x axb,"
+        + " (select * from dummy) axbc from dummy a, dummy b)";
+    f.withSql(sql)
+        .assertSimplify("SELECT ax _suggest_ FROM ( SELECT a.x+0 axa , b.x axb ,"
+            + " ( SELECT * FROM dummy ) axbc FROM dummy a , dummy b )")
+        .assertComplete("COLUMN(AXA)\nCOLUMN(AXB)\nCOLUMN(AXBC)\n", "ax");
 
     sql = "select ^ from (select * from dummy)";
-    assertSimplify(sql, "SELECT _suggest_ FROM ( SELECT * FROM dummy )");
+    f.withSql(sql)
+        .assertSimplify("SELECT _suggest_ FROM ( SELECT * FROM dummy )");
 
     sql = "select ^ from (select x.* from dummy x)";
-    assertSimplify(sql, "SELECT _suggest_ FROM ( SELECT x.* FROM dummy x )");
+    f.withSql(sql)
+        .assertSimplify("SELECT _suggest_ FROM ( SELECT x.* FROM dummy x )");
 
     sql = "select ^ from (select a.x + b.y from dummy a, dummy b)";
-    assertSimplify(sql, "SELECT _suggest_ FROM ( SELECT a.x + b.y FROM dummy a , dummy b )");
+    f.withSql(sql)
+        .assertSimplify("SELECT _suggest_ FROM ( "
+            + "SELECT a.x + b.y FROM dummy a , dummy b )");
   }
 
   @Test void testSimplifySubQueryMultipleFrom() {
+    final Fixture f = fixture();
     String sql;
+
     // "dummy b" should be removed
-    sql = "select axc from (select (select ^ from dummy) axc from dummy a), dummy b";
-    assertSimplify(sql,
-        "SELECT * FROM ( SELECT ( SELECT _suggest_ FROM dummy ) axc FROM dummy a )");
+    sql = "select axc\n"
+        + "from (select (select ^ from dummy) axc from dummy a), dummy b";
+    f.withSql(sql)
+        .assertSimplify("SELECT * FROM ("
+            + " SELECT ( SELECT _suggest_ FROM dummy ) axc FROM dummy a )");
 
     // "dummy b" should be removed
-    sql = "select axc from dummy b, (select (select ^ from dummy) axc from dummy a)";
-    assertSimplify(sql,
-        "SELECT * FROM ( SELECT ( SELECT _suggest_ FROM dummy ) axc FROM dummy a )");
+    sql = "select axc\n"
+        + "from dummy b, (select (select ^ from dummy) axc from dummy a)";
+    f.withSql(sql)
+        .assertSimplify("SELECT * FROM ("
+            + " SELECT ( SELECT _suggest_ FROM dummy ) axc FROM dummy a )");
   }
 
   @Test void testSimplifyMinus() {
+    final Fixture f = fixture();
     String sql;
+
     sql = "select ^ from dummy a minus select * from dummy b";
-    assertSimplify(sql, "SELECT _suggest_ FROM dummy a");
+    f.withSql(sql).assertSimplify("SELECT _suggest_ FROM dummy a");
 
     sql = "select * from dummy a minus select ^ from dummy b";
-    assertSimplify(sql, "SELECT _suggest_ FROM dummy b");
+    f.withSql(sql).assertSimplify("SELECT _suggest_ FROM dummy b");
   }
 
-  @Test void testOnCondition() throws Exception {
+  @Test void testOnCondition() {
+    final Fixture f = fixture();
     String sql;
 
     sql =
         "select a.empno, b.deptno from sales.emp a join sales.dept b "
             + "on ^a.deptno=b.dummy where empno=1";
-    assertHint(sql, AB_TABLES, EXPR_KEYWORDS); // on left
+    f.withSql(sql).assertHint(AB_TABLES, EXPR_KEYWORDS); // on left
 
     sql =
         "select a.empno, b.deptno from sales.emp a join sales.dept b "
             + "on a.^";
-    assertComplete(sql, EMP_COLUMNS); // on left
+    f.withSql(sql).assertComplete(EMP_COLUMNS); // on left
 
     sql =
         "select a.empno, b.deptno from sales.emp a join sales.dept b "
             + "on a.deptno=^b.dummy where empno=1";
-    assertHint(sql, EXPR_KEYWORDS, QUANTIFIERS, AB_TABLES); // on right
+    f.withSql(sql).assertHint(EXPR_KEYWORDS, QUANTIFIERS, AB_TABLES); // on right
 
     sql =
         "select a.empno, b.deptno from sales.emp a join sales.dept b "
             + "on a.deptno=b.^ where empno=1";
-    assertComplete(sql, DEPT_COLUMNS); // on right
+    f.withSql(sql).assertComplete(DEPT_COLUMNS); // on right
 
     sql =
         "select a.empno, b.deptno from sales.emp a join sales.dept b "
             + "on a.deptno=b.^";
-    assertComplete(sql, DEPT_COLUMNS); // on right
+    f.withSql(sql).assertComplete(DEPT_COLUMNS); // on right
   }
 
-  @Test void testFromWhere() throws Exception {
+  @Test void testFromWhere() {
+    final Fixture f = fixture();
     String sql;
 
-    sql =
-        "select a.empno, b.deptno from sales.emp a, sales.dept b "
-            + "where b.deptno=^a.dummy";
-    assertHint(sql, AB_TABLES, EXPR_KEYWORDS, QUANTIFIERS); // where list
+    sql = "select a.empno, b.deptno from sales.emp a, sales.dept b "
+        + "where b.deptno=^a.dummy";
+    f.withSql(sql)
+        .assertHint(AB_TABLES, EXPR_KEYWORDS, QUANTIFIERS); // where list
 
-    sql =
-        "select a.empno, b.deptno from sales.emp a, sales.dept b "
-            + "where b.deptno=a.^";
-    assertComplete(sql, ImmutableMap.of("COLUMN(COMM)", "COMM"),
-        EMP_COLUMNS); // where list
+    sql = "select a.empno, b.deptno from sales.emp a, sales.dept b\n"
+        + "where b.deptno=a.^";
+    f.withSql(sql)
+        .assertComplete(ImmutableMap.of("COLUMN(COMM)", "COMM"),
+            EMP_COLUMNS); // where list
 
     sql =
         "select a.empno, b.deptno from sales.emp a, sales.dept b "
             + "where b.deptno=a.e^";
-    assertComplete(sql, ImmutableMap.of("COLUMN(ENAME)", "ename"),
-        EMP_COLUMNS_E); // where list
+    f.withSql(sql)
+        .assertComplete(ImmutableMap.of("COLUMN(ENAME)", "ename"),
+            EMP_COLUMNS_E); // where list
 
     // hints contain no columns, only table aliases, because there are >1
     // aliases
     sql =
         "select a.empno, b.deptno from sales.emp a, sales.dept b "
             + "where ^dummy=1";
-    assertComplete(sql, ImmutableMap.of("KEYWORD(CURRENT_TIMESTAMP)", "CURRENT_TIMESTAMP"),
-        AB_TABLES, EXPR_KEYWORDS); // where list
+    f.withSql(sql)
+        .assertComplete(
+            ImmutableMap.of("KEYWORD(CURRENT_TIMESTAMP)", "CURRENT_TIMESTAMP"),
+            AB_TABLES, EXPR_KEYWORDS); // where list
 
     sql =
         "select a.empno, b.deptno from sales.emp a, sales.dept b "
             + "where ^";
-    assertComplete(sql, AB_TABLES, EXPR_KEYWORDS); // where list
+    f.withSql(sql)
+        .assertComplete(AB_TABLES, EXPR_KEYWORDS); // where list
 
     // If there's only one table alias, we allow both the alias and the
     // unqualified columns
-    assertComplete(
-        "select a.empno, a.deptno from sales.emp a "
-            + "where ^",
-        A_TABLE,
-        EMP_COLUMNS,
-        EXPR_KEYWORDS);
+    sql = "select a.empno, a.deptno from sales.emp a "
+        + "where ^";
+    f.withSql(sql)
+        .assertComplete(A_TABLE, EMP_COLUMNS, EXPR_KEYWORDS);
   }
 
-  @Test void testWhereList() throws Exception {
+  @Test void testWhereList() {
+    final Fixture f = fixture();
     String sql;
 
     sql =
         "select a.empno, b.deptno from sales.emp a join sales.dept b "
             + "on a.deptno=b.deptno where ^dummy=1";
-    assertHint(sql, EXPR_KEYWORDS, AB_TABLES); // where list
+    f.withSql(sql).assertHint(EXPR_KEYWORDS, AB_TABLES); // where list
 
     sql =
         "select a.empno, b.deptno from sales.emp a join sales.dept b "
             + "on a.deptno=b.deptno where ^";
-    assertComplete(sql, EXPR_KEYWORDS, AB_TABLES); // where list
+    f.withSql(sql).assertComplete(EXPR_KEYWORDS, AB_TABLES); // where list
 
     sql =
         "select a.empno, b.deptno from sales.emp a join sales.dept b "
             + "on a.deptno=b.deptno where ^a.dummy=1";
-    assertHint(sql, EXPR_KEYWORDS, AB_TABLES); // where list
+    f.withSql(sql).assertHint(EXPR_KEYWORDS, AB_TABLES); // where list
 
     sql =
         "select a.empno, b.deptno from sales.emp a join sales.dept b "
             + "on a.deptno=b.deptno where a.^";
-    assertComplete(sql, EMP_COLUMNS);
+    f.withSql(sql).assertComplete(EMP_COLUMNS);
 
     sql =
         "select a.empno, b.deptno from sales.emp a join sales.dept b "
             + "on a.deptno=b.deptno where a.empno ^ ";
-    assertComplete(sql, PREDICATE_KEYWORDS, WHERE_KEYWORDS);
+    f.withSql(sql).assertComplete(PREDICATE_KEYWORDS, WHERE_KEYWORDS);
   }
 
-  @Test void testSelectList() throws Exception {
+  @Test void testSelectList() {
+    final Fixture f = fixture();
     String sql;
 
     sql =
         "select ^dummy, b.dummy from sales.emp a join sales.dept b "
             + "on a.deptno=b.deptno where empno=1";
-    assertHint(
-        sql, getSelectKeywords(), EXPR_KEYWORDS, AB_TABLES);
+    f.withSql(sql).assertHint(getSelectKeywords(), EXPR_KEYWORDS, AB_TABLES);
 
     sql = "select ^ from (values (1))";
-    assertComplete(
-        sql,
-        getSelectKeywords(),
-        EXPR_KEYWORDS,
-        Arrays.asList("TABLE(EXPR$0)", "COLUMN(EXPR$0)"));
+    f.withSql(sql)
+        .assertComplete(getSelectKeywords(), EXPR_KEYWORDS,
+            Arrays.asList("TABLE(EXPR$0)", "COLUMN(EXPR$0)"));
 
     sql = "select ^ from (values (1)) as t(c)";
-    assertComplete(
-        sql,
-        getSelectKeywords(),
-        EXPR_KEYWORDS,
-        Arrays.asList("TABLE(T)", "COLUMN(C)"));
+    f.withSql(sql)
+        .assertComplete(getSelectKeywords(), EXPR_KEYWORDS,
+            Arrays.asList("TABLE(T)", "COLUMN(C)"));
 
     sql = "select ^, b.dummy from sales.emp a join sales.dept b ";
-    assertComplete(
-        sql, getSelectKeywords(), EXPR_KEYWORDS, AB_TABLES);
+    f.withSql(sql)
+        .assertComplete(getSelectKeywords(), EXPR_KEYWORDS, AB_TABLES);
 
     sql =
         "select dummy, ^b.dummy from sales.emp a join sales.dept b "
             + "on a.deptno=b.deptno where empno=1";
-    assertHint(sql, EXPR_KEYWORDS, STAR_KEYWORD, AB_TABLES);
+    f.withSql(sql).assertHint(EXPR_KEYWORDS, STAR_KEYWORD, AB_TABLES);
 
     sql = "select dummy, b.^ from sales.emp a join sales.dept b on true";
-    assertComplete(sql, STAR_KEYWORD, DEPT_COLUMNS);
+    f.withSql(sql).assertComplete(STAR_KEYWORD, DEPT_COLUMNS);
 
     // REVIEW: Since 'b' is not a valid alias, should it suggest anything?
     // We don't get through validation, so the only suggestion, '*', comes
     // from the parser.
     sql = "select dummy, b.^ from sales.emp a";
-    assertComplete(sql, STAR_KEYWORD);
+    f.withSql(sql).assertComplete(STAR_KEYWORD);
 
     sql = "select ^emp.dummy from sales.emp";
-    assertHint(
-        sql,
-        getSelectKeywords(),
-        EXPR_KEYWORDS,
-        EMP_COLUMNS,
-        Arrays.asList("TABLE(EMP)"));
-
-    sql = "select emp.^ from sales.emp";
-    assertComplete(sql, EMP_COLUMNS, STAR_KEYWORD);
+    f.withSql(sql)
+        .assertHint(getSelectKeywords(),
+            EXPR_KEYWORDS,
+            EMP_COLUMNS,
+            Arrays.asList("TABLE(EMP)"));
+
+    // Suggest columns for a table name or table alias in the SELECT clause.
+    final Consumer<String> c = sql_ ->
+        f.withSql(sql_).assertComplete(EMP_COLUMNS, STAR_KEYWORD);
+    c.accept("select emp.^ from sales.emp");
+    c.accept("select emp.^ from sales.emp as emp");
+    c.accept("select emp.^ from sales.emp emp");
+    c.accept("select e.^ from sales.emp as e");
+    c.accept("select e.^ from sales.emp e");
+    c.accept("select e.^ from sales.emp e, sales.dept d");
+    c.accept("select e.^ from sales.emp e cross join sales.dept d");
+    c.accept("select e.^ from sales.emp e where deptno = 20");
+    c.accept("select e.^ from sales.emp e order by deptno");
   }
 
-  @Test void testOrderByList() throws Exception {
+  @Test void testOrderByList() {
+    final Fixture f = fixture();
     String sql;
 
     sql = "select emp.empno from sales.emp where empno=1 order by ^dummy";
-    assertHint(sql, EXPR_KEYWORDS, EMP_COLUMNS, EMP_TABLE);
+    f.withSql(sql).assertHint(EXPR_KEYWORDS, EMP_COLUMNS, EMP_TABLE);
 
     sql = "select emp.empno from sales.emp where empno=1 order by ^";
-    assertComplete(sql, EXPR_KEYWORDS, EMP_COLUMNS, EMP_TABLE);
+    f.withSql(sql).assertComplete(EXPR_KEYWORDS, EMP_COLUMNS, EMP_TABLE);
 
     sql =
         "select emp.empno\n"
             + "from sales.emp as e(\n"
             + "  mpno,name,ob,gr,iredate,al,omm,eptno,lacker)\n"
             + "where e.mpno=1 order by ^";
-    assertComplete(
-        sql,
-        EXPR_KEYWORDS,
-        Arrays.asList(
-            "COLUMN(MPNO)",
-            "COLUMN(NAME)",
-            "COLUMN(OB)",
-            "COLUMN(GR)",
-            "COLUMN(IREDATE)",
-            "COLUMN(AL)",
-            "COLUMN(OMM)",
-            "COLUMN(EPTNO)",
-            "COLUMN(LACKER)"),
-        Arrays.asList(
-            "TABLE(E)"));
+    f.withSql(sql)
+        .assertComplete(EXPR_KEYWORDS,
+            Arrays.asList("COLUMN(MPNO)",
+                "COLUMN(NAME)",
+                "COLUMN(OB)",
+                "COLUMN(GR)",
+                "COLUMN(IREDATE)",
+                "COLUMN(AL)",
+                "COLUMN(OMM)",
+                "COLUMN(EPTNO)",
+                "COLUMN(LACKER)"),
+            Arrays.asList("TABLE(E)"));
 
     sql =
         "select emp.empno from sales.emp where empno=1 order by empno ^, deptno";
-    assertComplete(sql, PREDICATE_KEYWORDS, ORDER_KEYWORDS, FETCH_OFFSET);
+    f.withSql(sql)
+        .assertComplete(PREDICATE_KEYWORDS, ORDER_KEYWORDS, FETCH_OFFSET);
   }
 
-  @Test void testSubQuery() throws Exception {
+  @Test void testSubQuery() {
+    final Fixture f = fixture();
     String sql;
     final List<String> xyColumns =
         Arrays.asList(
@@ -925,70 +764,74 @@ class SqlAdvisorTest extends SqlValidatorTestCase {
         Arrays.asList(
             "TABLE(T)");
 
-    sql =
-        "select ^t.dummy from (select 1 as x, 2 as y from sales.emp) as t where t.dummy=1";
-    assertHint(
-        sql, EXPR_KEYWORDS, getSelectKeywords(), xyColumns, tTable);
+    sql = "select ^t.dummy from (\n"
+        + "  select 1 as x, 2 as y from sales.emp) as t\n"
+        + "where t.dummy=1";
+    f.withSql(sql)
+        .assertHint(EXPR_KEYWORDS, getSelectKeywords(), xyColumns, tTable);
 
     sql = "select t.^ from (select 1 as x, 2 as y from sales.emp) as t";
-    assertComplete(sql, xyColumns, STAR_KEYWORD);
+    f.withSql(sql).assertComplete(xyColumns, STAR_KEYWORD);
 
-    sql =
-        "select t.x from (select 1 as x, 2 as y from sales.emp) as t where ^t.dummy=1";
-    assertHint(sql, EXPR_KEYWORDS, tTable, xyColumns);
+    sql = "select t.x from (select 1 as x, 2 as y from sales.emp) as t "
+        + "where ^t.dummy=1";
+    f.withSql(sql).assertHint(EXPR_KEYWORDS, tTable, xyColumns);
 
-    sql =
-        "select t.x from (select 1 as x, 2 as y from sales.emp) as t where t.^";
-    assertComplete(sql, xyColumns);
+    sql = "select t.x\n"
+        + "from (select 1 as x, 2 as y from sales.emp) as t\n"
+        + "where t.^";
+    f.withSql(sql).assertComplete(xyColumns);
 
-    sql =
-        "select t.x from (select 1 as x, 2 as y from sales.emp) as t where ^";
-    assertComplete(sql, EXPR_KEYWORDS, tTable, xyColumns);
+    sql = "select t.x from (select 1 as x, 2 as y from sales.emp) as t where ^";
+    f.withSql(sql).assertComplete(EXPR_KEYWORDS, tTable, xyColumns);
 
     // with extra from item, aliases are ambiguous, so columns are not
     // offered
-    sql =
-        "select a.x from (select 1 as x, 2 as y from sales.emp) as a, dept as b where ^";
-    assertComplete(sql, EXPR_KEYWORDS, AB_TABLES);
+    sql = "select a.x\n"
+        + "from (select 1 as x, 2 as y from sales.emp) as a,\n"
+        + "  dept as b\n"
+        + "where ^";
+    f.withSql(sql).assertComplete(EXPR_KEYWORDS, AB_TABLES);
 
     // note that we get hints even though there's a syntax error in
     // select clause ('t.')
-    sql =
-        "select t. from (select 1 as x, 2 as y from (select x from sales.emp)) as t where ^";
-    String simplified =
-        "SELECT * FROM ( SELECT 1 as x , 2 as y FROM ( SELECT x FROM sales.emp ) ) as t WHERE _suggest_";
-    assertSimplify(sql, simplified);
-    assertComplete(sql, EXPR_KEYWORDS, tTable, xyColumns);
+    sql = "select t.\n"
+        + "from (select 1 as x, 2 as y from (select x from sales.emp)) as t\n"
+        + "where ^";
+    String simplified = "SELECT * "
+        + "FROM ( SELECT 1 as x , 2 as y FROM ( SELECT x FROM sales.emp ) ) as t "
+        + "WHERE _suggest_";
+    f.withSql(sql)
+        .assertSimplify(simplified)
+        .assertComplete(EXPR_KEYWORDS, tTable, xyColumns);
 
     sql = "select t.x from (select 1 as x, 2 as y from sales.^) as t";
-    assertComplete(sql, getSalesTables());
+    f.withSql(sql).assertComplete(getSalesTables());
 
     // CALCITE-3474:SqlSimpleParser toke.s equals NullPointerException
     sql = "select ^ from (select * from sales.emp) as t";
-    assertComplete(sql, getSelectKeywords(), tTable, EMP_COLUMNS, EXPR_KEYWORDS);
+    f.withSql(sql)
+        .assertComplete(getSelectKeywords(), tTable, EMP_COLUMNS,
+            EXPR_KEYWORDS);
   }
 
   @Test void testSubQueryInWhere() {
-    String sql;
-
     // Aliases from enclosing sub-queries are inherited: hence A from
     // enclosing, B from same scope.
     // The raw columns from dept are suggested (because they can
     // be used unqualified in the inner scope) but the raw
     // columns from emp are not (because they would need to be qualified
     // with A).
-    sql =
-        "select * from sales.emp a where deptno in ("
-            + "select * from sales.dept b where ^)";
-    String simplifiedSql =
-        "SELECT * FROM sales.emp a WHERE deptno in ("
-            + " SELECT * FROM sales.dept b WHERE _suggest_ )";
-    assertSimplify(sql, simplifiedSql);
-    assertComplete(
-        sql,
-        AB_TABLES,
-        DEPT_COLUMNS,
-        EXPR_KEYWORDS);
+    String sql = "select * from sales.emp a where deptno in ("
+        + "select * from sales.dept b where ^)";
+    String simplifiedSql = "SELECT * FROM sales.emp a WHERE deptno in ("
+        + " SELECT * FROM sales.dept b WHERE _suggest_ )";
+    fixture().withSql(sql)
+        .assertSimplify(simplifiedSql)
+        .assertComplete(
+            AB_TABLES,
+            DEPT_COLUMNS,
+            EXPR_KEYWORDS);
   }
 
   @Test void testSimpleParserTokenizer() {
@@ -1056,71 +899,75 @@ class SqlAdvisorTest extends SqlValidatorTestCase {
             + "SQID('quoted')\n"
             + "SQID('string with ''single and \"double\"\" quote')\n"
             + "RPAREN\n";
-    assertTokenizesTo(sql, expected);
+    final Fixture f = fixture();
+    f.withSql(sql).assertTokenizesTo(expected);
 
     // Tokenizer should be lenient if input ends mid-token
-    assertTokenizesTo("select /* unfinished comment", "SELECT\nCOMMENT\n");
-    assertTokenizesTo("select // unfinished comment", "SELECT\nCOMMENT\n");
-    assertTokenizesTo(
-        "'starts with string'",
-        "SQID('starts with string')\n");
-    assertTokenizesTo("'unfinished string", "SQID('unfinished string)\n");
-    assertTokenizesTo(
-        "\"unfinished double-quoted id",
-        "DQID(\"unfinished double-quoted id)\n");
-    assertTokenizesTo("123", "ID(123)\n");
+    f.withSql("select /* unfinished comment")
+        .assertTokenizesTo("SELECT\nCOMMENT\n");
+    f.withSql("select // unfinished comment")
+        .assertTokenizesTo("SELECT\nCOMMENT\n");
+    f.withSql("'starts with string'")
+        .assertTokenizesTo("SQID('starts with string')\n");
+    f.withSql("'unfinished string")
+        .assertTokenizesTo("SQID('unfinished string)\n");
+    f.withSql("\"unfinished double-quoted id")
+        .assertTokenizesTo("DQID(\"unfinished double-quoted id)\n");
+    f.withSql("123")
+        .assertTokenizesTo("ID(123)\n");
   }
 
   @Test void testSimpleParser() {
+    final Fixture f = fixture();
     String sql;
     String expected;
 
     // from
     sql = "select * from ^where";
     expected = "SELECT * FROM _suggest_";
-    assertSimplify(sql, expected);
+    f.withSql(sql).assertSimplify(expected);
 
     // from
     sql = "select a.empno, b.deptno from ^";
     expected = "SELECT * FROM _suggest_";
-    assertSimplify(sql, expected);
+    f.withSql(sql).assertSimplify(expected);
 
     // select list
     sql = "select ^ from (values (1))";
     expected = "SELECT _suggest_ FROM ( values ( 1 ) )";
-    assertSimplify(sql, expected);
+    f.withSql(sql).assertSimplify(expected);
 
     sql = "select emp.^ from sales.emp";
     expected = "SELECT emp. _suggest_ FROM sales.emp";
-    assertSimplify(sql, expected);
+    f.withSql(sql).assertSimplify(expected);
 
     sql = "select ^from sales.emp";
     expected = "SELECT _suggest_ FROM sales.emp";
-    assertSimplify(sql, expected);
+    f.withSql(sql).assertSimplify(expected);
 
     // remove other expressions in select clause
     sql = "select a.empno ,^  from sales.emp a , sales.dept b";
     expected = "SELECT _suggest_ FROM sales.emp a , sales.dept b";
-    assertSimplify(sql, expected);
+    f.withSql(sql).assertSimplify(expected);
 
     sql = "select ^, a.empno from sales.emp a , sales.dept b";
     expected = "SELECT _suggest_ FROM sales.emp a , sales.dept b";
-    assertSimplify(sql, expected);
+    f.withSql(sql).assertSimplify(expected);
 
     sql = "select dummy, b.^ from sales.emp a , sales.dept b";
     expected = "SELECT b. _suggest_ FROM sales.emp a , sales.dept b";
-    assertSimplify(sql, expected);
+    f.withSql(sql).assertSimplify(expected);
 
     // join
     sql = "select a.empno, b.deptno from dummy a join ^on where empno=1";
     expected = "SELECT * FROM dummy a JOIN _suggest_ ON TRUE";
-    assertSimplify(sql, expected);
+    f.withSql(sql).assertSimplify(expected);
 
     // join
     sql =
         "select a.empno, b.deptno from dummy a join sales.^ where empno=1";
     expected = "SELECT * FROM dummy a JOIN sales. _suggest_";
-    assertSimplify(sql, expected);
+    f.withSql(sql).assertSimplify(expected);
 
     // on
     sql =
@@ -1129,19 +976,19 @@ class SqlAdvisorTest extends SqlValidatorTestCase {
     expected =
         "SELECT * FROM sales.emp a JOIN sales.dept b "
             + "ON a.deptno= _suggest_";
-    assertSimplify(sql, expected);
+    f.withSql(sql).assertSimplify(expected);
 
     // where
     sql =
         "select a.empno, b.deptno from sales.emp a, sales.dept b "
             + "where ^";
     expected = "SELECT * FROM sales.emp a , sales.dept b WHERE _suggest_";
-    assertSimplify(sql, expected);
+    f.withSql(sql).assertSimplify(expected);
 
     // order by
     sql = "select emp.empno from sales.emp where empno=1 order by ^";
     expected = "SELECT emp.empno FROM sales.emp ORDER BY _suggest_";
-    assertSimplify(sql, expected);
+    f.withSql(sql).assertSimplify(expected);
 
     // sub-query in from
     sql =
@@ -1150,7 +997,7 @@ class SqlAdvisorTest extends SqlValidatorTestCase {
     expected =
         "SELECT t. _suggest_ "
             + "FROM ( SELECT 1 as x , 2 as y FROM sales.emp ) as t";
-    assertSimplify(sql, expected);
+    f.withSql(sql).assertSimplify(expected);
 
     sql =
         "select t. from (select 1 as x, 2 as y from "
@@ -1158,7 +1005,7 @@ class SqlAdvisorTest extends SqlValidatorTestCase {
     expected =
         "SELECT * FROM ( SELECT 1 as x , 2 as y FROM "
             + "( SELECT x FROM sales.emp ) ) as t WHERE _suggest_";
-    assertSimplify(sql, expected);
+    f.withSql(sql).assertSimplify(expected);
 
     sql =
         "select ^from (select 1 as x, 2 as y from sales.emp), "
@@ -1167,18 +1014,18 @@ class SqlAdvisorTest extends SqlValidatorTestCase {
     expected =
         "SELECT _suggest_ FROM ( SELECT 1 as x , 2 as y FROM sales.emp ) "
             + ", ( SELECT 2 as y FROM ( SELECT m FROM n ) ) as t";
-    assertSimplify(sql, expected);
+    f.withSql(sql).assertSimplify(expected);
 
     // Note: completes the missing close paren; wipes out select clause of
     // both outer and inner queries since not relevant.
     sql = "select t.x from ( select 1 as x, 2 as y from sales.^";
     expected = "SELECT * FROM ( SELECT * FROM sales. _suggest_ )";
-    assertSimplify(sql, expected);
+    f.withSql(sql).assertSimplify(expected);
 
     sql = "select t.^ from (select 1 as x, 2 as y from sales)";
     expected =
         "SELECT t. _suggest_ FROM ( SELECT 1 as x , 2 as y FROM sales )";
-    assertSimplify(sql, expected);
+    f.withSql(sql).assertSimplify(expected);
 
     // sub-query in where; note that:
     // 1. removes the SELECT clause of sub-query in WHERE clause;
@@ -1192,17 +1039,17 @@ class SqlAdvisorTest extends SqlValidatorTestCase {
     expected =
         "SELECT * FROM ( SELECT 1 as x , 2 as y FROM sales ) as t "
             + "WHERE x in ( SELECT * FROM emp WHERE foo + t. _suggest_ < 10 )";
-    assertSimplify(sql, expected);
+    f.withSql(sql).assertSimplify(expected);
 
     // if hint is in FROM, can remove other members of FROM clause
     sql = "select a.empno, b.deptno from dummy a, sales.^";
     expected = "SELECT * FROM sales. _suggest_";
-    assertSimplify(sql, expected);
+    f.withSql(sql).assertSimplify(expected);
 
     // function
     sql = "select count(1) from sales.emp a where ^";
     expected = "SELECT * FROM sales.emp a WHERE _suggest_";
-    assertSimplify(sql, expected);
+    f.withSql(sql).assertSimplify(expected);
 
     sql =
         "select count(1) from sales.emp a "
@@ -1210,7 +1057,7 @@ class SqlAdvisorTest extends SqlValidatorTestCase {
     expected =
         "SELECT * FROM sales.emp a "
             + "WHERE substring ( a. _suggest_ FROM 3 for 6 ) = '1234'";
-    assertSimplify(sql, expected);
+    f.withSql(sql).assertSimplify(expected);
 
     // missing ')' following sub-query
     sql =
@@ -1219,7 +1066,7 @@ class SqlAdvisorTest extends SqlValidatorTestCase {
     expected =
         "SELECT * FROM sales.emp a WHERE deptno in ("
             + " SELECT * FROM sales.dept b WHERE _suggest_ )";
-    assertSimplify(sql, expected);
+    f.withSql(sql).assertSimplify(expected);
 
     // keyword embedded in single and double quoted string should be
     // ignored
@@ -1227,47 +1074,48 @@ class SqlAdvisorTest extends SqlValidatorTestCase {
         "select 'a cat from a king' as foobar, 1 / 2 \"where\" from t "
             + "group by t.^ order by 123";
     expected = "SELECT * FROM t GROUP BY t. _suggest_";
-    assertSimplify(sql, expected);
+    f.withSql(sql).assertSimplify(expected);
 
     // skip comments
-    sql =
-        "select /* here is from */ 'cat' as foobar, 1 as x from t group by t.^ order by 123";
+    sql = "select /* here is from */ 'cat' as foobar, 1 as x\n"
+        + "from t group by t.^ order by 123";
     expected = "SELECT * FROM t GROUP BY t. _suggest_";
-    assertSimplify(sql, expected);
+    f.withSql(sql).assertSimplify(expected);
 
     // skip comments
-    sql =
-        "select // here is from clause\n 'cat' as foobar, 1 as x from t group by t.^ order by 123";
+    sql = "select // here is from clause\n"
+        + " 'cat' as foobar, 1 as x from t group by t.^ order by 123";
     expected = "SELECT * FROM t GROUP BY t. _suggest_";
-    assertSimplify(sql, expected);
+    f.withSql(sql).assertSimplify(expected);
 
     // skip comments
-    sql =
-        "select -- here is from clause\n 'cat' as foobar, 1 as x from t group by t.^ order by 123";
+    sql = "select -- here is from clause\n"
+        + " 'cat' as foobar, 1 as x from t group by t.^ order by 123";
     expected = "SELECT * FROM t GROUP BY t. _suggest_";
-    assertSimplify(sql, expected);
+    f.withSql(sql).assertSimplify(expected);
 
     // skip comments
-    sql =
-        "-- test test\nselect -- here is from\n'cat' as foobar, 1 as x from t group by t.^ order by 123";
+    sql = "-- test test\n"
+        + "select -- here is from\n"
+        + "'cat' as foobar, 1 as x from t group by t.^ order by 123";
     expected = "SELECT * FROM t GROUP BY t. _suggest_";
-    assertSimplify(sql, expected);
+    f.withSql(sql).assertSimplify(expected);
   }
 
-  @WithLex(Lex.SQL_SERVER) @Test void testSimpleParserQuotedIdSqlServer() {
-    testSimpleParserQuotedIdImpl();
+  @Test void testSimpleParserQuotedIdSqlServer() {
+    checkSimpleParserQuotedIdImpl(fixture().withLex(Lex.SQL_SERVER));
   }
 
-  @WithLex(Lex.MYSQL) @Test void testSimpleParserQuotedIdMySql() {
-    testSimpleParserQuotedIdImpl();
+  @Test void testSimpleParserQuotedIdMySql() {
+    checkSimpleParserQuotedIdImpl(fixture().withLex(Lex.MYSQL));
   }
 
-  @WithLex(Lex.JAVA) @Test void testSimpleParserQuotedIdJava() {
-    testSimpleParserQuotedIdImpl();
+  @Test void testSimpleParserQuotedIdJava() {
+    checkSimpleParserQuotedIdImpl(fixture().withLex(Lex.JAVA));
   }
 
   @Test void testSimpleParserQuotedIdDefault() {
-    testSimpleParserQuotedIdImpl();
+    checkSimpleParserQuotedIdImpl(fixture());
   }
 
   private String replaceQuotes(SqlParser.Config parserConfig, String sql) {
@@ -1276,33 +1124,38 @@ class SqlAdvisorTest extends SqlValidatorTestCase {
     return sql.replace('[', openQuote).replace(']', closeQuote);
   }
 
-  private void testSimpleParserQuotedIdImpl() {
-    SqlParser.Config parserConfig = tester.getFactory().getParserConfig();
+  private void checkSimpleParserQuotedIdImpl(Fixture fixture) {
+    SqlParser.Config parserConfig = fixture.parserConfig();
     String sql;
     String expected;
 
     // unclosed double-quote
     sql = replaceQuotes(parserConfig, "select * from t where [^");
     expected = replaceQuotes(parserConfig, "SELECT * FROM t WHERE _suggest_");
-    assertSimplify(sql, expected);
+    fixture.withSql(sql).assertSimplify(expected);
 
     // closed double-quote
     sql = replaceQuotes(parserConfig, "select * from t where [^] and x = y");
-    expected = replaceQuotes(parserConfig, "SELECT * FROM t WHERE _suggest_ and x = y");
-    assertSimplify(sql, expected);
+    expected = replaceQuotes(parserConfig,
+        "SELECT * FROM t WHERE _suggest_ and x = y");
+    fixture.withSql(sql).assertSimplify(expected);
 
     // closed double-quote containing extra stuff
     sql = replaceQuotes(parserConfig, "select * from t where [^foo] and x = y");
-    expected = replaceQuotes(parserConfig, "SELECT * FROM t WHERE _suggest_ and x = y");
-    assertSimplify(sql, expected);
+    expected = replaceQuotes(parserConfig,
+        "SELECT * FROM t WHERE _suggest_ and x = y");
+    fixture.withSql(sql).assertSimplify(expected);
 
     // escaped double-quote containing extra stuff
-    sql = replaceQuotes(parserConfig, "select * from t where [^f]]oo] and x = y");
-    expected = replaceQuotes(parserConfig, "SELECT * FROM t WHERE _suggest_ and x = y");
-    assertSimplify(sql, expected);
+    sql = replaceQuotes(parserConfig,
+        "select * from t where [^f]]oo] and x = y");
+    expected = replaceQuotes(parserConfig,
+        "SELECT * FROM t WHERE _suggest_ and x = y");
+    fixture.withSql(sql).assertSimplify(expected);
   }
 
   @Test void testPartialIdentifier() {
+    final Fixture f = fixture();
     String sql = "select * from emp where e^ and emp.deptno = 10";
     String expected =
         "COLUMN(EMPNO)\n"
@@ -1313,9 +1166,10 @@ class SqlAdvisorTest extends SqlValidatorTestCase {
             + "KEYWORD(EXP)\n"
             + "KEYWORD(EXTRACT)\n"
             + "TABLE(EMP)\n";
-    assertComplete(sql, expected, "e",
-        ImmutableMap.of("KEYWORD(EXISTS)", "exists",
-            "TABLE(EMP)", "emp"));
+    f.withSql(sql)
+        .assertComplete(expected, "e",
+            ImmutableMap.of("KEYWORD(EXISTS)", "exists",
+                "TABLE(EMP)", "emp"));
 
     sql = "select * from emp where \"e^ and emp.deptno = 10";
     expected =
@@ -1327,9 +1181,10 @@ class SqlAdvisorTest extends SqlValidatorTestCase {
             + "KEYWORD(EXP)\n"
             + "KEYWORD(EXTRACT)\n"
             + "TABLE(EMP)\n";
-    assertComplete(sql, expected, "\"e",
-        ImmutableMap.of("KEYWORD(EXISTS)", "exists",
-            "TABLE(EMP)", "\"EMP\""));
+    f.withSql(sql)
+        .assertComplete(expected, "\"e",
+            ImmutableMap.of("KEYWORD(EXISTS)", "exists",
+                "TABLE(EMP)", "\"EMP\""));
 
     sql = "select * from emp where E^ and emp.deptno = 10";
     expected =
@@ -1341,259 +1196,256 @@ class SqlAdvisorTest extends SqlValidatorTestCase {
             + "KEYWORD(EXP)\n"
             + "KEYWORD(EXTRACT)\n"
             + "TABLE(EMP)\n";
-    assertComplete(sql, expected, "E",
-        ImmutableMap.of("KEYWORD(EXISTS)", "EXISTS",
-            "TABLE(EMP)", "EMP"));
+    f.withSql(sql)
+        .assertComplete(expected, "E",
+            ImmutableMap.of("KEYWORD(EXISTS)", "EXISTS",
+                "TABLE(EMP)", "EMP"));
 
     // cursor in middle of word and at end
     sql = "select * from emp where e^";
-    assertComplete(sql, expected, null);
+    f.withSql(sql)
+        .assertComplete(expected, null);
 
     // longer completion
     sql = "select * from emp where em^";
-    assertComplete(sql, EMPNO_EMP, null, ImmutableMap.of("COLUMN(EMPNO)", "empno"));
+    f.withSql(sql)
+        .assertComplete(EMPNO_EMP, null,
+            ImmutableMap.of("COLUMN(EMPNO)", "empno"));
 
     // word after punctuation
     sql = "select deptno,em^ from emp where 1+2<3+4";
-    assertComplete(sql, EMPNO_EMP, null, ImmutableMap.of("COLUMN(EMPNO)", "empno"));
+    f.withSql(sql)
+        .assertComplete(EMPNO_EMP, null,
+            ImmutableMap.of("COLUMN(EMPNO)", "empno"));
 
     // inside double-quotes, no terminating double-quote.
     // Only identifiers should be suggested (no keywords),
     // and suggestion should include double-quotes
     sql = "select deptno,\"EM^ from emp where 1+2<3+4";
-    assertComplete(sql, EMPNO_EMP, "\"EM", ImmutableMap.of("COLUMN(EMPNO)", "\"EMPNO\""));
+    f.withSql(sql)
+        .assertComplete(EMPNO_EMP, "\"EM",
+            ImmutableMap.of("COLUMN(EMPNO)", "\"EMPNO\""));
 
     // inside double-quotes, match is case-insensitive as well
     sql = "select deptno,\"em^ from emp where 1+2<3+4";
-    assertComplete(sql, EMPNO_EMP, "\"em", ImmutableMap.of("COLUMN(EMPNO)", "\"EMPNO\""));
+    f.withSql(sql)
+        .assertComplete(EMPNO_EMP, "\"em",
+            ImmutableMap.of("COLUMN(EMPNO)", "\"EMPNO\""));
 
     // when input strings has mixed casing, match should be case-sensitive
     sql = "select deptno,eM^ from emp where 1+2<3+4";
-    assertComplete(sql, "", "eM");
+    f.withSql(sql).assertComplete("", "eM");
 
     // when input strings has mixed casing, match should be case-sensitive
     sql = "select deptno,\"eM^ from emp where 1+2<3+4";
-    assertComplete(sql, "", "\"eM");
+    f.withSql(sql).assertComplete("", "\"eM");
 
     // eat up following double-quote
     sql = "select deptno,\"EM^ps\" from emp where 1+2<3+4";
-    assertComplete(sql, EMPNO_EMP, "\"EM", ImmutableMap.of("COLUMN(EMPNO)", "\"EMPNO\""));
+    f.withSql(sql)
+        .assertComplete(EMPNO_EMP, "\"EM",
+            ImmutableMap.of("COLUMN(EMPNO)", "\"EMPNO\""));
 
     // closing double-quote is at very end of string
     sql = "select * from emp where 5 = \"EM^xxx\"";
-    assertComplete(sql, EMPNO_EMP, "\"EM", ImmutableMap.of("COLUMN(EMPNO)", "\"EMPNO\""));
+    f.withSql(sql)
+        .assertComplete(EMPNO_EMP, "\"EM",
+            ImmutableMap.of("COLUMN(EMPNO)", "\"EMPNO\""));
 
     // just before dot
     sql = "select emp.^name from emp";
-    assertComplete(sql, EMP_COLUMNS, STAR_KEYWORD);
+    f.withSql(sql).assertComplete(EMP_COLUMNS, STAR_KEYWORD);
   }
 
-  @Test @WithLex(Lex.JAVA) public void testAdviceKeywordsJava() {
-    String sql;
-    sql = "select deptno, exi^ from emp where 1+2<3+4";
-    assertComplete(sql, "KEYWORD(EXISTS)\n", "exi",
-        ImmutableMap.of("KEYWORD(EXISTS)", "exists"));
+  @Test void testAdviceKeywordsJava() {
+    String sql = "select deptno, exi^ from emp where 1+2<3+4";
+    fixture().withSql(sql).withLex(Lex.JAVA)
+        .assertComplete("KEYWORD(EXISTS)\n", "exi",
+            ImmutableMap.of("KEYWORD(EXISTS)", "exists"));
   }
 
-  @Test @WithLex(Lex.JAVA) public void testAdviceMixedCase() {
-    String sql;
-    sql = "select is^ from (select 1 isOne from emp)";
-    assertComplete(sql, "COLUMN(isOne)\n", "is",
-        ImmutableMap.of("COLUMN(isOne)", "isOne"));
+  @Test void testAdviceMixedCase() {
+    String sql = "select is^ from (select 1 isOne from emp)";
+    fixture().withSql(sql).withLex(Lex.JAVA)
+        .assertComplete("COLUMN(isOne)\n", "is",
+            ImmutableMap.of("COLUMN(isOne)", "isOne"));
   }
 
-  @Test @WithLex(Lex.JAVA) public void testAdviceExpression() {
-    String sql;
-    sql = "select s.`count`+s.co^ from (select 1 `count` from emp) s";
-    assertComplete(sql, "COLUMN(count)\n", "co",
-        ImmutableMap.of("COLUMN(count)", "`count`"));
+  @Test void testAdviceExpression() {
+    String sql = "select s.`count`+s.co^ from (select 1 `count` from emp) s";
+    fixture().withSql(sql).withLex(Lex.JAVA)
+        .assertComplete("COLUMN(count)\n", "co",
+            ImmutableMap.of("COLUMN(count)", "`count`"));
   }
 
-  @Test @WithLex(Lex.JAVA) public void testAdviceEmptyFrom() {
-    String sql;
-    sql = "select * from^";
-    assertComplete(sql, "KEYWORD(FROM)\n", "from",
-        ImmutableMap.of("KEYWORD(FROM)", "from"));
+  @Test void testAdviceEmptyFrom() {
+    String sql = "select * from^";
+    fixture().withSql(sql).withLex(Lex.JAVA)
+        .assertComplete("KEYWORD(FROM)\n", "from",
+            ImmutableMap.of("KEYWORD(FROM)", "from"));
   }
 
   @Disabled("Inserts are not supported by SimpleParser yet")
-  @Test void testInsert() throws Exception {
+  @Test void testInsert() {
+    final Fixture f = fixture();
     String sql;
+
     sql = "insert into emp(empno, mgr) select ^ from dept a";
-    assertComplete(
-        sql,
-        getSelectKeywords(),
-        EXPR_KEYWORDS,
-        A_TABLE,
-        DEPT_COLUMNS,
-        SETOPS,
-        FETCH_OFFSET);
+    f.withSql(sql)
+        .assertComplete(getSelectKeywords(),
+            EXPR_KEYWORDS,
+            A_TABLE,
+            DEPT_COLUMNS,
+            SETOPS,
+            FETCH_OFFSET);
 
     sql = "insert into emp(empno, mgr) values (123, 3 + ^)";
-    assertComplete(sql, EXPR_KEYWORDS);
+    f.withSql(sql).assertComplete(EXPR_KEYWORDS);
 
     // Wish we could do better here. Parser gives error 'Non-query
     // expression encountered in illegal context' and cannot suggest
     // possible tokens.
     sql = "insert into emp(empno, mgr) ^";
-    assertComplete(sql, "", null);
+    f.withSql(sql).assertComplete("", null);
   }
 
-  @Test void testNestSchema() throws Exception {
+  @Test void testNestSchema() {
+    final Fixture f = fixture();
     String sql;
+
     sql = "select * from sales.n^";
-    assertComplete(
-        sql,
-        "SCHEMA(CATALOG.SALES.NEST)\n",
-        "n",
-        ImmutableMap.of("SCHEMA(CATALOG.SALES.NEST)", "nest"));
+    f.withSql(sql)
+        .assertComplete("SCHEMA(CATALOG.SALES.NEST)\n", "n",
+            ImmutableMap.of("SCHEMA(CATALOG.SALES.NEST)", "nest"));
 
     sql = "select * from sales.\"n^asfasdf";
-    assertComplete(
-        sql,
-        "SCHEMA(CATALOG.SALES.NEST)\n",
-        "\"n",
-        ImmutableMap.of("SCHEMA(CATALOG.SALES.NEST)", "\"NEST\""));
+    f.withSql(sql)
+        .assertComplete("SCHEMA(CATALOG.SALES.NEST)\n", "\"n",
+            ImmutableMap.of("SCHEMA(CATALOG.SALES.NEST)", "\"NEST\""));
 
     sql = "select * from sales.n^est";
-    assertComplete(
-        sql,
-        "SCHEMA(CATALOG.SALES.NEST)\n",
-        "n",
-        ImmutableMap.of("SCHEMA(CATALOG.SALES.NEST)", "nest"));
+    f.withSql(sql)
+        .assertComplete("SCHEMA(CATALOG.SALES.NEST)\n", "n",
+            ImmutableMap.of("SCHEMA(CATALOG.SALES.NEST)", "nest"));
 
     sql = "select * from sales.nu^";
-    assertComplete(sql, "", "nu");
+    f.withSql(sql).assertComplete("", "nu");
   }
 
   @Disabled("The set of completion results is empty")
-  @Test void testNestTable1() throws Exception {
+  @Test void testNestTable1() {
+    final Fixture f = fixture();
     String sql;
+
     // select scott.emp.deptno from scott.emp; # valid
     sql = "select catalog.sales.emp.em^ from catalog.sales.emp";
-    assertComplete(
-        sql,
-        "COLUMN(EMPNO)\n",
-        "em",
-        ImmutableMap.of("COLUMN(EMPNO)", "empno"));
+    f.withSql(sql)
+        .assertComplete("COLUMN(EMPNO)\n", "em",
+            ImmutableMap.of("COLUMN(EMPNO)", "empno"));
 
     sql = "select catalog.sales.em^ from catalog.sales.emp";
-    assertComplete(
-        sql,
-        "TABLE(EMP)\n",
-        "em",
-        ImmutableMap.of("TABLE(EMP)", "emp"));
+    f.withSql(sql)
+        .assertComplete("TABLE(EMP)\n", "em",
+            ImmutableMap.of("TABLE(EMP)", "emp"));
   }
 
-  @Test void testNestTable2() throws Exception {
-    String sql;
+  @Test void testNestTable2() {
     // select scott.emp.deptno from scott.emp as e; # not valid
-    sql = "select catalog.sales.emp.em^ from catalog.sales.emp as e";
-    assertComplete(
-        sql,
-        "",
-        "em");
+    String sql = "select catalog.sales.emp.em^ from catalog.sales.emp as e";
+    fixture().withSql(sql)
+        .assertComplete("", "em");
   }
 
 
   @Disabled("The set of completion results is empty")
-  @Test void testNestTable3() throws Exception {
+  @Test void testNestTable3() {
     String sql;
+
     // select scott.emp.deptno from emp; # valid
     sql = "select catalog.sales.emp.em^ from emp";
-    assertComplete(
-        sql,
-        "COLUMN(EMPNO)\n",
-        "em",
-        ImmutableMap.of("COLUMN(EMP)", "empno"));
+    fixture().withSql(sql)
+        .assertComplete("COLUMN(EMPNO)\n", "em",
+            ImmutableMap.of("COLUMN(EMP)", "empno"));
 
     sql = "select catalog.sales.em^ from emp";
-    assertComplete(
-        sql,
-        "TABLE(EMP)\n",
-        "em",
-        ImmutableMap.of("TABLE(EMP)", "emp"));
+    fixture().withSql(sql)
+        .assertComplete("TABLE(EMP)\n", "em",
+            ImmutableMap.of("TABLE(EMP)", "emp"));
   }
 
-  @Test void testNestTable4() throws Exception {
-    String sql;
+  @Test void testNestTable4() {
     // select scott.emp.deptno from emp as emp; # not valid
-    sql = "select catalog.sales.emp.em^ from catalog.sales.emp as emp";
-    assertComplete(
-        sql,
-        "",
-        "em");
+    String sql = "select catalog.sales.emp.em^ from catalog.sales.emp as emp";
+    fixture().withSql(sql)
+        .assertComplete("", "em");
   }
 
-  @Test void testNestTableSchemaMustMatch() throws Exception {
+  @Test void testNestTableSchemaMustMatch() {
     String sql;
+
     // select foo.emp.deptno from emp; # not valid
     sql = "select sales.nest.em^ from catalog.sales.emp_r";
-    assertComplete(
-        sql,
-        "",
-        "em");
+    fixture().withSql(sql)
+        .assertComplete("", "em");
   }
 
-  @WithLex(Lex.SQL_SERVER) @Test void testNestSchemaSqlServer() throws Exception {
-    String sql;
-    sql = "select * from SALES.N^";
-    assertComplete(
-        sql,
-        "SCHEMA(CATALOG.SALES.NEST)\n",
-        "N",
-        ImmutableMap.of("SCHEMA(CATALOG.SALES.NEST)", "NEST"));
-
-    sql = "select * from SALES.[n^asfasdf";
-    assertComplete(
-        sql,
-        "SCHEMA(CATALOG.SALES.NEST)\n",
-        "[n",
-        ImmutableMap.of("SCHEMA(CATALOG.SALES.NEST)", "[NEST]"));
-
-    sql = "select * from SALES.[N^est";
-    assertComplete(
-        sql,
-        "SCHEMA(CATALOG.SALES.NEST)\n",
-        "[N",
-        ImmutableMap.of("SCHEMA(CATALOG.SALES.NEST)", "[NEST]"));
-
-    sql = "select * from SALES.NU^";
-    assertComplete(sql, "", "NU");
+  @Test void testNestSchemaSqlServer() {
+    final Fixture f = fixture().withLex(Lex.SQL_SERVER);
+    f.withSql("select * from SALES.N^")
+        .assertComplete("SCHEMA(CATALOG.SALES.NEST)\n", "N",
+            ImmutableMap.of("SCHEMA(CATALOG.SALES.NEST)", "NEST"));
+
+    f.withSql("select * from SALES.[n^asfasdf")
+        .assertComplete("SCHEMA(CATALOG.SALES.NEST)\n", "[n",
+            ImmutableMap.of("SCHEMA(CATALOG.SALES.NEST)", "[NEST]"));
+
+    f.withSql("select * from SALES.[N^est")
+        .assertComplete("SCHEMA(CATALOG.SALES.NEST)\n", "[N",
+            ImmutableMap.of("SCHEMA(CATALOG.SALES.NEST)", "[NEST]"));
+
+    f.withSql("select * from SALES.NU^")
+        .assertComplete("", "NU");
   }
 
-  @Test void testUnion() throws Exception {
+  @Test void testUnion() {
     // we simplify set ops such as UNION by removing other queries -
     // thereby avoiding validation errors due to mismatched select lists
     String sql =
         "select 1 from emp union select 2 from dept a where ^ and deptno < 5";
     String simplified =
         "SELECT * FROM dept a WHERE _suggest_ and deptno < 5";
-    assertSimplify(sql, simplified);
-    assertComplete(sql, EXPR_KEYWORDS, A_TABLE, DEPT_COLUMNS);
+    final Fixture f = fixture();
+    f.withSql(sql)
+        .assertSimplify(simplified)
+        .assertComplete(EXPR_KEYWORDS, A_TABLE, DEPT_COLUMNS);
 
     // UNION ALL
-    sql =
-        "select 1 from emp union all select 2 from dept a where ^ and deptno < 5";
-    assertSimplify(sql, simplified);
+    sql = "select 1 from emp\n"
+        + "union all\n"
+        + "select 2 from dept a where ^ and deptno < 5";
+    f.withSql(sql).assertSimplify(simplified);
 
     // hint is in first query
     sql = "select 1 from emp group by ^ except select 2 from dept a";
     simplified = "SELECT * FROM emp GROUP BY _suggest_";
-    assertSimplify(sql, simplified);
+    f.withSql(sql).assertSimplify(simplified);
   }
 
-  @WithLex(Lex.SQL_SERVER) @Test void testMssql() {
-    String sql =
-        "select 1 from [emp] union select 2 from [DEPT] a where ^ and deptno < 5";
+  @Test void testMssql() {
+    String sql = "select 1 from [emp]\n"
+        + "union\n"
+        + "select 2 from [DEPT] a where ^ and deptno < 5";
     String simplified =
         "SELECT * FROM [DEPT] a WHERE _suggest_ and deptno < 5";
-    assertSimplify(sql, simplified);
-    assertComplete(sql, EXPR_KEYWORDS, Collections.singletonList("TABLE(a)"), DEPT_COLUMNS);
+    fixture()
+        .withLex(Lex.SQL_SERVER)
+        .withSql(sql)
+        .assertSimplify(simplified)
+        .assertComplete(EXPR_KEYWORDS, Collections.singletonList("TABLE(a)"),
+            DEPT_COLUMNS);
   }
 
-
-  @Test public void testFilterComment() {
+  @Test void testFilterComment() {
     // SqlSimpleParser.Tokenizer#nextToken() lines 401 - 423
     // is used to recognize the sql of TokenType.ID or some keywords
     // if a certain segment of characters is continuously composed of Token,
@@ -1618,13 +1470,16 @@ class SqlAdvisorTest extends SqlValidatorTestCase {
     assertSimplifySql(originSql, baseResultSql + "WHERE price > 10.0");
 
     originSql = baseOriginSql + "where column_b='/* this is not comment */'";
-    assertSimplifySql(originSql, baseResultSql + "WHERE column_b= '/* this is not comment */'");
+    assertSimplifySql(originSql,
+        baseResultSql + "WHERE column_b= '/* this is not comment */'");
 
     originSql = baseOriginSql + "where column_b='2021 --this is not comment'";
-    assertSimplifySql(originSql, baseResultSql + "WHERE column_b= '2021 --this is not comment'");
+    assertSimplifySql(originSql,
+        baseResultSql + "WHERE column_b= '2021 --this is not comment'");
 
     originSql = baseOriginSql + "where column_b='2021--this is not comment'";
-    assertSimplifySql(originSql, baseResultSql + "WHERE column_b= '2021--this is not comment'");
+    assertSimplifySql(originSql,
+        baseResultSql + "WHERE column_b= '2021--this is not comment'");
   }
 
   /**
@@ -1638,6 +1493,193 @@ class SqlAdvisorTest extends SqlValidatorTestCase {
         new SqlSimpleParser("_suggest_", SqlParser.Config.DEFAULT);
 
     String actualSql = simpleParser.simplifySql(originSql);
-    assertThat("simpleParser.simplifySql(" + originSql + ")", actualSql, equalTo(expectedSql));
+    assertThat("simpleParser.simplifySql(" + originSql + ")",
+        actualSql, equalTo(expectedSql));
+  }
+
+  /** Fixture for the advisor test. */
+  static class Fixture extends SqlValidatorFixture {
+    protected Fixture(SqlTester tester, SqlTestFactory factory,
+        StringAndPos sap, boolean expression, boolean whole) {
+      super(tester, factory, sap, expression, whole);
+    }
+
+    @SuppressWarnings("deprecation")
+    @Override public Fixture withTester(UnaryOperator<SqlTester> transform) {
+      final SqlTester tester = transform.apply(this.tester);
+      return new Fixture(tester, factory, sap, expression, whole);
+    }
+
+    @Override public Fixture withFactory(
+        UnaryOperator<SqlTestFactory> transform) {
+      final SqlTestFactory factory = transform.apply(this.factory);
+      return new Fixture(tester, factory, sap, expression, whole);
+    }
+
+    @Override public Fixture withLex(Lex lex) {
+      return (Fixture) super.withLex(lex);
+    }
+
+    @Override public Fixture withSql(String sql) {
+      return new Fixture(tester, factory, StringAndPos.of(sql), false, false);
+    }
+
+    private void assertTokenizesTo(String expected) {
+      SqlSimpleParser.Tokenizer tokenizer =
+          new SqlSimpleParser.Tokenizer(sap.sql, "xxxxx",
+              factory.parserConfig().quoting());
+      StringBuilder buf = new StringBuilder();
+      while (true) {
+        SqlSimpleParser.Token token = tokenizer.nextToken();
+        if (token == null) {
+          break;
+        }
+        buf.append(token).append("\n");
+      }
+      assertEquals(expected, buf.toString());
+    }
+
+    protected void assertHint(List<String>... expectedLists) {
+      List<String> expectedList = plus(expectedLists);
+      final String expected = toString(new TreeSet<>(expectedList));
+      assertHint(expected);
+    }
+
+    /**
+     * Checks that a given SQL statement yields the expected set of completion
+     * hints.
+     *
+     * @param expectedResults Expected list of hints
+     */
+    protected void assertHint(String expectedResults) {
+      SqlAdvisor advisor = factory.createAdvisor();
+
+      List<SqlMoniker> results =
+          advisor.getCompletionHints(
+              sap.sql,
+              requireNonNull(sap.pos, "sap.pos"));
+      assertEquals(
+          expectedResults, convertCompletionHints(results));
+    }
+
+    /**
+     * Tests that a given SQL statement simplifies to the salesTables result.
+     *
+     * @param expected Expected result after simplification.
+     */
+    protected Fixture assertSimplify(String expected) {
+      SqlAdvisor advisor = factory.createAdvisor();
+
+      String actual = advisor.simplifySql(sap.sql, sap.cursor);
+      assertEquals(expected, actual);
+      return this;
+    }
+
+    protected void assertComplete(List<String>... expectedResults) {
+      assertComplete(null, expectedResults);
+    }
+
+    protected void assertComplete(Map<String, String> replacements,
+        List<String>... expectedResults) {
+      List<String> expectedList = plus(expectedResults);
+      String expected = toString(new TreeSet<>(expectedList));
+      assertComplete(expected, null, replacements);
+    }
+
+    protected void assertComplete(String expectedResults,
+        @Nullable String expectedWord) {
+      assertComplete(expectedResults, expectedWord, null);
+    }
+
+    /**
+     * Tests that a given SQL which may be invalid or incomplete simplifies
+     * itself and yields the salesTables set of completion hints. This is an
+     * integration test of {@link #assertHint} and {@link #assertSimplify}.
+     *
+     * @param expectedResults Expected list of hints
+     * @param expectedWord    Word that we expect to be replaced, or null if we
+     *                        don't care
+     */
+    protected void assertComplete(String expectedResults,
+        @Nullable String expectedWord,
+        @Nullable Map<String, String> replacements) {
+      SqlAdvisor advisor = factory.createAdvisor();
+
+      final String[] replaced = {null};
+      List<SqlMoniker> results =
+          advisor.getCompletionHints(sap.sql, sap.cursor, replaced);
+      assertEquals(expectedResults, convertCompletionHints(results),
+          () -> "Completion hints for " + sap);
+      if (expectedWord != null) {
+        assertEquals(expectedWord, replaced[0],
+            "replaced[0] for " + sap);
+      } else {
+        assertNotNull(replaced[0]);
+      }
+      assertReplacements(replacements, advisor, replaced[0], results);
+    }
+
+    private void assertReplacements(@Nullable Map<String, String> replacements,
+        SqlAdvisor advisor, String word, List<SqlMoniker> results) {
+      if (replacements == null) {
+        return;
+      }
+      Set<String> missingReplacemenets = new HashSet<>(replacements.keySet());
+      for (SqlMoniker result : results) {
+        String id = result.id();
+        String expectedReplacement = replacements.get(id);
+        if (expectedReplacement == null) {
+          continue;
+        }
+        missingReplacemenets.remove(id);
+        String actualReplacement = advisor.getReplacement(result, word);
+        assertEquals(expectedReplacement, actualReplacement,
+            () -> sap + ", replacement of " + word + " with " + id);
+      }
+      if (missingReplacemenets.isEmpty()) {
+        return;
+      }
+      fail("Sql " + sap + " did not produce replacement hints "
+          + missingReplacemenets);
+    }
+
+    private String convertCompletionHints(List<SqlMoniker> hints) {
+      List<String> list = new ArrayList<>();
+      for (SqlMoniker hint : hints) {
+        if (hint.getType() != SqlMonikerType.FUNCTION) {
+          list.add(hint.id());
+        }
+      }
+      Collections.sort(list);
+      return toString(list);
+    }
+
+    /**
+     * Converts a list to a string, one item per line.
+     *
+     * @param list List
+     * @return String with one item of the list per line
+     */
+    private static <T> String toString(Collection<T> list) {
+      StringBuilder buf = new StringBuilder();
+      for (T t : list) {
+        buf.append(t).append("\n");
+      }
+      return buf.toString();
+    }
+
+    /**
+     * Concatenates several lists of the same type into a single list.
+     *
+     * @param lists Lists to concatenate
+     * @return Sum list
+     */
+    protected static <T> List<T> plus(List<T>... lists) {
+      final List<T> result = new ArrayList<>();
+      for (List<T> list : lists) {
+        result.addAll(list);
+      }
+      return result;
+    }
   }
 }
diff --git a/core/src/test/java/org/apache/calcite/sql/test/SqlOperatorBaseTest.java b/core/src/test/java/org/apache/calcite/sql/test/SqlOperatorBaseTest.java
deleted file mode 100644
index f3097ec..0000000
--- a/core/src/test/java/org/apache/calcite/sql/test/SqlOperatorBaseTest.java
+++ /dev/null
@@ -1,10490 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to you under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.calcite.sql.test;
-
-import org.apache.calcite.avatica.util.DateTimeUtils;
-import org.apache.calcite.config.CalciteConnectionProperty;
-import org.apache.calcite.linq4j.Linq4j;
-import org.apache.calcite.plan.Strong;
-import org.apache.calcite.rel.type.RelDataType;
-import org.apache.calcite.rel.type.RelDataTypeFactory;
-import org.apache.calcite.runtime.CalciteContextException;
-import org.apache.calcite.runtime.CalciteException;
-import org.apache.calcite.runtime.Hook;
-import org.apache.calcite.sql.SqlAggFunction;
-import org.apache.calcite.sql.SqlCall;
-import org.apache.calcite.sql.SqlCallBinding;
-import org.apache.calcite.sql.SqlFunction;
-import org.apache.calcite.sql.SqlIdentifier;
-import org.apache.calcite.sql.SqlJdbcFunctionCall;
-import org.apache.calcite.sql.SqlLiteral;
-import org.apache.calcite.sql.SqlNode;
-import org.apache.calcite.sql.SqlNodeList;
-import org.apache.calcite.sql.SqlOperandCountRange;
-import org.apache.calcite.sql.SqlOperator;
-import org.apache.calcite.sql.dialect.AnsiSqlDialect;
-import org.apache.calcite.sql.fun.SqlLibrary;
-import org.apache.calcite.sql.fun.SqlLibraryOperatorTableFactory;
-import org.apache.calcite.sql.fun.SqlLibraryOperators;
-import org.apache.calcite.sql.fun.SqlStdOperatorTable;
-import org.apache.calcite.sql.parser.SqlParseException;
-import org.apache.calcite.sql.parser.SqlParserPos;
-import org.apache.calcite.sql.pretty.SqlPrettyWriter;
-import org.apache.calcite.sql.type.BasicSqlType;
-import org.apache.calcite.sql.type.SqlOperandTypeChecker;
-import org.apache.calcite.sql.type.SqlTypeName;
-import org.apache.calcite.sql.type.SqlTypeUtil;
-import org.apache.calcite.sql.util.SqlString;
-import org.apache.calcite.sql.validate.SqlConformance;
-import org.apache.calcite.sql.validate.SqlConformanceEnum;
-import org.apache.calcite.sql.validate.SqlNameMatchers;
-import org.apache.calcite.sql.validate.SqlValidatorImpl;
-import org.apache.calcite.sql.validate.SqlValidatorScope;
-import org.apache.calcite.test.CalciteAssert;
-import org.apache.calcite.test.SqlLimitsTest;
-import org.apache.calcite.util.Bug;
-import org.apache.calcite.util.Holder;
-import org.apache.calcite.util.Pair;
-import org.apache.calcite.util.TestUtil;
-import org.apache.calcite.util.TimestampString;
-import org.apache.calcite.util.Util;
-import org.apache.calcite.util.trace.CalciteTrace;
-
-import com.google.common.base.Throwables;
-
-import org.checkerframework.checker.nullness.qual.Nullable;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.api.Tag;
-import org.junit.jupiter.api.Test;
-import org.slf4j.Logger;
-
-import java.math.BigDecimal;
-import java.sql.Connection;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.sql.Statement;
-import java.text.SimpleDateFormat;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Calendar;
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Locale;
-import java.util.Set;
-import java.util.TimeZone;
-import java.util.function.Consumer;
-import java.util.function.UnaryOperator;
-import java.util.regex.Pattern;
-import java.util.stream.Stream;
-
-import static org.apache.calcite.rel.type.RelDataTypeImpl.NON_NULLABLE_SUFFIX;
-import static org.apache.calcite.sql.fun.SqlStdOperatorTable.PI;
-import static org.apache.calcite.util.DateTimeStringUtils.getDateFormatter;
-
-import static org.hamcrest.CoreMatchers.equalTo;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.fail;
-import static org.junit.jupiter.api.Assumptions.assumeTrue;
-
-/**
- * Contains unit tests for all operators. Each of the methods is named after an
- * operator.
- *
- * <p>The class is abstract. It contains a test for every operator, but does not
- * provide a mechanism to execute the tests: parse, validate, and execute
- * expressions on the operators. This is left to a {@link SqlTester} object
- * which the derived class must provide.</p>
- *
- * <p>Different implementations of {@link SqlTester} are possible, such as:</p>
- *
- * <ul>
- * <li>Execute against a real farrago database
- * <li>Execute in pure java (parsing and validation can be done, but expression
- * evaluation is not possible)
- * <li>Generate a SQL script.
- * <li>Analyze which operators are adequately tested.
- * </ul>
- *
- * <p>A typical method will be named after the operator it is testing (say
- * <code>testSubstringFunc</code>). It first calls
- * {@link SqlTester#setFor(org.apache.calcite.sql.SqlOperator, org.apache.calcite.sql.test.SqlTester.VmName...)}
- * to declare which operator it is testing.
- *
- * <blockquote>
- * <pre><code>
- * public void testSubstringFunc() {
- *     tester.setFor(SqlStdOperatorTable.substringFunc);
- *     tester.checkScalar("sin(0)", "0");
- *     tester.checkScalar("sin(1.5707)", "1");
- * }</code></pre>
- * </blockquote>
- *
- * <p>The rest of the method contains calls to the various {@code checkXxx}
- * methods in the {@link SqlTester} interface. For an operator
- * to be adequately tested, there need to be tests for:
- *
- * <ul>
- * <li>Parsing all of its the syntactic variants.
- * <li>Deriving the type of in all combinations of arguments.
- *
- * <ul>
- * <li>Pay particular attention to nullability. For example, the result of the
- * "+" operator is NOT NULL if and only if both of its arguments are NOT
- * NULL.</li>
- * <li>Also pay attention to precision/scale/length. For example, the maximum
- * length of the "||" operator is the sum of the maximum lengths of its
- * arguments.</li>
- * </ul>
- * </li>
- * <li>Executing the function. Pay particular attention to corner cases such as
- * null arguments or null results.</li>
- * </ul>
- */
-public abstract class SqlOperatorBaseTest {
-  //~ Static fields/initializers ---------------------------------------------
-
-  private static final Logger LOGGER = CalciteTrace.getTestTracer(SqlOperatorBaseTest.class);
-
-  // TODO: Change message when Fnl3Fixed to something like
-  // "Invalid character for cast: PC=0 Code=22018"
-  public static final String INVALID_CHAR_MESSAGE =
-      Bug.FNL3_FIXED ? null : "(?s).*";
-
-  // TODO: Change message when Fnl3Fixed to something like
-  // "Overflow during calculation or cast: PC=0 Code=22003"
-  public static final String OUT_OF_RANGE_MESSAGE =
-      Bug.FNL3_FIXED ? null : "(?s).*";
-
-  // TODO: Change message when Fnl3Fixed to something like
-  // "Division by zero: PC=0 Code=22012"
-  public static final String DIVISION_BY_ZERO_MESSAGE =
-      Bug.FNL3_FIXED ? null : "(?s).*";
-
-  // TODO: Change message when Fnl3Fixed to something like
-  // "String right truncation: PC=0 Code=22001"
-  public static final String STRING_TRUNC_MESSAGE =
-      Bug.FNL3_FIXED ? null : "(?s).*";
-
-  // TODO: Change message when Fnl3Fixed to something like
-  // "Invalid datetime format: PC=0 Code=22007"
-  public static final String BAD_DATETIME_MESSAGE =
-      Bug.FNL3_FIXED ? null : "(?s).*";
-
-  // Error messages when an invalid time unit is given as
-  // input to extract for a particular input type.
-  public static final String INVALID_EXTRACT_UNIT_CONVERTLET_ERROR =
-      "Extract.*from.*type data is not supported";
-
-  public static final String INVALID_EXTRACT_UNIT_VALIDATION_ERROR =
-      "Cannot apply 'EXTRACT' to arguments of type .*'\n.*";
-
-  public static final String LITERAL_OUT_OF_RANGE_MESSAGE =
-      "(?s).*Numeric literal.*out of range.*";
-
-  public static final String INVALID_ARGUMENTS_NUMBER =
-      "Invalid number of arguments to function .* Was expecting .* arguments";
-
-  public static final boolean TODO = false;
-
-  /**
-   * Regular expression for a SQL TIME(0) value.
-   */
-  public static final Pattern TIME_PATTERN =
-      Pattern.compile(
-          "[0-9][0-9]:[0-9][0-9]:[0-9][0-9]");
-
-  /**
-   * Regular expression for a SQL TIMESTAMP(0) value.
-   */
-  public static final Pattern TIMESTAMP_PATTERN =
-      Pattern.compile(
-          "[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9] "
-              + "[0-9][0-9]:[0-9][0-9]:[0-9][0-9]");
-
-  /**
-   * Regular expression for a SQL DATE value.
-   */
-  public static final Pattern DATE_PATTERN =
-      Pattern.compile(
-          "[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]");
-
-  public static final String[] NUMERIC_TYPE_NAMES = {
-      "TINYINT", "SMALLINT", "INTEGER", "BIGINT",
-      "DECIMAL(5, 2)", "REAL", "FLOAT", "DOUBLE"
-  };
-
-  // REVIEW jvs 27-Apr-2006:  for Float and Double, MIN_VALUE
-  // is the smallest positive value, not the smallest negative value
-  public static final String[] MIN_NUMERIC_STRINGS = {
-      Long.toString(Byte.MIN_VALUE),
-      Long.toString(Short.MIN_VALUE),
-      Long.toString(Integer.MIN_VALUE),
-      Long.toString(Long.MIN_VALUE),
-      "-999.99",
-
-      // NOTE jvs 26-Apr-2006:  Win32 takes smaller values from win32_values.h
-      "1E-37", /*Float.toString(Float.MIN_VALUE)*/
-      "2E-307", /*Double.toString(Double.MIN_VALUE)*/
-      "2E-307" /*Double.toString(Double.MIN_VALUE)*/,
-  };
-
-  public static final String[] MIN_OVERFLOW_NUMERIC_STRINGS = {
-      Long.toString(Byte.MIN_VALUE - 1),
-      Long.toString(Short.MIN_VALUE - 1),
-      Long.toString((long) Integer.MIN_VALUE - 1),
-      new BigDecimal(Long.MIN_VALUE).subtract(BigDecimal.ONE).toString(),
-      "-1000.00",
-      "1e-46",
-      "1e-324",
-      "1e-324"
-  };
-
-  public static final String[] MAX_NUMERIC_STRINGS = {
-      Long.toString(Byte.MAX_VALUE),
-      Long.toString(Short.MAX_VALUE),
-      Long.toString(Integer.MAX_VALUE),
-      Long.toString(Long.MAX_VALUE), "999.99",
-
-      // NOTE jvs 26-Apr-2006:  use something slightly less than MAX_VALUE
-      // because roundtripping string to approx to string doesn't preserve
-      // MAX_VALUE on win32
-      "3.4028234E38", /*Float.toString(Float.MAX_VALUE)*/
-      "1.79769313486231E308", /*Double.toString(Double.MAX_VALUE)*/
-      "1.79769313486231E308" /*Double.toString(Double.MAX_VALUE)*/
-  };
-
-  public static final String[] MAX_OVERFLOW_NUMERIC_STRINGS = {
-      Long.toString(Byte.MAX_VALUE + 1),
-      Long.toString(Short.MAX_VALUE + 1),
-      Long.toString((long) Integer.MAX_VALUE + 1),
-      (new BigDecimal(Long.MAX_VALUE)).add(BigDecimal.ONE).toString(),
-      "1000.00",
-      "1e39",
-      "-1e309",
-      "1e309"
-  };
-  private static final boolean[] FALSE_TRUE = {false, true};
-  private static final SqlTester.VmName VM_FENNEL = SqlTester.VmName.FENNEL;
-  private static final SqlTester.VmName VM_JAVA = SqlTester.VmName.JAVA;
-  private static final SqlTester.VmName VM_EXPAND = SqlTester.VmName.EXPAND;
-  protected static final TimeZone UTC_TZ = TimeZone.getTimeZone("GMT");
-  // time zone for the LOCAL_{DATE,TIME,TIMESTAMP} functions
-  protected static final TimeZone LOCAL_TZ = TimeZone.getDefault();
-  // time zone for the CURRENT{DATE,TIME,TIMESTAMP} functions
-  protected static final TimeZone CURRENT_TZ = LOCAL_TZ;
-
-  private static final Pattern INVALID_ARG_FOR_POWER = Pattern.compile(
-      "(?s).*Invalid argument\\(s\\) for 'POWER' function.*");
-
-  private static final Pattern CODE_2201F = Pattern.compile(
-      "(?s).*could not calculate results for the following row.*PC=5 Code=2201F.*");
-
-  /**
-   * Whether DECIMAL type is implemented.
-   */
-  public static final boolean DECIMAL = false;
-
-  private final boolean enable;
-
-  protected final SqlTester tester;
-
-  // same with tester but without implicit type coercion.
-  protected final SqlTester strictTester;
-
-  /** Function object that returns a string with 2 copies of each character.
-   * For example, {@code DOUBLER.apply("xy")} returns {@code "xxyy"}. */
-  private static final UnaryOperator<String> DOUBLER =
-      new UnaryOperator<String>() {
-        final Pattern pattern = Pattern.compile("(.)");
-
-        @Override public String apply(String s) {
-          return pattern.matcher(s).replaceAll("$1$1");
-        }
-      };
-
-  /**
-   * Creates a SqlOperatorBaseTest.
-   *
-   * @param enable Whether to run "failing" tests.
-   * @param tester Means to validate, execute various statements.
-   */
-  protected SqlOperatorBaseTest(boolean enable, SqlTester tester) {
-    this.enable = enable;
-    this.tester = tester;
-    assert tester != null;
-    this.strictTester = tester.enableTypeCoercion(false);
-  }
-
-  @BeforeEach
-  public void setUp() throws Exception {
-    tester.setFor(null);
-  }
-
-  protected SqlTester libraryTester(SqlLibrary library) {
-    return tester.withOperatorTable(
-        SqlLibraryOperatorTableFactory.INSTANCE
-            .getOperatorTable(SqlLibrary.STANDARD, library))
-        .withConnectionFactory(
-            CalciteAssert.EMPTY_CONNECTION_FACTORY
-                .with(new CalciteAssert
-                    .AddSchemaSpecPostProcessor(CalciteAssert.SchemaSpec.HR))
-                .with(CalciteConnectionProperty.FUN, library.fun));
-  }
-
-  protected SqlTester oracleTester(SqlConformance conformance) {
-    if (conformance == null) {
-      conformance = SqlConformanceEnum.DEFAULT;
-    }
-    return tester
-        .withConformance(conformance)
-        .withOperatorTable(
-            SqlLibraryOperatorTableFactory.INSTANCE
-                .getOperatorTable(SqlLibrary.STANDARD, SqlLibrary.ORACLE))
-        .withConnectionFactory(
-            CalciteAssert.EMPTY_CONNECTION_FACTORY
-                .with(new CalciteAssert
-                    .AddSchemaSpecPostProcessor(CalciteAssert.SchemaSpec.HR))
-                .with("fun", "oracle")
-                .with("conformance", conformance));
-  }
-
-  /** Creates a tester with special sql library. */
-  protected SqlTester tester(SqlLibrary library) {
-    return tester.withOperatorTable(
-        SqlLibraryOperatorTableFactory.INSTANCE
-            .getOperatorTable(SqlLibrary.STANDARD, library))
-        .withConnectionFactory(
-            CalciteAssert.EMPTY_CONNECTION_FACTORY
-                .with(new CalciteAssert
-                    .AddSchemaSpecPostProcessor(CalciteAssert.SchemaSpec.HR))
-                .with("fun", library.name()));
-  }
-
-  //--- Tests -----------------------------------------------------------
-
-  /**
-   * For development. Put any old code in here.
-   */
-  @Test void testDummy() {
-  }
-
-  @Test void testSqlOperatorOverloading() {
-    final SqlStdOperatorTable operatorTable = SqlStdOperatorTable.instance();
-    for (SqlOperator sqlOperator : operatorTable.getOperatorList()) {
-      String operatorName = sqlOperator.getName();
-      List<SqlOperator> routines = new ArrayList<>();
-      final SqlIdentifier id =
-          new SqlIdentifier(operatorName, SqlParserPos.ZERO);
-      operatorTable.lookupOperatorOverloads(id, null, sqlOperator.getSyntax(),
-          routines, SqlNameMatchers.withCaseSensitive(true));
-
-      routines.removeIf(operator ->
-          !sqlOperator.getClass().isInstance(operator));
-      assertThat(routines.size(), equalTo(1));
-      assertThat(sqlOperator, equalTo(routines.get(0)));
-    }
-  }
-
-  @Test void testBetween() {
-    tester.setFor(
-        SqlStdOperatorTable.BETWEEN,
-        SqlTester.VmName.EXPAND);
-    tester.checkBoolean("2 between 1 and 3", Boolean.TRUE);
-    tester.checkBoolean("2 between 3 and 2", Boolean.FALSE);
-    tester.checkBoolean("2 between symmetric 3 and 2", Boolean.TRUE);
-    tester.checkBoolean("3 between 1 and 3", Boolean.TRUE);
-    tester.checkBoolean("4 between 1 and 3", Boolean.FALSE);
-    tester.checkBoolean("1 between 4 and -3", Boolean.FALSE);
-    tester.checkBoolean("1 between -1 and -3", Boolean.FALSE);
-    tester.checkBoolean("1 between -1 and 3", Boolean.TRUE);
-    tester.checkBoolean("1 between 1 and 1", Boolean.TRUE);
-    tester.checkBoolean("1.5 between 1 and 3", Boolean.TRUE);
-    tester.checkBoolean("1.2 between 1.1 and 1.3", Boolean.TRUE);
-    tester.checkBoolean("1.5 between 2 and 3", Boolean.FALSE);
-    tester.checkBoolean("1.5 between 1.6 and 1.7", Boolean.FALSE);
-    tester.checkBoolean("1.2e1 between 1.1 and 1.3", Boolean.FALSE);
-    tester.checkBoolean("1.2e0 between 1.1 and 1.3", Boolean.TRUE);
-    tester.checkBoolean("1.5e0 between 2 and 3", Boolean.FALSE);
-    tester.checkBoolean("1.5e0 between 2e0 and 3e0", Boolean.FALSE);
-    tester.checkBoolean(
-        "1.5e1 between 1.6e1 and 1.7e1",
-        Boolean.FALSE);
-    tester.checkBoolean("x'' between x'' and x''", Boolean.TRUE);
-    tester.checkNull("cast(null as integer) between -1 and 2");
-    tester.checkNull("1 between -1 and cast(null as integer)");
-    tester.checkNull(
-        "1 between cast(null as integer) and cast(null as integer)");
-    tester.checkNull("1 between cast(null as integer) and 1");
-    tester.checkBoolean("x'0A00015A' between x'0A000130' and x'0A0001B0'", Boolean.TRUE);
-    tester.checkBoolean("x'0A00015A' between x'0A0001A0' and x'0A0001B0'", Boolean.FALSE);
-  }
-
-  @Test void testNotBetween() {
-    tester.setFor(SqlStdOperatorTable.NOT_BETWEEN, VM_EXPAND);
-    tester.checkBoolean("2 not between 1 and 3", Boolean.FALSE);
-    tester.checkBoolean("3 not between 1 and 3", Boolean.FALSE);
-    tester.checkBoolean("4 not between 1 and 3", Boolean.TRUE);
-    tester.checkBoolean(
-        "1.2e0 not between 1.1 and 1.3",
-        Boolean.FALSE);
-    tester.checkBoolean("1.2e1 not between 1.1 and 1.3", Boolean.TRUE);
-    tester.checkBoolean("1.5e0 not between 2 and 3", Boolean.TRUE);
-    tester.checkBoolean("1.5e0 not between 2e0 and 3e0", Boolean.TRUE);
-    tester.checkBoolean("x'0A00015A' not between x'0A000130' and x'0A0001B0'", Boolean.FALSE);
-    tester.checkBoolean("x'0A00015A' not between x'0A0001A0' and x'0A0001B0'", Boolean.TRUE);
-  }
-
-  private String getCastString(
-      String value,
-      String targetType,
-      boolean errorLoc) {
-    if (errorLoc) {
-      value = "^" + value + "^";
-    }
-    return "cast(" + value + " as " + targetType + ")";
-  }
-
-  private void checkCastToApproxOkay(
-      String value,
-      String targetType,
-      double expected,
-      double delta) {
-    tester.checkScalarApprox(
-        getCastString(value, targetType, false),
-        targetType + NON_NULLABLE_SUFFIX,
-        expected,
-        delta);
-  }
-
-  private void checkCastToStringOkay(
-      String value,
-      String targetType,
-      String expected) {
-    tester.checkString(
-        getCastString(value, targetType, false),
-        expected,
-        targetType + NON_NULLABLE_SUFFIX);
-  }
-
-  private void checkCastToScalarOkay(
-      String value,
-      String targetType,
-      String expected) {
-    tester.checkScalarExact(
-        getCastString(value, targetType, false),
-        targetType + NON_NULLABLE_SUFFIX,
-        expected);
-  }
-
-  private void checkCastToScalarOkay(String value, String targetType) {
-    checkCastToScalarOkay(value, targetType, value);
-  }
-
-  private void checkCastFails(
-      String value,
-      String targetType,
-      String expectedError,
-      boolean runtime) {
-    tester.checkFails(
-        getCastString(value, targetType, !runtime),
-        expectedError,
-        runtime);
-  }
-
-  private void checkCastToString(String value, String type, String expected) {
-    String spaces = "     ";
-    if (expected == null) {
-      expected = value.trim();
-    }
-    int len = expected.length();
-    if (type != null) {
-      value = getCastString(value, type, false);
-    }
-
-    // currently no exception thrown for truncation
-    if (Bug.DT239_FIXED) {
-      checkCastFails(
-          value,
-          "VARCHAR(" + (len - 1) + ")", STRING_TRUNC_MESSAGE,
-          true);
-    }
-
-    checkCastToStringOkay(value, "VARCHAR(" + len + ")", expected);
-    checkCastToStringOkay(value, "VARCHAR(" + (len + 5) + ")", expected);
-
-    // currently no exception thrown for truncation
-    if (Bug.DT239_FIXED) {
-      checkCastFails(
-          value,
-          "CHAR(" + (len - 1) + ")", STRING_TRUNC_MESSAGE,
-          true);
-    }
-
-    checkCastToStringOkay(
-        value,
-        "CHAR(" + len + ")",
-        expected);
-    checkCastToStringOkay(
-        value,
-        "CHAR(" + (len + 5) + ")",
-        expected + spaces);
-  }
-
-  @Test void testCastToString() {
-    tester.setFor(SqlStdOperatorTable.CAST);
-    checkCastToString("cast(cast('abc' as char(4)) as varchar(6))", null,
-        "abc ");
-
-    // integer
-    checkCastToString("123", "CHAR(3)", "123");
-    checkCastToString("0", "CHAR", "0");
-    checkCastToString("-123", "CHAR(4)", "-123");
-
-    // decimal
-    checkCastToString("123.4", "CHAR(5)", "123.4");
-    checkCastToString("-0.0", "CHAR(2)", ".0");
-    checkCastToString("-123.4", "CHAR(6)", "-123.4");
-
-    tester.checkString(
-        "cast(1.29 as varchar(10))",
-        "1.29",
-        "VARCHAR(10) NOT NULL");
-    tester.checkString(
-        "cast(.48 as varchar(10))",
-        ".48",
-        "VARCHAR(10) NOT NULL");
-    if (Bug.CALCITE_2539_FIXED) {
-      tester.checkFails(
-          "cast(2.523 as char(2))", STRING_TRUNC_MESSAGE,
-          true);
-    }
-
-    tester.checkString(
-        "cast(-0.29 as varchar(10))",
-        "-.29",
-        "VARCHAR(10) NOT NULL");
-    tester.checkString(
-        "cast(-1.29 as varchar(10))",
-        "-1.29",
-        "VARCHAR(10) NOT NULL");
-
-    // approximate
-    checkCastToString("1.23E45", "CHAR(7)", "1.23E45");
-    checkCastToString("CAST(0 AS DOUBLE)", "CHAR(3)", "0E0");
-    checkCastToString("-1.20e-07", "CHAR(7)", "-1.2E-7");
-    checkCastToString("cast(0e0 as varchar(5))", "CHAR(3)", "0E0");
-    if (TODO) {
-      checkCastToString(
-          "cast(-45e-2 as varchar(17))", "CHAR(7)",
-          "-4.5E-1");
-    }
-    if (TODO) {
-      checkCastToString(
-          "cast(4683442.3432498375e0 as varchar(20))",
-          "CHAR(19)",
-          "4.683442343249838E6");
-    }
-    if (TODO) {
-      checkCastToString("cast(-0.1 as real)", "CHAR(5)", "-1E-1");
-    }
-    if (Bug.CALCITE_2539_FIXED) {
-      tester.checkFails(
-          "cast(1.3243232e0 as varchar(4))", STRING_TRUNC_MESSAGE,
-          true);
-      tester.checkFails(
-          "cast(1.9e5 as char(4))", STRING_TRUNC_MESSAGE,
-          true);
-    }
-
-    // string
-    checkCastToString("'abc'", "CHAR(1)", "a");
-    checkCastToString("'abc'", "CHAR(3)", "abc");
-    checkCastToString("cast('abc' as varchar(6))", "CHAR(3)", "abc");
-    checkCastToString("cast(' abc  ' as varchar(10))", null, " abc  ");
-    checkCastToString("cast(cast('abc' as char(4)) as varchar(6))", null,
-        "abc ");
-    tester.checkString("cast(cast('a' as char(2)) as varchar(3)) || 'x' ",
-        "a x", "VARCHAR(4) NOT NULL");
-    tester.checkString("cast(cast('a' as char(3)) as varchar(5)) || 'x' ",
-        "a  x", "VARCHAR(6) NOT NULL");
-    tester.checkString("cast('a' as char(3)) || 'x'", "a  x",
-        "CHAR(4) NOT NULL");
-
-    tester.checkScalar("char_length(cast(' x ' as char(4)))", 4,
-        "INTEGER NOT NULL");
-    tester.checkScalar("char_length(cast(' x ' as varchar(3)))", 3,
-        "INTEGER NOT NULL");
-    tester.checkScalar("char_length(cast(' x ' as varchar(4)))", 3,
-        "INTEGER NOT NULL");
-    tester.checkScalar("char_length(cast(cast(' x ' as char(4)) as varchar(5)))",
-        4, "INTEGER NOT NULL");
-    tester.checkScalar("char_length(cast(' x ' as varchar(3)))", 3,
-        "INTEGER NOT NULL");
-
-    // date & time
-    checkCastToString("date '2008-01-01'", "CHAR(10)", "2008-01-01");
-    checkCastToString("time '1:2:3'", "CHAR(8)", "01:02:03");
-    checkCastToString(
-        "timestamp '2008-1-1 1:2:3'",
-        "CHAR(19)",
-        "2008-01-01 01:02:03");
-    checkCastToString(
-        "timestamp '2008-1-1 1:2:3'",
-        "VARCHAR(30)",
-        "2008-01-01 01:02:03");
-
-    checkCastToString(
-        "interval '3-2' year to month",
-        "CHAR(5)",
-        "+3-02");
-    checkCastToString(
-        "interval '32' month",
-        "CHAR(3)",
-        "+32");
-    checkCastToString(
-        "interval '1 2:3:4' day to second",
-        "CHAR(11)",
-        "+1 02:03:04");
-    checkCastToString(
-        "interval '1234.56' second(4,2)",
-        "CHAR(8)",
-        "+1234.56");
-    checkCastToString(
-        "interval '60' day",
-        "CHAR(8)",
-        "+60     ");
-
-    // boolean
-    checkCastToString("True", "CHAR(4)", "TRUE");
-    checkCastToString("True", "CHAR(6)", "TRUE  ");
-    checkCastToString("True", "VARCHAR(6)", "TRUE");
-    checkCastToString("False", "CHAR(5)", "FALSE");
-
-    if (Bug.CALCITE_2539_FIXED) {
-      tester.checkFails(
-          "cast(true as char(3))", INVALID_CHAR_MESSAGE,
-          true);
-      tester.checkFails(
-          "cast(false as char(4))", INVALID_CHAR_MESSAGE,
-          true);
-      tester.checkFails(
-          "cast(true as varchar(3))", INVALID_CHAR_MESSAGE,
-          true);
-      tester.checkFails(
-          "cast(false as varchar(4))", INVALID_CHAR_MESSAGE,
-          true);
-    }
-  }
-
-  @Test void testCastExactNumericLimits() {
-    tester.setFor(SqlStdOperatorTable.CAST);
-
-    // Test casting for min,max, out of range for exact numeric types
-    for (int i = 0; i < NUMERIC_TYPE_NAMES.length; i++) {
-      String type = NUMERIC_TYPE_NAMES[i];
-
-      if (type.equalsIgnoreCase("DOUBLE")
-          || type.equalsIgnoreCase("FLOAT")
-          || type.equalsIgnoreCase("REAL")) {
-        // Skip approx types
-        continue;
-      }
-
-      // Convert from literal to type
-      checkCastToScalarOkay(MAX_NUMERIC_STRINGS[i], type);
-      checkCastToScalarOkay(MIN_NUMERIC_STRINGS[i], type);
-
-      // Overflow test
-      if (type.equalsIgnoreCase("BIGINT")) {
-        // Literal of range
-        checkCastFails(
-            MAX_OVERFLOW_NUMERIC_STRINGS[i],
-            type, LITERAL_OUT_OF_RANGE_MESSAGE,
-            false);
-        checkCastFails(
-            MIN_OVERFLOW_NUMERIC_STRINGS[i],
-            type, LITERAL_OUT_OF_RANGE_MESSAGE,
-            false);
-      } else {
-        if (Bug.CALCITE_2539_FIXED) {
-          checkCastFails(
-              MAX_OVERFLOW_NUMERIC_STRINGS[i],
-              type, OUT_OF_RANGE_MESSAGE,
-              true);
-          checkCastFails(
-              MIN_OVERFLOW_NUMERIC_STRINGS[i],
-              type, OUT_OF_RANGE_MESSAGE,
-              true);
-        }
-      }
-
-      // Convert from string to type
-      checkCastToScalarOkay(
-          "'" + MAX_NUMERIC_STRINGS[i] + "'",
-          type,
-          MAX_NUMERIC_STRINGS[i]);
-      checkCastToScalarOkay(
-          "'" + MIN_NUMERIC_STRINGS[i] + "'",
-          type,
-          MIN_NUMERIC_STRINGS[i]);
-
-      if (Bug.CALCITE_2539_FIXED) {
-        checkCastFails(
-            "'" + MAX_OVERFLOW_NUMERIC_STRINGS[i] + "'",
-            type, OUT_OF_RANGE_MESSAGE,
-            true);
-        checkCastFails(
-            "'" + MIN_OVERFLOW_NUMERIC_STRINGS[i] + "'",
-            type,
-            OUT_OF_RANGE_MESSAGE,
-            true);
-      }
-
-      // Convert from type to string
-      checkCastToString(MAX_NUMERIC_STRINGS[i], null, null);
-      checkCastToString(MAX_NUMERIC_STRINGS[i], type, null);
-
-      checkCastToString(MIN_NUMERIC_STRINGS[i], null, null);
-      checkCastToString(MIN_NUMERIC_STRINGS[i], type, null);
-
-      if (Bug.CALCITE_2539_FIXED) {
-        checkCastFails("'notnumeric'", type, INVALID_CHAR_MESSAGE, true);
-      }
-    }
-  }
-
-  @Test void testCastToExactNumeric() {
-    tester.setFor(SqlStdOperatorTable.CAST);
-
-    checkCastToScalarOkay("1", "BIGINT");
-    checkCastToScalarOkay("1", "INTEGER");
-    checkCastToScalarOkay("1", "SMALLINT");
-    checkCastToScalarOkay("1", "TINYINT");
-    checkCastToScalarOkay("1", "DECIMAL(4, 0)");
-    checkCastToScalarOkay("-1", "BIGINT");
-    checkCastToScalarOkay("-1", "INTEGER");
-    checkCastToScalarOkay("-1", "SMALLINT");
-    checkCastToScalarOkay("-1", "TINYINT");
-    checkCastToScalarOkay("-1", "DECIMAL(4, 0)");
-
-    checkCastToScalarOkay("1.234E3", "INTEGER", "1234");
-    checkCastToScalarOkay("-9.99E2", "INTEGER", "-999");
-    checkCastToScalarOkay("'1'", "INTEGER", "1");
-    checkCastToScalarOkay("' 01 '", "INTEGER", "1");
-    checkCastToScalarOkay("'-1'", "INTEGER", "-1");
-    checkCastToScalarOkay("' -00 '", "INTEGER", "0");
-
-    // string to integer
-    tester.checkScalarExact("cast('6543' as integer)", "6543");
-    tester.checkScalarExact("cast(' -123 ' as int)", "-123");
-    tester.checkScalarExact(
-        "cast('654342432412312' as bigint)",
-        "BIGINT NOT NULL",
-        "654342432412312");
-  }
-
-  @Test void testCastStringToDecimal() {
-    tester.setFor(SqlStdOperatorTable.CAST);
-    if (!DECIMAL) {
-      return;
-    }
-    // string to decimal
-    tester.checkScalarExact(
-        "cast('1.29' as decimal(2,1))",
-        "DECIMAL(2, 1) NOT NULL",
-        "1.3");
-    tester.checkScalarExact(
-        "cast(' 1.25 ' as decimal(2,1))",
-        "DECIMAL(2, 1) NOT NULL",
-        "1.3");
-    tester.checkScalarExact(
-        "cast('1.21' as decimal(2,1))",
-        "DECIMAL(2, 1) NOT NULL",
-        "1.2");
-    tester.checkScalarExact(
-        "cast(' -1.29 ' as decimal(2,1))",
-        "DECIMAL(2, 1) NOT NULL",
-        "-1.3");
-    tester.checkScalarExact(
-        "cast('-1.25' as decimal(2,1))",
-        "DECIMAL(2, 1) NOT NULL",
-        "-1.3");
-    tester.checkScalarExact(
-        "cast(' -1.21 ' as decimal(2,1))",
-        "DECIMAL(2, 1) NOT NULL",
-        "-1.2");
-    tester.checkFails(
-        "cast(' -1.21e' as decimal(2,1))", INVALID_CHAR_MESSAGE,
-        true);
-  }
-
-  @Test void testCastIntervalToNumeric() {
-    tester.setFor(SqlStdOperatorTable.CAST);
-
-    // interval to decimal
-    if (DECIMAL) {
-      tester.checkScalarExact(
-          "cast(INTERVAL '1.29' second(1,2) as decimal(2,1))",
-          "DECIMAL(2, 1) NOT NULL",
-          "1.3");
-      tester.checkScalarExact(
-          "cast(INTERVAL '1.25' second as decimal(2,1))",
-          "DECIMAL(2, 1) NOT NULL",
-          "1.3");
-      tester.checkScalarExact(
-          "cast(INTERVAL '-1.29' second as decimal(2,1))",
-          "DECIMAL(2, 1) NOT NULL",
-          "-1.3");
-      tester.checkScalarExact(
-          "cast(INTERVAL '-1.25' second as decimal(2,1))",
-          "DECIMAL(2, 1) NOT NULL",
-          "-1.3");
-      tester.checkScalarExact(
-          "cast(INTERVAL '-1.21' second as decimal(2,1))",
-          "DECIMAL(2, 1) NOT NULL",
-          "-1.2");
-      tester.checkScalarExact(
-          "cast(INTERVAL '5' minute as decimal(2,1))",
-          "DECIMAL(2, 1) NOT NULL",
-          "5.0");
-      tester.checkScalarExact(
-          "cast(INTERVAL '5' hour as decimal(2,1))",
-          "DECIMAL(2, 1) NOT NULL",
-          "5.0");
-      tester.checkScalarExact(
-          "cast(INTERVAL '5' day as decimal(2,1))",
-          "DECIMAL(2, 1) NOT NULL",
-          "5.0");
-      tester.checkScalarExact(
-          "cast(INTERVAL '5' month as decimal(2,1))",
-          "DECIMAL(2, 1) NOT NULL",
-          "5.0");
-      tester.checkScalarExact(
-          "cast(INTERVAL '5' year as decimal(2,1))",
-          "DECIMAL(2, 1) NOT NULL",
-          "5.0");
-      tester.checkScalarExact(
-          "cast(INTERVAL '-5' day as decimal(2,1))",
-          "DECIMAL(2, 1) NOT NULL",
-          "-5.0");
-    }
-
-    // Interval to bigint
-    tester.checkScalarExact(
-        "cast(INTERVAL '1.25' second as bigint)",
-        "BIGINT NOT NULL",
-        "1");
-    tester.checkScalarExact(
-        "cast(INTERVAL '-1.29' second(1,2) as bigint)",
-        "BIGINT NOT NULL",
-        "-1");
-    tester.checkScalarExact(
-        "cast(INTERVAL '5' day as bigint)",
-        "BIGINT NOT NULL",
-        "5");
-
-    // Interval to integer
-    tester.checkScalarExact(
-        "cast(INTERVAL '1.25' second as integer)",
-        "INTEGER NOT NULL",
-        "1");
-    tester.checkScalarExact(
-        "cast(INTERVAL '-1.29' second(1,2) as integer)",
-        "INTEGER NOT NULL",
-        "-1");
-    tester.checkScalarExact(
-        "cast(INTERVAL '5' day as integer)",
-        "INTEGER NOT NULL",
-        "5");
-
-    tester.checkScalarExact(
-        "cast(INTERVAL '1' year as integer)",
-        "INTEGER NOT NULL",
-        "1");
-    tester.checkScalarExact(
-        "cast((INTERVAL '1' year - INTERVAL '2' year) as integer)",
-        "INTEGER NOT NULL",
-        "-1");
-    tester.checkScalarExact(
-        "cast(INTERVAL '1' month as integer)",
-        "INTEGER NOT NULL",
-        "1");
-    tester.checkScalarExact(
-        "cast((INTERVAL '1' month - INTERVAL '2' month) as integer)",
-        "INTEGER NOT NULL",
-        "-1");
-    tester.checkScalarExact(
-        "cast(INTERVAL '1' day as integer)",
-        "INTEGER NOT NULL",
-        "1");
-    tester.checkScalarExact(
-        "cast((INTERVAL '1' day - INTERVAL '2' day) as integer)",
-        "INTEGER NOT NULL",
-        "-1");
-    tester.checkScalarExact(
-        "cast(INTERVAL '1' hour as integer)",
-        "INTEGER NOT NULL",
-        "1");
-    tester.checkScalarExact(
-        "cast((INTERVAL '1' hour - INTERVAL '2' hour) as integer)",
-        "INTEGER NOT NULL",
-        "-1");
-    tester.checkScalarExact(
-        "cast(INTERVAL '1' hour as integer)",
-        "INTEGER NOT NULL",
-        "1");
-    tester.checkScalarExact(
-        "cast((INTERVAL '1' minute - INTERVAL '2' minute) as integer)",
-        "INTEGER NOT NULL",
-        "-1");
-    tester.checkScalarExact(
-        "cast(INTERVAL '1' minute as integer)",
-        "INTEGER NOT NULL",
-        "1");
-    tester.checkScalarExact(
-        "cast((INTERVAL '1' second - INTERVAL '2' second) as integer)",
-        "INTEGER NOT NULL",
-        "-1");
-  }
-
-  @Test void testCastToInterval() {
-    tester.setFor(SqlStdOperatorTable.CAST);
-    tester.checkScalar(
-        "cast(5 as interval second)",
-        "+5.000000",
-        "INTERVAL SECOND NOT NULL");
-    tester.checkScalar(
-        "cast(5 as interval minute)",
-        "+5",
-        "INTERVAL MINUTE NOT NULL");
-    tester.checkScalar(
-        "cast(5 as interval hour)",
-        "+5",
-        "INTERVAL HOUR NOT NULL");
-    tester.checkScalar(
-        "cast(5 as interval day)",
-        "+5",
-        "INTERVAL DAY NOT NULL");
-    tester.checkScalar(
-        "cast(5 as interval month)",
-        "+5",
-        "INTERVAL MONTH NOT NULL");
-    tester.checkScalar(
-        "cast(5 as interval year)",
-        "+5",
-        "INTERVAL YEAR NOT NULL");
-    if (DECIMAL) {
-      // Due to DECIMAL rounding bugs, currently returns "+5"
-      tester.checkScalar(
-          "cast(5.7 as interval day)",
-          "+6",
-          "INTERVAL DAY NOT NULL");
-      tester.checkScalar(
-          "cast(-5.7 as interval day)",
-          "-6",
-          "INTERVAL DAY NOT NULL");
-    } else {
-      // An easier case
-      tester.checkScalar(
-          "cast(6.2 as interval day)",
-          "+6",
-          "INTERVAL DAY NOT NULL");
-    }
-    tester.checkScalar(
-        "cast(3456 as interval month(4))",
-        "+3456",
-        "INTERVAL MONTH(4) NOT NULL");
-    tester.checkScalar(
-        "cast(-5723 as interval minute(4))",
-        "-5723",
-        "INTERVAL MINUTE(4) NOT NULL");
-  }
-
-  @Test void testCastIntervalToInterval() {
-    tester.checkScalar(
-        "cast(interval '2 5' day to hour as interval hour to minute)",
-        "+53:00",
-        "INTERVAL HOUR TO MINUTE NOT NULL");
-    tester.checkScalar(
-        "cast(interval '2 5' day to hour as interval day to minute)",
-        "+2 05:00",
-        "INTERVAL DAY TO MINUTE NOT NULL");
-    tester.checkScalar(
-        "cast(interval '2 5' day to hour as interval hour to second)",
-        "+53:00:00.000000",
-        "INTERVAL HOUR TO SECOND NOT NULL");
-    tester.checkScalar(
-        "cast(interval '2 5' day to hour as interval hour)",
-        "+53",
-        "INTERVAL HOUR NOT NULL");
-    tester.checkScalar(
-        "cast(interval '-29:15' hour to minute as interval day to hour)",
-        "-1 05",
-        "INTERVAL DAY TO HOUR NOT NULL");
-  }
-
-  @Test void testCastWithRoundingToScalar() {
-    tester.setFor(SqlStdOperatorTable.CAST);
-
-    checkCastToScalarOkay("1.25", "INTEGER", "1");
-    checkCastToScalarOkay("1.25E0", "INTEGER", "1");
-    if (!enable) {
-      return;
-    }
-    checkCastToScalarOkay("1.5", "INTEGER", "2");
-    checkCastToScalarOkay("5E-1", "INTEGER", "1");
-    checkCastToScalarOkay("1.75", "INTEGER", "2");
-    checkCastToScalarOkay("1.75E0", "INTEGER", "2");
-
-    checkCastToScalarOkay("-1.25", "INTEGER", "-1");
-    checkCastToScalarOkay("-1.25E0", "INTEGER", "-1");
-    checkCastToScalarOkay("-1.5", "INTEGER", "-2");
-    checkCastToScalarOkay("-5E-1", "INTEGER", "-1");
-    checkCastToScalarOkay("-1.75", "INTEGER", "-2");
-    checkCastToScalarOkay("-1.75E0", "INTEGER", "-2");
-
-    checkCastToScalarOkay("1.23454", "DECIMAL(8, 4)", "1.2345");
-    checkCastToScalarOkay("1.23454E0", "DECIMAL(8, 4)", "1.2345");
-    checkCastToScalarOkay("1.23455", "DECIMAL(8, 4)", "1.2346");
-    checkCastToScalarOkay("5E-5", "DECIMAL(8, 4)", "0.0001");
-    checkCastToScalarOkay("1.99995", "DECIMAL(8, 4)", "2.0000");
-    checkCastToScalarOkay("1.99995E0", "DECIMAL(8, 4)", "2.0000");
-
-    checkCastToScalarOkay("-1.23454", "DECIMAL(8, 4)", "-1.2345");
-    checkCastToScalarOkay("-1.23454E0", "DECIMAL(8, 4)", "-1.2345");
-    checkCastToScalarOkay("-1.23455", "DECIMAL(8, 4)", "-1.2346");
-    checkCastToScalarOkay("-5E-5", "DECIMAL(8, 4)", "-0.0001");
-    checkCastToScalarOkay("-1.99995", "DECIMAL(8, 4)", "-2.0000");
-    checkCastToScalarOkay("-1.99995E0", "DECIMAL(8, 4)", "-2.0000");
-
-    // 9.99 round to 10.0, should give out of range error
-    tester.checkFails(
-        "cast(9.99 as decimal(2,1))", OUT_OF_RANGE_MESSAGE,
-        true);
-  }
-
-  @Test void testCastDecimalToDoubleToInteger() {
-    tester.setFor(SqlStdOperatorTable.CAST);
-
-    tester.checkScalarExact(
-        "cast( cast(1.25 as double) as integer)",
-        "1");
-    tester.checkScalarExact(
-        "cast( cast(-1.25 as double) as integer)",
-        "-1");
-    if (!enable) {
-      return;
-    }
-    tester.checkScalarExact(
-        "cast( cast(1.75 as double) as integer)",
-        "2");
-    tester.checkScalarExact(
-        "cast( cast(-1.75 as double) as integer)",
-        "-2");
-    tester.checkScalarExact(
-        "cast( cast(1.5 as double) as integer)",
-        "2");
-    tester.checkScalarExact(
-        "cast( cast(-1.5 as double) as integer)",
-        "-2");
-  }
-
-  @Test void testCastApproxNumericLimits() {
-    tester.setFor(SqlStdOperatorTable.CAST);
-
-    // Test casting for min,max, out of range for approx numeric types
-    for (int i = 0; i < NUMERIC_TYPE_NAMES.length; i++) {
-      String type = NUMERIC_TYPE_NAMES[i];
-      boolean isFloat;
-
-      if (type.equalsIgnoreCase("DOUBLE")
-          || type.equalsIgnoreCase("FLOAT")) {
-        isFloat = false;
-      } else if (type.equalsIgnoreCase("REAL")) {
-        isFloat = true;
-      } else {
-        // Skip non-approx types
-        continue;
-      }
-
-      if (!enable) {
-        return;
-      }
-
-      // Convert from literal to type
-      checkCastToApproxOkay(
-          MAX_NUMERIC_STRINGS[i],
-          type,
-          Double.parseDouble(MAX_NUMERIC_STRINGS[i]),
-          isFloat ? 1E32 : 0);
-      checkCastToApproxOkay(
-          MIN_NUMERIC_STRINGS[i],
-          type,
-          Double.parseDouble(MIN_NUMERIC_STRINGS[i]),
-          0);
-
-      if (isFloat) {
-        checkCastFails(
-            MAX_OVERFLOW_NUMERIC_STRINGS[i],
-            type, OUT_OF_RANGE_MESSAGE,
-            true);
-      } else {
-        // Double: Literal out of range
-        checkCastFails(
-            MAX_OVERFLOW_NUMERIC_STRINGS[i],
-            type, LITERAL_OUT_OF_RANGE_MESSAGE,
-            false);
-      }
-
-      // Underflow: goes to 0
-      checkCastToApproxOkay(MIN_OVERFLOW_NUMERIC_STRINGS[i], type, 0, 0);
-
-      // Convert from string to type
-      checkCastToApproxOkay(
-          "'" + MAX_NUMERIC_STRINGS[i] + "'",
-          type,
-          Double.parseDouble(MAX_NUMERIC_STRINGS[i]),
-          isFloat ? 1E32 : 0);
-      checkCastToApproxOkay(
-          "'" + MIN_NUMERIC_STRINGS[i] + "'",
-          type,
-          Double.parseDouble(MIN_NUMERIC_STRINGS[i]),
-          0);
-
-      checkCastFails(
-          "'" + MAX_OVERFLOW_NUMERIC_STRINGS[i] + "'",
-          type,
-          OUT_OF_RANGE_MESSAGE,
-          true);
-
-      // Underflow: goes to 0
-      checkCastToApproxOkay(
-          "'" + MIN_OVERFLOW_NUMERIC_STRINGS[i] + "'",
-          type,
-          0,
-          0);
-
-      // Convert from type to string
-
-      // Treated as DOUBLE
-      checkCastToString(
-          MAX_NUMERIC_STRINGS[i], null,
-          isFloat ? null : "1.79769313486231E308");
-
-      // TODO: The following tests are slightly different depending on
-      // whether the java or fennel calc are used.
-      // Try to make them the same
-      if (false /* fennel calc*/) { // Treated as FLOAT or DOUBLE
-        checkCastToString(
-            MAX_NUMERIC_STRINGS[i],
-            type,
-            // Treated as DOUBLE
-            isFloat ? "3.402824E38" : "1.797693134862316E308");
-        checkCastToString(
-            MIN_NUMERIC_STRINGS[i],
-            null,
-            // Treated as FLOAT or DOUBLE
-            isFloat ? null : "4.940656458412465E-324");
-        checkCastToString(
-            MIN_NUMERIC_STRINGS[i],
-            type,
-            isFloat ? "1.401299E-45" : "4.940656458412465E-324");
-      } else if (false /* JavaCalc */) {
-        // Treated as FLOAT or DOUBLE
-        checkCastToString(
-            MAX_NUMERIC_STRINGS[i],
-            type,
-            // Treated as DOUBLE
-            isFloat ? "3.402823E38" : "1.797693134862316E308");
-        checkCastToString(
-            MIN_NUMERIC_STRINGS[i],
-            null,
-            isFloat ? null : null); // Treated as FLOAT or DOUBLE
-        checkCastToString(
-            MIN_NUMERIC_STRINGS[i],
-            type,
-            isFloat ? "1.401298E-45" : null);
-      }
-
-      checkCastFails("'notnumeric'", type, INVALID_CHAR_MESSAGE, true);
-    }
-  }
-
-  @Test void testCastToApproxNumeric() {
-    tester.setFor(SqlStdOperatorTable.CAST);
-
-    checkCastToApproxOkay("1", "DOUBLE", 1, 0);
-    checkCastToApproxOkay("1.0", "DOUBLE", 1, 0);
-    checkCastToApproxOkay("-2.3", "FLOAT", -2.3, 0.000001);
-    checkCastToApproxOkay("'1'", "DOUBLE", 1, 0);
-    checkCastToApproxOkay("'  -1e-37  '", "DOUBLE", -1e-37, 0);
-    checkCastToApproxOkay("1e0", "DOUBLE", 1, 0);
-    checkCastToApproxOkay("0e0", "REAL", 0, 0);
-  }
-
-  @Test void testCastNull() {
-    tester.setFor(SqlStdOperatorTable.CAST);
-
-    // null
-    tester.checkNull("cast(null as integer)");
-    if (DECIMAL) {
-      tester.checkNull("cast(null as decimal(4,3))");
-    }
-    tester.checkNull("cast(null as double)");
-    tester.checkNull("cast(null as varchar(10))");
-    tester.checkNull("cast(null as char(10))");
-    tester.checkNull("cast(null as date)");
-    tester.checkNull("cast(null as time)");
-    tester.checkNull("cast(null as timestamp)");
-    tester.checkNull("cast(null as interval year to month)");
-    tester.checkNull("cast(null as interval day to second(3))");
-    tester.checkNull("cast(null as boolean)");
-  }
-
-  /** Test case for
-   * <a href="https://issues.apache.org/jira/browse/CALCITE-1439">[CALCITE-1439]
-   * Handling errors during constant reduction</a>. */
-  @Test void testCastInvalid() {
-    // Before CALCITE-1439 was fixed, constant reduction would kick in and
-    // generate Java constants that throw when the class is loaded, thus
-    // ExceptionInInitializerError.
-    tester.checkScalarExact("cast('15' as integer)", "INTEGER NOT NULL", "15");
-    if (Bug.CALCITE_2539_FIXED) {
-      tester.checkFails("cast('15.4' as integer)", "xxx", true);
-      tester.checkFails("cast('15.6' as integer)", "xxx", true);
-      tester.checkFails("cast('ue' as boolean)", "xxx", true);
-      tester.checkFails("cast('' as boolean)", "xxx", true);
-      tester.checkFails("cast('' as integer)", "xxx", true);
-      tester.checkFails("cast('' as real)", "xxx", true);
-      tester.checkFails("cast('' as double)", "xxx", true);
-      tester.checkFails("cast('' as smallint)", "xxx", true);
-    }
-  }
-
-  @Test void testCastDateTime() {
-    // Test cast for date/time/timestamp
-    tester.setFor(SqlStdOperatorTable.CAST);
-
-    tester.checkScalar(
-        "cast(TIMESTAMP '1945-02-24 12:42:25.34' as TIMESTAMP)",
-        "1945-02-24 12:42:25",
-        "TIMESTAMP(0) NOT NULL");
-
-    tester.checkScalar(
-        "cast(TIME '12:42:25.34' as TIME)",
-        "12:42:25",
-        "TIME(0) NOT NULL");
-
-    // test rounding
-    if (enable) {
-      tester.checkScalar(
-          "cast(TIME '12:42:25.9' as TIME)",
-          "12:42:26",
-          "TIME(0) NOT NULL");
-    }
-
-    if (Bug.FRG282_FIXED) {
-      // test precision
-      tester.checkScalar(
-          "cast(TIME '12:42:25.34' as TIME(2))",
-          "12:42:25.34",
-          "TIME(2) NOT NULL");
-    }
-
-    tester.checkScalar(
-        "cast(DATE '1945-02-24' as DATE)",
-        "1945-02-24",
-        "DATE NOT NULL");
-
-    // timestamp <-> time
-    tester.checkScalar(
-        "cast(TIMESTAMP '1945-02-24 12:42:25.34' as TIME)",
-        "12:42:25",
-        "TIME(0) NOT NULL");
-
-    // time <-> string
-    checkCastToString("TIME '12:42:25'", null, "12:42:25");
-    if (TODO) {
-      checkCastToString("TIME '12:42:25.34'", null, "12:42:25.34");
-    }
-
-    // Generate the current date as a string, e.g. "2007-04-18". The value
-    // is guaranteed to be good for at least 2 minutes, which should give
-    // us time to run the rest of the tests.
-    final String today =
-        new SimpleDateFormat("yyyy-MM-dd", Locale.ROOT).format(
-            getCalendarNotTooNear(Calendar.DAY_OF_MONTH).getTime());
-
-    tester.checkScalar(
-        "cast(DATE '1945-02-24' as TIMESTAMP)",
-        "1945-02-24 00:00:00",
-        "TIMESTAMP(0) NOT NULL");
-
-    // Note: Casting to time(0) should lose date info and fractional
-    // seconds, then casting back to timestamp should initialize to
-    // current_date.
-    tester.checkScalar(
-        "cast(cast(TIMESTAMP '1945-02-24 12:42:25.34' as TIME) as TIMESTAMP)",
-        today + " 12:42:25",
-        "TIMESTAMP(0) NOT NULL");
-
-    tester.checkScalar(
-        "cast(TIME '12:42:25.34' as TIMESTAMP)",
-        today + " 12:42:25",
-        "TIMESTAMP(0) NOT NULL");
-
-    // timestamp <-> date
-    tester.checkScalar(
-        "cast(TIMESTAMP '1945-02-24 12:42:25.34' as DATE)",
-        "1945-02-24",
-        "DATE NOT NULL");
-
-    // Note: casting to Date discards Time fields
-    tester.checkScalar(
-        "cast(cast(TIMESTAMP '1945-02-24 12:42:25.34' as DATE) as TIMESTAMP)",
-        "1945-02-24 00:00:00",
-        "TIMESTAMP(0) NOT NULL");
-  }
-
-  @Test void testCastStringToDateTime() {
-    tester.checkScalar(
-        "cast('12:42:25' as TIME)",
-        "12:42:25",
-        "TIME(0) NOT NULL");
-    tester.checkScalar(
-        "cast('1:42:25' as TIME)",
-        "01:42:25",
-        "TIME(0) NOT NULL");
-    tester.checkScalar(
-        "cast('1:2:25' as TIME)",
-        "01:02:25",
-        "TIME(0) NOT NULL");
-    tester.checkScalar(
-        "cast('  12:42:25  ' as TIME)",
-        "12:42:25",
-        "TIME(0) NOT NULL");
-    tester.checkScalar(
-        "cast('12:42:25.34' as TIME)",
-        "12:42:25",
-        "TIME(0) NOT NULL");
-
-    if (Bug.FRG282_FIXED) {
-      tester.checkScalar(
-          "cast('12:42:25.34' as TIME(2))",
-          "12:42:25.34",
-          "TIME(2) NOT NULL");
-    }
-
-    tester.checkFails(
-        "cast('nottime' as TIME)", BAD_DATETIME_MESSAGE,
-        true);
-    if (Bug.CALCITE_2539_FIXED) {
-      tester.checkFails(
-          "cast('1241241' as TIME)", BAD_DATETIME_MESSAGE,
-          true);
-      tester.checkFails(
-          "cast('12:54:78' as TIME)", BAD_DATETIME_MESSAGE,
-          true);
-      tester.checkFails(
-          "cast('12:34:5' as TIME)", BAD_DATETIME_MESSAGE,
-          true);
-      tester.checkFails(
-          "cast('12:3:45' as TIME)", BAD_DATETIME_MESSAGE,
-          true);
-      tester.checkFails(
-          "cast('1:23:45' as TIME)", BAD_DATETIME_MESSAGE,
-          true);
-    }
-
-    // timestamp <-> string
-    checkCastToString(
-        "TIMESTAMP '1945-02-24 12:42:25'",
-        null,
-        "1945-02-24 12:42:25");
-
-    if (TODO) {
-      // TODO: casting allows one to discard precision without error
-      checkCastToString(
-          "TIMESTAMP '1945-02-24 12:42:25.34'",
-          null,
-          "1945-02-24 12:42:25.34");
-    }
-
-    tester.checkScalar(
-        "cast('1945-02-24 12:42:25' as TIMESTAMP)",
-        "1945-02-24 12:42:25",
-        "TIMESTAMP(0) NOT NULL");
-    tester.checkScalar(
-        "cast('1945-2-2 12:2:5' as TIMESTAMP)",
-        "1945-02-02 12:02:05",
-        "TIMESTAMP(0) NOT NULL");
-    tester.checkScalar(
-        "cast('  1945-02-24 12:42:25  ' as TIMESTAMP)",
-        "1945-02-24 12:42:25",
-        "TIMESTAMP(0) NOT NULL");
-    tester.checkScalar(
-        "cast('1945-02-24 12:42:25.34' as TIMESTAMP)",
-        "1945-02-24 12:42:25",
-        "TIMESTAMP(0) NOT NULL");
-    tester.checkScalar(
-        "cast('1945-12-31' as TIMESTAMP)",
-        "1945-12-31 00:00:00",
-        "TIMESTAMP(0) NOT NULL");
-    tester.checkScalar(
-        "cast('2004-02-29' as TIMESTAMP)",
-        "2004-02-29 00:00:00",
-        "TIMESTAMP(0) NOT NULL");
-
-    if (Bug.FRG282_FIXED) {
-      tester.checkScalar(
-          "cast('1945-02-24 12:42:25.34' as TIMESTAMP(2))",
-          "1945-02-24 12:42:25.34",
-          "TIMESTAMP(2) NOT NULL");
-    }
-    tester.checkFails(
-        "cast('nottime' as TIMESTAMP)", BAD_DATETIME_MESSAGE,
-        true);
-
-    if (Bug.CALCITE_2539_FIXED) {
-      tester.checkFails(
-          "cast('1241241' as TIMESTAMP)", BAD_DATETIME_MESSAGE,
-          true);
-      tester.checkFails(
-          "cast('1945-20-24 12:42:25.34' as TIMESTAMP)", BAD_DATETIME_MESSAGE,
-          true);
-      tester.checkFails(
-          "cast('1945-01-24 25:42:25.34' as TIMESTAMP)", BAD_DATETIME_MESSAGE,
-          true);
-      tester.checkFails(
-          "cast('1945-1-24 12:23:34.454' as TIMESTAMP)", BAD_DATETIME_MESSAGE,
-          true);
-    }
-
-    // date <-> string
-    checkCastToString("DATE '1945-02-24'", null, "1945-02-24");
-    checkCastToString("DATE '1945-2-24'", null, "1945-02-24");
-
-    tester.checkScalar(
-        "cast('1945-02-24' as DATE)",
-        "1945-02-24",
-        "DATE NOT NULL");
-    tester.checkScalar(
-        "cast(' 1945-2-4 ' as DATE)",
-        "1945-02-04",
-        "DATE NOT NULL");
-    tester.checkScalar(
-        "cast('  1945-02-24  ' as DATE)",
-        "1945-02-24",
-        "DATE NOT NULL");
-    tester.checkFails(
-        "cast('notdate' as DATE)", BAD_DATETIME_MESSAGE,
-        true);
-
-    if (Bug.CALCITE_2539_FIXED) {
-      tester.checkFails(
-          "cast('52534253' as DATE)", BAD_DATETIME_MESSAGE,
-          true);
-      tester.checkFails(
-          "cast('1945-30-24' as DATE)", BAD_DATETIME_MESSAGE,
-          true);
-    }
-
-    // cast null
-    tester.checkNull("cast(null as date)");
-    tester.checkNull("cast(null as timestamp)");
-    tester.checkNull("cast(null as time)");
-    tester.checkNull("cast(cast(null as varchar(10)) as time)");
-    tester.checkNull("cast(cast(null as varchar(10)) as date)");
-    tester.checkNull("cast(cast(null as varchar(10)) as timestamp)");
-    tester.checkNull("cast(cast(null as date) as timestamp)");
-    tester.checkNull("cast(cast(null as time) as timestamp)");
-    tester.checkNull("cast(cast(null as timestamp) as date)");
-    tester.checkNull("cast(cast(null as timestamp) as time)");
-  }
-
-  private static Calendar getFixedCalendar() {
-    Calendar calendar = Util.calendar();
-    calendar.set(Calendar.YEAR, 2014);
-    calendar.set(Calendar.MONTH, 8);
-    calendar.set(Calendar.DATE, 7);
-    calendar.set(Calendar.HOUR_OF_DAY, 17);
-    calendar.set(Calendar.MINUTE, 8);
-    calendar.set(Calendar.SECOND, 48);
-    calendar.set(Calendar.MILLISECOND, 15);
-    return calendar;
-  }
-
-  /**
-   * Returns a Calendar that is the current time, pausing if we are within 2
-   * minutes of midnight or the top of the hour.
-   *
-   * @param timeUnit Time unit
-   * @return calendar
-   */
-  protected static Calendar getCalendarNotTooNear(int timeUnit) {
-    final Calendar cal = Util.calendar();
-    while (true) {
-      cal.setTimeInMillis(System.currentTimeMillis());
-      try {
-        switch (timeUnit) {
-        case Calendar.DAY_OF_MONTH:
-          // Within two minutes of the end of the day. Wait in 10s
-          // increments until calendar moves into the next next day.
-          if ((cal.get(Calendar.HOUR_OF_DAY) == 23)
-              && (cal.get(Calendar.MINUTE) >= 58)) {
-            Thread.sleep(10 * 1000);
-            continue;
-          }
-          return cal;
-
-        case Calendar.HOUR_OF_DAY:
-          // Within two minutes of the top of the hour. Wait in 10s
-          // increments until calendar moves into the next next day.
-          if (cal.get(Calendar.MINUTE) >= 58) {
-            Thread.sleep(10 * 1000);
-            continue;
-          }
-          return cal;
-
-        default:
-          throw new AssertionError("unexpected time unit: " + timeUnit);
-        }
-      } catch (InterruptedException e) {
-        throw TestUtil.rethrow(e);
-      }
-    }
-  }
-
-  @Test void testCastToBoolean() {
-    tester.setFor(SqlStdOperatorTable.CAST);
-
-    // string to boolean
-    tester.checkBoolean("cast('true' as boolean)", Boolean.TRUE);
-    tester.checkBoolean("cast('false' as boolean)", Boolean.FALSE);
-    tester.checkBoolean("cast('  trUe' as boolean)", Boolean.TRUE);
-    tester.checkBoolean("cast('  tr' || 'Ue' as boolean)", Boolean.TRUE);
-    tester.checkBoolean("cast('  fALse' as boolean)", Boolean.FALSE);
-    tester.checkFails(
-        "cast('unknown' as boolean)", INVALID_CHAR_MESSAGE,
-        true);
-
-    tester.checkBoolean(
-        "cast(cast('true' as varchar(10))  as boolean)",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "cast(cast('false' as varchar(10)) as boolean)",
-        Boolean.FALSE);
-    tester.checkFails(
-        "cast(cast('blah' as varchar(10)) as boolean)", INVALID_CHAR_MESSAGE,
-        true);
-  }
-
-  @Test void testCase() {
-    tester.setFor(SqlStdOperatorTable.CASE);
-    tester.checkScalarExact("case when 'a'='a' then 1 end", "1");
-
-    tester.checkString(
-        "case 2 when 1 then 'a' when 2 then 'bcd' end",
-        "bcd",
-        "CHAR(3)");
-    tester.checkString(
-        "case 1 when 1 then 'a' when 2 then 'bcd' end",
-        "a  ",
-        "CHAR(3)");
-    tester.checkString(
-        "case 1 when 1 then cast('a' as varchar(1)) "
-            + "when 2 then cast('bcd' as varchar(3)) end",
-        "a",
-        "VARCHAR(3)");
-    if (DECIMAL) {
-      tester.checkScalarExact(
-          "case 2 when 1 then 11.2 when 2 then 4.543 else null end",
-          "DECIMAL(5, 3)",
-          "4.543");
-      tester.checkScalarExact(
-          "case 1 when 1 then 11.2 when 2 then 4.543 else null end",
-          "DECIMAL(5, 3)",
-          "11.200");
-    }
-    tester.checkScalarExact("case 'a' when 'a' then 1 end", "1");
-    tester.checkScalarApprox(
-        "case 1 when 1 then 11.2e0 when 2 then cast(4 as bigint) else 3 end",
-        "DOUBLE NOT NULL",
-        11.2,
-        0);
-    tester.checkScalarApprox(
-        "case 1 when 1 then 11.2e0 when 2 then 4 else null end",
-        "DOUBLE",
-        11.2,
-        0);
-    tester.checkScalarApprox(
-        "case 2 when 1 then 11.2e0 when 2 then 4 else null end",
-        "DOUBLE",
-        4,
-        0);
-    tester.checkScalarApprox(
-        "case 1 when 1 then 11.2e0 when 2 then 4.543 else null end",
-        "DOUBLE",
-        11.2,
-        0);
-    tester.checkScalarApprox(
-        "case 2 when 1 then 11.2e0 when 2 then 4.543 else null end",
-        "DOUBLE",
-        4.543,
-        0);
-    tester.checkNull("case 'a' when 'b' then 1 end");
-
-    // Per spec, 'case x when y then ...'
-    // translates to 'case when x = y then ...'
-    // so nulls do not match.
-    // (Unlike Oracle's 'decode(null, null, ...)', by the way.)
-    tester.checkString(
-        "case cast(null as int) when cast(null as int) then 'nulls match' else 'nulls do not match' end",
-        "nulls do not match",
-        "CHAR(18) NOT NULL");
-
-    tester.checkScalarExact(
-        "case when 'a'=cast(null as varchar(1)) then 1 else 2 end",
-        "2");
-
-    // equivalent to "nullif('a',cast(null as varchar(1)))"
-    tester.checkString(
-        "case when 'a' = cast(null as varchar(1)) then null else 'a' end",
-        "a",
-        "CHAR(1)");
-
-    if (TODO) {
-      tester.checkScalar(
-          "case 1 when 1 then row(1,2) when 2 then row(2,3) end",
-          "ROW(INTEGER NOT NULL, INTEGER NOT NULL)",
-          "row(1,2)");
-      tester.checkScalar(
-          "case 1 when 1 then row('a','b') when 2 then row('ab','cd') end",
-          "ROW(CHAR(2) NOT NULL, CHAR(2) NOT NULL)",
-          "row('a ','b ')");
-    }
-
-    // multiple values in some cases (introduced in SQL:2011)
-    tester.checkString(
-        "case 1 "
-            + "when 1, 2 then '1 or 2' "
-            + "when 2 then 'not possible' "
-            + "when 3, 2 then '3' "
-            + "else 'none of the above' "
-            + "end",
-        "1 or 2           ",
-        "CHAR(17) NOT NULL");
-    tester.checkString(
-        "case 2 "
-            + "when 1, 2 then '1 or 2' "
-            + "when 2 then 'not possible' "
-            + "when 3, 2 then '3' "
-            + "else 'none of the above' "
-            + "end",
-        "1 or 2           ",
-        "CHAR(17) NOT NULL");
-    tester.checkString(
-        "case 3 "
-            + "when 1, 2 then '1 or 2' "
-            + "when 2 then 'not possible' "
-            + "when 3, 2 then '3' "
-            + "else 'none of the above' "
-            + "end",
-        "3                ",
-        "CHAR(17) NOT NULL");
-    tester.checkString(
-        "case 4 "
-            + "when 1, 2 then '1 or 2' "
-            + "when 2 then 'not possible' "
-            + "when 3, 2 then '3' "
-            + "else 'none of the above' "
-            + "end",
-        "none of the above",
-        "CHAR(17) NOT NULL");
-
-    // tests with SqlConformance
-    final SqlTester tester2 =
-        tester.withConformance(SqlConformanceEnum.PRAGMATIC_2003);
-    tester2.checkString(
-        "case 2 when 1 then 'a' when 2 then 'bcd' end",
-        "bcd",
-        "VARCHAR(3)");
-    tester2.checkString(
-        "case 1 when 1 then 'a' when 2 then 'bcd' end",
-        "a",
-        "VARCHAR(3)");
-    tester2.checkString(
-        "case 1 when 1 then cast('a' as varchar(1)) "
-            + "when 2 then cast('bcd' as varchar(3)) end",
-        "a",
-        "VARCHAR(3)");
-
-    tester2.checkString(
-        "case cast(null as int) when cast(null as int)"
-            + " then 'nulls match'"
-            + " else 'nulls do not match' end",
-        "nulls do not match",
-        "VARCHAR(18) NOT NULL");
-    tester2.checkScalarExact(
-        "case when 'a'=cast(null as varchar(1)) then 1 else 2 end",
-        "2");
-
-    // equivalent to "nullif('a',cast(null as varchar(1)))"
-    tester2.checkString(
-        "case when 'a' = cast(null as varchar(1)) then null else 'a' end",
-        "a",
-        "CHAR(1)");
-
-    // multiple values in some cases (introduced in SQL:2011)
-    tester2.checkString(
-        "case 1 "
-            + "when 1, 2 then '1 or 2' "
-            + "when 2 then 'not possible' "
-            + "when 3, 2 then '3' "
-            + "else 'none of the above' "
-            + "end",
-        "1 or 2",
-        "VARCHAR(17) NOT NULL");
-    tester2.checkString(
-        "case 2 "
-            + "when 1, 2 then '1 or 2' "
-            + "when 2 then 'not possible' "
-            + "when 3, 2 then '3' "
-            + "else 'none of the above' "
-            + "end",
-        "1 or 2",
-        "VARCHAR(17) NOT NULL");
-    tester2.checkString(
-        "case 3 "
-            + "when 1, 2 then '1 or 2' "
-            + "when 2 then 'not possible' "
-            + "when 3, 2 then '3' "
-            + "else 'none of the above' "
-            + "end",
-        "3",
-        "VARCHAR(17) NOT NULL");
-    tester2.checkString(
-        "case 4 "
-            + "when 1, 2 then '1 or 2' "
-            + "when 2 then 'not possible' "
-            + "when 3, 2 then '3' "
-            + "else 'none of the above' "
-            + "end",
-        "none of the above",
-        "VARCHAR(17) NOT NULL");
-
-    // TODO: Check case with multisets
-  }
-
-  @Test void testCaseNull() {
-    tester.setFor(SqlStdOperatorTable.CASE);
-    tester.checkScalarExact("case when 1 = 1 then 10 else null end", "10");
-    tester.checkNull("case when 1 = 2 then 10 else null end");
-  }
-
-  @Test void testCaseType() {
-    tester.setFor(SqlStdOperatorTable.CASE);
-    tester.checkType(
-        "case 1 when 1 then current_timestamp else null end",
-        "TIMESTAMP(0)");
-    tester.checkType(
-        "case 1 when 1 then current_timestamp else current_timestamp end",
-        "TIMESTAMP(0) NOT NULL");
-    tester.checkType(
-        "case when true then current_timestamp else null end",
-        "TIMESTAMP(0)");
-    tester.checkType(
-        "case when true then current_timestamp end",
-        "TIMESTAMP(0)");
-    tester.checkType(
-        "case 'x' when 'a' then 3 when 'b' then null else 4.5 end",
-        "DECIMAL(11, 1)");
-  }
-
-  /**
-   * Tests support for JDBC functions.
-   *
-   * <p>See FRG-97 "Support for JDBC escape syntax is incomplete".
-   */
-  @Test void testJdbcFn() {
-    tester.setFor(new SqlJdbcFunctionCall("dummy"));
-
-    // There follows one test for each function in appendix C of the JDBC
-    // 3.0 specification. The test is 'if-false'd out if the function is
-    // not implemented or is broken.
-
-    // Numeric Functions
-    tester.checkScalar("{fn ABS(-3)}", 3, "INTEGER NOT NULL");
-    tester.checkScalarApprox("{fn ACOS(0.2)}", "DOUBLE NOT NULL", 1.36943, 0.001);
-    tester.checkScalarApprox("{fn ASIN(0.2)}", "DOUBLE NOT NULL", 0.20135, 0.001);
-    tester.checkScalarApprox("{fn ATAN(0.2)}", "DOUBLE NOT NULL", 0.19739, 0.001);
-    tester.checkScalarApprox("{fn ATAN2(-2, 2)}", "DOUBLE NOT NULL", -0.78539, 0.001);
-    tester.checkScalar("{fn CBRT(8)}", 2.0, "DOUBLE NOT NULL");
-    tester.checkScalar("{fn CEILING(-2.6)}", -2, "DECIMAL(2, 0) NOT NULL");
-    tester.checkScalarApprox("{fn COS(0.2)}", "DOUBLE NOT NULL", 0.98007, 0.001);
-    tester.checkScalarApprox("{fn COT(0.2)}", "DOUBLE NOT NULL", 4.93315, 0.001);
-    tester.checkScalarApprox("{fn DEGREES(-1)}", "DOUBLE NOT NULL", -57.29578, 0.001);
-
-    tester.checkScalarApprox(
-        "{fn EXP(2)}",
-        "DOUBLE NOT NULL",
-        7.389,
-        0.001);
-    tester.checkScalar("{fn FLOOR(2.6)}", 2, "DECIMAL(2, 0) NOT NULL");
-    tester.checkScalarApprox(
-        "{fn LOG(10)}",
-        "DOUBLE NOT NULL",
-        2.30258,
-        0.001);
-    tester.checkScalarApprox(
-        "{fn LOG10(100)}",
-        "DOUBLE NOT NULL",
-        2,
-        0);
-    tester.checkScalar("{fn MOD(19, 4)}", 3, "INTEGER NOT NULL");
-    tester.checkScalarApprox("{fn PI()}", "DOUBLE NOT NULL", 3.14159, 0.0001);
-    tester.checkScalarApprox("{fn POWER(2, 3)}", "DOUBLE NOT NULL", 8.0, 0.001);
-    tester.checkScalarApprox("{fn RADIANS(90)}", "DOUBLE NOT NULL", 1.57080, 0.001);
-    tester.checkScalarApprox("{fn RAND(42)}", "DOUBLE NOT NULL", 0.63708, 0.001);
-    tester.checkScalar("{fn ROUND(1251, -2)}", 1300, "INTEGER NOT NULL");
-    tester.checkFails("^{fn ROUND(1251)}^", "Cannot apply '\\{fn ROUND\\}' to "
-        + "arguments of type '\\{fn ROUND\\}\\(<INTEGER>\\)'.*", false);
-    tester.checkScalar("{fn SIGN(-1)}", -1, "INTEGER NOT NULL");
-    tester.checkScalarApprox("{fn SIN(0.2)}", "DOUBLE NOT NULL", 0.19867, 0.001);
-    tester.checkScalarApprox("{fn SQRT(4.2)}", "DOUBLE NOT NULL", 2.04939, 0.001);
-    tester.checkScalarApprox("{fn TAN(0.2)}", "DOUBLE NOT NULL", 0.20271, 0.001);
-    tester.checkScalar("{fn TRUNCATE(12.34, 1)}", 12.3, "DECIMAL(4, 2) NOT NULL");
-    tester.checkScalar("{fn TRUNCATE(-12.34, -1)}", -10, "DECIMAL(4, 2) NOT NULL");
-
-    // String Functions
-    tester.checkScalar("{fn ASCII('a')}", 97, "INTEGER NOT NULL");
-    tester.checkScalar("{fn ASCII('ABC')}", "65", "INTEGER NOT NULL");
-    tester.checkNull("{fn ASCII(cast(null as varchar(1)))}");
-
-    if (false) {
-      tester.checkScalar("{fn CHAR(code)}", null, "");
-    }
-    tester.checkScalar(
-        "{fn CONCAT('foo', 'bar')}",
-        "foobar",
-        "CHAR(6) NOT NULL");
-
-    tester.checkScalar("{fn DIFFERENCE('Miller', 'miller')}", "4", "INTEGER NOT NULL");
-    tester.checkNull("{fn DIFFERENCE('muller', cast(null as varchar(1)))}");
-
-    tester.checkString("{fn REVERSE('abc')}", "cba", "VARCHAR(3) NOT NULL");
-    tester.checkNull("{fn REVERSE(cast(null as varchar(1)))}");
-
-    tester.checkString("{fn LEFT('abcd', 3)}", "abc", "VARCHAR(4) NOT NULL");
-    tester.checkString("{fn LEFT('abcd', 4)}", "abcd", "VARCHAR(4) NOT NULL");
-    tester.checkString("{fn LEFT('abcd', 5)}", "abcd", "VARCHAR(4) NOT NULL");
-    tester.checkNull("{fn LEFT(cast(null as varchar(1)), 3)}");
-    tester.checkString("{fn RIGHT('abcd', 3)}", "bcd", "VARCHAR(4) NOT NULL");
-    tester.checkString("{fn RIGHT('abcd', 4)}", "abcd", "VARCHAR(4) NOT NULL");
-    tester.checkString("{fn RIGHT('abcd', 5)}", "abcd", "VARCHAR(4) NOT NULL");
-    tester.checkNull("{fn RIGHT(cast(null as varchar(1)), 3)}");
-
-    // REVIEW: is this result correct? I think it should be "abcCdef"
-    tester.checkScalar(
-        "{fn INSERT('abc', 1, 2, 'ABCdef')}",
-        "ABCdefc",
-        "VARCHAR(9) NOT NULL");
-    tester.checkScalar(
-        "{fn LCASE('foo' || 'bar')}",
-        "foobar",
-        "CHAR(6) NOT NULL");
-    if (false) {
-      tester.checkScalar("{fn LENGTH(string)}", null, "");
-    }
-    tester.checkScalar(
-        "{fn LOCATE('ha', 'alphabet')}",
-        4,
-        "INTEGER NOT NULL");
-
-    tester.checkScalar(
-        "{fn LOCATE('ha', 'alphabet', 6)}",
-        0,
-        "INTEGER NOT NULL");
-
-    tester.checkScalar(
-        "{fn LTRIM(' xxx  ')}",
-        "xxx  ",
-        "VARCHAR(6) NOT NULL");
-
-    tester.checkScalar("{fn REPEAT('a', -100)}", "", "VARCHAR(1) NOT NULL");
-    tester.checkNull("{fn REPEAT('abc', cast(null as integer))}");
-    tester.checkNull("{fn REPEAT(cast(null as varchar(1)), cast(null as integer))}");
-
-    tester.checkString("{fn REPLACE('JACK and JUE','J','BL')}",
-        "BLACK and BLUE", "VARCHAR(12) NOT NULL");
-
-    // REPLACE returns NULL in Oracle but not in Postgres or in Calcite.
-    // When [CALCITE-815] is implemented and SqlConformance#emptyStringIsNull is
-    // enabled, it will return empty string as NULL.
-    tester.checkString("{fn REPLACE('ciao', 'ciao', '')}", "",
-        "VARCHAR(4) NOT NULL");
-
-    tester.checkString("{fn REPLACE('hello world', 'o', '')}", "hell wrld",
-        "VARCHAR(11) NOT NULL");
-
-    tester.checkNull("{fn REPLACE(cast(null as varchar(5)), 'ciao', '')}");
-    tester.checkNull("{fn REPLACE('ciao', cast(null as varchar(3)), 'zz')}");
-    tester.checkNull("{fn REPLACE('ciao', 'bella', cast(null as varchar(3)))}");
-
-
-    tester.checkScalar(
-        "{fn RTRIM(' xxx  ')}",
-        " xxx",
-        "VARCHAR(6) NOT NULL");
-
-    tester.checkScalar("{fn SOUNDEX('Miller')}", "M460", "VARCHAR(4) NOT NULL");
-    tester.checkNull("{fn SOUNDEX(cast(null as varchar(1)))}");
-
-    tester.checkScalar("{fn SPACE(-100)}", "", "VARCHAR(2000) NOT NULL");
-    tester.checkNull("{fn SPACE(cast(null as integer))}");
-
-    tester.checkScalar(
-        "{fn SUBSTRING('abcdef', 2, 3)}",
-        "bcd",
-        "VARCHAR(6) NOT NULL");
-    tester.checkScalar("{fn UCASE('xxx')}", "XXX", "CHAR(3) NOT NULL");
-
-    // Time and Date Functions
-    tester.checkType("{fn CURDATE()}", "DATE NOT NULL");
-    tester.checkType("{fn CURTIME()}", "TIME(0) NOT NULL");
-    tester.checkScalar("{fn DAYNAME(DATE '2014-12-10')}",
-        // Day names in root locale changed from long to short in JDK 9
-        TestUtil.getJavaMajorVersion() <= 8 ? "Wednesday" : "Wed",
-        "VARCHAR(2000) NOT NULL");
-    tester.checkScalar("{fn DAYOFMONTH(DATE '2014-12-10')}", 10,
-        "BIGINT NOT NULL");
-    if (Bug.CALCITE_2539_FIXED) {
-      tester.checkFails("{fn DAYOFWEEK(DATE '2014-12-10')}",
-          "cannot translate call EXTRACT.*",
-          true);
-      tester.checkFails("{fn DAYOFYEAR(DATE '2014-12-10')}",
-          "cannot translate call EXTRACT.*",
-          true);
-    }
-    tester.checkScalar("{fn HOUR(TIMESTAMP '2014-12-10 12:34:56')}", 12,
-        "BIGINT NOT NULL");
-    tester.checkScalar("{fn MINUTE(TIMESTAMP '2014-12-10 12:34:56')}", 34,
-        "BIGINT NOT NULL");
-    tester.checkScalar("{fn MONTH(DATE '2014-12-10')}", 12, "BIGINT NOT NULL");
-    tester.checkScalar("{fn MONTHNAME(DATE '2014-12-10')}",
-        // Month names in root locale changed from long to short in JDK 9
-        TestUtil.getJavaMajorVersion() <= 8 ? "December" : "Dec",
-        "VARCHAR(2000) NOT NULL");
-    tester.checkType("{fn NOW()}", "TIMESTAMP(0) NOT NULL");
-    tester.checkScalar("{fn QUARTER(DATE '2014-12-10')}", "4",
-        "BIGINT NOT NULL");
-    tester.checkScalar("{fn SECOND(TIMESTAMP '2014-12-10 12:34:56')}", 56,
-        "BIGINT NOT NULL");
-    tester.checkScalar("{fn TIMESTAMPADD(HOUR, 5,"
-            + " TIMESTAMP '2014-03-29 12:34:56')}",
-        "2014-03-29 17:34:56", "TIMESTAMP(0) NOT NULL");
-    tester.checkScalar("{fn TIMESTAMPDIFF(HOUR,"
-        + " TIMESTAMP '2014-03-29 12:34:56',"
-        + " TIMESTAMP '2014-03-29 12:34:56')}", "0", "INTEGER NOT NULL");
-    tester.checkScalar("{fn TIMESTAMPDIFF(MONTH,"
-        + " TIMESTAMP '2019-09-01 00:00:00',"
-        + " TIMESTAMP '2020-03-01 00:00:00')}", "6", "INTEGER NOT NULL");
-
-    if (Bug.CALCITE_2539_FIXED) {
-      tester.checkFails("{fn WEEK(DATE '2014-12-10')}",
-          "cannot translate call EXTRACT.*",
-          true);
-    }
-    tester.checkScalar("{fn YEAR(DATE '2014-12-10')}", 2014, "BIGINT NOT NULL");
-
-    // System Functions
-    tester.checkType("{fn DATABASE()}", "VARCHAR(2000) NOT NULL");
-    tester.checkString("{fn IFNULL('a', 'b')}", "a", "CHAR(1) NOT NULL");
-    tester.checkString("{fn USER()}", "sa", "VARCHAR(2000) NOT NULL");
-
-
-    // Conversion Functions
-    // Legacy JDBC style
-    tester.checkScalar("{fn CONVERT('123', INTEGER)}", 123, "INTEGER NOT NULL");
-    // ODBC/JDBC style
-    tester.checkScalar("{fn CONVERT('123', SQL_INTEGER)}", 123, "INTEGER NOT NULL");
-    tester.checkScalar("{fn CONVERT(INTERVAL '1' DAY, SQL_INTERVAL_DAY_TO_SECOND)}",
-        "+1 00:00:00.000000", "INTERVAL DAY TO SECOND NOT NULL");
-
-  }
-
-  @Test void testChr() {
-    tester.setFor(SqlLibraryOperators.CHR, VM_FENNEL, VM_JAVA);
-    final SqlTester tester1 = libraryTester(SqlLibrary.ORACLE);
-    tester1.checkScalar("chr(97)",
-            "a", "CHAR(1) NOT NULL");
-    tester1.checkScalar("chr(48)",
-            "0", "CHAR(1) NOT NULL");
-    tester1.checkScalar("chr(0)",
-            String.valueOf('\u0000'), "CHAR(1) NOT NULL");
-    tester.checkFails("^chr(97.1)^",
-            "No match found for function signature CHR\\(<NUMERIC>\\)", false);
-  }
-
-  @Test void testSelect() {
-    tester.check(
-        "select * from (values(1))",
-        SqlTests.INTEGER_TYPE_CHECKER,
-        "1",
-        0);
-
-    // Check return type on scalar sub-query in select list.  Note return
-    // type is always nullable even if sub-query select value is NOT NULL.
-    // Bug FRG-189 causes this test to fail only in SqlOperatorTest; not
-    // in subtypes.
-    if (Bug.FRG189_FIXED
-        || (getClass() != SqlOperatorTest.class) && Bug.TODO_FIXED) {
-      tester.checkType(
-          "SELECT *,(SELECT * FROM (VALUES(1))) FROM (VALUES(2))",
-          "RecordType(INTEGER NOT NULL EXPR$0, INTEGER EXPR$1) NOT NULL");
-      tester.checkType(
-          "SELECT *,(SELECT * FROM (VALUES(CAST(10 as BIGINT)))) "
-              + "FROM (VALUES(CAST(10 as bigint)))",
-          "RecordType(BIGINT NOT NULL EXPR$0, BIGINT EXPR$1) NOT NULL");
-      tester.checkType(
-          " SELECT *,(SELECT * FROM (VALUES(10.5))) FROM (VALUES(10.5))",
-          "RecordType(DECIMAL(3, 1) NOT NULL EXPR$0, DECIMAL(3, 1) EXPR$1) NOT NULL");
-      tester.checkType(
-          "SELECT *,(SELECT * FROM (VALUES('this is a char'))) "
-              + "FROM (VALUES('this is a char too'))",
-          "RecordType(CHAR(18) NOT NULL EXPR$0, CHAR(14) EXPR$1) NOT NULL");
-      tester.checkType(
-          "SELECT *,(SELECT * FROM (VALUES(true))) FROM (values(false))",
-          "RecordType(BOOLEAN NOT NULL EXPR$0, BOOLEAN EXPR$1) NOT NULL");
-      tester.checkType(
-          " SELECT *,(SELECT * FROM (VALUES(cast('abcd' as varchar(10))))) "
-              + "FROM (VALUES(CAST('abcd' as varchar(10))))",
-          "RecordType(VARCHAR(10) NOT NULL EXPR$0, VARCHAR(10) EXPR$1) NOT NULL");
-      tester.checkType(
-          "SELECT *,"
-              + "  (SELECT * FROM (VALUES(TIMESTAMP '2006-01-01 12:00:05'))) "
-              + "FROM (VALUES(TIMESTAMP '2006-01-01 12:00:05'))",
-          "RecordType(TIMESTAMP(0) NOT NULL EXPR$0, TIMESTAMP(0) EXPR$1) NOT NULL");
-    }
-  }
-
-  @Test void testLiteralChain() {
-    tester.setFor(SqlStdOperatorTable.LITERAL_CHAIN, VM_EXPAND);
-    tester.checkString(
-        "'buttered'\n' toast'",
-        "buttered toast",
-        "CHAR(14) NOT NULL");
-    tester.checkString(
-        "'corned'\n' beef'\n' on'\n' rye'",
-        "corned beef on rye",
-        "CHAR(18) NOT NULL");
-    tester.checkString(
-        "_latin1'Spaghetti'\n' all''Amatriciana'",
-        "Spaghetti all'Amatriciana",
-        "CHAR(25) NOT NULL");
-    tester.checkBoolean("x'1234'\n'abcd' = x'1234abcd'", Boolean.TRUE);
-    tester.checkBoolean("x'1234'\n'' = x'1234'", Boolean.TRUE);
-    tester.checkBoolean("x''\n'ab' = x'ab'", Boolean.TRUE);
-  }
-
-  @Test void testComplexLiteral() {
-    tester.check("select 2 * 2 * x from (select 2 as x)",
-        new SqlTests.StringTypeChecker("INTEGER NOT NULL"),
-        "8",
-        0);
-    tester.check("select 1 * 2 * 3 * x from (select 2 as x)",
-        new SqlTests.StringTypeChecker("INTEGER NOT NULL"),
-        "12",
-        0);
-    tester.check("select 1 + 2 + 3 + 4 + x from (select 2 as x)",
-        new SqlTests.StringTypeChecker("INTEGER NOT NULL"),
-        "12",
-        0);
-  }
-
-  @Test void testRow() {
-    tester.setFor(SqlStdOperatorTable.ROW, VM_FENNEL);
-  }
-
-  @Test void testAndOperator() {
-    tester.setFor(SqlStdOperatorTable.AND);
-    tester.checkBoolean("true and false", Boolean.FALSE);
-    tester.checkBoolean("true and true", Boolean.TRUE);
-    tester.checkBoolean(
-        "cast(null as boolean) and false",
-        Boolean.FALSE);
-    tester.checkBoolean(
-        "false and cast(null as boolean)",
-        Boolean.FALSE);
-    tester.checkNull("cast(null as boolean) and true");
-    tester.checkBoolean("true and (not false)", Boolean.TRUE);
-  }
-
-  @Test void testAndOperator2() {
-    tester.checkBoolean(
-        "case when false then unknown else true end and true",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "case when false then cast(null as boolean) else true end and true",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "case when false then null else true end and true",
-        Boolean.TRUE);
-  }
-
-  @Test void testAndOperatorLazy() {
-    tester.setFor(SqlStdOperatorTable.AND);
-
-    // lazy eval returns FALSE;
-    // eager eval executes RHS of AND and throws;
-    // both are valid
-    tester.check(
-        "values 1 > 2 and sqrt(-4) = -2",
-        SqlTests.BOOLEAN_TYPE_CHECKER, SqlTests.ANY_PARAMETER_CHECKER,
-        new ValueOrExceptionResultChecker(
-            Boolean.FALSE, INVALID_ARG_FOR_POWER, CODE_2201F));
-  }
-
-  @Test void testConcatOperator() {
-    tester.setFor(SqlStdOperatorTable.CONCAT);
-    tester.checkString(" 'a'||'b' ", "ab", "CHAR(2) NOT NULL");
-    tester.checkNull(" 'a' || cast(null as char(2)) ");
-    tester.checkNull(" cast(null as char(2)) || 'b' ");
-    tester.checkNull(
-        " cast(null as char(1)) || cast(null as char(2)) ");
-
-    tester.checkString(
-        " x'fe'||x'df' ",
-        "fedf",
-        "BINARY(2) NOT NULL");
-    tester.checkString(
-        " cast('fe' as char(2)) || cast('df' as varchar)",
-        "fedf",
-        "VARCHAR NOT NULL");
-    // Precision is larger than VARCHAR allows, so result is unbounded
-    tester.checkString(
-        " cast('fe' as char(2)) || cast('df' as varchar(65535))",
-        "fedf",
-        "VARCHAR NOT NULL");
-    tester.checkString(
-        " cast('fe' as char(2)) || cast('df' as varchar(33333))",
-        "fedf",
-        "VARCHAR(33335) NOT NULL");
-    tester.checkNull("x'ff' || cast(null as varbinary)");
-    tester.checkNull(" cast(null as ANY) || cast(null as ANY) ");
-    tester.checkString("cast('a' as varchar) || cast('b' as varchar) "
-        + "|| cast('c' as varchar)", "abc", "VARCHAR NOT NULL");
-  }
-
-  @Test void testConcatFunc() {
-    checkConcatFunc(tester(SqlLibrary.MYSQL));
-    checkConcatFunc(tester(SqlLibrary.POSTGRESQL));
-    checkConcat2Func(tester(SqlLibrary.ORACLE));
-  }
-
-  private void checkConcatFunc(SqlTester t) {
-    t.setFor(SqlLibraryOperators.CONCAT_FUNCTION);
-    t.checkString("concat('a', 'b', 'c')", "abc", "VARCHAR(3) NOT NULL");
-    t.checkString("concat(cast('a' as varchar), cast('b' as varchar), "
-        + "cast('c' as varchar))", "abc", "VARCHAR NOT NULL");
-    t.checkNull("concat('a', 'b', cast(null as char(2)))");
-    t.checkNull("concat(cast(null as ANY), 'b', cast(null as char(2)))");
-    t.checkString("concat('', '', 'a')", "a", "VARCHAR(1) NOT NULL");
-    t.checkString("concat('', '', '')", "", "VARCHAR(0) NOT NULL");
-    t.checkFails("^concat()^", INVALID_ARGUMENTS_NUMBER, false);
-  }
-
-  private void checkConcat2Func(SqlTester t) {
-    t.setFor(SqlLibraryOperators.CONCAT2);
-    t.checkString("concat(cast('fe' as char(2)), cast('df' as varchar(65535)))",
-        "fedf", "VARCHAR NOT NULL");
-    t.checkString("concat(cast('fe' as char(2)), cast('df' as varchar))",
-        "fedf", "VARCHAR NOT NULL");
-    t.checkString("concat(cast('fe' as char(2)), cast('df' as varchar(33333)))",
-        "fedf", "VARCHAR(33335) NOT NULL");
-    t.checkString("concat('', '')", "", "VARCHAR(0) NOT NULL");
-    t.checkString("concat('', 'a')", "a", "VARCHAR(1) NOT NULL");
-    t.checkString("concat('a', 'b')", "ab", "VARCHAR(2) NOT NULL");
-    t.checkNull("concat('a', cast(null as varchar))");
-    t.checkFails("^concat('a', 'b', 'c')^", INVALID_ARGUMENTS_NUMBER, false);
-    t.checkFails("^concat('a')^", INVALID_ARGUMENTS_NUMBER, false);
-  }
-
-  @Test void testModOperator() {
-    // "%" is allowed under MYSQL_5 SQL conformance level
-    final SqlTester tester1 = tester.withConformance(SqlConformanceEnum.MYSQL_5);
-    tester1.setFor(SqlStdOperatorTable.PERCENT_REMAINDER);
-    tester1.checkScalarExact("4%2", "0");
-    tester1.checkScalarExact("8%5", "3");
-    tester1.checkScalarExact("-12%7", "-5");
-    tester1.checkScalarExact("-12%-7", "-5");
-    tester1.checkScalarExact("12%-7", "5");
-    tester1.checkScalarExact(
-        "cast(12 as tinyint) % cast(-7 as tinyint)",
-        "TINYINT NOT NULL",
-        "5");
-    if (!DECIMAL) {
-      return;
-    }
-    tester1.checkScalarExact(
-        "cast(9 as decimal(2, 0)) % 7",
-        "INTEGER NOT NULL",
-        "2");
-    tester1.checkScalarExact(
-        "7 % cast(9 as decimal(2, 0))",
-        "DECIMAL(2, 0) NOT NULL",
-        "7");
-    tester1.checkScalarExact(
-        "cast(-9 as decimal(2, 0)) % cast(7 as decimal(1, 0))",
-        "DECIMAL(1, 0) NOT NULL",
-        "-2");
-  }
-
-  @Test void testModPrecedence() {
-    // "%" is allowed under MYSQL_5 SQL conformance level
-    final SqlTester tester1 = tester.withConformance(SqlConformanceEnum.MYSQL_5);
-    tester1.setFor(SqlStdOperatorTable.PERCENT_REMAINDER);
-    tester1.checkScalarExact("1 + 5 % 3 % 4 * 14 % 17", "12");
-    tester1.checkScalarExact("(1 + 5 % 3) % 4 + 14 % 17", "17");
-  }
-
-  @Test void testModOperatorNull() {
-    // "%" is allowed under MYSQL_5 SQL conformance level
-    final SqlTester tester1 = tester.withConformance(SqlConformanceEnum.MYSQL_5);
-    tester1.checkNull("cast(null as integer) % 2");
-    tester1.checkNull("4 % cast(null as tinyint)");
-    if (!DECIMAL) {
-      return;
-    }
-    tester1.checkNull("4 % cast(null as decimal(12,0))");
-  }
-
-  @Test void testModOperatorDivByZero() {
-    // "%" is allowed under MYSQL_5 SQL conformance level
-    final SqlTester tester1 = tester.withConformance(SqlConformanceEnum.MYSQL_5);
-    // The extra CASE expression is to fool Janino.  It does constant
-    // reduction and will throw the divide by zero exception while
-    // compiling the expression.  The test frame work would then issue
-    // unexpected exception occurred during "validation".  You cannot
-    // submit as non-runtime because the janino exception does not have
-    // error position information and the framework is unhappy with that.
-    tester1.checkFails(
-        "3 % case 'a' when 'a' then 0 end", DIVISION_BY_ZERO_MESSAGE, true);
-  }
-
-  @Test void testDivideOperator() {
-    tester.setFor(SqlStdOperatorTable.DIVIDE);
-    tester.checkScalarExact(
-        "10 / 5",
-        "INTEGER NOT NULL",
-        "2");
-    tester.checkScalarExact(
-        "-10 / 5",
-        "INTEGER NOT NULL",
-        "-2");
-    tester.checkScalarExact(
-        "-10 / 5.0",
-        "DECIMAL(17, 6) NOT NULL",
-        "-2");
-    tester.checkScalarApprox(
-        " cast(10.0 as double) / 5",
-        "DOUBLE NOT NULL",
-        2.0,
-        0);
-    tester.checkScalarApprox(
-        " cast(10.0 as real) / 4",
-        "REAL NOT NULL",
-        2.5,
-        0);
-    tester.checkScalarApprox(
-        " 6.0 / cast(10.0 as real) ",
-        "DOUBLE NOT NULL",
-        0.6,
-        0);
-    tester.checkScalarExact(
-        "10.0 / 5.0",
-        "DECIMAL(9, 6) NOT NULL",
-        "2");
-    if (DECIMAL) {
-      tester.checkScalarExact(
-          "1.0 / 3.0",
-          "DECIMAL(8, 6) NOT NULL",
-          "0.333333");
-      tester.checkScalarExact(
-          "100.1 / 0.0001",
-          "DECIMAL(14, 7) NOT NULL",
-          "1001000.0000000");
-      tester.checkScalarExact(
-          "100.1 / 0.00000001",
-          "DECIMAL(19, 8) NOT NULL",
-          "10010000000.00000000");
-    }
-    tester.checkNull("1e1 / cast(null as float)");
-
-    if (Bug.CALCITE_2539_FIXED) {
-      tester.checkFails(
-          "100.1 / 0.00000000000000001", OUT_OF_RANGE_MESSAGE,
-          true);
-    }
-  }
-
-  @Test void testDivideOperatorIntervals() {
-    tester.checkScalar(
-        "interval '-2:2' hour to minute / 3",
-        "-0:41",
-        "INTERVAL HOUR TO MINUTE NOT NULL");
-    tester.checkScalar(
-        "interval '2:5:12' hour to second / 2 / -3",
-        "-0:20:52.000000",
-        "INTERVAL HOUR TO SECOND NOT NULL");
-    tester.checkNull(
-        "interval '2' day / cast(null as bigint)");
-    tester.checkNull(
-        "cast(null as interval month) / 2");
-    tester.checkScalar(
-        "interval '3-3' year to month / 15e-1",
-        "+2-02",
-        "INTERVAL YEAR TO MONTH NOT NULL");
-    tester.checkScalar(
-        "interval '3-4' year to month / 4.5",
-        "+0-09",
-        "INTERVAL YEAR TO MONTH NOT NULL");
-  }
-
-  @Test void testEqualsOperator() {
-    tester.setFor(SqlStdOperatorTable.EQUALS);
-    tester.checkBoolean("1=1", Boolean.TRUE);
-    tester.checkBoolean("1=1.0", Boolean.TRUE);
-    tester.checkBoolean("1.34=1.34", Boolean.TRUE);
-    tester.checkBoolean("1=1.34", Boolean.FALSE);
-    tester.checkBoolean("1e2=100e0", Boolean.TRUE);
-    tester.checkBoolean("1e2=101", Boolean.FALSE);
-    tester.checkBoolean(
-        "cast(1e2 as real)=cast(101 as bigint)",
-        Boolean.FALSE);
-    tester.checkBoolean("'a'='b'", Boolean.FALSE);
-    tester.checkBoolean("true = true", Boolean.TRUE);
-    tester.checkBoolean("true = false", Boolean.FALSE);
-    tester.checkBoolean("false = true", Boolean.FALSE);
-    tester.checkBoolean("false = false", Boolean.TRUE);
-    tester.checkBoolean(
-        "cast('a' as varchar(30))=cast('a' as varchar(30))",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "cast('a ' as varchar(30))=cast('a' as varchar(30))",
-        Boolean.FALSE);
-    tester.checkBoolean(
-        "cast(' a' as varchar(30))=cast(' a' as varchar(30))",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "cast('a ' as varchar(15))=cast('a ' as varchar(30))",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "cast(' ' as varchar(3))=cast(' ' as varchar(2))",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "cast('abcd' as varchar(2))='ab'",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "cast('a' as varchar(30))=cast('b' as varchar(30))",
-        Boolean.FALSE);
-    tester.checkBoolean(
-        "cast('a' as varchar(30))=cast('a' as varchar(15))",
-        Boolean.TRUE);
-    tester.checkNull("cast(null as boolean)=cast(null as boolean)");
-    tester.checkNull("cast(null as integer)=1");
-    tester.checkNull("cast(null as varchar(10))='a'");
-  }
-
-  @Test void testEqualsOperatorInterval() {
-    tester.checkBoolean(
-        "interval '2' day = interval '1' day",
-        Boolean.FALSE);
-    tester.checkBoolean(
-        "interval '2' day = interval '2' day",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "interval '2:2:2' hour to second = interval '2' hour",
-        Boolean.FALSE);
-    tester.checkNull(
-        "cast(null as interval hour) = interval '2' minute");
-  }
-
-  @Test void testGreaterThanOperator() {
-    tester.setFor(SqlStdOperatorTable.GREATER_THAN);
-    tester.checkBoolean("1>2", Boolean.FALSE);
-    tester.checkBoolean(
-        "cast(-1 as TINYINT)>cast(1 as TINYINT)",
-        Boolean.FALSE);
-    tester.checkBoolean(
-        "cast(1 as SMALLINT)>cast(1 as SMALLINT)",
-        Boolean.FALSE);
-    tester.checkBoolean("2>1", Boolean.TRUE);
-    tester.checkBoolean("1.1>1.2", Boolean.FALSE);
-    tester.checkBoolean("-1.1>-1.2", Boolean.TRUE);
-    tester.checkBoolean("1.1>1.1", Boolean.FALSE);
-    tester.checkBoolean("1.2>1", Boolean.TRUE);
-    tester.checkBoolean("1.1e1>1.2e1", Boolean.FALSE);
-    tester.checkBoolean(
-        "cast(-1.1 as real) > cast(-1.2 as real)",
-        Boolean.TRUE);
-    tester.checkBoolean("1.1e2>1.1e2", Boolean.FALSE);
-    tester.checkBoolean("1.2e0>1", Boolean.TRUE);
-    tester.checkBoolean("cast(1.2e0 as real)>1", Boolean.TRUE);
-    tester.checkBoolean("true>false", Boolean.TRUE);
-    tester.checkBoolean("true>true", Boolean.FALSE);
-    tester.checkBoolean("false>false", Boolean.FALSE);
-    tester.checkBoolean("false>true", Boolean.FALSE);
-    tester.checkNull("3.0>cast(null as double)");
-
-    tester.checkBoolean(
-        "DATE '2013-02-23' > DATE '1945-02-24'", Boolean.TRUE);
-    tester.checkBoolean(
-        "DATE '2013-02-23' > CAST(NULL AS DATE)", null);
-
-    tester.checkBoolean("x'0A000130'>x'0A0001B0'", Boolean.FALSE);
-  }
-
-  @Test void testGreaterThanOperatorIntervals() {
-    tester.checkBoolean(
-        "interval '2' day > interval '1' day",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "interval '2' day > interval '5' day",
-        Boolean.FALSE);
-    tester.checkBoolean(
-        "interval '2 2:2:2' day to second > interval '2' day",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "interval '2' day > interval '2' day",
-        Boolean.FALSE);
-    tester.checkBoolean(
-        "interval '2' day > interval '-2' day",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "interval '2' day > interval '2' hour",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "interval '2' minute > interval '2' hour",
-        Boolean.FALSE);
-    tester.checkBoolean(
-        "interval '2' second > interval '2' minute",
-        Boolean.FALSE);
-    tester.checkNull(
-        "cast(null as interval hour) > interval '2' minute");
-    tester.checkNull(
-        "interval '2:2' hour to minute > cast(null as interval second)");
-  }
-
-  @Test void testIsDistinctFromOperator() {
-    tester.setFor(
-        SqlStdOperatorTable.IS_DISTINCT_FROM,
-        VM_EXPAND);
-    tester.checkBoolean("1 is distinct from 1", Boolean.FALSE);
-    tester.checkBoolean("1 is distinct from 1.0", Boolean.FALSE);
-    tester.checkBoolean("1 is distinct from 2", Boolean.TRUE);
-    tester.checkBoolean(
-        "cast(null as integer) is distinct from 2",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "cast(null as integer) is distinct from cast(null as integer)",
-        Boolean.FALSE);
-    tester.checkBoolean("1.23 is distinct from 1.23", Boolean.FALSE);
-    tester.checkBoolean("1.23 is distinct from 5.23", Boolean.TRUE);
-    tester.checkBoolean(
-        "-23e0 is distinct from -2.3e1",
-        Boolean.FALSE);
-
-    // IS DISTINCT FROM not implemented for ROW yet
-    if (false) {
-      tester.checkBoolean(
-          "row(1,1) is distinct from row(1,1)",
-          true);
-      tester.checkBoolean(
-          "row(1,1) is distinct from row(1,2)",
-          false);
-    }
-
-    // Intervals
-    tester.checkBoolean(
-        "interval '2' day is distinct from interval '1' day",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "interval '10' hour is distinct from interval '10' hour",
-        Boolean.FALSE);
-  }
-
-  @Test void testIsNotDistinctFromOperator() {
-    tester.setFor(
-        SqlStdOperatorTable.IS_NOT_DISTINCT_FROM,
-        VM_EXPAND);
-    tester.checkBoolean("1 is not distinct from 1", Boolean.TRUE);
-    tester.checkBoolean("1 is not distinct from 1.0", Boolean.TRUE);
-    tester.checkBoolean("1 is not distinct from 2", Boolean.FALSE);
-    tester.checkBoolean(
-        "cast(null as integer) is not distinct from 2",
-        Boolean.FALSE);
-    tester.checkBoolean(
-        "cast(null as integer) is not distinct from cast(null as integer)",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "1.23 is not distinct from 1.23",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "1.23 is not distinct from 5.23",
-        Boolean.FALSE);
-    tester.checkBoolean(
-        "-23e0 is not distinct from -2.3e1",
-        Boolean.TRUE);
-
-    // IS NOT DISTINCT FROM not implemented for ROW yet
-    if (false) {
-      tester.checkBoolean(
-          "row(1,1) is not distinct from row(1,1)",
-          false);
-      tester.checkBoolean(
-          "row(1,1) is not distinct from row(1,2)",
-          true);
-    }
-
-    // Intervals
-    tester.checkBoolean(
-        "interval '2' day is not distinct from interval '1' day",
-        Boolean.FALSE);
-    tester.checkBoolean(
-        "interval '10' hour is not distinct from interval '10' hour",
-        Boolean.TRUE);
-  }
-
-  @Test void testGreaterThanOrEqualOperator() {
-    tester.setFor(SqlStdOperatorTable.GREATER_THAN_OR_EQUAL);
-    tester.checkBoolean("1>=2", Boolean.FALSE);
-    tester.checkBoolean("-1>=1", Boolean.FALSE);
-    tester.checkBoolean("1>=1", Boolean.TRUE);
-    tester.checkBoolean("2>=1", Boolean.TRUE);
-    tester.checkBoolean("1.1>=1.2", Boolean.FALSE);
-    tester.checkBoolean("-1.1>=-1.2", Boolean.TRUE);
-    tester.checkBoolean("1.1>=1.1", Boolean.TRUE);
-    tester.checkBoolean("1.2>=1", Boolean.TRUE);
-    tester.checkBoolean("1.2e4>=1e5", Boolean.FALSE);
-    tester.checkBoolean("1.2e4>=cast(1e5 as real)", Boolean.FALSE);
-    tester.checkBoolean("1.2>=cast(1e5 as double)", Boolean.FALSE);
-    tester.checkBoolean("120000>=cast(1e5 as real)", Boolean.TRUE);
-    tester.checkBoolean("true>=false", Boolean.TRUE);
-    tester.checkBoolean("true>=true", Boolean.TRUE);
-    tester.checkBoolean("false>=false", Boolean.TRUE);
-    tester.checkBoolean("false>=true", Boolean.FALSE);
-    tester.checkNull("cast(null as real)>=999");
-    tester.checkBoolean("x'0A000130'>=x'0A0001B0'", Boolean.FALSE);
-    tester.checkBoolean("x'0A0001B0'>=x'0A0001B0'", Boolean.TRUE);
-  }
-
-  @Test void testGreaterThanOrEqualOperatorIntervals() {
-    tester.checkBoolean(
-        "interval '2' day >= interval '1' day",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "interval '2' day >= interval '5' day",
-        Boolean.FALSE);
-    tester.checkBoolean(
-        "interval '2 2:2:2' day to second >= interval '2' day",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "interval '2' day >= interval '2' day",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "interval '2' day >= interval '-2' day",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "interval '2' day >= interval '2' hour",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "interval '2' minute >= interval '2' hour",
-        Boolean.FALSE);
-    tester.checkBoolean(
-        "interval '2' second >= interval '2' minute",
-        Boolean.FALSE);
-    tester.checkNull(
-        "cast(null as interval hour) >= interval '2' minute");
-    tester.checkNull(
-        "interval '2:2' hour to minute >= cast(null as interval second)");
-  }
-
-  @Test void testInOperator() {
-    tester.setFor(SqlStdOperatorTable.IN, VM_EXPAND);
-    tester.checkBoolean("1 in (0, 1, 2)", true);
-    tester.checkBoolean("3 in (0, 1, 2)", false);
-    tester.checkBoolean("cast(null as integer) in (0, 1, 2)", null);
-    tester.checkBoolean(
-        "cast(null as integer) in (0, cast(null as integer), 2)",
-        null);
-    if (Bug.FRG327_FIXED) {
-      tester.checkBoolean(
-          "cast(null as integer) in (0, null, 2)",
-          null);
-      tester.checkBoolean("1 in (0, null, 2)", null);
-    }
-
-    if (!enable) {
-      return;
-    }
-    // AND has lower precedence than IN
-    tester.checkBoolean("false and true in (false, false)", false);
-
-    if (!Bug.TODO_FIXED) {
-      return;
-    }
-    tester.checkFails(
-        "'foo' in (^)^",
-        "(?s).*Encountered \"\\)\" at .*",
-        false);
-  }
-
-  @Test void testNotInOperator() {
-    tester.setFor(SqlStdOperatorTable.NOT_IN, VM_EXPAND);
-    tester.checkBoolean("1 not in (0, 1, 2)", false);
-    tester.checkBoolean("3 not in (0, 1, 2)", true);
-    if (!enable) {
-      return;
-    }
-    tester.checkBoolean(
-        "cast(null as integer) not in (0, 1, 2)",
-        null);
-    tester.checkBoolean(
-        "cast(null as integer) not in (0, cast(null as integer), 2)",
-        null);
-    if (Bug.FRG327_FIXED) {
-      tester.checkBoolean(
-          "cast(null as integer) not in (0, null, 2)",
-          null);
-      tester.checkBoolean("1 not in (0, null, 2)", null);
-    }
-
-    // AND has lower precedence than NOT IN
-    tester.checkBoolean("true and false not in (true, true)", true);
-
-    if (!Bug.TODO_FIXED) {
-      return;
-    }
-    tester.checkFails(
-        "'foo' not in (^)^",
-        "(?s).*Encountered \"\\)\" at .*",
-        false);
-  }
-
-  @Test void testOverlapsOperator() {
-    tester.setFor(SqlStdOperatorTable.OVERLAPS, VM_EXPAND);
-    tester.checkBoolean(
-        "(date '1-2-3', date '1-2-3') overlaps (date '1-2-3', interval '1' year)",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "(date '1-2-3', date '1-2-3') overlaps (date '4-5-6', interval '1' year)",
-        Boolean.FALSE);
-    tester.checkBoolean(
-        "(date '1-2-3', date '4-5-6') overlaps (date '2-2-3', date '3-4-5')",
-        Boolean.TRUE);
-    tester.checkNull(
-        "(cast(null as date), date '1-2-3') overlaps (date '1-2-3', interval '1' year)");
-    tester.checkNull(
-        "(date '1-2-3', date '1-2-3') overlaps (date '1-2-3', cast(null as date))");
-
-    tester.checkBoolean(
-        "(time '1:2:3', interval '1' second) overlaps (time '23:59:59', time '1:2:3')",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "(time '1:2:3', interval '1' second) overlaps (time '23:59:59', time '1:2:2')",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "(time '1:2:3', interval '1' second) overlaps (time '23:59:59', interval '2' hour)",
-        Boolean.FALSE);
-    tester.checkNull(
-        "(time '1:2:3', cast(null as time)) overlaps (time '23:59:59', time '1:2:3')");
-    tester.checkNull(
-        "(time '1:2:3', interval '1' second) overlaps (time '23:59:59', cast(null as interval hour))");
-
-    tester.checkBoolean(
-        "(timestamp '1-2-3 4:5:6', timestamp '1-2-3 4:5:6' ) overlaps (timestamp '1-2-3 4:5:6', interval '1 2:3:4.5' day to second)",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "(timestamp '1-2-3 4:5:6', timestamp '1-2-3 4:5:6' ) overlaps (timestamp '2-2-3 4:5:6', interval '1 2:3:4.5' day to second)",
-        Boolean.FALSE);
-    tester.checkNull(
-        "(timestamp '1-2-3 4:5:6', cast(null as interval day) ) overlaps (timestamp '1-2-3 4:5:6', interval '1 2:3:4.5' day to second)");
-    tester.checkNull(
-        "(timestamp '1-2-3 4:5:6', timestamp '1-2-3 4:5:6' ) overlaps (cast(null as timestamp), interval '1 2:3:4.5' day to second)");
-  }
-
-  /** Test case for
-   * <a href="https://issues.apache.org/jira/browse/CALCITE-715">[CALCITE-715]
-   * Add PERIOD type constructor and period operators (CONTAINS, PRECEDES,
-   * etc.)</a>.
-   *
-   * <p>Tests OVERLAP and similar period operators CONTAINS, EQUALS, PRECEDES,
-   * SUCCEEDS, IMMEDIATELY PRECEDES, IMMEDIATELY SUCCEEDS for DATE, TIME and
-   * TIMESTAMP values. */
-  @Test void testPeriodOperators() {
-    String[] times = {
-        "TIME '01:00:00'",
-        "TIME '02:00:00'",
-        "TIME '03:00:00'",
-        "TIME '04:00:00'",
-    };
-    String[] dates = {
-        "DATE '1970-01-01'",
-        "DATE '1970-02-01'",
-        "DATE '1970-03-01'",
-        "DATE '1970-04-01'",
-    };
-    String[] timestamps = {
-        "TIMESTAMP '1970-01-01 00:00:00'",
-        "TIMESTAMP '1970-02-01 00:00:00'",
-        "TIMESTAMP '1970-03-01 00:00:00'",
-        "TIMESTAMP '1970-04-01 00:00:00'",
-    };
-    checkOverlaps(new OverlapChecker(times));
-    checkOverlaps(new OverlapChecker(dates));
-    checkOverlaps(new OverlapChecker(timestamps));
-  }
-
-  private void checkOverlaps(OverlapChecker c) {
-    c.isTrue("($0,$0) OVERLAPS ($0,$0)");
-    c.isFalse("($0,$1) OVERLAPS ($2,$3)");
-    c.isTrue("($0,$1) OVERLAPS ($1,$2)");
-    c.isTrue("($0,$2) OVERLAPS ($1,$3)");
-    c.isTrue("($0,$2) OVERLAPS ($3,$1)");
-    c.isTrue("($2,$0) OVERLAPS ($3,$1)");
-    c.isFalse("($3,$2) OVERLAPS ($1,$0)");
-    c.isTrue("($2,$3) OVERLAPS ($0,$2)");
-    c.isTrue("($2,$3) OVERLAPS ($2,$0)");
-    c.isTrue("($3,$2) OVERLAPS ($2,$0)");
-    c.isTrue("($0,$2) OVERLAPS ($2,$0)");
-    c.isTrue("($0,$3) OVERLAPS ($1,$3)");
-    c.isTrue("($0,$3) OVERLAPS ($3,$3)");
-
-    c.isTrue("($0,$0) CONTAINS ($0,$0)");
-    c.isFalse("($0,$1) CONTAINS ($2,$3)");
-    c.isFalse("($0,$1) CONTAINS ($1,$2)");
-    c.isFalse("($0,$2) CONTAINS ($1,$3)");
-    c.isFalse("($0,$2) CONTAINS ($3,$1)");
-    c.isFalse("($2,$0) CONTAINS ($3,$1)");
-    c.isFalse("($3,$2) CONTAINS ($1,$0)");
-    c.isFalse("($2,$3) CONTAINS ($0,$2)");
-    c.isFalse("($2,$3) CONTAINS ($2,$0)");
-    c.isFalse("($3,$2) CONTAINS ($2,$0)");
-    c.isTrue("($0,$2) CONTAINS ($2,$0)");
-    c.isTrue("($0,$3) CONTAINS ($1,$3)");
-    c.isTrue("($0,$3) CONTAINS ($3,$3)");
-    c.isTrue("($3,$0) CONTAINS ($3,$3)");
-    c.isTrue("($3,$0) CONTAINS ($0,$0)");
-
-    c.isTrue("($0,$0) CONTAINS $0");
-    c.isTrue("($3,$0) CONTAINS $0");
-    c.isTrue("($3,$0) CONTAINS $1");
-    c.isTrue("($3,$0) CONTAINS $2");
-    c.isTrue("($3,$0) CONTAINS $3");
-    c.isTrue("($0,$3) CONTAINS $0");
-    c.isTrue("($0,$3) CONTAINS $1");
-    c.isTrue("($0,$3) CONTAINS $2");
-    c.isTrue("($0,$3) CONTAINS $3");
-    c.isFalse("($1,$3) CONTAINS $0");
-    c.isFalse("($1,$2) CONTAINS $3");
-
-    c.isTrue("($0,$0) EQUALS ($0,$0)");
-    c.isFalse("($0,$1) EQUALS ($2,$3)");
-    c.isFalse("($0,$1) EQUALS ($1,$2)");
-    c.isFalse("($0,$2) EQUALS ($1,$3)");
-    c.isFalse("($0,$2) EQUALS ($3,$1)");
-    c.isFalse("($2,$0) EQUALS ($3,$1)");
-    c.isFalse("($3,$2) EQUALS ($1,$0)");
-    c.isFalse("($2,$3) EQUALS ($0,$2)");
-    c.isFalse("($2,$3) EQUALS ($2,$0)");
-    c.isFalse("($3,$2) EQUALS ($2,$0)");
-    c.isTrue("($0,$2) EQUALS ($2,$0)");
-    c.isFalse("($0,$3) EQUALS ($1,$3)");
-    c.isFalse("($0,$3) EQUALS ($3,$3)");
-    c.isFalse("($3,$0) EQUALS ($3,$3)");
-    c.isFalse("($3,$0) EQUALS ($0,$0)");
-
-    c.isTrue("($0,$0) PRECEDES ($0,$0)");
-    c.isTrue("($0,$1) PRECEDES ($2,$3)");
-    c.isTrue("($0,$1) PRECEDES ($1,$2)");
-    c.isFalse("($0,$2) PRECEDES ($1,$3)");
-    c.isFalse("($0,$2) PRECEDES ($3,$1)");
-    c.isFalse("($2,$0) PRECEDES ($3,$1)");
-    c.isFalse("($3,$2) PRECEDES ($1,$0)");
-    c.isFalse("($2,$3) PRECEDES ($0,$2)");
-    c.isFalse("($2,$3) PRECEDES ($2,$0)");
-    c.isFalse("($3,$2) PRECEDES ($2,$0)");
-    c.isFalse("($0,$2) PRECEDES ($2,$0)");
-    c.isFalse("($0,$3) PRECEDES ($1,$3)");
-    c.isTrue("($0,$3) PRECEDES ($3,$3)");
-    c.isTrue("($3,$0) PRECEDES ($3,$3)");
-    c.isFalse("($3,$0) PRECEDES ($0,$0)");
-
-    c.isTrue("($0,$0) SUCCEEDS ($0,$0)");
-    c.isFalse("($0,$1) SUCCEEDS ($2,$3)");
-    c.isFalse("($0,$1) SUCCEEDS ($1,$2)");
-    c.isFalse("($0,$2) SUCCEEDS ($1,$3)");
-    c.isFalse("($0,$2) SUCCEEDS ($3,$1)");
-    c.isFalse("($2,$0) SUCCEEDS ($3,$1)");
-    c.isTrue("($3,$2) SUCCEEDS ($1,$0)");
-    c.isTrue("($2,$3) SUCCEEDS ($0,$2)");
-    c.isTrue("($2,$3) SUCCEEDS ($2,$0)");
-    c.isTrue("($3,$2) SUCCEEDS ($2,$0)");
-    c.isFalse("($0,$2) SUCCEEDS ($2,$0)");
-    c.isFalse("($0,$3) SUCCEEDS ($1,$3)");
-    c.isFalse("($0,$3) SUCCEEDS ($3,$3)");
-    c.isFalse("($3,$0) SUCCEEDS ($3,$3)");
-    c.isTrue("($3,$0) SUCCEEDS ($0,$0)");
-
-    c.isTrue("($0,$0) IMMEDIATELY PRECEDES ($0,$0)");
-    c.isFalse("($0,$1) IMMEDIATELY PRECEDES ($2,$3)");
-    c.isTrue("($0,$1) IMMEDIATELY PRECEDES ($1,$2)");
-    c.isFalse("($0,$2) IMMEDIATELY PRECEDES ($1,$3)");
-    c.isFalse("($0,$2) IMMEDIATELY PRECEDES ($3,$1)");
-    c.isFalse("($2,$0) IMMEDIATELY PRECEDES ($3,$1)");
-    c.isFalse("($3,$2) IMMEDIATELY PRECEDES ($1,$0)");
-    c.isFalse("($2,$3) IMMEDIATELY PRECEDES ($0,$2)");
-    c.isFalse("($2,$3) IMMEDIATELY PRECEDES ($2,$0)");
-    c.isFalse("($3,$2) IMMEDIATELY PRECEDES ($2,$0)");
-    c.isFalse("($0,$2) IMMEDIATELY PRECEDES ($2,$0)");
-    c.isFalse("($0,$3) IMMEDIATELY PRECEDES ($1,$3)");
-    c.isTrue("($0,$3) IMMEDIATELY PRECEDES ($3,$3)");
-    c.isTrue("($3,$0) IMMEDIATELY PRECEDES ($3,$3)");
-    c.isFalse("($3,$0) IMMEDIATELY PRECEDES ($0,$0)");
-
-    c.isTrue("($0,$0) IMMEDIATELY SUCCEEDS ($0,$0)");
-    c.isFalse("($0,$1) IMMEDIATELY SUCCEEDS ($2,$3)");
-    c.isFalse("($0,$1) IMMEDIATELY SUCCEEDS ($1,$2)");
-    c.isFalse("($0,$2) IMMEDIATELY SUCCEEDS ($1,$3)");
-    c.isFalse("($0,$2) IMMEDIATELY SUCCEEDS ($3,$1)");
-    c.isFalse("($2,$0) IMMEDIATELY SUCCEEDS ($3,$1)");
-    c.isFalse("($3,$2) IMMEDIATELY SUCCEEDS ($1,$0)");
-    c.isTrue("($2,$3) IMMEDIATELY SUCCEEDS ($0,$2)");
-    c.isTrue("($2,$3) IMMEDIATELY SUCCEEDS ($2,$0)");
-    c.isTrue("($3,$2) IMMEDIATELY SUCCEEDS ($2,$0)");
-    c.isFalse("($0,$2) IMMEDIATELY SUCCEEDS ($2,$0)");
-    c.isFalse("($0,$3) IMMEDIATELY SUCCEEDS ($1,$3)");
-    c.isFalse("($0,$3) IMMEDIATELY SUCCEEDS ($3,$3)");
-    c.isFalse("($3,$0) IMMEDIATELY SUCCEEDS ($3,$3)");
-    c.isTrue("($3,$0) IMMEDIATELY SUCCEEDS ($0,$0)");
-  }
-
-  @Test void testLessThanOperator() {
-    tester.setFor(SqlStdOperatorTable.LESS_THAN);
-    tester.checkBoolean("1<2", Boolean.TRUE);
-    tester.checkBoolean("-1<1", Boolean.TRUE);
-    tester.checkBoolean("1<1", Boolean.FALSE);
-    tester.checkBoolean("2<1", Boolean.FALSE);
-    tester.checkBoolean("1.1<1.2", Boolean.TRUE);
-    tester.checkBoolean("-1.1<-1.2", Boolean.FALSE);
-    tester.checkBoolean("1.1<1.1", Boolean.FALSE);
-    tester.checkBoolean("cast(1.1 as real)<1", Boolean.FALSE);
-    tester.checkBoolean("cast(1.1 as real)<1.1", Boolean.FALSE);
-    tester.checkBoolean(
-        "cast(1.1 as real)<cast(1.2 as real)",
-        Boolean.TRUE);
-    tester.checkBoolean("-1.1e-1<-1.2e-1", Boolean.FALSE);
-    tester.checkBoolean(
-        "cast(1.1 as real)<cast(1.1 as double)",
-        Boolean.FALSE);
-    tester.checkBoolean("true<false", Boolean.FALSE);
-    tester.checkBoolean("true<true", Boolean.FALSE);
-    tester.checkBoolean("false<false", Boolean.FALSE);
-    tester.checkBoolean("false<true", Boolean.TRUE);
-    tester.checkNull("123<cast(null as bigint)");
-    tester.checkNull("cast(null as tinyint)<123");
-    tester.checkNull("cast(null as integer)<1.32");
-    tester.checkBoolean("x'0A000130'<x'0A0001B0'", Boolean.TRUE);
-  }
-
-  @Test void testLessThanOperatorInterval() {
-    if (!DECIMAL) {
-      return;
-    }
-    tester.checkBoolean(
-        "interval '2' day < interval '1' day",
-        Boolean.FALSE);
-    tester.checkBoolean(
-        "interval '2' day < interval '5' day",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "interval '2 2:2:2' day to second < interval '2' day",
-        Boolean.FALSE);
-    tester.checkBoolean(
-        "interval '2' day < interval '2' day",
-        Boolean.FALSE);
-    tester.checkBoolean(
-        "interval '2' day < interval '-2' day",
-        Boolean.FALSE);
-    tester.checkBoolean(
-        "interval '2' day < interval '2' hour",
-        Boolean.FALSE);
-    tester.checkBoolean(
-        "interval '2' minute < interval '2' hour",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "interval '2' second < interval '2' minute",
-        Boolean.TRUE);
-    tester.checkNull(
-        "cast(null as interval hour) < interval '2' minute");
-    tester.checkNull(
-        "interval '2:2' hour to minute < cast(null as interval second)");
-  }
-
-  @Test void testLessThanOrEqualOperator() {
-    tester.setFor(SqlStdOperatorTable.LESS_THAN_OR_EQUAL);
-    tester.checkBoolean("1<=2", Boolean.TRUE);
-    tester.checkBoolean("1<=1", Boolean.TRUE);
-    tester.checkBoolean("-1<=1", Boolean.TRUE);
-    tester.checkBoolean("2<=1", Boolean.FALSE);
-    tester.checkBoolean("1.1<=1.2", Boolean.TRUE);
-    tester.checkBoolean("-1.1<=-1.2", Boolean.FALSE);
-    tester.checkBoolean("1.1<=1.1", Boolean.TRUE);
-    tester.checkBoolean("1.2<=1", Boolean.FALSE);
-    tester.checkBoolean("1<=cast(1e2 as real)", Boolean.TRUE);
-    tester.checkBoolean("1000<=cast(1e2 as real)", Boolean.FALSE);
-    tester.checkBoolean("1.2e1<=1e2", Boolean.TRUE);
-    tester.checkBoolean("1.2e1<=cast(1e2 as real)", Boolean.TRUE);
-    tester.checkBoolean("true<=false", Boolean.FALSE);
-    tester.checkBoolean("true<=true", Boolean.TRUE);
-    tester.checkBoolean("false<=false", Boolean.TRUE);
-    tester.checkBoolean("false<=true", Boolean.TRUE);
-    tester.checkNull("cast(null as real)<=cast(1 as real)");
-    tester.checkNull("cast(null as integer)<=3");
-    tester.checkNull("3<=cast(null as smallint)");
-    tester.checkNull("cast(null as integer)<=1.32");
-    tester.checkBoolean("x'0A000130'<=x'0A0001B0'", Boolean.TRUE);
-    tester.checkBoolean("x'0A0001B0'<=x'0A0001B0'", Boolean.TRUE);
-  }
-
-  @Test void testLessThanOrEqualOperatorInterval() {
-    tester.checkBoolean(
-        "interval '2' day <= interval '1' day",
-        Boolean.FALSE);
-    tester.checkBoolean(
-        "interval '2' day <= interval '5' day",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "interval '2 2:2:2' day to second <= interval '2' day",
-        Boolean.FALSE);
-    tester.checkBoolean(
-        "interval '2' day <= interval '2' day",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "interval '2' day <= interval '-2' day",
-        Boolean.FALSE);
-    tester.checkBoolean(
-        "interval '2' day <= interval '2' hour",
-        Boolean.FALSE);
-    tester.checkBoolean(
-        "interval '2' minute <= interval '2' hour",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "interval '2' second <= interval '2' minute",
-        Boolean.TRUE);
-    tester.checkNull(
-        "cast(null as interval hour) <= interval '2' minute");
-    tester.checkNull(
-        "interval '2:2' hour to minute <= cast(null as interval second)");
-  }
-
-  @Test void testMinusOperator() {
-    tester.setFor(SqlStdOperatorTable.MINUS);
-    tester.checkScalarExact("-2-1", "-3");
-    tester.checkScalarExact("-2-1-5", "-8");
-    tester.checkScalarExact("2-1", "1");
-    tester.checkScalarApprox(
-        "cast(2.0 as double) -1",
-        "DOUBLE NOT NULL",
-        1,
-        0);
-    tester.checkScalarApprox(
-        "cast(1 as smallint)-cast(2.0 as real)",
-        "REAL NOT NULL",
-        -1,
-        0);
-    tester.checkScalarApprox(
-        "2.4-cast(2.0 as real)",
-        "DOUBLE NOT NULL",
-        0.4,
-        0.00000001);
-    tester.checkScalarExact("1-2", "-1");
-    tester.checkScalarExact(
-        "10.0 - 5.0",
-        "DECIMAL(4, 1) NOT NULL",
-        "5.0");
-    tester.checkScalarExact(
-        "19.68 - 4.2",
-        "DECIMAL(5, 2) NOT NULL",
-        "15.48");
-    tester.checkNull("1e1-cast(null as double)");
-    tester.checkNull("cast(null as tinyint) - cast(null as smallint)");
-
-    // TODO: Fix bug
-    if (Bug.FNL25_FIXED) {
-      // Should throw out of range error
-      tester.checkFails(
-          "cast(100 as tinyint) - cast(-100 as tinyint)", OUT_OF_RANGE_MESSAGE,
-          true);
-      tester.checkFails(
-          "cast(-20000 as smallint) - cast(20000 as smallint)",
-          OUT_OF_RANGE_MESSAGE,
-          true);
-      tester.checkFails(
-          "cast(1.5e9 as integer) - cast(-1.5e9 as integer)",
-          OUT_OF_RANGE_MESSAGE,
-          true);
-      tester.checkFails(
-          "cast(-5e18 as bigint) - cast(5e18 as bigint)", OUT_OF_RANGE_MESSAGE,
-          true);
-      tester.checkFails(
-          "cast(5e18 as decimal(19,0)) - cast(-5e18 as decimal(19,0))",
-          OUT_OF_RANGE_MESSAGE,
-          true);
-      tester.checkFails(
-          "cast(-5e8 as decimal(19,10)) - cast(5e8 as decimal(19,10))",
-          OUT_OF_RANGE_MESSAGE,
-          true);
-    }
-  }
-
-  @Test void testMinusIntervalOperator() {
-    tester.setFor(SqlStdOperatorTable.MINUS);
-    tester.checkScalar(
-        "interval '2' day - interval '1' day",
-        "+1",
-        "INTERVAL DAY NOT NULL");
-    tester.checkScalar(
-        "interval '2' day - interval '1' minute",
-        "+1 23:59",
-        "INTERVAL DAY TO MINUTE NOT NULL");
-    tester.checkScalar(
-        "interval '2' year - interval '1' month",
-        "+1-11",
-        "INTERVAL YEAR TO MONTH NOT NULL");
-    tester.checkScalar(
-        "interval '2' year - interval '1' month - interval '3' year",
-        "-1-01",
-        "INTERVAL YEAR TO MONTH NOT NULL");
-    tester.checkNull(
-        "cast(null as interval day) + interval '2' hour");
-
-    // Datetime minus interval
-    tester.checkScalar(
-        "time '12:03:01' - interval '1:1' hour to minute",
-        "11:02:01",
-        "TIME(0) NOT NULL");
-    // Per [CALCITE-1632] Return types of datetime + interval
-    // make sure that TIME values say in range
-    tester.checkScalar(
-        "time '12:03:01' - interval '1' day",
-        "12:03:01",
-        "TIME(0) NOT NULL");
-    tester.checkScalar(
-        "time '12:03:01' - interval '25' hour",
-        "11:03:01",
-        "TIME(0) NOT NULL");
-    tester.checkScalar(
-        "time '12:03:03' - interval '25:0:1' hour to second",
-        "11:03:02",
-        "TIME(0) NOT NULL");
-    tester.checkScalar(
-        "date '2005-03-02' - interval '5' day",
-        "2005-02-25",
-        "DATE NOT NULL");
-    tester.checkScalar(
-        "date '2005-03-02' - interval '5' day",
-        "2005-02-25",
-        "DATE NOT NULL");
-    tester.checkScalar(
-        "date '2005-03-02' - interval '5' hour",
-        "2005-03-02",
-        "DATE NOT NULL");
-    tester.checkScalar(
-        "date '2005-03-02' - interval '25' hour",
-        "2005-03-01",
-        "DATE NOT NULL");
-    tester.checkScalar(
-        "date '2005-03-02' - interval '25:45' hour to minute",
-        "2005-03-01",
-        "DATE NOT NULL");
-    tester.checkScalar(
-        "date '2005-03-02' - interval '25:45:54' hour to second",
-        "2005-03-01",
-        "DATE NOT NULL");
-    tester.checkScalar(
-        "timestamp '2003-08-02 12:54:01' - interval '-4 2:4' day to minute",
-        "2003-08-06 14:58:01",
-        "TIMESTAMP(0) NOT NULL");
-
-    // Datetime minus year-month interval
-    tester.checkScalar(
-        "timestamp '2003-08-02 12:54:01' - interval '12' year",
-        "1991-08-02 12:54:01",
-        "TIMESTAMP(0) NOT NULL");
-    tester.checkScalar(
-        "date '2003-08-02' - interval '12' year",
-        "1991-08-02",
-        "DATE NOT NULL");
-    tester.checkScalar(
-        "date '2003-08-02' - interval '12-3' year to month",
-        "1991-05-02",
-        "DATE NOT NULL");
-  }
-
-  @Test void testMinusDateOperator() {
-    tester.setFor(SqlStdOperatorTable.MINUS_DATE);
-    tester.checkScalar(
-        "(time '12:03:34' - time '11:57:23') minute to second",
-        "+6:11.000000",
-        "INTERVAL MINUTE TO SECOND NOT NULL");
-    tester.checkScalar(
-        "(time '12:03:23' - time '11:57:23') minute",
-        "+6",
-        "INTERVAL MINUTE NOT NULL");
-    tester.checkScalar(
-        "(time '12:03:34' - time '11:57:23') minute",
-        "+6",
-        "INTERVAL MINUTE NOT NULL");
-    tester.checkScalar(
-        "(timestamp '2004-05-01 12:03:34' - timestamp '2004-04-29 11:57:23') day to second",
-        "+2 00:06:11.000000",
-        "INTERVAL DAY TO SECOND NOT NULL");
-    tester.checkScalar(
-        "(timestamp '2004-05-01 12:03:34' - timestamp '2004-04-29 11:57:23') day to hour",
-        "+2 00",
-        "INTERVAL DAY TO HOUR NOT NULL");
-    tester.checkScalar(
-        "(date '2004-12-02' - date '2003-12-01') day",
-        "+367",
-        "INTERVAL DAY NOT NULL");
-    tester.checkNull(
-        "(cast(null as date) - date '2003-12-01') day");
-
-    // combine '<datetime> + <interval>' with '<datetime> - <datetime>'
-    tester.checkScalar(
-        "timestamp '1969-04-29 0:0:0' +"
-            + " (timestamp '2008-07-15 15:28:00' - "
-            + "  timestamp '1969-04-29 0:0:0') day to second / 2",
-        "1988-12-06 07:44:00",
-        "TIMESTAMP(0) NOT NULL");
-
-    tester.checkScalar(
-        "date '1969-04-29' +"
-            + " (date '2008-07-15' - "
-            + "  date '1969-04-29') day / 2",
-        "1988-12-06",
-        "DATE NOT NULL");
-
-    tester.checkScalar(
-        "time '01:23:44' +"
-            + " (time '15:28:00' - "
-            + "  time '01:23:44') hour to second / 2",
-        "08:25:52",
-        "TIME(0) NOT NULL");
-
-    if (Bug.DT1684_FIXED) {
-      tester.checkBoolean(
-          "(date '1969-04-29' +"
-              + " (CURRENT_DATE - "
-              + "  date '1969-04-29') day / 2) is not null",
-          Boolean.TRUE);
-    }
-    // TODO: Add tests for year month intervals (currently not supported)
-  }
-
-  @Test void testMultiplyOperator() {
-    tester.setFor(SqlStdOperatorTable.MULTIPLY);
-    tester.checkScalarExact("2*3", "6");
-    tester.checkScalarExact("2*-3", "-6");
-    tester.checkScalarExact("+2*3", "6");
-    tester.checkScalarExact("2*0", "0");
-    tester.checkScalarApprox(
-        "cast(2.0 as float)*3",
-        "FLOAT NOT NULL",
-        6,
-        0);
-    tester.checkScalarApprox(
-        "3*cast(2.0 as real)",
-        "REAL NOT NULL",
-        6,
-        0);
-    tester.checkScalarApprox(
-        "cast(2.0 as real)*3.2",
-        "DOUBLE NOT NULL",
-        6.4,
-        0);
-    tester.checkScalarExact(
-        "10.0 * 5.0",
-        "DECIMAL(5, 2) NOT NULL",
-        "50.00");
-    tester.checkScalarExact(
-        "19.68 * 4.2",
-        "DECIMAL(6, 3) NOT NULL",
-        "82.656");
-    tester.checkNull("cast(1 as real)*cast(null as real)");
-    tester.checkNull("2e-3*cast(null as integer)");
-    tester.checkNull("cast(null as tinyint) * cast(4 as smallint)");
-
-    if (Bug.FNL25_FIXED) {
-      // Should throw out of range error
-      tester.checkFails(
-          "cast(100 as tinyint) * cast(-2 as tinyint)", OUT_OF_RANGE_MESSAGE,
-          true);
-      tester.checkFails(
-          "cast(200 as smallint) * cast(200 as smallint)", OUT_OF_RANGE_MESSAGE,
-          true);
-      tester.checkFails(
-          "cast(1.5e9 as integer) * cast(-2 as integer)", OUT_OF_RANGE_MESSAGE,
-          true);
-      tester.checkFails(
-          "cast(5e9 as bigint) * cast(2e9 as bigint)", OUT_OF_RANGE_MESSAGE,
-          true);
-      tester.checkFails(
-          "cast(2e9 as decimal(19,0)) * cast(-5e9 as decimal(19,0))",
-          OUT_OF_RANGE_MESSAGE,
-          true);
-      tester.checkFails(
-          "cast(5e4 as decimal(19,10)) * cast(2e4 as decimal(19,10))",
-          OUT_OF_RANGE_MESSAGE,
-          true);
-    }
-  }
-
-  @Test void testMultiplyIntervals() {
-    tester.checkScalar(
-        "interval '2:2' hour to minute * 3",
-        "+6:06",
-        "INTERVAL HOUR TO MINUTE NOT NULL");
-    tester.checkScalar(
-        "3 * 2 * interval '2:5:12' hour to second",
-        "+12:31:12.000000",
-        "INTERVAL HOUR TO SECOND NOT NULL");
-    tester.checkNull(
-        "interval '2' day * cast(null as bigint)");
-    tester.checkNull(
-        "cast(null as interval month) * 2");
-    if (TODO) {
-      tester.checkScalar(
-          "interval '3-2' year to month * 15e-1",
-          "+04-09",
-          "INTERVAL YEAR TO MONTH NOT NULL");
-      tester.checkScalar(
-          "interval '3-4' year to month * 4.5",
-          "+15-00",
-          "INTERVAL YEAR TO MONTH NOT NULL");
-    }
-  }
-
-  @Test void testDatePlusInterval() {
-    tester.checkScalar(
-        "date '2014-02-11' + interval '2' day",
-        "2014-02-13",
-        "DATE NOT NULL");
-    // 60 days is more than 2^32 milliseconds
-    tester.checkScalar(
-        "date '2014-02-11' + interval '60' day",
-        "2014-04-12",
-        "DATE NOT NULL");
-  }
-
-  /** Test case for
-   * <a href="https://issues.apache.org/jira/browse/CALCITE-1864">[CALCITE-1864]
-   * Allow NULL literal as argument</a>. */
-  @Test void testNullOperand() {
-    checkNullOperand(tester, "=");
-    checkNullOperand(tester, ">");
-    checkNullOperand(tester, "<");
-    checkNullOperand(tester, "<=");
-    checkNullOperand(tester, ">=");
-    checkNullOperand(tester, "<>");
-
-    // "!=" is allowed under ORACLE_10 SQL conformance level
-    final SqlTester tester1 =
-        tester.withConformance(SqlConformanceEnum.ORACLE_10);
-    checkNullOperand(tester1, "<>");
-  }
-
-  private void checkNullOperand(SqlTester tester, String op) {
-    tester.checkBoolean("1 " + op + " null", null);
-    tester.checkBoolean("null " + op + " -3", null);
-    tester.checkBoolean("null " + op + " null", null);
-  }
-
-  @Test void testNotEqualsOperator() {
-    tester.setFor(SqlStdOperatorTable.NOT_EQUALS);
-    tester.checkBoolean("1<>1", Boolean.FALSE);
-    tester.checkBoolean("'a'<>'A'", Boolean.TRUE);
-    tester.checkBoolean("1e0<>1e1", Boolean.TRUE);
-    tester.checkNull("'a'<>cast(null as varchar(1))");
-
-    // "!=" is not an acceptable alternative to "<>" under default SQL conformance level
-    tester.checkFails("1 ^!=^ 1",
-        "Bang equal '!=' is not allowed under the current SQL conformance level",
-        false);
-    // "!=" is allowed under ORACLE_10 SQL conformance level
-    final SqlTester tester1 =
-        tester.withConformance(SqlConformanceEnum.ORACLE_10);
-
-    tester1.checkBoolean("1 <> 1", Boolean.FALSE);
-    tester1.checkBoolean("1 != 1", Boolean.FALSE);
-    tester1.checkBoolean("1 != null", null);
-  }
-
-  @Test void testNotEqualsOperatorIntervals() {
-    tester.checkBoolean(
-        "interval '2' day <> interval '1' day",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "interval '2' day <> interval '2' day",
-        Boolean.FALSE);
-    tester.checkBoolean(
-        "interval '2:2:2' hour to second <> interval '2' hour",
-        Boolean.TRUE);
-    tester.checkNull(
-        "cast(null as interval hour) <> interval '2' minute");
-  }
-
-  @Test void testOrOperator() {
-    tester.setFor(SqlStdOperatorTable.OR);
-    tester.checkBoolean("true or false", Boolean.TRUE);
-    tester.checkBoolean("false or false", Boolean.FALSE);
-    tester.checkBoolean("true or cast(null as boolean)", Boolean.TRUE);
-    tester.checkNull("false or cast(null as boolean)");
-  }
-
-  @Test void testOrOperatorLazy() {
-    tester.setFor(SqlStdOperatorTable.OR);
-
-    // need to evaluate 2nd argument if first evaluates to null, therefore
-    // get error
-    tester.check(
-        "values 1 < cast(null as integer) or sqrt(-4) = -2",
-        SqlTests.BOOLEAN_TYPE_CHECKER, SqlTests.ANY_PARAMETER_CHECKER,
-        new ValueOrExceptionResultChecker(
-            null, INVALID_ARG_FOR_POWER, CODE_2201F));
-
-    // Do not need to evaluate 2nd argument if first evaluates to true.
-    // In eager evaluation, get error;
-    // lazy evaluation returns true;
-    // both are valid.
-    tester.check(
-        "values 1 < 2 or sqrt(-4) = -2",
-        SqlTests.BOOLEAN_TYPE_CHECKER, SqlTests.ANY_PARAMETER_CHECKER,
-        new ValueOrExceptionResultChecker(
-            Boolean.TRUE, INVALID_ARG_FOR_POWER, CODE_2201F));
-
-    // NULL OR FALSE --> NULL
-    // In eager evaluation, get error;
-    // lazy evaluation returns NULL;
-    // both are valid.
-    tester.check(
-        "values 1 < cast(null as integer) or sqrt(4) = -2",
-        SqlTests.BOOLEAN_TYPE_CHECKER, SqlTests.ANY_PARAMETER_CHECKER,
-        new ValueOrExceptionResultChecker(
-            null, INVALID_ARG_FOR_POWER, CODE_2201F));
-
-    // NULL OR TRUE --> TRUE
-    tester.checkBoolean(
-        "1 < cast(null as integer) or sqrt(4) = 2", Boolean.TRUE);
-  }
-
-  @Test void testPlusOperator() {
-    tester.setFor(SqlStdOperatorTable.PLUS);
-    tester.checkScalarExact("1+2", "3");
-    tester.checkScalarExact("-1+2", "1");
-    tester.checkScalarExact("1+2+3", "6");
-    tester.checkScalarApprox(
-        "1+cast(2.0 as double)",
-        "DOUBLE NOT NULL",
-        3,
-        0);
-    tester.checkScalarApprox(
-        "1+cast(2.0 as double)+cast(6.0 as float)",
-        "DOUBLE NOT NULL",
-        9,
-        0);
-    tester.checkScalarExact(
-        "10.0 + 5.0",
-        "DECIMAL(4, 1) NOT NULL",
-        "15.0");
-    tester.checkScalarExact(
-        "19.68 + 4.2",
-        "DECIMAL(5, 2) NOT NULL",
-        "23.88");
-    tester.checkScalarExact(
-        "19.68 + 4.2 + 6",
-        "DECIMAL(13, 2) NOT NULL",
-        "29.88");
-    tester.checkScalarApprox(
-        "19.68 + cast(4.2 as float)",
-        "DOUBLE NOT NULL",
-        23.88,
-        0.02);
-    tester.checkNull("cast(null as tinyint)+1");
-    tester.checkNull("1e-2+cast(null as double)");
-
-    if (Bug.FNL25_FIXED) {
-      // Should throw out of range error
-      tester.checkFails(
-          "cast(100 as tinyint) + cast(100 as tinyint)", OUT_OF_RANGE_MESSAGE,
-          true);
-      tester.checkFails(
-          "cast(-20000 as smallint) + cast(-20000 as smallint)",
-          OUT_OF_RANGE_MESSAGE,
-          true);
-      tester.checkFails(
-          "cast(1.5e9 as integer) + cast(1.5e9 as integer)",
-          OUT_OF_RANGE_MESSAGE,
-          true);
-      tester.checkFails(
-          "cast(5e18 as bigint) + cast(5e18 as bigint)", OUT_OF_RANGE_MESSAGE,
-          true);
-      tester.checkFails(
-          "cast(-5e18 as decimal(19,0)) + cast(-5e18 as decimal(19,0))",
-          OUT_OF_RANGE_MESSAGE,
-          true);
-      tester.checkFails(
-          "cast(5e8 as decimal(19,10)) + cast(5e8 as decimal(19,10))",
-          OUT_OF_RANGE_MESSAGE,
-          true);
-    }
-  }
-
-  @Test void testPlusOperatorAny() {
-    tester.setFor(SqlStdOperatorTable.PLUS);
-    tester.checkScalar("1+CAST(2 AS ANY)", "3", "ANY NOT NULL");
-  }
-
-  @Test void testPlusIntervalOperator() {
-    tester.setFor(SqlStdOperatorTable.PLUS);
-    tester.checkScalar(
-        "interval '2' day + interval '1' day",
-        "+3",
-        "INTERVAL DAY NOT NULL");
-    tester.checkScalar(
-        "interval '2' day + interval '1' minute",
-        "+2 00:01",
-        "INTERVAL DAY TO MINUTE NOT NULL");
-    tester.checkScalar(
-        "interval '2' day + interval '5' minute + interval '-3' second",
-        "+2 00:04:57.000000",
-        "INTERVAL DAY TO SECOND NOT NULL");
-    tester.checkScalar(
-        "interval '2' year + interval '1' month",
-        "+2-01",
-        "INTERVAL YEAR TO MONTH NOT NULL");
-    tester.checkNull(
-        "interval '2' year + cast(null as interval month)");
-
-    // Datetime plus interval
-    tester.checkScalar(
-        "time '12:03:01' + interval '1:1' hour to minute",
-        "13:04:01",
-        "TIME(0) NOT NULL");
-    // Per [CALCITE-1632] Return types of datetime + interval
-    // make sure that TIME values say in range
-    tester.checkScalar(
-        "time '12:03:01' + interval '1' day",
-        "12:03:01",
-        "TIME(0) NOT NULL");
-    tester.checkScalar(
-        "time '12:03:01' + interval '25' hour",
-        "13:03:01",
-        "TIME(0) NOT NULL");
-    tester.checkScalar(
-        "time '12:03:01' + interval '25:0:1' hour to second",
-        "13:03:02",
-        "TIME(0) NOT NULL");
-    tester.checkScalar(
-        "interval '5' day + date '2005-03-02'",
-        "2005-03-07",
-        "DATE NOT NULL");
-    tester.checkScalar(
-        "date '2005-03-02' + interval '5' day",
-        "2005-03-07",
-        "DATE NOT NULL");
-    tester.checkScalar(
-        "date '2005-03-02' + interval '5' hour",
-        "2005-03-02",
-        "DATE NOT NULL");
-    tester.checkScalar(
-        "date '2005-03-02' + interval '25' hour",
-        "2005-03-03",
-        "DATE NOT NULL");
-    tester.checkScalar(
-        "date '2005-03-02' + interval '25:45' hour to minute",
-        "2005-03-03",
-        "DATE NOT NULL");
-    tester.checkScalar(
-        "date '2005-03-02' + interval '25:45:54' hour to second",
-        "2005-03-03",
-        "DATE NOT NULL");
-    tester.checkScalar(
-        "timestamp '2003-08-02 12:54:01' + interval '-4 2:4' day to minute",
-        "2003-07-29 10:50:01",
-        "TIMESTAMP(0) NOT NULL");
-
-    // Datetime plus year-to-month interval
-    tester.checkScalar(
-        "interval '5-3' year to month + date '2005-03-02'",
-        "2010-06-02",
-        "DATE NOT NULL");
-    tester.checkScalar(
-        "timestamp '2003-08-02 12:54:01' + interval '5-3' year to month",
-        "2008-11-02 12:54:01",
-        "TIMESTAMP(0) NOT NULL");
-    tester.checkScalar(
-        "interval '5-3' year to month + timestamp '2003-08-02 12:54:01'",
-        "2008-11-02 12:54:01",
-        "TIMESTAMP(0) NOT NULL");
-  }
-
-  @Test void testDescendingOperator() {
-    tester.setFor(SqlStdOperatorTable.DESC, VM_EXPAND);
-  }
-
-  @Test void testIsNotNullOperator() {
-    tester.setFor(SqlStdOperatorTable.IS_NOT_NULL);
-    tester.checkBoolean("true is not null", Boolean.TRUE);
-    tester.checkBoolean(
-        "cast(null as boolean) is not null",
-        Boolean.FALSE);
-  }
-
-  @Test void testIsNullOperator() {
-    tester.setFor(SqlStdOperatorTable.IS_NULL);
-    tester.checkBoolean("true is null", Boolean.FALSE);
-    tester.checkBoolean(
-        "cast(null as boolean) is null",
-        Boolean.TRUE);
-  }
-
-  @Test void testIsNotTrueOperator() {
-    tester.setFor(SqlStdOperatorTable.IS_NOT_TRUE);
-    tester.checkBoolean("true is not true", Boolean.FALSE);
-    tester.checkBoolean("false is not true", Boolean.TRUE);
-    tester.checkBoolean(
-        "cast(null as boolean) is not true",
-        Boolean.TRUE);
-    tester.checkFails(
-        "select ^'a string' is not true^ from (values (1))",
-        "(?s)Cannot apply 'IS NOT TRUE' to arguments of type '<CHAR\\(8\\)> IS NOT TRUE'. Supported form\\(s\\): '<BOOLEAN> IS NOT TRUE'.*",
-        false);
-  }
-
-  @Test void testIsTrueOperator() {
-    tester.setFor(SqlStdOperatorTable.IS_TRUE);
-    tester.checkBoolean("true is true", Boolean.TRUE);
-    tester.checkBoolean("false is true", Boolean.FALSE);
-    tester.checkBoolean(
-        "cast(null as boolean) is true",
-        Boolean.FALSE);
-  }
-
-  @Test void testIsNotFalseOperator() {
-    tester.setFor(SqlStdOperatorTable.IS_NOT_FALSE);
-    tester.checkBoolean("false is not false", Boolean.FALSE);
-    tester.checkBoolean("true is not false", Boolean.TRUE);
-    tester.checkBoolean(
-        "cast(null as boolean) is not false",
-        Boolean.TRUE);
-  }
-
-  @Test void testIsFalseOperator() {
-    tester.setFor(SqlStdOperatorTable.IS_FALSE);
-    tester.checkBoolean("false is false", Boolean.TRUE);
-    tester.checkBoolean("true is false", Boolean.FALSE);
-    tester.checkBoolean(
-        "cast(null as boolean) is false",
-        Boolean.FALSE);
-  }
-
-  @Test void testIsNotUnknownOperator() {
-    tester.setFor(SqlStdOperatorTable.IS_NOT_UNKNOWN, VM_EXPAND);
-    tester.checkBoolean("false is not unknown", Boolean.TRUE);
-    tester.checkBoolean("true is not unknown", Boolean.TRUE);
-    tester.checkBoolean(
-        "cast(null as boolean) is not unknown",
-        Boolean.FALSE);
-    tester.checkBoolean("unknown is not unknown", Boolean.FALSE);
-    tester.checkFails(
-        "^'abc' IS NOT UNKNOWN^",
-        "(?s).*Cannot apply 'IS NOT UNKNOWN'.*",
-        false);
-  }
-
-  @Test void testIsUnknownOperator() {
-    tester.setFor(SqlStdOperatorTable.IS_UNKNOWN, VM_EXPAND);
-    tester.checkBoolean("false is unknown", Boolean.FALSE);
-    tester.checkBoolean("true is unknown", Boolean.FALSE);
-    tester.checkBoolean(
-        "cast(null as boolean) is unknown",
-        Boolean.TRUE);
-    tester.checkBoolean("unknown is unknown", Boolean.TRUE);
-    tester.checkFails(
-        "0 = 1 AND ^2 IS UNKNOWN^ AND 3 > 4",
-        "(?s).*Cannot apply 'IS UNKNOWN'.*",
-        false);
-  }
-
-  @Test void testIsASetOperator() {
-    tester.setFor(SqlStdOperatorTable.IS_A_SET, VM_EXPAND);
-    tester.checkBoolean("multiset[1] is a set", Boolean.TRUE);
-    tester.checkBoolean("multiset[1, 1] is a set", Boolean.FALSE);
-    tester.checkBoolean("multiset[cast(null as boolean), cast(null as boolean)] is a set",
-        Boolean.FALSE);
-    tester.checkBoolean("multiset[cast(null as boolean)] is a set", Boolean.TRUE);
-    tester.checkBoolean("multiset['a'] is a set", Boolean.TRUE);
-    tester.checkBoolean("multiset['a', 'b'] is a set", Boolean.TRUE);
-    tester.checkBoolean("multiset['a', 'b', 'a'] is a set", Boolean.FALSE);
-  }
-
-  @Test void testIsNotASetOperator() {
-    tester.setFor(SqlStdOperatorTable.IS_NOT_A_SET, VM_EXPAND);
-    tester.checkBoolean("multiset[1] is not a set", Boolean.FALSE);
-    tester.checkBoolean("multiset[1, 1] is not a set", Boolean.TRUE);
-    tester.checkBoolean("multiset[cast(null as boolean), cast(null as boolean)] is not a set",
-        Boolean.TRUE);
-    tester.checkBoolean("multiset[cast(null as boolean)] is not a set", Boolean.FALSE);
-    tester.checkBoolean("multiset['a'] is not a set", Boolean.FALSE);
-    tester.checkBoolean("multiset['a', 'b'] is not a set", Boolean.FALSE);
-    tester.checkBoolean("multiset['a', 'b', 'a'] is not a set", Boolean.TRUE);
-  }
-
-  @Test void testIntersectOperator() {
-    tester.setFor(SqlStdOperatorTable.MULTISET_INTERSECT, VM_EXPAND);
-    tester.checkScalar("multiset[1] multiset intersect multiset[1]",
-        "[1]",
-        "INTEGER NOT NULL MULTISET NOT NULL");
-    tester.checkScalar("multiset[2] multiset intersect all multiset[1]",
-        "[]",
-        "INTEGER NOT NULL MULTISET NOT NULL");
-    tester.checkScalar("multiset[2] multiset intersect distinct multiset[1]",
-        "[]",
-        "INTEGER NOT NULL MULTISET NOT NULL");
-    tester.checkScalar("multiset[1, 1] multiset intersect distinct multiset[1, 1]",
-        "[1]",
-        "INTEGER NOT NULL MULTISET NOT NULL");
-    tester.checkScalar("multiset[1, 1] multiset intersect all multiset[1, 1]",
-        "[1, 1]",
-        "INTEGER NOT NULL MULTISET NOT NULL");
-    tester.checkScalar("multiset[1, 1] multiset intersect distinct multiset[1, 1]",
-        "[1]",
-        "INTEGER NOT NULL MULTISET NOT NULL");
-    tester.checkScalar(
-        "multiset[cast(null as integer), cast(null as integer)] "
-            + "multiset intersect distinct multiset[cast(null as integer)]",
-        "[null]",
-        "INTEGER MULTISET NOT NULL");
-    tester.checkScalar(
-        "multiset[cast(null as integer), cast(null as integer)] "
-            + "multiset intersect all multiset[cast(null as integer)]",
-        "[null]",
-        "INTEGER MULTISET NOT NULL");
-    tester.checkScalar(
-        "multiset[cast(null as integer), cast(null as integer)] "
-            + "multiset intersect distinct multiset[cast(null as integer)]",
-        "[null]",
-        "INTEGER MULTISET NOT NULL");
-  }
-
-  @Test void testExceptOperator() {
-    tester.setFor(SqlStdOperatorTable.MULTISET_EXCEPT, VM_EXPAND);
-    tester.checkScalar("multiset[1] multiset except multiset[1]",
-        "[]",
-        "INTEGER NOT NULL MULTISET NOT NULL");
-    tester.checkScalar("multiset[1] multiset except distinct multiset[1]",
-        "[]",
-        "INTEGER NOT NULL MULTISET NOT NULL");
-    tester.checkScalar("multiset[2] multiset except multiset[1]",
-        "[2]",
-        "INTEGER NOT NULL MULTISET NOT NULL");
-    tester.checkScalar("multiset[1,2,3] multiset except multiset[1]",
-        "[2, 3]",
-        "INTEGER NOT NULL MULTISET NOT NULL");
-    tester.checkScalar("cardinality(multiset[1,2,3,2] multiset except distinct multiset[1])",
-        "2",
-        "INTEGER NOT NULL");
-    tester.checkScalar("cardinality(multiset[1,2,3,2] multiset except all multiset[1])",
-        "3",
-        "INTEGER NOT NULL");
-    tester.checkBoolean(
-        "(multiset[1,2,3,2] multiset except distinct multiset[1]) submultiset of multiset[2, 3]",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "(multiset[1,2,3,2] multiset except distinct multiset[1]) submultiset of multiset[2, 3]",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "(multiset[1,2,3,2] multiset except all multiset[1]) submultiset of multiset[2, 2, 3]",
-        Boolean.TRUE);
-    tester.checkBoolean("(multiset[1,2,3] multiset except multiset[1]) is empty", Boolean.FALSE);
-    tester.checkBoolean("(multiset[1] multiset except multiset[1]) is empty", Boolean.TRUE);
-  }
-
-  @Test void testIsEmptyOperator() {
-    tester.setFor(SqlStdOperatorTable.IS_EMPTY, VM_EXPAND);
-    tester.checkBoolean("multiset[1] is empty", Boolean.FALSE);
-  }
-
-  @Test void testIsNotEmptyOperator() {
-    tester.setFor(SqlStdOperatorTable.IS_NOT_EMPTY, VM_EXPAND);
-    tester.checkBoolean("multiset[1] is not empty", Boolean.TRUE);
-  }
-
-  @Test void testExistsOperator() {
-    tester.setFor(SqlStdOperatorTable.EXISTS, VM_EXPAND);
-  }
-
-  @Test void testNotOperator() {
-    tester.setFor(SqlStdOperatorTable.NOT);
-    tester.checkBoolean("not true", Boolean.FALSE);
-    tester.checkBoolean("not false", Boolean.TRUE);
-    tester.checkBoolean("not unknown", null);
-    tester.checkNull("not cast(null as boolean)");
-  }
-
-  @Test void testPrefixMinusOperator() {
-    tester.setFor(SqlStdOperatorTable.UNARY_MINUS);
-    strictTester.checkFails(
-        "'a' + ^- 'b'^ + 'c'",
-        "(?s)Cannot apply '-' to arguments of type '-<CHAR\\(1\\)>'.*",
-        false);
-    tester.checkType("'a' + - 'b' + 'c'", "DECIMAL(19, 9) NOT NULL");
-    tester.checkScalarExact("-1", "-1");
-    tester.checkScalarExact(
-        "-1.23",
-        "DECIMAL(3, 2) NOT NULL",
-        "-1.23");
-    tester.checkScalarApprox("-1.0e0", "DOUBLE NOT NULL", -1, 0);
-    tester.checkNull("-cast(null as integer)");
-    tester.checkNull("-cast(null as tinyint)");
-  }
-
-  @Test void testPrefixMinusOperatorIntervals() {
-    tester.checkScalar(
-        "-interval '-6:2:8' hour to second",
-        "+6:02:08.000000",
-        "INTERVAL HOUR TO SECOND NOT NULL");
-    tester.checkScalar(
-        "- -interval '-6:2:8' hour to second",
-        "-6:02:08.000000",
-        "INTERVAL HOUR TO SECOND NOT NULL");
-    tester.checkScalar(
-        "-interval '5' month",
-        "-5",
-        "INTERVAL MONTH NOT NULL");
-    tester.checkNull(
-        "-cast(null as interval day to minute)");
-  }
-
-  @Test void testPrefixPlusOperator() {
-    tester.setFor(SqlStdOperatorTable.UNARY_PLUS, VM_EXPAND);
-    tester.checkScalarExact("+1", "1");
-    tester.checkScalarExact("+1.23", "DECIMAL(3, 2) NOT NULL", "1.23");
-    tester.checkScalarApprox("+1.0e0", "DOUBLE NOT NULL", 1, 0);
-    tester.checkNull("+cast(null as integer)");
-    tester.checkNull("+cast(null as tinyint)");
-  }
-
-  @Test void testPrefixPlusOperatorIntervals() {
-    tester.checkScalar(
-        "+interval '-6:2:8' hour to second",
-        "-6:02:08.000000",
-        "INTERVAL HOUR TO SECOND NOT NULL");
-    tester.checkScalar(
-        "++interval '-6:2:8' hour to second",
-        "-6:02:08.000000",
-        "INTERVAL HOUR TO SECOND NOT NULL");
-    if (Bug.FRG254_FIXED) {
-      tester.checkScalar(
-          "+interval '6:2:8.234' hour to second",
-          "+06:02:08.234",
-          "INTERVAL HOUR TO SECOND NOT NULL");
-    }
-    tester.checkScalar(
-        "+interval '5' month",
-        "+5",
-        "INTERVAL MONTH NOT NULL");
-    tester.checkNull(
-        "+cast(null as interval day to minute)");
-  }
-
-  @Test void testExplicitTableOperator() {
-    tester.setFor(
-        SqlStdOperatorTable.EXPLICIT_TABLE,
-        VM_EXPAND);
-  }
-
-  @Test void testValuesOperator() {
-    tester.setFor(SqlStdOperatorTable.VALUES, VM_EXPAND);
-    tester.check(
-        "select 'abc' from (values(true))",
-        new SqlTests.StringTypeChecker("CHAR(3) NOT NULL"),
-        "abc",
-        0);
-  }
-
-  @Test void testNotLikeOperator() {
-    tester.setFor(SqlStdOperatorTable.NOT_LIKE, VM_EXPAND);
-    tester.checkBoolean("'abc' not like '_b_'", Boolean.FALSE);
-    tester.checkBoolean("'ab\ncd' not like 'ab%'", Boolean.FALSE);
-    tester.checkBoolean("'123\n\n45\n' not like '%'", Boolean.FALSE);
-    tester.checkBoolean("'ab\ncd\nef' not like '%cd%'", Boolean.FALSE);
-    tester.checkBoolean("'ab\ncd\nef' not like '%cde%'", Boolean.TRUE);
-  }
-
-  @Test void testRlikeOperator() {
-    checkRlike(SqlLibrary.SPARK);
-    checkRlike(SqlLibrary.HIVE);
-    checkRlikeFails(SqlLibrary.MYSQL);
-    checkRlikeFails(SqlLibrary.ORACLE);
-  }
-
-  void checkRlike(SqlLibrary library) {
-    final SqlTester tester1 = libraryTester(library);
-    tester1.setFor(SqlLibraryOperators.RLIKE, VM_EXPAND);
-    tester1.checkBoolean("'Merrisa@gmail.com' rlike '.+@*\\.com'", Boolean.TRUE);
-    tester1.checkBoolean("'Merrisa@gmail.com' rlike '.com$'", Boolean.TRUE);
-    tester1.checkBoolean("'acbd' rlike '^ac+'", Boolean.TRUE);
-    tester1.checkBoolean("'acb' rlike 'acb|efg'", Boolean.TRUE);
-    tester1.checkBoolean("'acb|efg' rlike 'acb\\|efg'", Boolean.TRUE);
-    tester1.checkBoolean("'Acbd' rlike '^ac+'", Boolean.FALSE);
-    tester1.checkBoolean("'Merrisa@gmail.com' rlike 'Merrisa_'", Boolean.FALSE);
-    tester1.checkBoolean("'abcdef' rlike '%cd%'", Boolean.FALSE);
-
-    tester1.setFor(SqlLibraryOperators.NOT_RLIKE, VM_EXPAND);
-    tester1.checkBoolean("'Merrisagmail' not rlike '.+@*\\.com'", Boolean.TRUE);
-    tester1.checkBoolean("'acbd' not rlike '^ac+'", Boolean.FALSE);
-    tester1.checkBoolean("'acb|efg' not rlike 'acb\\|efg'", Boolean.FALSE);
-    tester1.checkBoolean("'Merrisa@gmail.com' not rlike 'Merrisa_'", Boolean.TRUE);
-  }
-
-  void checkRlikeFails(SqlLibrary library) {
-    final SqlTester tester1 = libraryTester(library);
-    tester1.setFor(SqlLibraryOperators.RLIKE, VM_EXPAND);
-    final String noRlike = "(?s).*No match found for function signature RLIKE";
-    tester1.checkFails("^'Merrisa@gmail.com' rlike '.+@*\\.com'^", noRlike, false);
-    tester1.checkFails("^'acb' rlike 'acb|efg'^", noRlike, false);
-    final String noNotRlike = "(?s).*No match found for function signature NOT RLIKE";
-    tester1.checkFails("^'abcdef' not rlike '%cd%'^", noNotRlike, false);
-    tester1.checkFails("^'Merrisa@gmail.com' not rlike 'Merrisa_'^", noNotRlike, false);
-  }
-
-  @Test void testLikeEscape() {
-    tester.setFor(SqlStdOperatorTable.LIKE);
-    tester.checkBoolean("'a_c' like 'a#_c' escape '#'", Boolean.TRUE);
-    tester.checkBoolean("'axc' like 'a#_c' escape '#'", Boolean.FALSE);
-    tester.checkBoolean("'a_c' like 'a\\_c' escape '\\'", Boolean.TRUE);
-    tester.checkBoolean("'axc' like 'a\\_c' escape '\\'", Boolean.FALSE);
-    tester.checkBoolean("'a%c' like 'a\\%c' escape '\\'", Boolean.TRUE);
-    tester.checkBoolean("'a%cde' like 'a\\%c_e' escape '\\'", Boolean.TRUE);
-    tester.checkBoolean("'abbc' like 'a%c' escape '\\'", Boolean.TRUE);
-    tester.checkBoolean("'abbc' like 'a\\%c' escape '\\'", Boolean.FALSE);
-  }
-
-  @Test void testIlikeEscape() {
-    tester.setFor(SqlLibraryOperators.ILIKE);
-    final SqlTester tester1 = libraryTester(SqlLibrary.POSTGRESQL);
-    tester1.checkBoolean("'a_c' ilike 'a#_C' escape '#'", Boolean.TRUE);
-    tester1.checkBoolean("'axc' ilike 'a#_C' escape '#'", Boolean.FALSE);
-    tester1.checkBoolean("'a_c' ilike 'a\\_C' escape '\\'", Boolean.TRUE);
-    tester1.checkBoolean("'axc' ilike 'a\\_C' escape '\\'", Boolean.FALSE);
-    tester1.checkBoolean("'a%c' ilike 'a\\%C' escape '\\'", Boolean.TRUE);
-    tester1.checkBoolean("'a%cde' ilike 'a\\%C_e' escape '\\'", Boolean.TRUE);
-    tester1.checkBoolean("'abbc' ilike 'a%C' escape '\\'", Boolean.TRUE);
-    tester1.checkBoolean("'abbc' ilike 'a\\%C' escape '\\'", Boolean.FALSE);
-  }
-
-  @Disabled("[CALCITE-525] Exception-handling in built-in functions")
-  @Test void testLikeEscape2() {
-    tester.checkBoolean("'x' not like 'x' escape 'x'", Boolean.TRUE);
-    tester.checkBoolean("'xyz' not like 'xyz' escape 'xyz'", Boolean.TRUE);
-  }
-
-  @Test void testLikeOperator() {
-    tester.setFor(SqlStdOperatorTable.LIKE);
-    tester.checkBoolean("''  like ''", Boolean.TRUE);
-    tester.checkBoolean("'a' like 'a'", Boolean.TRUE);
-    tester.checkBoolean("'a' like 'b'", Boolean.FALSE);
-    tester.checkBoolean("'a' like 'A'", Boolean.FALSE);
-    tester.checkBoolean("'a' like 'a_'", Boolean.FALSE);
-    tester.checkBoolean("'a' like '_a'", Boolean.FALSE);
-    tester.checkBoolean("'a' like '%a'", Boolean.TRUE);
-    tester.checkBoolean("'a' like '%a%'", Boolean.TRUE);
-    tester.checkBoolean("'a' like 'a%'", Boolean.TRUE);
-    tester.checkBoolean("'ab'   like 'a_'", Boolean.TRUE);
-    tester.checkBoolean("'abc'  like 'a_'", Boolean.FALSE);
-    tester.checkBoolean("'abcd' like 'a%'", Boolean.TRUE);
-    tester.checkBoolean("'ab'   like '_b'", Boolean.TRUE);
-    tester.checkBoolean("'abcd' like '_d'", Boolean.FALSE);
-    tester.checkBoolean("'abcd' like '%d'", Boolean.TRUE);
-    tester.checkBoolean("'ab\ncd' like 'ab%'", Boolean.TRUE);
-    tester.checkBoolean("'abc\ncd' like 'ab%'", Boolean.TRUE);
-    tester.checkBoolean("'123\n\n45\n' like '%'", Boolean.TRUE);
-    tester.checkBoolean("'ab\ncd\nef' like '%cd%'", Boolean.TRUE);
-    tester.checkBoolean("'ab\ncd\nef' like '%cde%'", Boolean.FALSE);
-  }
-
-  @Test void testIlikeOperator() {
-    tester.setFor(SqlLibraryOperators.ILIKE);
-    final String noLike = "No match found for function signature ILIKE";
-    tester.checkFails("^'a' ilike 'b'^", noLike, false);
-    tester.checkFails("^'a' ilike 'b' escape 'c'^", noLike, false);
-    final String noNotLike = "No match found for function signature NOT ILIKE";
-    tester.checkFails("^'a' not ilike 'b'^", noNotLike, false);
-    tester.checkFails("^'a' not ilike 'b' escape 'c'^", noNotLike, false);
-
-    final SqlTester tester1 = libraryTester(SqlLibrary.POSTGRESQL);
-    tester1.checkBoolean("''  ilike ''", Boolean.TRUE);
-    tester1.checkBoolean("'a' ilike 'a'", Boolean.TRUE);
-    tester1.checkBoolean("'a' ilike 'b'", Boolean.FALSE);
-    tester1.checkBoolean("'a' ilike 'A'", Boolean.TRUE);
-    tester1.checkBoolean("'a' ilike 'a_'", Boolean.FALSE);
-    tester1.checkBoolean("'a' ilike '_a'", Boolean.FALSE);
-    tester1.checkBoolean("'a' ilike '%a'", Boolean.TRUE);
-    tester1.checkBoolean("'a' ilike '%A'", Boolean.TRUE);
-    tester1.checkBoolean("'a' ilike '%a%'", Boolean.TRUE);
-    tester1.checkBoolean("'a' ilike '%A%'", Boolean.TRUE);
-    tester1.checkBoolean("'a' ilike 'a%'", Boolean.TRUE);
-    tester1.checkBoolean("'a' ilike 'A%'", Boolean.TRUE);
-    tester1.checkBoolean("'ab'   ilike 'a_'", Boolean.TRUE);
-    tester1.checkBoolean("'ab'   ilike 'A_'", Boolean.TRUE);
-    tester1.checkBoolean("'abc'  ilike 'a_'", Boolean.FALSE);
-    tester1.checkBoolean("'abcd' ilike 'a%'", Boolean.TRUE);
-    tester1.checkBoolean("'abcd' ilike 'A%'", Boolean.TRUE);
-    tester1.checkBoolean("'ab'   ilike '_b'", Boolean.TRUE);
-    tester1.checkBoolean("'ab'   ilike '_B'", Boolean.TRUE);
-    tester1.checkBoolean("'abcd' ilike '_d'", Boolean.FALSE);
-    tester1.checkBoolean("'abcd' ilike '%d'", Boolean.TRUE);
-    tester1.checkBoolean("'abcd' ilike '%D'", Boolean.TRUE);
-    tester1.checkBoolean("'ab\ncd' ilike 'ab%'", Boolean.TRUE);
-    tester1.checkBoolean("'ab\ncd' ilike 'aB%'", Boolean.TRUE);
-    tester1.checkBoolean("'abc\ncd' ilike 'ab%'", Boolean.TRUE);
-    tester1.checkBoolean("'abc\ncd' ilike 'Ab%'", Boolean.TRUE);
-    tester1.checkBoolean("'123\n\n45\n' ilike '%'", Boolean.TRUE);
-    tester1.checkBoolean("'ab\ncd\nef' ilike '%cd%'", Boolean.TRUE);
-    tester1.checkBoolean("'ab\ncd\nef' ilike '%CD%'", Boolean.TRUE);
-    tester1.checkBoolean("'ab\ncd\nef' ilike '%cde%'", Boolean.FALSE);
-  }
-
-  /** Test case for
-   * <a href="https://issues.apache.org/jira/browse/CALCITE-1898">[CALCITE-1898]
-   * LIKE must match '.' (period) literally</a>. */
-  @Test void testLikeDot() {
-    tester.checkBoolean("'abc' like 'a.c'", Boolean.FALSE);
-    tester.checkBoolean("'abcde' like '%c.e'", Boolean.FALSE);
-    tester.checkBoolean("'abc.e' like '%c.e'", Boolean.TRUE);
-  }
-
-  @Test void testIlikeDot() {
-    tester.setFor(SqlLibraryOperators.ILIKE);
-    final SqlTester tester1 = libraryTester(SqlLibrary.POSTGRESQL);
-    tester1.checkBoolean("'abc' ilike 'a.c'", Boolean.FALSE);
-    tester1.checkBoolean("'abcde' ilike '%c.e'", Boolean.FALSE);
-    tester1.checkBoolean("'abc.e' ilike '%c.e'", Boolean.TRUE);
-    tester1.checkBoolean("'abc.e' ilike '%c.E'", Boolean.TRUE);
-  }
-
-  @Test void testNotSimilarToOperator() {
-    tester.setFor(SqlStdOperatorTable.NOT_SIMILAR_TO, VM_EXPAND);
-    tester.checkBoolean("'ab' not similar to 'a_'", false);
-    tester.checkBoolean("'aabc' not similar to 'ab*c+d'", true);
-    tester.checkBoolean("'ab' not similar to 'a' || '_'", false);
-    tester.checkBoolean("'ab' not similar to 'ba_'", true);
-    tester.checkBoolean(
-        "cast(null as varchar(2)) not similar to 'a_'",
-        null);
-    tester.checkBoolean(
-        "cast(null as varchar(3)) not similar to cast(null as char(2))",
-        null);
-  }
-
-  @Test void testSimilarToOperator() {
-    tester.setFor(SqlStdOperatorTable.SIMILAR_TO);
-
-    // like LIKE
-    tester.checkBoolean("''  similar to ''", Boolean.TRUE);
-    tester.checkBoolean("'a' similar to 'a'", Boolean.TRUE);
-    tester.checkBoolean("'a' similar to 'b'", Boolean.FALSE);
-    tester.checkBoolean("'a' similar to 'A'", Boolean.FALSE);
-    tester.checkBoolean("'a' similar to 'a_'", Boolean.FALSE);
-    tester.checkBoolean("'a' similar to '_a'", Boolean.FALSE);
-    tester.checkBoolean("'a' similar to '%a'", Boolean.TRUE);
-    tester.checkBoolean("'a' similar to '%a%'", Boolean.TRUE);
-    tester.checkBoolean("'a' similar to 'a%'", Boolean.TRUE);
-    tester.checkBoolean("'ab'   similar to 'a_'", Boolean.TRUE);
-    tester.checkBoolean("'abc'  similar to 'a_'", Boolean.FALSE);
-    tester.checkBoolean("'abcd' similar to 'a%'", Boolean.TRUE);
-    tester.checkBoolean("'ab'   similar to '_b'", Boolean.TRUE);
-    tester.checkBoolean("'abcd' similar to '_d'", Boolean.FALSE);
-    tester.checkBoolean("'abcd' similar to '%d'", Boolean.TRUE);
-    tester.checkBoolean("'ab\ncd' similar to 'ab%'", Boolean.TRUE);
-    tester.checkBoolean("'abc\ncd' similar to 'ab%'", Boolean.TRUE);
-    tester.checkBoolean("'123\n\n45\n' similar to '%'", Boolean.TRUE);
-    tester.checkBoolean("'ab\ncd\nef' similar to '%cd%'", Boolean.TRUE);
-    tester.checkBoolean("'ab\ncd\nef' similar to '%cde%'", Boolean.FALSE);
-
-    // simple regular expressions
-    // ab*c+d matches acd, abcd, acccd, abcccd but not abd, aabc
-    tester.checkBoolean("'acd'    similar to 'ab*c+d'", Boolean.TRUE);
-    tester.checkBoolean("'abcd'   similar to 'ab*c+d'", Boolean.TRUE);
-    tester.checkBoolean("'acccd'  similar to 'ab*c+d'", Boolean.TRUE);
-    tester.checkBoolean("'abcccd' similar to 'ab*c+d'", Boolean.TRUE);
-    tester.checkBoolean("'abd'    similar to 'ab*c+d'", Boolean.FALSE);
-    tester.checkBoolean("'aabc'   similar to 'ab*c+d'", Boolean.FALSE);
-
-    // compound regular expressions
-    // x(ab|c)*y matches xy, xccy, xababcy but not xbcy
-    tester.checkBoolean(
-        "'xy'      similar to 'x(ab|c)*y'",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "'xccy'    similar to 'x(ab|c)*y'",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "'xababcy' similar to 'x(ab|c)*y'",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "'xbcy'    similar to 'x(ab|c)*y'",
-        Boolean.FALSE);
-
-    // x(ab|c)+y matches xccy, xababcy but not xy, xbcy
-    tester.checkBoolean(
-        "'xy'      similar to 'x(ab|c)+y'",
-        Boolean.FALSE);
-    tester.checkBoolean(
-        "'xccy'    similar to 'x(ab|c)+y'",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "'xababcy' similar to 'x(ab|c)+y'",
-        Boolean.TRUE);
-    tester.checkBoolean(
-        "'xbcy'    similar to 'x(ab|c)+y'",
-        Boolean.FALSE);
-
-    tester.checkBoolean("'ab' similar to 'a%' ", Boolean.TRUE);
-    tester.checkBoolean("'a' similar to 'a%' ", Boolean.TRUE);
-    tester.checkBoolean("'abcd' similar to 'a_' ", Boolean.FALSE);
-    tester.checkBoolean("'abcd' similar to 'a%' ", Boolean.TRUE);
-    tester.checkBoolean("'1a' similar to '_a' ", Boolean.TRUE);
-    tester.checkBoolean("'123aXYZ' similar to '%a%'", Boolean.TRUE);
-
-    tester.checkBoolean(
-        "'123aXYZ' similar to '_%_a%_' ",
-        Boolean.TRUE);
-
-    tester.checkBoolean("'xy' similar to '(xy)' ", Boolean.TRUE);
-
-    tester.checkBoolean(
-        "'abd' similar to '[ab][bcde]d' ",
-        Boolean.TRUE);
-
-    tester.checkBoolean(
-        "'bdd' similar to '[ab][bcde]d' ",
-        Boolean.TRUE);
-
-    tester.checkBoolean("'abd' similar to '[ab]d' ", Boolean.FALSE);
-    tester.checkBoolean("'cd' similar to '[a-e]d' ", Boolean.TRUE);
-    tester.checkBoolean("'amy' similar to 'amy|fred' ", Boolean.TRUE);
-    tester.checkBoolean("'fred' similar to 'amy|fred' ", Boolean.TRUE);
-
-    tester.checkBoolean(
-        "'mike' similar to 'amy|fred' ",
-        Boolean.FALSE);
-
-    tester.checkBoolean("'acd' similar to 'ab*c+d' ", Boolean.TRUE);
-    tester.checkBoolean("'accccd' similar to 'ab*c+d' ", Boolean.TRUE);
-    tester.checkBoolean("'abd' similar to 'ab*c+d' ", Boolean.FALSE);
-    tester.checkBoolean("'aabc' similar to 'ab*c+d' ", Boolean.FALSE);
-    tester.checkBoolean("'abb' similar to 'a(b{3})' ", Boolean.FALSE);
-    tester.checkBoolean("'abbb' similar to 'a(b{3})' ", Boolean.TRUE);
-
-    tester.checkBoolean(
-        "'abbbbb' similar to 'a(b{3})' ",
-        Boolean.FALSE);
-
-    tester.checkBoolean(
-        "'abbbbb' similar to 'ab{3,6}' ",
-        Boolean.TRUE);
-
-    tester.checkBoolean(
-        "'abbbbbbbb' similar to 'ab{3,6}' ",
-        Boolean.FALSE);
-    tester.checkBoolean("'' similar to 'ab?' ", Boolean.FALSE);
-    tester.checkBoolean("'a' similar to 'ab?' ", Boolean.TRUE);
-    tester.checkBoolean("'a' similar to 'a(b?)' ", Boolean.TRUE);
-    tester.checkBoolean("'ab' similar to 'ab?' ", Boolean.TRUE);
-    tester.checkBoolean("'ab' similar to 'a(b?)' ", Boolean.TRUE);
-    tester.checkBoolean("'abb' similar to 'ab?' ", Boolean.FALSE);
-
-    tester.checkBoolean(
-        "'ab' similar to 'a\\_' ESCAPE '\\' ",
-        Boolean.FALSE);
-
-    tester.checkBoolean(
-        "'ab' similar to 'a\\%' ESCAPE '\\' ",
-        Boolean.FALSE);
-
-    tester.checkBoolean(
-        "'a_' similar to 'a\\_' ESCAPE '\\' ",
-        Boolean.TRUE);
-
-    tester.checkBoolean(
-        "'a%' similar to 'a\\%' ESCAPE '\\' ",
-        Boolean.TRUE);
-
-    tester.checkBoolean(
-        "'a(b{3})' similar to 'a(b{3})' ",
-        Boolean.FALSE);
-
-    tester.checkBoolean(
-        "'a(b{3})' similar to 'a\\(b\\{3\\}\\)' ESCAPE '\\' ",
-        Boolean.TRUE);
-
-    tester.checkBoolean("'yd' similar to '[a-ey]d'", Boolean.TRUE);
-    tester.checkBoolean("'yd' similar to '[^a-ey]d'", Boolean.FALSE);
-    tester.checkBoolean("'yd' similar to '[^a-ex-z]d'", Boolean.FALSE);
-    tester.checkBoolean("'yd' similar to '[a-ex-z]d'", Boolean.TRUE);
-    tester.checkBoolean("'yd' similar to '[x-za-e]d'", Boolean.TRUE);
-    tester.checkBoolean("'yd' similar to '[^a-ey]?d'", Boolean.FALSE);
-    tester.checkBoolean("'yyyd' similar to '[a-ey]*d'", Boolean.TRUE);
-
-    // range must be specified in []
-    tester.checkBoolean("'yd' similar to 'x-zd'", Boolean.FALSE);
-    tester.checkBoolean("'y' similar to 'x-z'", Boolean.FALSE);
-
-    tester.checkBoolean("'cd' similar to '([a-e])d'", Boolean.TRUE);
-    tester.checkBoolean("'xy' similar to 'x*?y'", Boolean.TRUE);
-    tester.checkBoolean("'y' similar to 'x*?y'", Boolean.TRUE);
-    tester.checkBoolean("'y' similar to '(x?)*y'", Boolean.TRUE);
-    tester.checkBoolean("'y' similar to 'x+?y'", Boolean.FALSE);
-
-    tester.checkBoolean("'y' similar to 'x?+y'", Boolean.TRUE);
-    tester.checkBoolean("'y' similar to 'x*+y'", Boolean.TRUE);
-
-    // dot is a wildcard for SIMILAR TO but not LIKE
-    tester.checkBoolean("'abc' similar to 'a.c'", Boolean.TRUE);
-    tester.checkBoolean("'a.c' similar to 'a.c'", Boolean.TRUE);
-    tester.checkBoolean("'abcd' similar to 'a.*d'", Boolean.TRUE);
-    tester.checkBoolean("'abc' like 'a.c'", Boolean.FALSE);
-    tester.checkBoolean("'a.c' like 'a.c'", Boolean.TRUE);
-    tester.checkBoolean("'abcd' like 'a.*d'", Boolean.FALSE);
-
-    // The following two tests throws exception(They probably should).
-    // "Dangling meta character '*' near index 2"
-
-    if (enable) {
-      tester.checkBoolean("'y' similar to 'x+*y'", Boolean.TRUE);
-      tester.checkBoolean("'y' similar to 'x?*y'", Boolean.TRUE);
-    }
-
-    // some negative tests
-    tester.checkFails(
-        "'yd' similar to '[x-ze-a]d'",
-        "Illegal character range near index 6\n"
-            + "\\[x-ze-a\\]d\n"
-            + "      \\^",
-        true);   // illegal range
-
-    // Slightly different error message from JDK 13 onwards
-    final String expectedError =
-        TestUtil.getJavaMajorVersion() >= 13
-            ? "Illegal repetition near index 22\n"
-              + "\\[\\:LOWER\\:\\]\\{2\\}\\[\\:DIGIT\\:\\]\\{,5\\}\n"
-              + "                      \\^"
-            : "Illegal repetition near index 20\n"
-                + "\\[\\:LOWER\\:\\]\\{2\\}\\[\\:DIGIT\\:\\]\\{,5\\}\n"
-                + "                    \\^";
-    tester.checkFails("'yd3223' similar to '[:LOWER:]{2}[:DIGIT:]{,5}'",
-        expectedError, true);
-
-    if (Bug.CALCITE_2539_FIXED) {
-      tester.checkFails(
-          "'cd' similar to '[(a-e)]d' ",
-          "Invalid regular expression: \\[\\(a-e\\)\\]d at 1",
-          true);
-
-      tester.checkFails(
-          "'yd' similar to '[(a-e)]d' ",
-          "Invalid regular expression: \\[\\(a-e\\)\\]d at 1",
-          true);
-    }
-
-    // all the following tests wrong results due to missing functionality
-    // or defect (FRG-375, 377).
-
-    if (Bug.FRG375_FIXED) {
-      tester.checkBoolean(
-          "'cd' similar to '[a-e^c]d' ", Boolean.FALSE); // FRG-375
-    }
-
-    // following tests use regular character set identifiers.
-    // Not implemented yet. FRG-377.
-    if (Bug.FRG377_FIXED) {
-      tester.checkBoolean(
-          "'y' similar to '[:ALPHA:]*'",
-          Boolean.TRUE);
-
-      tester.checkBoolean(
-          "'yd32' similar to '[:LOWER:]{2}[:DIGIT:]*'",
-          Boolean.TRUE);
-
-      tester.checkBoolean(
-          "'yd32' similar to '[:ALNUM:]*'",
-          Boolean.TRUE);
-
-      tester.checkBoolean(
-          "'yd32' similar to '[:ALNUM:]*[:DIGIT:]?'",
-          Boolean.TRUE);
-
-      tester.checkBoolean(
-          "'yd32' similar to '[:ALNUM:]?[:DIGIT:]*'",
-          Boolean.FALSE);
-
-      tester.checkBoolean(
-          "'yd3223' similar to '([:LOWER:]{2})[:DIGIT:]{2,5}'",
-          Boolean.TRUE);
-
-      tester.checkBoolean(
-          "'yd3223' similar to '[:LOWER:]{2}[:DIGIT:]{2,}'",
-          Boolean.TRUE);
-
-      tester.checkBoolean(
-          "'yd3223' similar to '[:LOWER:]{2}||[:DIGIT:]{4}'",
-          Boolean.TRUE);
-
-      tester.checkBoolean(
-          "'yd3223' similar to '[:LOWER:]{2}[:DIGIT:]{3}'",
-          Boolean.FALSE);
-
-      tester.checkBoolean(
-          "'yd  3223' similar to '[:UPPER:]{2}  [:DIGIT:]{3}'",
-          Boolean.FALSE);
-
-      tester.checkBoolean(
-          "'YD  3223' similar to '[:UPPER:]{2}  [:DIGIT:]{3}'",
-          Boolean.FALSE);
-
-      tester.checkBoolean(
-          "'YD  3223' similar to "
-              + "'[:UPPER:]{2}||[:WHITESPACE:]*[:DIGIT:]{4}'",
-          Boolean.TRUE);
-
-      tester.checkBoolean(
-          "'YD\t3223' similar to '[:UPPER:]{2}[:SPACE:]*[:DIGIT:]{4}'",
-          Boolean.FALSE);
-
-      tester.checkBoolean(
-          "'YD\t3223' similar to "
-              + "'[:UPPER:]{2}[:WHITESPACE:]*[:DIGIT:]{4}'",
-          Boolean.TRUE);
-
-      tester.checkBoolean(
-          "'YD\t\t3223' similar to "
-              + "'([:UPPER:]{2}[:WHITESPACE:]+)||[:DIGIT:]{4}'",
-          Boolean.TRUE);
-    }
-  }
-
-  @Test void testEscapeOperator() {
-    tester.setFor(SqlStdOperatorTable.ESCAPE, VM_EXPAND);
-  }
-
-  @Test void testConvertFunc() {
-    tester.setFor(
-        SqlStdOperatorTable.CONVERT,
-        VM_FENNEL,
-        VM_JAVA);
-  }
-
-  @Test void testTranslateFunc() {
-    tester.setFor(
-        SqlStdOperatorTable.TRANSLATE,
-        VM_FENNEL,
-        VM_JAVA);
-  }
-
-  @Test void testTranslate3Func() {
-    final SqlTester tester1 = libraryTester(SqlLibrary.ORACLE);
-    tester1.setFor(SqlLibraryOperators.TRANSLATE3);
-    tester1.checkString(
-        "translate('aabbcc', 'ab', '+-')",
-        "++--cc",
-        "VARCHAR(6) NOT NULL");
-    tester1.checkString(
-        "translate('aabbcc', 'ab', 'ba')",
-        "bbaacc",
-        "VARCHAR(6) NOT NULL");
-    tester1.checkString(
-        "translate('aabbcc', 'ab', '')",
-        "cc",
-        "VARCHAR(6) NOT NULL");
-    tester1.checkString(
-        "translate('aabbcc', '', '+-')",
-        "aabbcc",
-        "VARCHAR(6) NOT NULL");
-    tester1.checkString(
-        "translate(cast('aabbcc' as varchar(10)), 'ab', '+-')",
-        "++--cc",
-        "VARCHAR(10) NOT NULL");
-    tester1.checkNull(
-        "translate(cast(null as varchar(7)), 'ab', '+-')");
-    tester1.checkNull(
-        "translate('aabbcc', cast(null as varchar(2)), '+-')");
-    tester1.checkNull(
-        "translate('aabbcc', 'ab', cast(null as varchar(2)))");
-  }
-
-  @Test void testOverlayFunc() {
-    tester.setFor(SqlStdOperatorTable.OVERLAY);
-    tester.checkString(
-        "overlay('ABCdef' placing 'abc' from 1)",
-        "abcdef",
-        "VARCHAR(9) NOT NULL");
-    tester.checkString(
-        "overlay('ABCdef' placing 'abc' from 1 for 2)",
-        "abcCdef",
-        "VARCHAR(9) NOT NULL");
-    if (enable) {
-      tester.checkString(
-          "overlay(cast('ABCdef' as varchar(10)) placing "
-              + "cast('abc' as char(5)) from 1 for 2)",
-          "abc  Cdef",
-          "VARCHAR(15) NOT NULL");
-    }
-    if (enable) {
-      tester.checkString(
-          "overlay(cast('ABCdef' as char(10)) placing "
-              + "cast('abc' as char(5)) from 1 for 2)",
-          "abc  Cdef    ",
-          "VARCHAR(15) NOT NULL");
-    }
-    tester.checkNull(
-        "overlay('ABCdef' placing 'abc' from 1 for cast(null as integer))");
-    tester.checkNull(
-        "overlay(cast(null as varchar(1)) placing 'abc' from 1)");
-
-    tester.checkString(
-        "overlay(x'ABCdef' placing x'abcd' from 1)",
-        "abcdef",
-        "VARBINARY(5) NOT NULL");
-    tester.checkString(
-        "overlay(x'ABCDEF1234' placing x'2345' from 1 for 2)",
-        "2345ef1234",
-        "VARBINARY(7) NOT NULL");
-    if (enable) {
-      tester.checkString(
-          "overlay(cast(x'ABCdef' as varbinary(5)) placing "
-              + "cast(x'abcd' as binary(3)) from 1 for 2)",
-          "abc  Cdef",
-          "VARBINARY(8) NOT NULL");
-    }
-    if (enable) {
-      tester.checkString(
-          "overlay(cast(x'ABCdef' as binary(5)) placing "
-              + "cast(x'abcd' as binary(3)) from 1 for 2)",
-          "abc  Cdef    ",
-          "VARBINARY(8) NOT NULL");
-    }
-    tester.checkNull(
-        "overlay(x'ABCdef' placing x'abcd' from 1 for cast(null as integer))");
-    tester.checkNull(
-        "overlay(cast(null as varbinary(1)) placing x'abcd' from 1)");
-
-    tester.checkNull(
-        "overlay(x'abcd' placing x'abcd' from cast(null as integer))");
-  }
-
-  @Test void testPositionFunc() {
-    tester.setFor(SqlStdOperatorTable.POSITION);
-    tester.checkScalarExact("position('b' in 'abc')", "2");
-    tester.checkScalarExact("position('' in 'abc')", "1");
-    tester.checkScalarExact("position('b' in 'abcabc' FROM 3)", "5");
-    tester.checkScalarExact("position('b' in 'abcabc' FROM 5)", "5");
-    tester.checkScalarExact("position('b' in 'abcabc' FROM 6)", "0");
-    tester.checkScalarExact("position('b' in 'abcabc' FROM -5)", "0");
-    tester.checkScalarExact("position('' in 'abc' FROM 3)", "3");
-    tester.checkScalarExact("position('' in 'abc' FROM 10)", "0");
-
-    tester.checkScalarExact("position(x'bb' in x'aabbcc')", "2");
-    tester.checkScalarExact("position(x'' in x'aabbcc')", "1");
-    tester.checkScalarExact("position(x'bb' in x'aabbccaabbcc' FROM 3)", "5");
-    tester.checkScalarExact("position(x'bb' in x'aabbccaabbcc' FROM 5)", "5");
-    tester.checkScalarExact("position(x'bb' in x'aabbccaabbcc' FROM 6)", "0");
-    tester.checkScalarExact("position(x'bb' in x'aabbccaabbcc' FROM -5)", "0");
-    tester.checkScalarExact("position(x'cc' in x'aabbccdd' FROM 2)", "3");
-    tester.checkScalarExact("position(x'' in x'aabbcc' FROM 3)", "3");
-    tester.checkScalarExact("position(x'' in x'aabbcc' FROM 10)", "0");
-
-    // FRG-211
-    tester.checkScalarExact("position('tra' in 'fdgjklewrtra')", "10");
-
-    tester.checkNull("position(cast(null as varchar(1)) in '0010')");
-    tester.checkNull("position('a' in cast(null as varchar(1)))");
-
-    tester.checkScalar(
-        "position(cast('a' as char) in cast('bca' as varchar))",
-        3,
-        "INTEGER NOT NULL");
-  }
-
-  @Test void testReplaceFunc() {
-    tester.setFor(SqlStdOperatorTable.REPLACE);
-    tester.checkString("REPLACE('ciao', 'ciao', '')", "",
-        "VARCHAR(4) NOT NULL");
-    tester.checkString("REPLACE('hello world', 'o', '')", "hell wrld",
-        "VARCHAR(11) NOT NULL");
-    tester.checkNull("REPLACE(cast(null as varchar(5)), 'ciao', '')");
-    tester.checkNull("REPLACE('ciao', cast(null as varchar(3)), 'zz')");
-    tester.checkNull("REPLACE('ciao', 'bella', cast(null as varchar(3)))");
-  }
-
-  @Test void testCharLengthFunc() {
-    tester.setFor(SqlStdOperatorTable.CHAR_LENGTH);
-    tester.checkScalarExact("char_length('abc')", "3");
-    tester.checkNull("char_length(cast(null as varchar(1)))");
-  }
-
-  @Test void testCharacterLengthFunc() {
-    tester.setFor(SqlStdOperatorTable.CHARACTER_LENGTH);
-    tester.checkScalarExact("CHARACTER_LENGTH('abc')", "3");
-    tester.checkNull("CHARACTER_LENGTH(cast(null as varchar(1)))");
-  }
-
-  @Test void testOctetLengthFunc() {
-    tester.setFor(SqlStdOperatorTable.OCTET_LENGTH);
-    tester.checkScalarExact("OCTET_LENGTH(x'aabbcc')", "3");
-    tester.checkNull("OCTET_LENGTH(cast(null as varbinary(1)))");
-  }
-
-  @Test void testAsciiFunc() {
-    tester.setFor(SqlStdOperatorTable.ASCII);
-    tester.checkScalarExact("ASCII('')", "0");
-    tester.checkScalarExact("ASCII('a')", "97");
-    tester.checkScalarExact("ASCII('1')", "49");
-    tester.checkScalarExact("ASCII('abc')", "97");
-    tester.checkScalarExact("ASCII('ABC')", "65");
-    tester.checkScalarExact("ASCII(_UTF8'\u0082')", "130");
-    tester.checkScalarExact("ASCII(_UTF8'\u5B57')", "23383");
-    tester.checkScalarExact("ASCII(_UTF8'\u03a9')", "937"); // omega
-    tester.checkNull("ASCII(cast(null as varchar(1)))");
-  }
-
-  @Test void testToBase64() {
-    final SqlTester tester1 = tester(SqlLibrary.MYSQL);
-    tester1.setFor(SqlLibraryOperators.TO_BASE64);
-    tester1.checkString("to_base64(x'546869732069732061207465737420537472696e672e')",
-            "VGhpcyBpcyBhIHRlc3QgU3RyaW5nLg==",
-            "VARCHAR NOT NULL");
-    tester1.checkString("to_base64(x'546869732069732061207465737420537472696e672e20636865"
-                    + "636b20726573756c7465206f7574206f66203736546869732069732061207465737420537472696e"
-                    + "672e546869732069732061207465737420537472696e672e54686973206973206120746573742053"
-                    + "7472696e672e546869732069732061207465737420537472696e672e546869732069732061207465"
-                    + "737420537472696e672e20546869732069732061207465737420537472696e672e20636865636b20"
-                    + "726573756c7465206f7574206f66203736546869732069732061207465737420537472696e672e54"
-                    + "6869732069732061207465737420537472696e672e54686973206973206120746573742053747269"
-                    + "6e672e546869732069732061207465737420537472696e672e546869732069732061207465737420"
-                    + "537472696e672e20546869732069732061207465737420537472696e672e20636865636b20726573"
-                    + "756c7465206f7574206f66203736546869732069732061207465737420537472696e672e54686973"
-                    + "2069732061207465737420537472696e672e546869732069732061207465737420537472696e672e"
-                    + "546869732069732061207465737420537472696e672e546869732069732061207465737420537472"
-                    + "696e672e')",
-            "VGhpcyBpcyBhIHRlc3QgU3RyaW5nLiBjaGVjayByZXN1bHRlIG91dCBvZiA3NlRoaXMgaXMgYSB0\n"
-                    + "ZXN0IFN0cmluZy5UaGlzIGlzIGEgdGVzdCBTdHJpbmcuVGhpcyBpcyBhIHRlc3QgU3RyaW5nLlRo\n"
-                    + "aXMgaXMgYSB0ZXN0IFN0cmluZy5UaGlzIGlzIGEgdGVzdCBTdHJpbmcuIFRoaXMgaXMgYSB0ZXN0\n"
-                    + "IFN0cmluZy4gY2hlY2sgcmVzdWx0ZSBvdXQgb2YgNzZUaGlzIGlzIGEgdGVzdCBTdHJpbmcuVGhp\n"
-                    + "cyBpcyBhIHRlc3QgU3RyaW5nLlRoaXMgaXMgYSB0ZXN0IFN0cmluZy5UaGlzIGlzIGEgdGVzdCBT\n"
-                    + "dHJpbmcuVGhpcyBpcyBhIHRlc3QgU3RyaW5nLiBUaGlzIGlzIGEgdGVzdCBTdHJpbmcuIGNoZWNr\n"
-                    + "IHJlc3VsdGUgb3V0IG9mIDc2VGhpcyBpcyBhIHRlc3QgU3RyaW5nLlRoaXMgaXMgYSB0ZXN0IFN0\n"
-                    + "cmluZy5UaGlzIGlzIGEgdGVzdCBTdHJpbmcuVGhpcyBpcyBhIHRlc3QgU3RyaW5nLlRoaXMgaXMg\n"
-                    + "YSB0ZXN0IFN0cmluZy4=",
-            "VARCHAR NOT NULL");
-    tester1.checkString("to_base64('This is a test String.')",
-            "VGhpcyBpcyBhIHRlc3QgU3RyaW5nLg==",
-            "VARCHAR NOT NULL");
-    tester1.checkString("to_base64('This is a test String. check resulte out of 76T"
-                    + "his is a test String.This is a test String.This is a test String.This is a "
-                    + "test String.This is a test String. This is a test String. check resulte out "
-                    + "of 76This is a test String.This is a test String.This is a test String.This "
-                    + "is a test String.This is a test String. This is a test String. check resulte "
-                    + "out of 76This is a test String.This is a test String.This is a test String."
-                    + "This is a test String.This is a test String.')",
-            "VGhpcyBpcyBhIHRlc3QgU3RyaW5nLiBjaGVjayByZXN1bHRlIG91dCBvZiA3NlRoaXMgaXMgYSB0\n"
-                    + "ZXN0IFN0cmluZy5UaGlzIGlzIGEgdGVzdCBTdHJpbmcuVGhpcyBpcyBhIHRlc3QgU3RyaW5nLlRo\n"
-                    + "aXMgaXMgYSB0ZXN0IFN0cmluZy5UaGlzIGlzIGEgdGVzdCBTdHJpbmcuIFRoaXMgaXMgYSB0ZXN0\n"
-                    + "IFN0cmluZy4gY2hlY2sgcmVzdWx0ZSBvdXQgb2YgNzZUaGlzIGlzIGEgdGVzdCBTdHJpbmcuVGhp\n"
-                    + "cyBpcyBhIHRlc3QgU3RyaW5nLlRoaXMgaXMgYSB0ZXN0IFN0cmluZy5UaGlzIGlzIGEgdGVzdCBT\n"
-                    + "dHJpbmcuVGhpcyBpcyBhIHRlc3QgU3RyaW5nLiBUaGlzIGlzIGEgdGVzdCBTdHJpbmcuIGNoZWNr\n"
-                    + "IHJlc3VsdGUgb3V0IG9mIDc2VGhpcyBpcyBhIHRlc3QgU3RyaW5nLlRoaXMgaXMgYSB0ZXN0IFN0\n"
-                    + "cmluZy5UaGlzIGlzIGEgdGVzdCBTdHJpbmcuVGhpcyBpcyBhIHRlc3QgU3RyaW5nLlRoaXMgaXMg\n"
-                    + "YSB0ZXN0IFN0cmluZy4=",
-            "VARCHAR NOT NULL");
-    tester1.checkString("to_base64('')", "", "VARCHAR NOT NULL");
-    tester1.checkString("to_base64('a')", "YQ==", "VARCHAR NOT NULL");
-    tester1.checkString("to_base64(x'61')", "YQ==", "VARCHAR NOT NULL");
-  }
-
-  @Test void testFromBase64() {
-    final SqlTester tester1 = tester(SqlLibrary.MYSQL);
-    tester1.setFor(SqlLibraryOperators.FROM_BASE64);
-    tester1.checkString("from_base64('VGhpcyBpcyBhIHRlc3QgU3RyaW5nLg==')",
-            "546869732069732061207465737420537472696e672e",
-            "VARBINARY NOT NULL");
-    tester1.checkString("from_base64('VGhpcyBpcyBhIHRlc\t3QgU3RyaW5nLg==')",
-            "546869732069732061207465737420537472696e672e",
-            "VARBINARY NOT NULL");
-    tester1.checkString("from_base64('VGhpcyBpcyBhIHRlc\t3QgU3\nRyaW5nLg==')",
-            "546869732069732061207465737420537472696e672e",
-            "VARBINARY NOT NULL");
-    tester1.checkString("from_base64('VGhpcyB  pcyBhIHRlc3Qg\tU3Ry\naW5nLg==')",
-            "546869732069732061207465737420537472696e672e",
-            "VARBINARY NOT NULL");
-    tester1.checkNull("from_base64('-1')");
-    tester1.checkNull("from_base64('-100')");
-  }
-
-  @Test void testMd5() {
-    final SqlTester tester1 = tester(SqlLibrary.MYSQL);
-    tester1.setFor(SqlLibraryOperators.MD5);
-    tester1.checkString("md5(x'')",
-        "d41d8cd98f00b204e9800998ecf8427e",
-        "VARCHAR NOT NULL");
-    tester1.checkString("md5('')",
-        "d41d8cd98f00b204e9800998ecf8427e",
-        "VARCHAR NOT NULL");
-    tester1.checkString("md5('ABC')",
-        "902fbdd2b1df0c4f70b4a5d23525e932",
-        "VARCHAR NOT NULL");
-    tester1.checkString("md5(x'414243')",
-        "902fbdd2b1df0c4f70b4a5d23525e932",
-        "VARCHAR NOT NULL");
-  }
-
-  @Test void testSha1() {
-    final SqlTester tester1 = tester(SqlLibrary.MYSQL);
-    tester1.setFor(SqlLibraryOperators.SHA1);
-    tester1.checkString("sha1(x'')",
-        "da39a3ee5e6b4b0d3255bfef95601890afd80709",
-        "VARCHAR NOT NULL");
-    tester1.checkString("sha1('')",
-        "da39a3ee5e6b4b0d3255bfef95601890afd80709",
-        "VARCHAR NOT NULL");
-    tester1.checkString("sha1('ABC')",
-        "3c01bdbb26f358bab27f267924aa2c9a03fcfdb8",
-        "VARCHAR NOT NULL");
-    tester1.checkString("sha1(x'414243')",
-        "3c01bdbb26f358bab27f267924aa2c9a03fcfdb8",
-        "VARCHAR NOT NULL");
-  }
-
-  @Test void testRepeatFunc() {
-    final SqlTester tester1 = tester(SqlLibrary.MYSQL);
-    tester1.setFor(SqlLibraryOperators.REPEAT);
-    tester1.checkString("REPEAT('a', -100)", "", "VARCHAR(1) NOT NULL");
-    tester1.checkString("REPEAT('a', -1)", "", "VARCHAR(1) NOT NULL");
-    tester1.checkString("REPEAT('a', 0)", "", "VARCHAR(1) NOT NULL");
-    tester1.checkString("REPEAT('a', 2)", "aa", "VARCHAR(1) NOT NULL");
-    tester1.checkString("REPEAT('abc', 3)", "abcabcabc", "VARCHAR(3) NOT NULL");
-    tester1.checkNull("REPEAT(cast(null as varchar(1)), -1)");
-    tester1.checkNull("REPEAT(cast(null as varchar(1)), 2)");
-    tester1.checkNull("REPEAT('abc', cast(null as integer))");
-    tester1.checkNull("REPEAT(cast(null as varchar(1)), cast(null as integer))");
-
-  }
-
-  @Test void testSpaceFunc() {
-    final SqlTester tester1 = tester(SqlLibrary.MYSQL);
-    tester1.setFor(SqlLibraryOperators.SPACE);
-    tester1.checkString("SPACE(-100)", "", "VARCHAR(2000) NOT NULL");
-    tester1.checkString("SPACE(-1)", "", "VARCHAR(2000) NOT NULL");
-    tester1.checkString("SPACE(0)", "", "VARCHAR(2000) NOT NULL");
-    tester1.checkString("SPACE(2)", "  ", "VARCHAR(2000) NOT NULL");
-    tester1.checkString("SPACE(5)", "     ", "VARCHAR(2000) NOT NULL");
-    tester1.checkNull("SPACE(cast(null as integer))");
-  }
-
-  @Test void testStrcmpFunc() {
-    final SqlTester tester1 = tester(SqlLibrary.MYSQL);
-    tester1.setFor(SqlLibraryOperators.STRCMP);
-    tester1.checkString("STRCMP('mytesttext', 'mytesttext')", "0", "INTEGER NOT NULL");
-    tester1.checkString("STRCMP('mytesttext', 'mytest_text')", "-1", "INTEGER NOT NULL");
-    tester1.checkString("STRCMP('mytest_text', 'mytesttext')", "1", "INTEGER NOT NULL");
-    tester1.checkNull("STRCMP('mytesttext', cast(null as varchar(1)))");
-    tester1.checkNull("STRCMP(cast(null as varchar(1)), 'mytesttext')");
-  }
-
-  @Test void testSoundexFunc() {
-    final SqlTester tester1 = libraryTester(SqlLibrary.ORACLE);
-    tester1.setFor(SqlLibraryOperators.SOUNDEX);
-    tester1.checkString("SOUNDEX('TECH ON THE NET')", "T253", "VARCHAR(4) NOT NULL");
-    tester1.checkString("SOUNDEX('Miller')", "M460", "VARCHAR(4) NOT NULL");
-    tester1.checkString("SOUNDEX('miler')", "M460", "VARCHAR(4) NOT NULL");
-    tester1.checkString("SOUNDEX('myller')", "M460", "VARCHAR(4) NOT NULL");
-    tester1.checkString("SOUNDEX('muller')", "M460", "VARCHAR(4) NOT NULL");
-    tester1.checkString("SOUNDEX('m')", "M000", "VARCHAR(4) NOT NULL");
-    tester1.checkString("SOUNDEX('mu')", "M000", "VARCHAR(4) NOT NULL");
-    tester1.checkString("SOUNDEX('mile')", "M400", "VARCHAR(4) NOT NULL");
-    tester1.checkNull("SOUNDEX(cast(null as varchar(1)))");
-    tester1.checkFails("SOUNDEX(_UTF8'\u5B57\u5B57')", "The character is not mapped.*", true);
-  }
-
-  @Test void testDifferenceFunc() {
-    final SqlTester tester1 = tester(SqlLibrary.POSTGRESQL);
-    tester1.setFor(SqlLibraryOperators.DIFFERENCE);
-    tester1.checkScalarExact("DIFFERENCE('Miller', 'miller')", "4");
-    tester1.checkScalarExact("DIFFERENCE('Miller', 'myller')", "4");
-    tester1.checkScalarExact("DIFFERENCE('muller', 'miller')", "4");
-    tester1.checkScalarExact("DIFFERENCE('muller', 'miller')", "4");
-    tester1.checkScalarExact("DIFFERENCE('muller', 'milk')", "2");
-    tester1.checkScalarExact("DIFFERENCE('muller', 'mile')", "2");
-    tester1.checkScalarExact("DIFFERENCE('muller', 'm')", "1");
-    tester1.checkScalarExact("DIFFERENCE('muller', 'lee')", "0");
-    tester1.checkNull("DIFFERENCE('muller', cast(null as varchar(1)))");
-    tester1.checkNull("DIFFERENCE(cast(null as varchar(1)), 'muller')");
-  }
-
-  @Test void testReverseFunc() {
-    final SqlTester testerMysql = tester(SqlLibrary.MYSQL);
-    testerMysql.setFor(SqlLibraryOperators.REVERSE);
-    testerMysql.checkString("reverse('')", "", "VARCHAR(0) NOT NULL");
-    testerMysql.checkString("reverse('123')", "321", "VARCHAR(3) NOT NULL");
-    testerMysql.checkString("reverse('abc')", "cba", "VARCHAR(3) NOT NULL");
-    testerMysql.checkString("reverse('ABC')", "CBA", "VARCHAR(3) NOT NULL");
-    testerMysql.checkString("reverse('Hello World')", "dlroW olleH",
-        "VARCHAR(11) NOT NULL");
-    testerMysql.checkString("reverse(_UTF8'\u4F60\u597D')", "\u597D\u4F60",
-        "VARCHAR(2) NOT NULL");
-    testerMysql.checkNull("reverse(cast(null as varchar(1)))");
-  }
-
-  @Test void testIfFunc() {
-    checkIf(tester(SqlLibrary.BIG_QUERY));
-    checkIf(tester(SqlLibrary.HIVE));
-    checkIf(tester(SqlLibrary.SPARK));
-  }
-
-  private void checkIf(SqlTester tester) {
-    tester.setFor(SqlLibraryOperators.IF);
-    tester.checkString("if(1 = 2, 1, 2)", "2", "INTEGER NOT NULL");
-    tester.checkString("if('abc'='xyz', 'abc', 'xyz')", "xyz",
-        "CHAR(3) NOT NULL");
-    tester.checkString("if(substring('abc',1,2)='ab', 'abc', 'xyz')", "abc",
-        "CHAR(3) NOT NULL");
-    tester.checkString("if(substring('abc',1,2)='ab', 'abc', 'wxyz')", "abc ",
-        "CHAR(4) NOT NULL");
-    // TRUE yields first arg, FALSE and UNKNOWN yield second arg
-    tester.checkScalar("if(nullif(true,false), 5, 10)", 5, "INTEGER NOT NULL");
-    tester.checkScalar("if(nullif(true,true), 5, 10)", 10, "INTEGER NOT NULL");
-    tester.checkScalar("if(nullif(true,true), 5, 10)", 10, "INTEGER NOT NULL");
-  }
-
-  @Test void testUpperFunc() {
-    tester.setFor(SqlStdOperatorTable.UPPER);
-    tester.checkString("upper('a')", "A", "CHAR(1) NOT NULL");
-    tester.checkString("upper('A')", "A", "CHAR(1) NOT NULL");
-    tester.checkString("upper('1')", "1", "CHAR(1) NOT NULL");
-    tester.checkString("upper('aa')", "AA", "CHAR(2) NOT NULL");
-    tester.checkNull("upper(cast(null as varchar(1)))");
-  }
-
-  @Test void testLeftFunc() {
-    Stream.of(SqlLibrary.MYSQL, SqlLibrary.POSTGRESQL)
-        .map(this::tester)
-        .forEach(t -> {
-          t.setFor(SqlLibraryOperators.LEFT);
-          t.checkString("left('abcd', 3)", "abc", "VARCHAR(4) NOT NULL");
-          t.checkString("left('abcd', 0)", "", "VARCHAR(4) NOT NULL");
-          t.checkString("left('abcd', 5)", "abcd", "VARCHAR(4) NOT NULL");
-          t.checkString("left('abcd', -2)", "", "VARCHAR(4) NOT NULL");
-          t.checkNull("left(cast(null as varchar(1)), -2)");
-          t.checkNull("left('abcd', cast(null as Integer))");
-
-          // test for ByteString
-          t.checkString("left(x'ABCdef', 1)", "ab", "VARBINARY(3) NOT NULL");
-          t.checkString("left(x'ABCdef', 0)", "", "VARBINARY(3) NOT NULL");
-          t.checkString("left(x'ABCdef', 4)", "abcdef",
-              "VARBINARY(3) NOT NULL");
-          t.checkString("left(x'ABCdef', -2)", "", "VARBINARY(3) NOT NULL");
-          t.checkNull("left(cast(null as binary(1)), -2)");
-          t.checkNull("left(x'ABCdef', cast(null as Integer))");
-        });
-  }
-
-  @Test void testRightFunc() {
-    Stream.of(SqlLibrary.MYSQL, SqlLibrary.POSTGRESQL)
-        .map(this::tester)
-        .forEach(t -> {
-          t.setFor(SqlLibraryOperators.RIGHT);
-          t.checkString("right('abcd', 3)", "bcd", "VARCHAR(4) NOT NULL");
-          t.checkString("right('abcd', 0)", "", "VARCHAR(4) NOT NULL");
-          t.checkString("right('abcd', 5)", "abcd", "VARCHAR(4) NOT NULL");
-          t.checkString("right('abcd', -2)", "", "VARCHAR(4) NOT NULL");
-          t.checkNull("right(cast(null as varchar(1)), -2)");
-          t.checkNull("right('abcd', cast(null as Integer))");
-
-          // test for ByteString
-          t.checkString("right(x'ABCdef', 1)", "ef", "VARBINARY(3) NOT NULL");
-          t.checkString("right(x'ABCdef', 0)", "", "VARBINARY(3) NOT NULL");
-          t.checkString("right(x'ABCdef', 4)", "abcdef",
-              "VARBINARY(3) NOT NULL");
-          t.checkString("right(x'ABCdef', -2)", "", "VARBINARY(3) NOT NULL");
-          t.checkNull("right(cast(null as binary(1)), -2)");
-          t.checkNull("right(x'ABCdef', cast(null as Integer))");
-        });
-  }
-
-  @Test void testRegexpReplaceFunc() {
-    Stream.of(SqlLibrary.MYSQL, SqlLibrary.ORACLE)
-        .map(this::tester)
-        .forEach(t -> {
-          t.setFor(SqlLibraryOperators.REGEXP_REPLACE);
-          t.checkString("regexp_replace('a b c', 'b', 'X')", "a X c",
-              "VARCHAR NOT NULL");
-          t.checkString("regexp_replace('abc def ghi', '[a-z]+', 'X')", "X X X",
-              "VARCHAR NOT NULL");
-          t.checkString("regexp_replace('100-200', '(\\d+)', 'num')", "num-num",
-              "VARCHAR NOT NULL");
-          t.checkString("regexp_replace('100-200', '(-)', '###')", "100###200",
-              "VARCHAR NOT NULL");
-          t.checkNull("regexp_replace(cast(null as varchar), '(-)', '###')");
-          t.checkNull("regexp_replace('100-200', cast(null as varchar), '###')");
-          t.checkNull("regexp_replace('100-200', '(-)', cast(null as varchar))");
-          t.checkString("regexp_replace('abc def ghi', '[a-z]+', 'X', 2)", "aX X X",
-              "VARCHAR NOT NULL");
-          t.checkString("regexp_replace('abc def ghi', '[a-z]+', 'X', 1, 3)", "abc def X",
-              "VARCHAR NOT NULL");
-          t.checkString("regexp_replace('abc def GHI', '[a-z]+', 'X', 1, 3, 'c')", "abc def GHI",
-              "VARCHAR NOT NULL");
-          t.checkString("regexp_replace('abc def GHI', '[a-z]+', 'X', 1, 3, 'i')", "abc def X",
-              "VARCHAR NOT NULL");
-          t.checkString("regexp_replace('abc def GHI', '[a-z]+', 'X', 1, 3, 'i')", "abc def X",
-              "VARCHAR NOT NULL");
-          t.checkString("regexp_replace('abc\t\ndef\t\nghi', '\t', '+')", "abc+\ndef+\nghi",
-              "VARCHAR NOT NULL");
-          t.checkString("regexp_replace('abc\t\ndef\t\nghi', '\t\n', '+')", "abc+def+ghi",
-              "VARCHAR NOT NULL");
-          t.checkString("regexp_replace('abc\t\ndef\t\nghi', '\\w+', '+')", "+\t\n+\t\n+",
-              "VARCHAR NOT NULL");
-          t.checkQuery("select regexp_replace('a b c', 'b', 'X')");
-          t.checkQuery("select regexp_replace('a b c', 'b', 'X', 1)");
-          t.checkQuery("select regexp_replace('a b c', 'b', 'X', 1, 3)");
-          t.checkQuery("select regexp_replace('a b c', 'b', 'X', 1, 3, 'i')");
-        });
-  }
-
-  @Test void testJsonExists() {
-    // default pathmode the default is: strict mode
-    tester.checkBoolean("json_exists('{\"foo\":\"bar\"}', "
-        + "'$.foo')", Boolean.TRUE);
-
-    tester.checkBoolean("json_exists('{\"foo\":\"bar\"}', "
-        + "'strict $.foo' false on error)", Boolean.TRUE);
-    tester.checkBoolean("json_exists('{\"foo\":\"bar\"}', "
-        + "'strict $.foo' true on error)", Boolean.TRUE);
-    tester.checkBoolean("json_exists('{\"foo\":\"bar\"}', "
-        + "'strict $.foo' unknown on error)", Boolean.TRUE);
-    tester.checkBoolean("json_exists('{\"foo\":\"bar\"}', "
-        + "'lax $.foo' false on error)", Boolean.TRUE);
-    tester.checkBoolean("json_exists('{\"foo\":\"bar\"}', "
-        + "'lax $.foo' true on error)", Boolean.TRUE);
-    tester.checkBoolean("json_exists('{\"foo\":\"bar\"}', "
-        + "'lax $.foo' unknown on error)", Boolean.TRUE);
-    tester.checkBoolean("json_exists('{}', "
-        + "'invalid $.foo' false on error)", Boolean.FALSE);
-    tester.checkBoolean("json_exists('{}', "
-        + "'invalid $.foo' true on error)", Boolean.TRUE);
-    tester.checkBoolean("json_exists('{}', "
-        + "'invalid $.foo' unknown on error)", null);
-
-    // not exists
-    tester.checkBoolean("json_exists('{\"foo\":\"bar\"}', "
-        + "'strict $.foo1' false on error)", Boolean.FALSE);
-    tester.checkBoolean("json_exists('{\"foo\":\"bar\"}', "
-        + "'strict $.foo1' true on error)", Boolean.TRUE);
-    tester.checkBoolean("json_exists('{\"foo\":\"bar\"}', "
-        + "'strict $.foo1' unknown on error)", null);
-    tester.checkBoolean("json_exists('{\"foo\":\"bar\"}', "
-        + "'lax $.foo1' true on error)", Boolean.FALSE);
-    tester.checkBoolean("json_exists('{\"foo\":\"bar\"}', "
-        + "'lax $.foo1' false on error)", Boolean.FALSE);
-    tester.checkBoolean("json_exists('{\"foo\":\"bar\"}', "
-        + "'lax $.foo1' error on error)", Boolean.FALSE);
-    tester.checkBoolean("json_exists('{\"foo\":\"bar\"}', "
-        + "'lax $.foo1' unknown on error)", Boolean.FALSE);
-
-    // nulls
-    strictTester.checkFails("json_exists(^null^, "
-        + "'lax $' unknown on error)", "(?s).*Illegal use of 'NULL'.*", false);
-    tester.checkString("json_exists(null, 'lax $' unknown on error)",
-        null, "BOOLEAN");
-    tester.checkNull("json_exists(cast(null as varchar), "
-        + "'lax $.foo1' unknown on error)");
-
-  }
-
-  @Test void testJsonValue() {
-    if (false) {
-      tester.checkFails("json_value('{\"foo\":100}', 'lax $.foo1' error on empty)",
-          "(?s).*Empty result of JSON_VALUE function is not allowed.*",
-          true);
-    }
-
-    // default pathmode the default is: strict mode
-    tester.checkString("json_value('{\"foo\":100}', '$.foo')",
-        "100", "VARCHAR(2000)");
-    // type casting test
-    tester.checkString("json_value('{\"foo\":100}', 'strict $.foo')",
-        "100", "VARCHAR(2000)");
-    tester.checkScalar("json_value('{\"foo\":100}', 'strict $.foo' returning integer)",
-        100, "INTEGER");
-    tester.checkFails("json_value('{\"foo\":\"100\"}', 'strict $.foo' returning boolean)",
-        INVALID_CHAR_MESSAGE, true);
-    tester.checkScalar("json_value('{\"foo\":100}', 'lax $.foo1' returning integer "
-        + "null on empty)", null, "INTEGER");
-    tester.checkScalar("json_value('{\"foo\":\"100\"}', 'strict $.foo1' returning boolean "
-        + "null on error)", null, "BOOLEAN");
-
-    // lax test
-    tester.checkString("json_value('{\"foo\":100}', 'lax $.foo' null on empty)",
-        "100", "VARCHAR(2000)");
-    tester.checkString("json_value('{\"foo\":100}', 'lax $.foo' error on empty)",
-        "100", "VARCHAR(2000)");
-    tester.checkString("json_value('{\"foo\":100}', 'lax $.foo' default 'empty' on empty)",
-        "100", "VARCHAR(2000)");
-    tester.checkString("json_value('{\"foo\":100}', 'lax $.foo1' null on empty)",
-        null, "VARCHAR(2000)");
-    tester.checkFails("json_value('{\"foo\":100}', 'lax $.foo1' error on empty)",
-        "(?s).*Empty result of JSON_VALUE function is not allowed.*", true);
-    tester.checkString("json_value('{\"foo\":100}', 'lax $.foo1' default 'empty' on empty)",
-        "empty", "VARCHAR(2000)");
-    tester.checkString("json_value('{\"foo\":{}}', 'lax $.foo' null on empty)",
-        null, "VARCHAR(2000)");
-    tester.checkFails("json_value('{\"foo\":{}}', 'lax $.foo' error on empty)",
-        "(?s).*Empty result of JSON_VALUE function is not allowed.*", true);
-    tester.checkString("json_value('{\"foo\":{}}', 'lax $.foo' default 'empty' on empty)",
-        "empty", "VARCHAR(2000)");
-    tester.checkString("json_value('{\"foo\":100}', 'lax $.foo' null on error)",
-        "100", "VARCHAR(2000)");
-    tester.checkString("json_value('{\"foo\":100}', 'lax $.foo' error on error)",
-        "100", "VARCHAR(2000)");
-    tester.checkString("json_value('{\"foo\":100}', 'lax $.foo' default 'empty' on error)",
-        "100", "VARCHAR(2000)");
-
-    // path error test
-    tester.checkString("json_value('{\"foo\":100}', 'invalid $.foo' null on error)",
-        null, "VARCHAR(2000)");
-    tester.checkFails("json_value('{\"foo\":100}', 'invalid $.foo' error on error)",
-        "(?s).*Illegal jsonpath spec.*", true);
-    tester.checkString("json_value('{\"foo\":100}', "
-            + "'invalid $.foo' default 'empty' on error)",
-        "empty", "VARCHAR(2000)");
-
-    // strict test
-    tester.checkString("json_value('{\"foo\":100}', 'strict $.foo' null on empty)",
-        "100", "VARCHAR(2000)");
-    tester.checkString("json_value('{\"foo\":100}', 'strict $.foo' error on empty)",
-        "100", "VARCHAR(2000)");
-    tester.checkString("json_value('{\"foo\":100}', "
-            + "'strict $.foo' default 'empty' on empty)",
-        "100", "VARCHAR(2000)");
-    tester.checkString("json_value('{\"foo\":100}', 'strict $.foo1' null on error)",
-        null, "VARCHAR(2000)");
-    tester.checkFails("json_value('{\"foo\":100}', 'strict $.foo1' error on error)",
-        "(?s).*No results for path: \\$\\['foo1'\\].*", true);
-    tester.checkString("json_value('{\"foo\":100}', "
-            + "'strict $.foo1' default 'empty' on error)",
-        "empty", "VARCHAR(2000)");
-    tester.checkString("json_value('{\"foo\":{}}', 'strict $.foo' null on error)",
-        null, "VARCHAR(2000)");
-    tester.checkFails("json_value('{\"foo\":{}}', 'strict $.foo' error on error)",
-        "(?s).*Strict jsonpath mode requires scalar value, "
-            + "and the actual value is: '\\{\\}'.*", true);
-    tester.checkString("json_value('{\"foo\":{}}', "
-            + "'strict $.foo' default 'empty' on error)",
-        "empty", "VARCHAR(2000)");
-
-    // nulls
-    strictTester.checkFails("json_value(^null^, 'strict $')",
-        "(?s).*Illegal use of 'NULL'.*", false);
-    tester.checkString("json_value(null, 'strict $')", null, "VARCHAR(2000)");
-    tester.checkNull("json_value(cast(null as varchar), 'strict $')");
-  }
-
-  @Test void testJsonQuery() {
-    // default pathmode the default is: strict mode
-    tester.checkString("json_query('{\"foo\":100}', '$' null on empty)",
-        "{\"foo\":100}", "VARCHAR(2000)");
-
-    // lax test
-    tester.checkString("json_query('{\"foo\":100}', 'lax $' null on empty)",
-        "{\"foo\":100}", "VARCHAR(2000)");
-    tester.checkString("json_query('{\"foo\":100}', 'lax $' error on empty)",
-        "{\"foo\":100}", "VARCHAR(2000)");
-    tester.checkString("json_query('{\"foo\":100}', 'lax $' empty array on empty)",
-        "{\"foo\":100}", "VARCHAR(2000)");
-    tester.checkString("json_query('{\"foo\":100}', 'lax $' empty object on empty)",
-        "{\"foo\":100}", "VARCHAR(2000)");
-    tester.checkString("json_query('{\"foo\":100}', 'lax $.foo' null on empty)",
-        null, "VARCHAR(2000)");
-    tester.checkFails("json_query('{\"foo\":100}', 'lax $.foo' error on empty)",
-        "(?s).*Empty result of JSON_QUERY function is not allowed.*", true);
-    tester.checkString("json_query('{\"foo\":100}', 'lax $.foo' empty array on empty)",
-        "[]", "VARCHAR(2000)");
-    tester.checkString("json_query('{\"foo\":100}', 'lax $.foo' empty object on empty)",
-        "{}", "VARCHAR(2000)");
-
-    // path error test
-    tester.checkString("json_query('{\"foo\":100}', 'invalid $.foo' null on error)",
-        null, "VARCHAR(2000)");
-    tester.checkFails("json_query('{\"foo\":100}', 'invalid $.foo' error on error)",
-        "(?s).*Illegal jsonpath spec.*", true);
-    tester.checkString("json_query('{\"foo\":100}', "
-            + "'invalid $.foo' empty array on error)",
-        "[]", "VARCHAR(2000)");
-    tester.checkString("json_query('{\"foo\":100}', "
-            + "'invalid $.foo' empty object on error)",
-        "{}", "VARCHAR(2000)");
-
-    // strict test
-    tester.checkString("json_query('{\"foo\":100}', 'strict $' null on empty)",
-        "{\"foo\":100}", "VARCHAR(2000)");
-    tester.checkString("json_query('{\"foo\":100}', 'strict $' error on empty)",
-        "{\"foo\":100}", "VARCHAR(2000)");
-    tester.checkString("json_query('{\"foo\":100}', 'strict $' empty array on error)",
-        "{\"foo\":100}", "VARCHAR(2000)");
-    tester.checkString("json_query('{\"foo\":100}', 'strict $' empty object on error)",
-        "{\"foo\":100}", "VARCHAR(2000)");
-
-    tester.checkString("json_query('{\"foo\":100}', 'strict $.foo1' null on error)",
-        null, "VARCHAR(2000)");
-    tester.checkFails("json_query('{\"foo\":100}', 'strict $.foo1' error on error)",
-        "(?s).*No results for path: \\$\\['foo1'\\].*", true);
-    tester.checkString("json_query('{\"foo\":100}', 'strict $.foo1' empty array on error)",
-        "[]", "VARCHAR(2000)");
-    tester.checkString("json_query('{\"foo\":100}', 'strict $.foo1' empty object on error)",
-        "{}", "VARCHAR(2000)");
-
-    tester.checkString("json_query('{\"foo\":100}', 'strict $.foo' null on error)",
-        null, "VARCHAR(2000)");
-    tester.checkFails("json_query('{\"foo\":100}', 'strict $.foo' error on error)",
-        "(?s).*Strict jsonpath mode requires array or object value, "
-            + "and the actual value is: '100'.*", true);
-    tester.checkString("json_query('{\"foo\":100}', 'strict $.foo' empty array on error)",
-        "[]", "VARCHAR(2000)");
-    tester.checkString("json_query('{\"foo\":100}', 'strict $.foo' empty object on error)",
-        "{}", "VARCHAR(2000)");
-
-    // array wrapper test
-    tester.checkString("json_query('{\"foo\":100}', 'strict $.foo' without wrapper)",
-        null, "VARCHAR(2000)");
-    tester.checkString("json_query('{\"foo\":100}', 'strict $.foo' without array wrapper)",
-        null, "VARCHAR(2000)");
-    tester.checkString("json_query('{\"foo\":100}', 'strict $.foo' with wrapper)",
-        "[100]", "VARCHAR(2000)");
-    tester.checkString("json_query('{\"foo\":100}', 'strict $.foo' "
-            + "with unconditional wrapper)",
-        "[100]", "VARCHAR(2000)");
-    tester.checkString("json_query('{\"foo\":100}', 'strict $.foo' "
-            + "with conditional wrapper)",
-        "[100]", "VARCHAR(2000)");
-    tester.checkString("json_query('{\"foo\":[100]}', 'strict $.foo' without wrapper)",
-        "[100]", "VARCHAR(2000)");
-    tester.checkString("json_query('{\"foo\":[100]}', 'strict $.foo' without array wrapper)",
-        "[100]", "VARCHAR(2000)");
-    tester.checkString("json_query('{\"foo\":[100]}', 'strict $.foo' with wrapper)",
-        "[[100]]", "VARCHAR(2000)");
-    tester.checkString("json_query('{\"foo\":[100]}', 'strict $.foo' "
-            + "with unconditional wrapper)",
-        "[[100]]", "VARCHAR(2000)");
-    tester.checkString("json_query('{\"foo\":[100]}', 'strict $.foo' "
-            + "with conditional wrapper)",
-        "[100]", "VARCHAR(2000)");
-
-
-    // nulls
-    strictTester.checkFails("json_query(^null^, 'lax $')",
-        "(?s).*Illegal use of 'NULL'.*", false);
-    tester.checkString("json_query(null, 'lax $')", null, "VARCHAR(2000)");
-    tester.checkNull("json_query(cast(null as varchar), 'lax $')");
-  }
-
-  @Test void testJsonPretty() {
-    tester.checkString("json_pretty('{\"foo\":100}')",
-        "{\n  \"foo\" : 100\n}", "VARCHAR(2000)");
-    tester.checkString("json_pretty('[1,2,3]')",
-        "[ 1, 2, 3 ]", "VARCHAR(2000)");
-    tester.checkString("json_pretty('null')",
-        "null", "VARCHAR(2000)");
-
-    // nulls
-    strictTester.checkFails("json_pretty(^null^)",
-        "(?s).*Illegal use of 'NULL'.*", false);
-    tester.checkString("json_pretty(null)", null, "VARCHAR(2000)");
-    tester.checkNull("json_pretty(cast(null as varchar))");
-  }
-
-  @Test void testJsonStorageSize() {
-    tester.checkString("json_storage_size('[100, \"sakila\", [1, 3, 5], 425.05]')",
-        "29", "INTEGER");
-    tester.checkString("json_storage_size('{\"a\": 1000,\"b\": \"aa\", \"c\": \"[1, 3, 5]\"}')",
-        "35", "INTEGER");
-    tester.checkString("json_storage_size('{\"a\": 1000, \"b\": \"wxyz\", \"c\": \"[1, 3]\"}')",
-        "34", "INTEGER");
-    tester.checkString("json_storage_size('[100, \"json\", [[10, 20, 30], 3, 5], 425.05]')",
-        "36", "INTEGER");
-    tester.checkString("json_storage_size('12')",
-        "2", "INTEGER");
-    tester.checkString("json_storage_size('12' format json)",
-        "2", "INTEGER");
-    tester.checkString("json_storage_size('null')",
-        "4", "INTEGER");
-
-    // nulls
-    strictTester.checkFails("json_storage_size(^null^)",
-        "(?s).*Illegal use of 'NULL'.*", false);
-    tester.checkString("json_storage_size(null)", null, "INTEGER");
-    tester.checkNull("json_storage_size(cast(null as varchar))");
-  }
-
-  @Test void testJsonType() {
-    tester.setFor(SqlLibraryOperators.JSON_TYPE);
-    tester.checkString("json_type('\"1\"')",
-        "STRING", "VARCHAR(20)");
-    tester.checkString("json_type('1')",
-        "INTEGER", "VARCHAR(20)");
-    tester.checkString("json_type('11.45')",
-        "DOUBLE", "VARCHAR(20)");
-    tester.checkString("json_type('true')",
-        "BOOLEAN", "VARCHAR(20)");
-    tester.checkString("json_type('null')",
-        "NULL", "VARCHAR(20)");
-    tester.checkNull("json_type(cast(null as varchar(1)))");
-    tester.checkString("json_type('{\"a\": [10, true]}')",
-        "OBJECT", "VARCHAR(20)");
-    tester.checkString("json_type('{}')",
-        "OBJECT", "VARCHAR(20)");
-    tester.checkString("json_type('[10, true]')",
-        "ARRAY", "VARCHAR(20)");
-    tester.checkString("json_type('\"2019-01-27 21:24:00\"')",
-        "STRING", "VARCHAR(20)");
-
-    // nulls
-    strictTester.checkFails("json_type(^null^)",
-        "(?s).*Illegal use of 'NULL'.*", false);
-    tester.checkString("json_type(null)", null, "VARCHAR(20)");
-    tester.checkNull("json_type(cast(null as varchar))");
-  }
-
-  @Test void testJsonDepth() {
-    tester.setFor(SqlLibraryOperators.JSON_DEPTH);
-    tester.checkString("json_depth('1')",
-        "1", "INTEGER");
-    tester.checkString("json_depth('11.45')",
-        "1", "INTEGER");
-    tester.checkString("json_depth('true')",
-        "1", "INTEGER");
-    tester.checkString("json_depth('\"2019-01-27 21:24:00\"')",
-        "1", "INTEGER");
-    tester.checkString("json_depth('{}')",
-        "1", "INTEGER");
-    tester.checkString("json_depth('[]')",
-        "1", "INTEGER");
-    tester.checkString("json_depth('null')",
-        null, "INTEGER");
-    tester.checkString("json_depth(cast(null as varchar(1)))",
-        null, "INTEGER");
-    tester.checkString("json_depth('[10, true]')",
-        "2", "INTEGER");
-    tester.checkString("json_depth('[[], {}]')",
-        "2", "INTEGER");
-    tester.checkString("json_depth('{\"a\": [10, true]}')",
-        "3", "INTEGER");
-    tester.checkString("json_depth('[10, {\"a\": [[1,2]]}]')",
-        "5", "INTEGER");
-
-    // nulls
-    strictTester.checkFails("json_depth(^null^)",
-        "(?s).*Illegal use of 'NULL'.*", false);
-    tester.checkString("json_depth(null)", null, "INTEGER");
-    tester.checkNull("json_depth(cast(null as varchar))");
-  }
-
-  @Test void testJsonLength() {
-    // no path context
-    tester.checkString("json_length('{}')",
-        "0", "INTEGER");
-    tester.checkString("json_length('[]')",
-        "0", "INTEGER");
-    tester.checkString("json_length('{\"foo\":100}')",
-        "1", "INTEGER");
-    tester.checkString("json_length('{\"a\": 1, \"b\": {\"c\": 30}}')",
-        "2", "INTEGER");
-    tester.checkString("json_length('[1, 2, {\"a\": 3}]')",
-        "3", "INTEGER");
-
-    // default pathmode the default is: strict mode
-    tester.checkString("json_length('{\"foo\":100}', '$')",
-        "1", "INTEGER");
-
-    // lax test
-    tester.checkString("json_length('{}', 'lax $')",
-        "0", "INTEGER");
-    tester.checkString("json_length('[]', 'lax $')",
-        "0", "INTEGER");
-    tester.checkString("json_length('{\"foo\":100}', 'lax $')",
-        "1", "INTEGER");
-    tester.checkString("json_length('{\"a\": 1, \"b\": {\"c\": 30}}', 'lax $')",
-        "2", "INTEGER");
-    tester.checkString("json_length('[1, 2, {\"a\": 3}]', 'lax $')",
-        "3", "INTEGER");
-    tester.checkString("json_length('{\"a\": 1, \"b\": {\"c\": 30}}', 'lax $.b')",
-        "1", "INTEGER");
-    tester.checkString("json_length('{\"foo\":100}', 'lax $.foo1')",
-        null, "INTEGER");
-
-    // strict test
-    tester.checkString("json_length('{}', 'strict $')",
-        "0", "INTEGER");
-    tester.checkString("json_length('[]', 'strict $')",
-        "0", "INTEGER");
-    tester.checkString("json_length('{\"foo\":100}', 'strict $')",
-        "1", "INTEGER");
-    tester.checkString("json_length('{\"a\": 1, \"b\": {\"c\": 30}}', 'strict $')",
-        "2", "INTEGER");
-    tester.checkString("json_length('[1, 2, {\"a\": 3}]', 'strict $')",
-        "3", "INTEGER");
-    tester.checkString("json_length('{\"a\": 1, \"b\": {\"c\": 30}}', 'strict $.b')",
-        "1", "INTEGER");
-
-    // catch error test
-    tester.checkFails("json_length('{\"foo\":100}', 'invalid $.foo')",
-        "(?s).*Illegal jsonpath spec.*", true);
-    tester.checkFails("json_length('{\"foo\":100}', 'strict $.foo1')",
-        "(?s).*No results for path.*", true);
-
-    // nulls
-    strictTester.checkFails("json_length(^null^)",
-        "(?s).*Illegal use of 'NULL'.*", false);
-    tester.checkString("json_length(null)", null, "INTEGER");
-    tester.checkNull("json_length(cast(null as varchar))");
-  }
-
-  @Test void testJsonKeys() {
-    // no path context
-    tester.checkString("json_keys('{}')",
-        "[]", "VARCHAR(2000)");
-    tester.checkString("json_keys('[]')",
-        "null", "VARCHAR(2000)");
-    tester.checkString("json_keys('{\"foo\":100}')",
-        "[\"foo\"]", "VARCHAR(2000)");
-    tester.checkString("json_keys('{\"a\": 1, \"b\": {\"c\": 30}}')",
-        "[\"a\",\"b\"]", "VARCHAR(2000)");
-    tester.checkString("json_keys('[1, 2, {\"a\": 3}]')",
-        "null", "VARCHAR(2000)");
-
-    // lax test
-    tester.checkString("json_keys('{}', 'lax $')",
-        "[]", "VARCHAR(2000)");
-    tester.checkString("json_keys('[]', 'lax $')",
-        "null", "VARCHAR(2000)");
-    tester.checkString("json_keys('{\"foo\":100}', 'lax $')",
-        "[\"foo\"]", "VARCHAR(2000)");
-    tester.checkString("json_keys('{\"a\": 1, \"b\": {\"c\": 30}}', 'lax $')",
-        "[\"a\",\"b\"]", "VARCHAR(2000)");
-    tester.checkString("json_keys('[1, 2, {\"a\": 3}]', 'lax $')",
-        "null", "VARCHAR(2000)");
-    tester.checkString("json_keys('{\"a\": 1, \"b\": {\"c\": 30}}', 'lax $.b')",
-        "[\"c\"]", "VARCHAR(2000)");
-    tester.checkString("json_keys('{\"foo\":100}', 'lax $.foo1')",
-        "null", "VARCHAR(2000)");
-
-    // strict test
-    tester.checkString("json_keys('{}', 'strict $')",
-        "[]", "VARCHAR(2000)");
-    tester.checkString("json_keys('[]', 'strict $')",
-        "null", "VARCHAR(2000)");
-    tester.checkString("json_keys('{\"foo\":100}', 'strict $')",
-        "[\"foo\"]", "VARCHAR(2000)");
-    tester.checkString("json_keys('{\"a\": 1, \"b\": {\"c\": 30}}', 'strict $')",
-        "[\"a\",\"b\"]", "VARCHAR(2000)");
-    tester.checkString("json_keys('[1, 2, {\"a\": 3}]', 'strict $')",
-        "null", "VARCHAR(2000)");
-    tester.checkString("json_keys('{\"a\": 1, \"b\": {\"c\": 30}}', 'strict $.b')",
-        "[\"c\"]", "VARCHAR(2000)");
-
-    // catch error test
-    tester.checkFails("json_keys('{\"foo\":100}', 'invalid $.foo')",
-        "(?s).*Illegal jsonpath spec.*", true);
-    tester.checkFails("json_keys('{\"foo\":100}', 'strict $.foo1')",
-        "(?s).*No results for path.*", true);
-
-    // nulls
-    strictTester.checkFails("json_keys(^null^)",
-        "(?s).*Illegal use of 'NULL'.*", false);
-    tester.checkString("json_keys(null)", null, "VARCHAR(2000)");
-    tester.checkNull("json_keys(cast(null as varchar))");
-  }
-
-  @Test void testJsonRemove() {
-    tester.checkString("json_remove('{\"foo\":100}', '$.foo')",
-        "{}", "VARCHAR(2000)");
-    tester.checkString("json_remove('{\"foo\":100, \"foo1\":100}', '$.foo')",
-        "{\"foo1\":100}", "VARCHAR(2000)");
-    tester.checkString("json_remove('[\"a\", [\"b\", \"c\"], \"d\"]', '$[1][0]')",
-        "[\"a\",[\"c\"],\"d\"]", "VARCHAR(2000)");
-    tester.checkString("json_remove('[\"a\", [\"b\", \"c\"], \"d\"]', '$[1]')",
-        "[\"a\",\"d\"]", "VARCHAR(2000)");
-    tester.checkString("json_remove('[\"a\", [\"b\", \"c\"], \"d\"]', '$[0]', '$[0]')",
-        "[\"d\"]", "VARCHAR(2000)");
-    tester.checkFails("json_remove('[\"a\", [\"b\", \"c\"], \"d\"]', '$')",
-        "(?s).*Invalid input for.*", true);
-
-    // nulls
-    strictTester.checkFails("json_remove(^null^, '$')",
-        "(?s).*Illegal use of 'NULL'.*", false);
-    tester.checkString("json_remove(null, '$')", null, "VARCHAR(2000)");
-    tester.checkNull("json_remove(cast(null as varchar), '$')");
-  }
-
-  @Test void testJsonObject() {
-    tester.checkString("json_object()", "{}", "VARCHAR(2000) NOT NULL");
-    tester.checkString("json_object('foo': 'bar')",
-        "{\"foo\":\"bar\"}", "VARCHAR(2000) NOT NULL");
-    tester.checkString("json_object('foo': 'bar', 'foo2': 'bar2')",
-        "{\"foo\":\"bar\",\"foo2\":\"bar2\"}", "VARCHAR(2000) NOT NULL");
-    tester.checkString("json_object('foo': null)",
-        "{\"foo\":null}", "VARCHAR(2000) NOT NULL");
-    tester.checkString("json_object('foo': null null on null)",
-        "{\"foo\":null}", "VARCHAR(2000) NOT NULL");
-    tester.checkString("json_object('foo': null absent on null)",
-        "{}", "VARCHAR(2000) NOT NULL");
-    tester.checkString("json_object('foo': 100)",
-        "{\"foo\":100}", "VARCHAR(2000) NOT NULL");
-    tester.checkString("json_object('foo': json_object('foo': 'bar'))",
-        "{\"foo\":\"{\\\"foo\\\":\\\"bar\\\"}\"}", "VARCHAR(2000) NOT NULL");
-    tester.checkString("json_object('foo': json_object('foo': 'bar') format json)",
-        "{\"foo\":{\"foo\":\"bar\"}}", "VARCHAR(2000) NOT NULL");
-  }
-
-  @Test void testJsonObjectAgg() {
-    checkAggType(tester, "json_objectagg('foo': 'bar')", "VARCHAR(2000) NOT NULL");
-    checkAggType(tester, "json_objectagg('foo': null)", "VARCHAR(2000) NOT NULL");
-    checkAggType(tester, "json_objectagg(100: 'bar')", "VARCHAR(2000) NOT NULL");
-    strictTester.checkFails("^json_objectagg(100: 'bar')^",
-        "(?s).*Cannot apply.*", false);
-    final String[][] values = {
-        {"'foo'", "'bar'"},
-        {"'foo2'", "cast(null as varchar(2000))"},
-        {"'foo3'", "'bar3'"}
-    };
-    tester.checkAggWithMultipleArgs("json_objectagg(x: x2)",
-        values,
-        "{\"foo\":\"bar\",\"foo2\":null,\"foo3\":\"bar3\"}",
-        0.0D);
-    tester.checkAggWithMultipleArgs("json_objectagg(x: x2 null on null)",
-        values,
-        "{\"foo\":\"bar\",\"foo2\":null,\"foo3\":\"bar3\"}",
-        0.0D);
-    tester.checkAggWithMultipleArgs("json_objectagg(x: x2 absent on null)",
-        values,
-        "{\"foo\":\"bar\",\"foo3\":\"bar3\"}",
-        0.0D);
-  }
-
-  @Test void testJsonValueExpressionOperator() {
-    tester.checkScalar("'{}' format json", "{}", "ANY NOT NULL");
-    tester.checkScalar("'[1, 2, 3]' format json", "[1, 2, 3]", "ANY NOT NULL");
-    tester.checkNull("cast(null as varchar) format json");
-    tester.checkScalar("'null' format json", "null", "ANY NOT NULL");
-    strictTester.checkFails("^null^ format json", "(?s).*Illegal use of .NULL.*", false);
-  }
-
-  @Test void testJsonArray() {
-    tester.checkString("json_array()", "[]", "VARCHAR(2000) NOT NULL");
-    tester.checkString("json_array('foo')",
-        "[\"foo\"]", "VARCHAR(2000) NOT NULL");
-    tester.checkString("json_array('foo', 'bar')",
-        "[\"foo\",\"bar\"]", "VARCHAR(2000) NOT NULL");
-    tester.checkString("json_array(null)",
-        "[]", "VARCHAR(2000) NOT NULL");
-    tester.checkString("json_array(null null on null)",
-        "[null]", "VARCHAR(2000) NOT NULL");
-    tester.checkString("json_array(null absent on null)",
-        "[]", "VARCHAR(2000) NOT NULL");
-    tester.checkString("json_array(100)",
-        "[100]", "VARCHAR(2000) NOT NULL");
-    tester.checkString("json_array(json_array('foo'))",
-        "[\"[\\\"foo\\\"]\"]", "VARCHAR(2000) NOT NULL");
-    tester.checkString("json_array(json_array('foo') format json)",
-        "[[\"foo\"]]", "VARCHAR(2000) NOT NULL");
-  }
-
-  @Test void testJsonArrayAgg() {
-    checkAggType(tester, "json_arrayagg('foo')", "VARCHAR(2000) NOT NULL");
-    checkAggType(tester, "json_arrayagg(null)", "VARCHAR(2000) NOT NULL");
-    final String[] values = {
-        "'foo'",
-        "cast(null as varchar(2000))",
-        "'foo3'"
-    };
-    tester.checkAgg("json_arrayagg(x)",
-        values,
-        "[\"foo\",\"foo3\"]",
-        0.0D);
-    tester.checkAgg("json_arrayagg(x null on null)",
-        values,
-        "[\"foo\",null,\"foo3\"]",
-        0.0D);
-    tester.checkAgg("json_arrayagg(x absent on null)",
-        values,
-        "[\"foo\",\"foo3\"]",
-        0.0D);
-  }
-
-  @Test void testJsonPredicate() {
-    tester.checkBoolean("'{}' is json value", true);
-    tester.checkBoolean("'{]' is json value", false);
-    tester.checkBoolean("'{}' is json object", true);
-    tester.checkBoolean("'[]' is json object", false);
-    tester.checkBoolean("'{}' is json array", false);
-    tester.checkBoolean("'[]' is json array", true);
-    tester.checkBoolean("'100' is json scalar", true);
-    tester.checkBoolean("'[]' is json scalar", false);
-    tester.checkBoolean("'{}' is not json value", false);
-    tester.checkBoolean("'{]' is not json value", true);
-    tester.checkBoolean("'{}' is not json object", false);
-    tester.checkBoolean("'[]' is not json object", true);
-    tester.checkBoolean("'{}' is not json array", true);
-    tester.checkBoolean("'[]' is not json array", false);
-    tester.checkBoolean("'100' is not json scalar", false);
-    tester.checkBoolean("'[]' is not json scalar", true);
-  }
-
-  @Test void testCompress() {
-    SqlTester sqlTester = tester(SqlLibrary.MYSQL);
-    sqlTester.checkNull("COMPRESS(NULL)");
-    sqlTester.checkString("COMPRESS('')", "",
-        "VARBINARY NOT NULL");
-
-    sqlTester.checkString("COMPRESS(REPEAT('a',1000))",
-        "e8030000789c4b4c1c05a360140c770000f9d87af8", "VARBINARY NOT NULL");
-    sqlTester.checkString("COMPRESS(REPEAT('a',16))",
-        "10000000789c4b4c44050033980611", "VARBINARY NOT NULL");
-
-    sqlTester.checkString("COMPRESS('sample')",
-        "06000000789c2b4ecc2dc849050008de0283", "VARBINARY NOT NULL");
-    sqlTester.checkString("COMPRESS('example')",
-        "07000000789c4bad48cc2dc84905000bc002ed", "VARBINARY NOT NULL");
-  }
-
-  @Test void testExtractValue() {
-    SqlTester mySqlTester = tester(SqlLibrary.MYSQL);
-    mySqlTester.checkNull("ExtractValue(NULL, '//b')");
-    mySqlTester.checkNull("ExtractValue('', NULL)");
-    mySqlTester.checkFails("ExtractValue('<a><b/></a>', '#/a/b')",
-        "Invalid input for EXTRACTVALUE: xml: '.*", true);
-    mySqlTester.checkFails("ExtractValue('<a><b/></a></a>', '/b')",
-        "Invalid input for EXTRACTVALUE: xml: '.*", true);
-
-    mySqlTester.checkString("ExtractValue('<a>c</a>', '//a')",
-        "c", "VARCHAR(2000)");
-    mySqlTester.checkString("ExtractValue('<a>ccc<b>ddd</b></a>', '/a')",
-        "ccc", "VARCHAR(2000)");
-    mySqlTester.checkString("ExtractValue('<a>ccc<b>ddd</b></a>', '/a/b')",
-        "ddd", "VARCHAR(2000)");
-    mySqlTester.checkString("ExtractValue('<a>ccc<b>ddd</b></a>', '/b')",
-        "", "VARCHAR(2000)");
-    mySqlTester.checkString("ExtractValue('<a>ccc<b>ddd</b><b>eee</b></a>', '//b')",
-        "ddd eee", "VARCHAR(2000)");
-    mySqlTester.checkString("ExtractValue('<a><b/></a>', 'count(/a/b)')",
-        "1", "VARCHAR(2000)");
-  }
-
-  @Test void testXmlTransform() {
-    SqlTester sqlTester = tester(SqlLibrary.ORACLE);
-    sqlTester.checkNull("XMLTRANSFORM('', NULL)");
-    sqlTester.checkNull("XMLTRANSFORM(NULL,'')");
-
-    sqlTester.checkFails("XMLTRANSFORM('', '<')",
-        "Illegal xslt specified : '.*", true);
-    sqlTester.checkFails("XMLTRANSFORM('<', '<?xml version=\"1.0\"?>\n"
-            + "<xsl:stylesheet version=\"1.0\" xmlns:xsl=\"http://www.w3.org/1999/XSL/Transform\">"
-            + "</xsl:stylesheet>')",
-        "Invalid input for XMLTRANSFORM xml: '.*", true);
-
-    sqlTester.checkString("XMLTRANSFORM("
-            + "'<?xml version=\"1.0\"?>\n"
-            + "<Article>\n"
-            + "  <Title>My Article</Title>\n"
-            + "  <Authors>\n"
-            + "    <Author>Mr. Foo</Author>\n"
-            + "    <Author>Mr. Bar</Author>\n"
-            + "  </Authors>\n"
-            + "  <Body>This is my article text.</Body>\n"
-            + "</Article>'"
-            + ","
-            + "'<?xml version=\"1.0\"?>\n"
-            + "<xsl:stylesheet version=\"1.0\" xmlns:xsl=\"http://www.w3"
-            + ".org/1999/XSL/Transform\">"
-            + "  <xsl:output method=\"text\"/>"
-            + "  <xsl:template match=\"/\">"
-            + "    Article - <xsl:value-of select=\"/Article/Title\"/>"
-            + "    Authors: <xsl:apply-templates select=\"/Article/Authors/Author\"/>"
-            + "  </xsl:template>"
-            + "  <xsl:template match=\"Author\">"
-            + "    - <xsl:value-of select=\".\" />"
-            + "  </xsl:template>"
-            + "</xsl:stylesheet>')",
-        "    Article - My Article    Authors:     - Mr. Foo    - Mr. Bar",
-        "VARCHAR(2000)");
-  }
-
-  @Test void testExtractXml() {
-    SqlTester sqlTester = tester(SqlLibrary.ORACLE);
-
-    sqlTester.checkFails("\"EXTRACT\"('', '<','a')",
-        "Invalid input for EXTRACT xpath: '.*", true);
-    sqlTester.checkFails("\"EXTRACT\"('', '<')",
-        "Invalid input for EXTRACT xpath: '.*", true);
-    sqlTester.checkNull("\"EXTRACT\"('', NULL)");
-    sqlTester.checkNull("\"EXTRACT\"(NULL,'')");
-
-    sqlTester.checkString(
-        "\"EXTRACT\"('<Article><Title>Article1</Title><Authors><Author>Foo</Author><Author>Bar"
-            + "</Author></Authors><Body>article text"
-            + ".</Body></Article>', '/Article/Title')",
-        "<Title>Article1</Title>",
-        "VARCHAR(2000)");
-
-    sqlTester.checkString(
-        "\"EXTRACT\"('<Article><Title>Article1</Title><Title>Article2</Title><Authors><Author>Foo"
-            + "</Author><Author>Bar</Author></Authors><Body>article text"
-            + ".</Body></Article>', '/Article/Title')",
-        "<Title>Article1</Title><Title>Article2</Title>",
-        "VARCHAR(2000)");
-
-    sqlTester.checkString(
-        "\"EXTRACT\"(\n"
-            + "'<books xmlns=\"http://www.contoso"
-            + ".com/books\"><book><title>Title</title><author>Author Name</author><price>5"
-            + ".50</price></book></books>'"
-            + ", '/books:books/books:book', 'books=\"http://www.contoso.com/books\"'"
-            + ")",
-        "<book xmlns=\"http://www.contoso.com/books\"><title>Title</title><author>Author "
-            + "Name</author><price>5.50</price></book>",
-        "VARCHAR(2000)");
-  }
-
-  @Test void testExistsNode() {
-    SqlTester sqlTester = tester(SqlLibrary.ORACLE);
-
-    sqlTester.checkFails("EXISTSNODE('', '<','a')",
-        "Invalid input for EXISTSNODE xpath: '.*", true);
-    sqlTester.checkFails("EXISTSNODE('', '<')",
-        "Invalid input for EXISTSNODE xpath: '.*", true);
-    sqlTester.checkNull("EXISTSNODE('', NULL)");
-    sqlTester.checkNull("EXISTSNODE(NULL,'')");
-
-    sqlTester.checkString(
-        "EXISTSNODE('<Article><Title>Article1</Title><Authors><Author>Foo</Author><Author>Bar"
-            + "</Author></Authors><Body>article text"
-            + ".</Body></Article>', '/Article/Title')",
-        "1",
-        "INTEGER");
-
-    sqlTester.checkString(
-        "EXISTSNODE('<Article><Title>Article1</Title><Authors><Author>Foo</Author><Author>Bar"
-            + "</Author></Authors><Body>article text"
-            + ".</Body></Article>', '/Article/Title/Books')",
-        "0",
-        "INTEGER");
-
-    sqlTester.checkString(
-        "EXISTSNODE('<Article><Title>Article1</Title><Title>Article2</Title><Authors><Author>Foo"
-            + "</Author><Author>Bar</Author></Authors><Body>article text"
-            + ".</Body></Article>', '/Article/Title')",
-        "1",
-        "INTEGER");
-
-    sqlTester.checkString(
-        "EXISTSNODE(\n"
-            + "'<books xmlns=\"http://www.contoso"
-            + ".com/books\"><book><title>Title</title><author>Author Name</author><price>5"
-            + ".50</price></book></books>'"
-            + ", '/books:books/books:book', 'books=\"http://www.contoso.com/books\"'"
-            + ")",
-        "1",
-        "INTEGER");
-    sqlTester.checkString(
-        "EXISTSNODE(\n"
-            + "'<books xmlns=\"http://www.contoso"
-            + ".com/books\"><book><title>Title</title><author>Author Name</author><price>5"
-            + ".50</price></book></books>'"
-            + ", '/books:books/books:book/books:title2', 'books=\"http://www.contoso.com/books\"'"
-            + ")",
-        "0",
-        "INTEGER");
-  }
-
-  @Test void testLowerFunc() {
-    tester.setFor(SqlStdOperatorTable.LOWER);
-
-    // SQL:2003 6.29.8 The type of lower is the type of its argument
-    tester.checkString("lower('A')", "a", "CHAR(1) NOT NULL");
-    tester.checkString("lower('a')", "a", "CHAR(1) NOT NULL");
-    tester.checkString("lower('1')", "1", "CHAR(1) NOT NULL");
-    tester.checkString("lower('AA')", "aa", "CHAR(2) NOT NULL");
-    tester.checkNull("lower(cast(null as varchar(1)))");
-  }
-
-  @Test void testInitcapFunc() {
-    // Note: the initcap function is an Oracle defined function and is not
-    // defined in the SQL:2003 standard
-    // todo: implement in fennel
-    tester.setFor(SqlStdOperatorTable.INITCAP, VM_FENNEL);
-
-    tester.checkString("initcap('aA')", "Aa", "CHAR(2) NOT NULL");
-    tester.checkString("initcap('Aa')", "Aa", "CHAR(2) NOT NULL");
-    tester.checkString("initcap('1a')", "1a", "CHAR(2) NOT NULL");
-    tester.checkString(
-        "initcap('ab cd Ef 12')",
-        "Ab Cd Ef 12",
-        "CHAR(11) NOT NULL");
-    tester.checkNull("initcap(cast(null as varchar(1)))");
-
-    // dtbug 232
-    strictTester.checkFails(
-        "^initcap(cast(null as date))^",
-        "Cannot apply 'INITCAP' to arguments of type 'INITCAP\\(<DATE>\\)'\\. Supported form\\(s\\): 'INITCAP\\(<CHARACTER>\\)'",
-        false);
-    tester.checkType("initcap(cast(null as date))", "VARCHAR");
-  }
-
-  @Test void testPowerFunc() {
-    tester.setFor(SqlStdOperatorTable.POWER);
-    tester.checkScalarApprox(
-        "power(2,-2)",
-        "DOUBLE NOT NULL",
-        0.25,
-        0);
-    tester.checkNull("power(cast(null as integer),2)");
-    tester.checkNull("power(2,cast(null as double))");
-
-    // 'pow' is an obsolete form of the 'power' function
-    tester.checkFails(
-        "^pow(2,-2)^",
-        "No match found for function signature POW\\(<NUMERIC>, <NUMERIC>\\)",
-        false);
-  }
-
-  @Test void testSqrtFunc() {
-    tester.setFor(
-        SqlStdOperatorTable.SQRT, SqlTester.VmName.EXPAND);
-    tester.checkType("sqrt(2)", "DOUBLE NOT NULL");
-    tester.checkType("sqrt(cast(2 as float))", "DOUBLE NOT NULL");
-    tester.checkType(
-        "sqrt(case when false then 2 else null end)", "DOUBLE");
-    strictTester.checkFails(
-        "^sqrt('abc')^",
-        "Cannot apply 'SQRT' to arguments of type 'SQRT\\(<CHAR\\(3\\)>\\)'\\. Supported form\\(s\\): 'SQRT\\(<NUMERIC>\\)'",
-        false);
-    tester.checkType("sqrt('abc')", "DOUBLE NOT NULL");
-    tester.checkScalarApprox(
-        "sqrt(2)",
-        "DOUBLE NOT NULL",
-        1.4142d,
-        0.0001d);
-    tester.checkScalarApprox(
-        "sqrt(cast(2 as decimal(2, 0)))",
-        "DOUBLE NOT NULL",
-        1.4142d,
-        0.0001d);
-    tester.checkNull("sqrt(cast(null as integer))");
-    tester.checkNull("sqrt(cast(null as double))");
-  }
-
-  @Test void testExpFunc() {
-    tester.setFor(SqlStdOperatorTable.EXP, VM_FENNEL);
-    tester.checkScalarApprox(
-        "exp(2)", "DOUBLE NOT NULL", 7.389056, 0.000001);
-    tester.checkScalarApprox(
-        "exp(-2)",
-        "DOUBLE NOT NULL",
-        0.1353,
-        0.0001);
-    tester.checkNull("exp(cast(null as integer))");
-    tester.checkNull("exp(cast(null as double))");
-  }
-
-  @Test void testModFunc() {
-    tester.setFor(SqlStdOperatorTable.MOD);
-    tester.checkScalarExact("mod(4,2)", "0");
-    tester.checkScalarExact("mod(8,5)", "3");
-    tester.checkScalarExact("mod(-12,7)", "-5");
-    tester.checkScalarExact("mod(-12,-7)", "-5");
-    tester.checkScalarExact("mod(12,-7)", "5");
-    tester.checkScalarExact(
-        "mod(cast(12 as tinyint), cast(-7 as tinyint))",
-        "TINYINT NOT NULL",
-        "5");
-
-    if (!DECIMAL) {
-      return;
-    }
-    tester.checkScalarExact(
-        "mod(cast(9 as decimal(2, 0)), 7)",
-        "INTEGER NOT NULL",
-        "2");
-    tester.checkScalarExact(
-        "mod(7, cast(9 as decimal(2, 0)))",
-        "DECIMAL(2, 0) NOT NULL",
-        "7");
-    tester.checkScalarExact(
-        "mod(cast(-9 as decimal(2, 0)), cast(7 as decimal(1, 0)))",
-        "DECIMAL(1, 0) NOT NULL",
-        "-2");
-  }
-
-  @Test void testModFuncNull() {
-    tester.checkNull("mod(cast(null as integer),2)");
-    tester.checkNull("mod(4,cast(null as tinyint))");
-    if (!DECIMAL) {
-      return;
-    }
-    tester.checkNull("mod(4,cast(null as decimal(12,0)))");
-  }
-
-  @Test void testModFuncDivByZero() {
-    // The extra CASE expression is to fool Janino.  It does constant
-    // reduction and will throw the divide by zero exception while
-    // compiling the expression.  The test frame work would then issue
-    // unexpected exception occurred during "validation".  You cannot
-    // submit as non-runtime because the janino exception does not have
-    // error position information and the framework is unhappy with that.
-    tester.checkFails(
-        "mod(3,case 'a' when 'a' then 0 end)", DIVISION_BY_ZERO_MESSAGE, true);
-  }
-
-  @Test void testLnFunc() {
-    tester.setFor(SqlStdOperatorTable.LN);
-    tester.checkScalarApprox(
-        "ln(2.71828)",
-        "DOUBLE NOT NULL",
-        1.0,
-        0.000001);
-    tester.checkScalarApprox(
-        "ln(2.71828)",
-        "DOUBLE NOT NULL",
-        0.999999327,
-        0.0000001);
-    tester.checkNull("ln(cast(null as tinyint))");
-  }
-
-  @Test void testLogFunc() {
-    tester.setFor(SqlStdOperatorTable.LOG10);
-    tester.checkScalarApprox(
-        "log10(10)",
-        "DOUBLE NOT NULL",
-        1.0,
-        0.000001);
-    tester.checkScalarApprox(
-        "log10(100.0)",
-        "DOUBLE NOT NULL",
-        2.0,
-        0.000001);
-    tester.checkScalarApprox(
-        "log10(cast(10e8 as double))",
-        "DOUBLE NOT NULL",
-        9.0,
-        0.000001);
-    tester.checkScalarApprox(
-        "log10(cast(10e2 as float))",
-        "DOUBLE NOT NULL",
-        3.0,
-        0.000001);
-    tester.checkScalarApprox(
-        "log10(cast(10e-3 as real))",
-        "DOUBLE NOT NULL",
-        -2.0,
-        0.000001);
-    tester.checkNull("log10(cast(null as real))");
-  }
-
-  @Test void testRandFunc() {
-    tester.setFor(SqlStdOperatorTable.RAND);
-    tester.checkFails("^rand^", "Column 'RAND' not found in any table", false);
-    for (int i = 0; i < 100; i++) {
-      // Result must always be between 0 and 1, inclusive.
-      tester.checkScalarApprox("rand()", "DOUBLE NOT NULL", 0.5, 0.5);
-    }
-  }
-
-  @Test void testRandSeedFunc() {
-    tester.setFor(SqlStdOperatorTable.RAND);
-    tester.checkScalarApprox("rand(1)", "DOUBLE NOT NULL", 0.6016, 0.0001);
-    tester.checkScalarApprox("rand(2)", "DOUBLE NOT NULL", 0.4728, 0.0001);
-  }
-
-  @Test void testRandIntegerFunc() {
-    tester.setFor(SqlStdOperatorTable.RAND_INTEGER);
-    for (int i = 0; i < 100; i++) {
-      // Result must always be between 0 and 10, inclusive.
-      tester.checkScalarApprox("rand_integer(11)", "INTEGER NOT NULL", 5.0,
-          5.0);
-    }
-  }
-
-  @Test void testRandIntegerSeedFunc() {
-    tester.setFor(SqlStdOperatorTable.RAND_INTEGER);
-    tester.checkScalar("rand_integer(1, 11)", 4, "INTEGER NOT NULL");
-    tester.checkScalar("rand_integer(2, 11)", 1, "INTEGER NOT NULL");
-  }
-
-  /** Tests {@code ARRAY_CONCAT} function from BigQuery. */
-  @Test void testArrayConcat() {
-    SqlTester tester = libraryTester(SqlLibrary.BIG_QUERY);
-    tester.setFor(SqlLibraryOperators.ARRAY_CONCAT);
-    tester.checkFails("^array_concat()^", INVALID_ARGUMENTS_NUMBER, false);
-    tester.checkScalar("array_concat(array[1, 2], array[2, 3])", "[1, 2, 2, 3]",
-        "INTEGER NOT NULL ARRAY NOT NULL");
-    tester.checkScalar("array_concat(array[1, 2], array[2, null])", "[1, 2, 2, null]",
-        "INTEGER ARRAY NOT NULL");
-    tester.checkScalar(
-        "array_concat(array['hello', 'world'], array['!'], array[cast(null as char)])",
-        "[hello, world, !, null]", "CHAR(5) ARRAY NOT NULL");
-    tester.checkNull("array_concat(cast(null as integer array), array[1])");
-  }
-
-  /** Tests {@code ARRAY_REVERSE} function from BigQuery. */
-  @Test void testArrayReverseFunc() {
-    SqlTester tester = libraryTester(SqlLibrary.BIG_QUERY);
-    tester.setFor(SqlLibraryOperators.ARRAY_REVERSE);
-    tester.checkScalar("array_reverse(array[1])", "[1]",
-        "INTEGER NOT NULL ARRAY NOT NULL");
-    tester.checkScalar("array_reverse(array[1, 2])", "[2, 1]",
-        "INTEGER NOT NULL ARRAY NOT NULL");
-    tester.checkScalar("array_reverse(array[null, 1])", "[1, null]",
-        "INTEGER ARRAY NOT NULL");
-  }
-
-  /** Tests {@code ARRAY_LENGTH} function from BigQuery. */
-  @Test void testArrayLengthFunc() {
-    SqlTester tester = libraryTester(SqlLibrary.BIG_QUERY);
-    tester.setFor(SqlLibraryOperators.ARRAY_LENGTH);
-    tester.checkScalar("array_length(array[1])", "1",
-        "INTEGER NOT NULL");
-    tester.checkScalar("array_length(array[1, 2, null])", "3",
-        "INTEGER NOT NULL");
-    tester.checkNull("array_length(null)");
-  }
-
-  /** Tests {@code UNIX_SECONDS} and other datetime functions from BigQuery. */
-  @Test void testUnixSecondsFunc() {
-    SqlTester tester = libraryTester(SqlLibrary.BIG_QUERY);
-    tester.setFor(SqlLibraryOperators.UNIX_SECONDS);
-    tester.checkScalar("unix_seconds(timestamp '1970-01-01 00:00:00')", 0,
-        "BIGINT NOT NULL");
-    tester.checkNull("unix_seconds(cast(null as timestamp))");
-    tester.checkNull("unix_millis(cast(null as timestamp))");
-    tester.checkNull("unix_micros(cast(null as timestamp))");
-    tester.checkScalar("timestamp_seconds(0)", "1970-01-01 00:00:00",
-        "TIMESTAMP(0) NOT NULL");
-    tester.checkNull("timestamp_seconds(cast(null as bigint))");
-    tester.checkNull("timestamp_millis(cast(null as bigint))");
-    tester.checkNull("timestamp_micros(cast(null as bigint))");
-    tester.checkScalar("date_from_unix_date(0)", "1970-01-01", "DATE NOT NULL");
-
-    // Have to quote the "DATE" function because we're not using the Babel
-    // parser. In the regular parser, DATE is a reserved keyword.
-    tester.checkNull("\"DATE\"(null)");
-    tester.checkScalar("\"DATE\"('1985-12-06')", "1985-12-06", "DATE NOT NULL");
-    tester.checkType("CURRENT_DATETIME()", "TIMESTAMP(0) NOT NULL");
-    tester.checkType("CURRENT_DATETIME('America/Los_Angeles')", "TIMESTAMP(0) NOT NULL");
-    tester.checkType("CURRENT_DATETIME(CAST(NULL AS VARCHAR(20)))", "TIMESTAMP(0)");
-  }
-
-  @Test void testAbsFunc() {
-    tester.setFor(SqlStdOperatorTable.ABS);
-    tester.checkScalarExact("abs(-1)", "1");
-    tester.checkScalarExact(
-        "abs(cast(10 as TINYINT))", "TINYINT NOT NULL", "10");
-    tester.checkScalarExact(
-        "abs(cast(-20 as SMALLINT))", "SMALLINT NOT NULL", "20");
-    tester.checkScalarExact(
-        "abs(cast(-100 as INT))", "INTEGER NOT NULL", "100");
-    tester.checkScalarExact(
-        "abs(cast(1000 as BIGINT))", "BIGINT NOT NULL", "1000");
-    tester.checkScalarExact(
-        "abs(54.4)",
-        "DECIMAL(3, 1) NOT NULL",
-        "54.4");
-    tester.checkScalarExact(
-        "abs(-54.4)",
-        "DECIMAL(3, 1) NOT NULL",
-        "54.4");
-    tester.checkScalarApprox(
-        "abs(-9.32E-2)",
-        "DOUBLE NOT NULL",
-        0.0932,
-        0);
-    tester.checkScalarApprox(
-        "abs(cast(-3.5 as double))",
-        "DOUBLE NOT NULL",
-        3.5,
-        0);
-    tester.checkScalarApprox(
-        "abs(cast(-3.5 as float))",
-        "FLOAT NOT NULL",
-        3.5,
-        0);
-    tester.checkScalarApprox(
-        "abs(cast(3.5 as real))",
-        "REAL NOT NULL",
-        3.5,
-        0);
-
-    tester.checkNull("abs(cast(null as double))");
-  }
-
-  @Test void testAbsFuncIntervals() {
-    tester.checkScalar(
-        "abs(interval '-2' day)",
-        "+2",
-        "INTERVAL DAY NOT NULL");
-    tester.checkScalar(
-        "abs(interval '-5-03' year to month)",
-        "+5-03",
-        "INTERVAL YEAR TO MONTH NOT NULL");
-    tester.checkNull("abs(cast(null as interval hour))");
-  }
-
-  @Test void testAcosFunc() {
-    tester.setFor(
-        SqlStdOperatorTable.ACOS);
-    tester.checkType("acos(0)", "DOUBLE NOT NULL");
-    tester.checkType("acos(cast(1 as float))", "DOUBLE NOT NULL");
-    tester.checkType(
-        "acos(case when false then 0.5 else null end)", "DOUBLE");
-    strictTester.checkFails(
-        "^acos('abc')^",
-        "Cannot apply 'ACOS' to arguments of type 'ACOS\\(<CHAR\\(3\\)>\\)'\\. Supported form\\(s\\): 'ACOS\\(<NUMERIC>\\)'",
-        false);
-    tester.checkType("acos('abc')", "DOUBLE NOT NULL");
-    tester.checkScalarApprox(
-        "acos(0.5)",
-        "DOUBLE NOT NULL",
-        1.0472d,
-        0.0001d);
-    tester.checkScalarApprox(
-        "acos(cast(0.5 as decimal(1, 1)))",
-        "DOUBLE NOT NULL",
-        1.0472d,
-        0.0001d);
-    tester.checkNull("acos(cast(null as integer))");
-    tester.checkNull("acos(cast(null as double))");
-  }
-
-  @Test void testAsinFunc() {
-    tester.setFor(
-        SqlStdOperatorTable.ASIN);
-    tester.checkType("asin(0)", "DOUBLE NOT NULL");
-    tester.checkType("asin(cast(1 as float))", "DOUBLE NOT NULL");
-    tester.checkType(
-        "asin(case when false then 0.5 else null end)", "DOUBLE");
-    strictTester.checkFails(
-        "^asin('abc')^",
-        "Cannot apply 'ASIN' to arguments of type 'ASIN\\(<CHAR\\(3\\)>\\)'\\. Supported form\\(s\\): 'ASIN\\(<NUMERIC>\\)'",
-        false);
-    tester.checkType("asin('abc')", "DOUBLE NOT NULL");
-    tester.checkScalarApprox(
-        "asin(0.5)",
-        "DOUBLE NOT NULL",
-        0.5236d,
-        0.0001d);
-    tester.checkScalarApprox(
-        "asin(cast(0.5 as decimal(1, 1)))",
-        "DOUBLE NOT NULL",
-        0.5236d,
-        0.0001d);
-    tester.checkNull("asin(cast(null as integer))");
-    tester.checkNull("asin(cast(null as double))");
-  }
-
-  @Test void testAtanFunc() {
-    tester.setFor(
-        SqlStdOperatorTable.ATAN);
-    tester.checkType("atan(2)", "DOUBLE NOT NULL");
-    tester.checkType("atan(cast(2 as float))", "DOUBLE NOT NULL");
-    tester.checkType(
-        "atan(case when false then 2 else null end)", "DOUBLE");
-    strictTester.checkFails(
-        "^atan('abc')^",
-        "Cannot apply 'ATAN' to arguments of type 'ATAN\\(<CHAR\\(3\\)>\\)'\\. Supported form\\(s\\): 'ATAN\\(<NUMERIC>\\)'",
-        false);
-    tester.checkType("atan('abc')", "DOUBLE NOT NULL");
-    tester.checkScalarApprox(
-        "atan(2)",
-        "DOUBLE NOT NULL",
-        1.1071d,
-        0.0001d);
-    tester.checkScalarApprox(
-        "atan(cast(2 as decimal(1, 0)))",
-        "DOUBLE NOT NULL",
-        1.1071d,
-        0.0001d);
-    tester.checkNull("atan(cast(null as integer))");
-    tester.checkNull("atan(cast(null as double))");
-  }
-
-  @Test void testAtan2Func() {
-    tester.setFor(
-        SqlStdOperatorTable.ATAN2);
-    tester.checkType("atan2(2, -2)", "DOUBLE NOT NULL");
-    tester.checkScalarApprox(
-        "atan2(cast(1 as float), -1)",
-        "DOUBLE NOT NULL",
-        2.3562d,
-        0.0001d);
-    tester.checkType(
-        "atan2(case when false then 0.5 else null end, -1)", "DOUBLE");
-    strictTester.checkFails(
-        "^atan2('abc', 'def')^",
-        "Cannot apply 'ATAN2' to arguments of type 'ATAN2\\(<CHAR\\(3\\)>, <CHAR\\(3\\)>\\)'\\. Supported form\\(s\\): 'ATAN2\\(<NUMERIC>, <NUMERIC>\\)'",
-        false);
-    tester.checkType("atan2('abc', 'def')", "DOUBLE NOT NULL");
-    tester.checkScalarApprox(
-        "atan2(0.5, -0.5)",
-        "DOUBLE NOT NULL",
-        2.3562d,
-        0.0001d);
-    tester.checkScalarApprox(
-        "atan2(cast(0.5 as decimal(1, 1)), cast(-0.5 as decimal(1, 1)))",
-        "DOUBLE NOT NULL",
-        2.3562d,
-        0.0001d);
-    tester.checkNull("atan2(cast(null as integer), -1)");
-    tester.checkNull("atan2(1, cast(null as double))");
-  }
-
-  @Test void testCbrtFunc() {
-    tester.setFor(
-        SqlStdOperatorTable.CBRT);
-    tester.checkType("cbrt(1)", "DOUBLE NOT NULL");
-    tester.checkType("cbrt(cast(1 as float))", "DOUBLE NOT NULL");
-    tester.checkType(
-        "cbrt(case when false then 1 else null end)", "DOUBLE");
-    strictTester.checkFails(
-        "^cbrt('abc')^",
-        "Cannot apply 'CBRT' to arguments of type 'CBRT\\(<CHAR\\(3\\)>\\)'\\. Supported form\\(s\\): 'CBRT\\(<NUMERIC>\\)'",
-        false);
-    tester.checkType("cbrt('abc')", "DOUBLE NOT NULL");
-    tester.checkScalar(
-        "cbrt(8)",
-        "2.0",
-        "DOUBLE NOT NULL");
-    tester.checkScalar(
-        "cbrt(-8)",
-        "-2.0",
-        "DOUBLE NOT NULL");
-    tester.checkScalar(
-        "cbrt(cast(1 as decimal(1, 0)))",
-        "1.0",
-        "DOUBLE NOT NULL");
-    tester.checkNull("cbrt(cast(null as integer))");
-    tester.checkNull("cbrt(cast(null as double))");
-  }
-
-  @Test void testCosFunc() {
-    tester.setFor(
-        SqlStdOperatorTable.COS);
-    tester.checkType("cos(1)", "DOUBLE NOT NULL");
-    tester.checkType("cos(cast(1 as float))", "DOUBLE NOT NULL");
-    tester.checkType(
-        "cos(case when false then 1 else null end)", "DOUBLE");
-    strictTester.checkFails(
-        "^cos('abc')^",
-        "Cannot apply 'COS' to arguments of type 'COS\\(<CHAR\\(3\\)>\\)'\\. Supported form\\(s\\): 'COS\\(<NUMERIC>\\)'",
-        false);
-    tester.checkType("cos('abc')", "DOUBLE NOT NULL");
-    tester.checkScalarApprox(
-        "cos(1)",
-        "DOUBLE NOT NULL",
-        0.5403d,
-        0.0001d);
-    tester.checkScalarApprox(
-        "cos(cast(1 as decimal(1, 0)))",
-        "DOUBLE NOT NULL",
-        0.5403d,
-        0.0001d);
-    tester.checkNull("cos(cast(null as integer))");
-    tester.checkNull("cos(cast(null as double))");
-  }
-
-  @Test void testCoshFunc() {
-    SqlTester tester = tester(SqlLibrary.ORACLE);
-    tester.checkType("cosh(1)", "DOUBLE NOT NULL");
-    tester.checkType("cosh(cast(1 as float))", "DOUBLE NOT NULL");
-    tester.checkType(
-        "cosh(case when false then 1 else null end)", "DOUBLE");
-    strictTester.checkFails(
-        "^cosh('abc')^",
-        "No match found for function signature COSH\\(<CHARACTER>\\)",
-        false);
-    tester.checkType("cosh('abc')", "DOUBLE NOT NULL");
-    tester.checkScalarApprox(
-        "cosh(1)",
-        "DOUBLE NOT NULL",
-        1.5430d,
-        0.0001d);
-    tester.checkScalarApprox(
-        "cosh(cast(1 as decimal(1, 0)))",
-        "DOUBLE NOT NULL",
-        1.5430d,
-        0.0001d);
-    tester.checkNull("cosh(cast(null as integer))");
-    tester.checkNull("cosh(cast(null as double))");
-  }
-
-  @Test void testCotFunc() {
-    tester.setFor(
-        SqlStdOperatorTable.COT);
-    tester.checkType("cot(1)", "DOUBLE NOT NULL");
-    tester.checkType("cot(cast(1 as float))", "DOUBLE NOT NULL");
-    tester.checkType(
-        "cot(case when false then 1 else null end)", "DOUBLE");
-    strictTester.checkFails(
-        "^cot('abc')^",
-        "Cannot apply 'COT' to arguments of type 'COT\\(<CHAR\\(3\\)>\\)'\\. Supported form\\(s\\): 'COT\\(<NUMERIC>\\)'",
-        false);
-    tester.checkType("cot('abc')", "DOUBLE NOT NULL");
-    tester.checkScalarApprox(
-        "cot(1)",
-        "DOUBLE NOT NULL",
-        0.6421d,
-        0.0001d);
-    tester.checkScalarApprox(
-        "cot(cast(1 as decimal(1, 0)))",
-        "DOUBLE NOT NULL",
-        0.6421d,
-        0.0001d);
-    tester.checkNull("cot(cast(null as integer))");
-    tester.checkNull("cot(cast(null as double))");
-  }
-
-  @Test void testDegreesFunc() {
-    tester.setFor(
-        SqlStdOperatorTable.DEGREES);
-    tester.checkType("degrees(1)", "DOUBLE NOT NULL");
-    tester.checkType("degrees(cast(1 as float))", "DOUBLE NOT NULL");
-    tester.checkType(
-        "degrees(case when false then 1 else null end)", "DOUBLE");
-    strictTester.checkFails(
-        "^degrees('abc')^",
-        "Cannot apply 'DEGREES' to arguments of type 'DEGREES\\(<CHAR\\(3\\)>\\)'\\. Supported form\\(s\\): 'DEGREES\\(<NUMERIC>\\)'",
-        false);
-    tester.checkType("degrees('abc')", "DOUBLE NOT NULL");
-    tester.checkScalarApprox(
-        "degrees(1)",
-        "DOUBLE NOT NULL",
-        57.2958d,
-        0.0001d);
-    tester.checkScalarApprox(
-        "degrees(cast(1 as decimal(1, 0)))",
-        "DOUBLE NOT NULL",
-        57.2958d,
-        0.0001d);
-    tester.checkNull("degrees(cast(null as integer))");
-    tester.checkNull("degrees(cast(null as double))");
-  }
-
-  @Test void testPiFunc() {
-    tester.setFor(SqlStdOperatorTable.PI);
-    tester.checkScalarApprox("PI", "DOUBLE NOT NULL", 3.1415d, 0.0001d);
-    tester.checkFails("^PI()^",
-        "No match found for function signature PI\\(\\)", false);
-
-    // assert that PI function is not dynamic [CALCITE-2750]
-    assertFalse(PI.isDynamicFunction(),
-        "PI operator should not be identified as dynamic function");
-  }
-
-  @Test void testRadiansFunc() {
-    tester.setFor(
-        SqlStdOperatorTable.RADIANS);
-    tester.checkType("radians(42)", "DOUBLE NOT NULL");
-    tester.checkType("radians(cast(42 as float))", "DOUBLE NOT NULL");
-    tester.checkType(
-        "radians(case when false then 42 else null end)", "DOUBLE");
-    strictTester.checkFails(
-        "^radians('abc')^",
-        "Cannot apply 'RADIANS' to arguments of type 'RADIANS\\(<CHAR\\(3\\)>\\)'\\. Supported form\\(s\\): 'RADIANS\\(<NUMERIC>\\)'",
-        false);
-    tester.checkType("radians('abc')", "DOUBLE NOT NULL");
-    tester.checkScalarApprox(
-        "radians(42)",
-        "DOUBLE NOT NULL",
-        0.7330d,
-        0.0001d);
-    tester.checkScalarApprox(
-        "radians(cast(42 as decimal(2, 0)))",
-        "DOUBLE NOT NULL",
-        0.7330d,
-        0.0001d);
-    tester.checkNull("radians(cast(null as integer))");
-    tester.checkNull("radians(cast(null as double))");
-  }
-
-
-  @Test void testRoundFunc() {
-    tester.setFor(
-        SqlStdOperatorTable.ROUND);
-    tester.checkType("round(42, -1)", "INTEGER NOT NULL");
-    tester.checkType("round(cast(42 as float), 1)", "FLOAT NOT NULL");
-    tester.checkType(
-        "round(case when false then 42 else null end, -1)", "INTEGER");
-    strictTester.checkFails(
-        "^round('abc', 'def')^",
-        "Cannot apply 'ROUND' to arguments of type 'ROUND\\(<CHAR\\(3\\)>, <CHAR\\(3\\)>\\)'\\. Supported form\\(s\\): 'ROUND\\(<NUMERIC>, <INTEGER>\\)'",
-        false);
-    tester.checkType("round('abc', 'def')", "DECIMAL(19, 9) NOT NULL");
-    tester.checkScalar(
-        "round(42, -1)",
-        40,
-        "INTEGER NOT NULL");
-    tester.checkScalar(
-        "round(cast(42.346 as decimal(2, 3)), 2)",
-        BigDecimal.valueOf(4235, 2),
-        "DECIMAL(2, 3) NOT NULL");
-    tester.checkScalar(
-        "round(cast(-42.346 as decimal(2, 3)), 2)",
-        BigDecimal.valueOf(-4235, 2),
-        "DECIMAL(2, 3) NOT NULL");
-    tester.checkNull("round(cast(null as integer), 1)");
-    tester.checkNull("round(cast(null as double), 1)");
-    tester.checkNull("round(43.21, cast(null as integer))");
-
-    tester.checkNull("round(cast(null as double))");
-    tester.checkScalar("round(42)", 42, "INTEGER NOT NULL");
-    tester.checkScalar(
-        "round(cast(42.346 as decimal(2, 3)))",
-        BigDecimal.valueOf(42, 0),
-        "DECIMAL(2, 3) NOT NULL");
-    tester.checkScalar("round(42.324)",
-        BigDecimal.valueOf(42, 0),
-        "DECIMAL(5, 3) NOT NULL");
-    tester.checkScalar("round(42.724)",
-        BigDecimal.valueOf(43, 0),
-        "DECIMAL(5, 3) NOT NULL");
-  }
-
-  @Test void testSignFunc() {
-    tester.setFor(
-        SqlStdOperatorTable.SIGN);
-    tester.checkType("sign(1)", "INTEGER NOT NULL");
-    tester.checkType("sign(cast(1 as float))", "FLOAT NOT NULL");
-    tester.checkType(
-        "sign(case when false then 1 else null end)", "INTEGER");
-    strictTester.checkFails(
-        "^sign('abc')^",
-        "Cannot apply 'SIGN' to arguments of type 'SIGN\\(<CHAR\\(3\\)>\\)'\\. Supported form\\(s\\): 'SIGN\\(<NUMERIC>\\)'",
-        false);
-    tester.checkType("sign('abc')", "DECIMAL(19, 9) NOT NULL");
-    tester.checkScalar(
-        "sign(1)",
-        1,
-        "INTEGER NOT NULL");
-    tester.checkScalar(
-        "sign(cast(-1 as decimal(1, 0)))",
-        BigDecimal.valueOf(-1),
-        "DECIMAL(1, 0) NOT NULL");
-    tester.checkScalar(
-        "sign(cast(0 as float))",
-        0d,
-        "FLOAT NOT NULL");
-    tester.checkNull("sign(cast(null as integer))");
-    tester.checkNull("sign(cast(null as double))");
-  }
-
-  @Test void testSinFunc() {
-    tester.setFor(
-        SqlStdOperatorTable.SIN);
-    tester.checkType("sin(1)", "DOUBLE NOT NULL");
-    tester.checkType("sin(cast(1 as float))", "DOUBLE NOT NULL");
-    tester.checkType(
-        "sin(case when false then 1 else null end)", "DOUBLE");
-    strictTester.checkFails(
-        "^sin('abc')^",
-        "Cannot apply 'SIN' to arguments of type 'SIN\\(<CHAR\\(3\\)>\\)'\\. Supported form\\(s\\): 'SIN\\(<NUMERIC>\\)'",
-        false);
-    tester.checkType("sin('abc')", "DOUBLE NOT NULL");
-    tester.checkScalarApprox(
-        "sin(1)",
-        "DOUBLE NOT NULL",
-        0.8415d,
-        0.0001d);
-    tester.checkScalarApprox(
-        "sin(cast(1 as decimal(1, 0)))",
-        "DOUBLE NOT NULL",
-        0.8415d,
-        0.0001d);
-    tester.checkNull("sin(cast(null as integer))");
-    tester.checkNull("sin(cast(null as double))");
-  }
-
-  @Test void testSinhFunc() {
-    SqlTester tester = tester(SqlLibrary.ORACLE);
-    tester.checkType("sinh(1)", "DOUBLE NOT NULL");
-    tester.checkType("sinh(cast(1 as float))", "DOUBLE NOT NULL");
-    tester.checkType(
-        "sinh(case when false then 1 else null end)", "DOUBLE");
-    strictTester.checkFails(
... 42932 lines suppressed ...