java.lang.Object
- org.apache.calcite.test.SqlToRelTestBase
- - org.apache.calcite.test.SqlToRelConverterTest

Direct Known Subclasses:

SqlToRelConverterExtendedTest
```
public class SqlToRelConverterTest
extends SqlToRelTestBase
```
Unit test for SqlToRelConverter.

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`static class`	`SqlToRelConverterTest.RelValidityChecker`	Visitor that checks that every `RelNode` in a tree is valid.
`class`	`SqlToRelConverterTest.Sql`	Allows fluent testing.

Nested classes/interfaces inherited from class org.apache.calcite.test.SqlToRelTestBase
SqlToRelTestBase.MockRelOptSchema, SqlToRelTestBase.Tester, SqlToRelTestBase.TesterImpl

Field Summary
- Fields inherited from class org.apache.calcite.test.SqlToRelTestBase
  NL, tester

Constructor Summary

Constructors
Constructor Description

SqlToRelConverterTest()

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`protected void`	`check(java.lang.String sql, java.lang.String plan)`
`protected DiffRepository`	`getDiffRepos()`	Returns the default diff repository for this test, or null if there is no repository.
`private SqlToRelTestBase.Tester`	`getExtendedTester()`
`SqlToRelConverterTest.Sql`	`sql(java.lang.String sql)`	Sets the SQL statement for a test.
`void`	`testAggCaseInSubQuery()`	Test aggregate function on a CASE expression involving IN with a sub-query.
`void`	`testAggCaseSubQuery()`	Test aggregate function on a CASE expression involving a non-query IN
`void`	`testAggDistinct()`
`void`	`testAggFilter()`
`void`	`testAggFilterWithIn()`
`void`	`testAggNoDuplicateColumnNames()`	Test case for [CALCITE-753] Test aggregate operators do not derive row types with duplicate column names.
`void`	`testAggregateAndScalarSubQueryInHaving()`	Test case for [CALCITE-716] Scalar sub-query and aggregate function in SELECT or HAVING clause gives AssertionError; variant involving HAVING clause.
`void`	`testAggregateAndScalarSubQueryInSelect()`	Test case for [CALCITE-716] Scalar sub-query and aggregate function in SELECT or HAVING clause gives AssertionError; variant involving SELECT clause.
`void`	`testAggregateNoGroup()`
`void`	`testAggScalarSubQuery()`
`void`	`testAliasInHaving()`
`void`	`testAliasList()`
`void`	`testAliasList2()`
`void`	`testAllValueList()`
`void`	`testAnyValueAggregateFunctionGroupBy()`
`void`	`testAnyValueAggregateFunctionNoGroupBy()`	Test case for [CALCITE-2366] Add support for ANY_VALUE aggregate function.
`void`	`testArrayOfRecord()`
`void`	`testCase()`	Test one of the custom conversions which is recognized by the class of the operator (in this case, `SqlCaseOperator`).
`void`	`testCharLength()`	Tests one of the custom conversions which is recognized by the identity of the operator (in this case, `SqlStdOperatorTable.CHARACTER_LENGTH`).
`void`	`testCollectionTable()`
`void`	`testCollectionTableWithCursorParam()`
`void`	`testCollectionTableWithLateral()`
`void`	`testCollectionTableWithLateral2()`
`void`	`testCollectionTableWithLateral3()`	Test case for [CALCITE-1732] IndexOutOfBoundsException when using LATERAL TABLE with more than one field.
`void`	`testCompositeInUncorrelatedSubQueryRex()`
`void`	`testConditionOffByOne()`	Test case for [CALCITE-245] Off-by-one translation of ON clause of JOIN.
`void`	`testConditionOffByOneReversed()`
`void`	`testCorrelatedSubQueryInAggregate()`
`void`	`testCorrelatedSubQueryInJoin()`	Test case for [CALCITE-864] Correlation variable has incorrect row type if it is populated by right side of a Join.
`void`	`testCorrelationExistsAndFilter()`	Test case (correlated EXISTS sub-query) for [CALCITE-714] When de-correlating, push join condition into sub-query.
`void`	`testCorrelationExistsAndFilterRex()`
`void`	`testCorrelationExistsAndFilterThetaRex()`	A theta join condition, unlike the equi-join condition in `testCorrelationExistsAndFilterRex()`, requires a value generator.
`void`	`testCorrelationJoin()`
`void`	`testCorrelationJoinRex()`
`void`	`testCorrelationMultiScalarAggregate()`	Test case for [CALCITE-1543] Correlated scalar sub-query with multiple aggregates gives AssertionError.
`void`	`testCorrelationNotExistsAndFilter()`	Test case (correlated NOT EXISTS sub-query) for [CALCITE-714] When de-correlating, push join condition into sub-query.
`void`	`testCorrelationScalarAggAndFilter()`	Test case (correlated scalar aggregate sub-query) for [CALCITE-714] When de-correlating, push join condition into sub-query.
`void`	`testCorrelationScalarAggAndFilterRex()`
`void`	`testCountNoGroup()`
`void`	`testCube()`
`void`	`testCustomColumnResolving()`
`void`	`testCustomColumnResolving2()`
`void`	`testCustomColumnResolving3()`
`void`	`testCustomColumnResolving4()`
`void`	`testCustomColumnResolving5()`
`void`	`testCustomColumnResolvingWithSelectFieldNameDotStar()`
`void`	`testCustomColumnResolvingWithSelectStar()`
`void`	`testDelete()`
`void`	`testDeleteBind()`
`void`	`testDeleteBindExtendedColumn()`
`void`	`testDeleteBindExtendedColumnModifiableView()`
`void`	`testDeleteBindModifiableView()`
`void`	`testDeleteWhere()`
`void`	`testDotLiteralAfterNestedRow()`
`void`	`testDotLiteralAfterRow()`
`void`	`testDuplicateColumnsInSubQuery()`	Tests referencing columns from a sub-query that has duplicate column names.
`void`	`testDuplicateGroupingSets()`	GROUP BY with duplicate (and heavily nested) GROUPING SETS.
`void`	`testDynamicNestedColumn()`
`void`	`testDynamicSchemaUnnest()`
`void`	`testDynamicStarInJoinAndSubQ()`	Test case for Dynamic Table / Dynamic Star support [CALCITE-1150]
`void`	`testDynamicStarInTableJoin()`	Test case for Dynamic Table / Dynamic Star support [CALCITE-1150]
`void`	`testDynStarInExistSubQ()`	Test case for Dynamic Table / Dynamic Star support [CALCITE-1150]
`void`	`testElement()`
`void`	`testElementInValues()`
`void`	`testExists()`
`void`	`testExistsCorrelated()`
`void`	`testExistsCorrelatedDecorrelate()`
`void`	`testExistsCorrelatedDecorrelateRex()`
`void`	`testExistsCorrelatedLimit()`
`void`	`testExistsCorrelatedLimitDecorrelate()`
`void`	`testExistsCorrelatedLimitDecorrelateRex()`
`void`	`testExplainAsXml()`
`void`	`testExplicitTable()`
`void`	`testFakeStar()`
`void`	`testFetch()`
`void`	`testFetchWithDynamicParameter()`
`void`	`testFlattenRecords()`
`void`	`testGroup()`
`void`	`testGroupAlias()`	Test case for [CALCITE-439] SqlValidatorUtil.uniquify() may not terminate under some conditions.
`void`	`testGroupBug281()`
`void`	`testGroupBug281b()`
`void`	`testGroupByAlias()`
`void`	`testGroupByAliasEqualToColumnName()`
`void`	`testGroupByAliasOfSubExpressionsInProject()`
`void`	`testGroupByCaseIn()`	Test case for [CALCITE-614] IN within CASE within GROUP BY gives AssertionError.
`void`	`testGroupByCaseSubQuery()`	Test group-by CASE expression involving a non-query IN
`void`	`testGroupByContainsLiterals()`
`void`	`testGroupByExpression()`
`void`	`testGroupByOrdinal()`
`void`	`testGroupByWithDuplicates()`	GROUP BY with duplicates.
`void`	`testGroupEmpty()`
`void`	`testGroupExpressionsInsideAndOut()`
`void`	`testGroupingFunction()`
`void`	`testGroupingFunctionWithGroupBy()`	When the GROUPING function occurs with GROUP BY (effectively just one grouping set), we can translate it directly to 1.
`void`	`testGroupingSets()`
`void`	`testGroupingSetsCartesianProduct()`
`void`	`testGroupingSetsCartesianProduct2()`
`void`	`testGroupingSetsProduct()`
`void`	`testGroupingSetsWith()`
`void`	`testGroupingSetsWithCube()`
`void`	`testGroupingSetsWithRollup()`	Test case for [CALCITE-2147] Incorrect plan in with with ROLLUP inside GROUPING SETS.
`void`	`testGroupingSetsWithRollupCube()`
`void`	`testGroupJustOneAgg()`
`void`	`testGrpByColFromStarInSubQuery()`	Test case for Dynamic Table / Dynamic Star support [CALCITE-1150]
`void`	`testHaving()`
`void`	`testHavingAggrFunctionIn()`	Test case for [CALCITE-694] Scan HAVING clause for sub-queries and IN-lists relating to IN.
`void`	`testHavingInSubQueryWithAggrFunction()`	Test case for [CALCITE-694] Scan HAVING clause for sub-queries and IN-lists, with a sub-query in the HAVING clause.
`void`	`testHopTable()`
`void`	`testIdenticalExpressionInSubQuery()`	Test case for [CALCITE-710] When look up sub-queries, perform the same logic as the way when ones were registered.
`void`	`testInsert()`
`void`	`testInsertBind()`
`void`	`testInsertBindExtendedColumn()`
`void`	`testInsertBindExtendedColumnModifiableView()`
`void`	`testInsertBindModifiableView()`
`void`	`testInsertBindSubset()`
`void`	`testInsertBindSubsetModifiableView()`
`void`	`testInsertBindSubsetWithCustomInitializerExpressionFactory()`
`void`	`testInsertBindWithCustomInitializerExpressionFactory()`
`void`	`testInsertExtendedColumn()`
`void`	`testInsertExtendedColumnModifiableView()`
`void`	`testInsertModifiableView()`
`void`	`testInsertSubset()`
`void`	`testInsertSubsetModifiableView()`
`void`	`testInsertSubsetView()`
`void`	`testInsertSubsetWithCustomInitializerExpressionFactory()`
`void`	`testInsertView()`
`void`	`testInsertViewWithCustomColumnResolving()`
`void`	`testInsertWithCustomColumnResolving()`
`void`	`testInsertWithCustomColumnResolving2()`
`void`	`testInsertWithCustomInitializerExpressionFactory()`
`void`	`testIntegerLiteral()`
`void`	`testInterval()`
`void`	`testIntervalLiteralHourToMinute()`
`void`	`testIntervalLiteralYearToMonth()`
`void`	`testInToSemiJoin()`	Test case for [CALCITE-1321] Configurable IN list size when converting IN clause to join.
`void`	`testInUncorrelatedSubQuery()`
`void`	`testInUncorrelatedSubQueryInHavingRex()`
`void`	`testInUncorrelatedSubQueryInSelect()`
`void`	`testInUncorrelatedSubQueryInSelectRex()`
`void`	`testInUncorrelatedSubQueryRex()`
`void`	`testInValueListLong()`
`void`	`testInValueListShort()`
`void`	`testIsDistinctFrom()`
`void`	`testIsNotDistinctFrom()`
`void`	`testJoinNatural()`
`void`	`testJoinNaturalMultipleCommonColumn()`
`void`	`testJoinNaturalNoCommonColumn()`
`void`	`testJoinOn()`
`void`	`testJoinOnExists()`
`void`	`testJoinOnExpression()`
`void`	`testJoinOnIn()`
`void`	`testJoinOnInSubQuery()`
`void`	`testJoinUnnest()`
`void`	`testJoinUnnestRex()`
`void`	`testJoinUsing()`
`void`	`testJoinUsingCompound()`
`void`	`testJoinUsingDynamicTable()`
`void`	`testJoinUsingThreeWay()`	Test case for [CALCITE-74] JOIN ...
`void`	`testJoinWithUnion()`
`void`	`testJsonArray()`
`void`	`testJsonArrayAgg()`
`void`	`testJsonExists()`
`void`	`testJsonObject()`
`void`	`testJsonObjectAgg()`
`void`	`testJsonPredicate()`
`void`	`testJsonQuery()`
`void`	`testJsonValue()`
`void`	`testLarge()`
`void`	`testLateral()`
`void`	`testLateralDecorrelate()`
`void`	`testLateralDecorrelateRex()`
`void`	`testLateralDecorrelateThetaRex()`
`void`	`testMatchRecognize1()`
`void`	`testMatchRecognizeMeasures1()`
`void`	`testMatchRecognizeMeasures2()`	Test case for [CALCITE-1909] Output rowType of Match should include PARTITION BY and ORDER BY columns.
`void`	`testMatchRecognizeMeasures3()`
`void`	`testMatchRecognizePatternSkip1()`
`void`	`testMatchRecognizePrevDown()`
`void`	`testMatchRecognizePrevLast()`
`void`	`testMatchRecognizeSubset1()`
`void`	`testMerge()`
`void`	`testModifiableViewDdlExtend()`
`void`	`testModifiableViewExtend()`
`void`	`testModifiableViewExtendExpression()`
`void`	`testModifiableViewExtendSubset()`
`void`	`testMultiAnd()`	Tests that AND(x, AND(y, z)) gets flattened to AND(x, y, z).
`void`	`testMultiset()`
`void`	`testMultisetOfColumns()`
`void`	`testMultisetOfColumnsRex()`
`void`	`testMultisetSubQuery()`
`void`	`testNestedAggregates()`	Test case for [CALCITE-750] Allow windowed aggregate on top of regular aggregate.
`void`	`testNestedCorrelations()`
`void`	`testNestedCorrelationsDecorrelated()`
`void`	`testNestedCorrelationsDecorrelatedRex()`
`void`	`testNotCaseInMoreClause()`
`void`	`testNotCaseInThreeClause()`
`void`	`testNotCaseInWithoutElse()`
`void`	`testNotExistsCorrelated()`
`void`	`testNotInUncorrelatedSubQuery()`
`void`	`testNotInUncorrelatedSubQueryInSelect()`	Plan should be as `testInUncorrelatedSubQueryInSelect()`, but with an extra NOT.
`void`	`testNotInUncorrelatedSubQueryInSelectDeduceNotNull()`	Even though "mgr" allows nulls, we can deduce from the WHERE clause that it will never be null.
`void`	`testNotInUncorrelatedSubQueryInSelectDeduceNotNull2()`	Similar to `testNotInUncorrelatedSubQueryInSelectDeduceNotNull()`, using `IS NOT NULL`.
`void`	`testNotInUncorrelatedSubQueryInSelectDeduceNotNull3()`	Similar to `testNotInUncorrelatedSubQueryInSelectDeduceNotNull()`, using `IN`.
`void`	`testNotInUncorrelatedSubQueryInSelectMayBeNull()`	Since 'deptno NOT IN (SELECT mgr FROM emp)' can be null, we need a more complex plan, including counts of null and not-null keys.
`void`	`testNotInUncorrelatedSubQueryInSelectNotNull()`	Since 'deptno NOT IN (SELECT deptno FROM dept)' can not be null, we generate a simpler plan.
`void`	`testNotInUncorrelatedSubQueryInSelectNotNullRex()`
`void`	`testNotInUncorrelatedSubQueryInSelectRex()`
`void`	`testNotInUncorrelatedSubQueryRex()`
`void`	`testNotInWithLiteral()`	Test case for [CALCITE-2080] Query with NOT IN operator and literal fails throws AssertionError: 'Cast for just nullability not allowed'.
`void`	`testNotLike()`
`void`	`testNotNotIn()`
`void`	`testOffset()`
`void`	`testOffset0()`
`void`	`testOffsetFetch()`
`void`	`testOffsetFetchWithDynamicParameter()`
`void`	`testOffsetWithDynamicParameter()`
`void`	`testOrder()`
`void`	`testOrderBasedRepeatFields()`	Tests that if a column occurs twice in ORDER BY, only the first key is kept.
`void`	`testOrderByAlias()`
`void`	`testOrderByAliasDoesNotOverride()`
`void`	`testOrderByAliasInExpr()`
`void`	`testOrderByAliasOverrides()`
`void`	`testOrderByIdenticalExpr()`
`void`	`testOrderByNegativeOrdinal()`
`void`	`testOrderByOrdinalDesc()`
`void`	`testOrderByOrdinalInExpr()`
`void`	`testOrderByOver()`	Test case for [CALCITE-1313] Validator should derive type of expression in ORDER BY.
`void`	`testOrderBySameExpr()`
`void`	`testOrderDescNullsLast()`
`void`	`testOrderDistinct()`
`void`	`testOrderGroup()`
`void`	`testOrderOffsetFetch()`
`void`	`testOrderOffsetFetchWithDynamicParameter()`
`void`	`testOrderUnion()`
`void`	`testOrderUnionExprs()`
`void`	`testOrderUnionOrdinal()`
`void`	`testOverAvg()`
`void`	`testOverAvg2()`
`void`	`testOverCountStar()`
`void`	`testOverMultiple()`
`void`	`testOverOrderFollowingWindow()`	Tests that a window with a FOLLOWING bound becomes BETWEEN CURRENT ROW AND FOLLOWING.
`void`	`testOverOrderWindow()`	Tests that a window containing only ORDER BY is implicitly CURRENT ROW.
`void`	`testPrevClassifier()`
`void`	`testReferDynamicStarInSelectOB()`	Test case for Dynamic Table / Dynamic Star support [CALCITE-1150]
`void`	`testReferDynamicStarInSelectWhereGB()`	Test case for Dynamic Table / Dynamic Star support [CALCITE-1150]
`void`	`testRollup()`
`void`	`testRollupSimple()`
`void`	`testRollupTuples()`
`void`	`testSample()`
`void`	`testSampleBernoulli()`
`void`	`testSampleBernoulliQuery()`
`void`	`testSampleQuery()`
`void`	`testSampleSystem()`
`void`	`testSampleSystemQuery()`
`void`	`testSelectDistinct()`
`void`	`testSelectDistinctDup()`	Tests that if the clause of SELECT DISTINCT contains duplicate expressions, they are only aggregated once.
`void`	`testSelectDistinctGroup()`
`void`	`testSelectDynamicStarOrderBy()`	Test case for [CALCITE-1150] Create the a new DynamicRecordType, avoiding star expansion when working with this type.
`void`	`testSelectFromDynamicTable()`	Test case for [CALCITE-1150] Dynamic Table / Dynamic Star support
`void`	`testSelectModifiableViewConstraint()`
`void`	`testSelectOverDistinct()`	Test case for [CALCITE-476] DISTINCT flag in windowed aggregates.
`void`	`testSelectStarFromDynamicTable()`	Test case for Dynamic Table / Dynamic Star support [CALCITE-1150]
`void`	`testSelectStreamPartitionDistinct()`	As `testSelectOverDistinct()` but for streaming queries.
`void`	`testSelectView()`
`void`	`testSelectViewExtendedColumnCaseSensitiveCollision()`
`void`	`testSelectViewExtendedColumnCaseSensitiveExtendedCollision()`
`void`	`testSelectViewExtendedColumnCaseSensitiveUnderlyingCollision()`
`void`	`testSelectViewExtendedColumnCollision()`
`void`	`testSelectViewExtendedColumnExtendedCollision()`
`void`	`testSelectViewExtendedColumnUnderlyingCollision()`
`void`	`testSelectWithoutFrom()`
`void`	`testSessionTable()`
`void`	`testSingletonGroupingSet()`
`void`	`testSome()`
`void`	`testSomeValueList()`
`void`	`testSortWithTrim()`	Test case for [CALCITE-412] RelFieldTrimmer: when trimming Sort, the collation and trait set don't match.
`void`	`testStarDynamicSchemaUnnest()`
`void`	`testStarDynamicSchemaUnnest2()`
`void`	`testStarDynamicSchemaUnnestNestedSubQuery()`
`void`	`testStarJoinStaticDynTable()`	Test case for Dynamic Table / Dynamic Star support [CALCITE-1150]
`void`	`testStream()`
`void`	`testStreamGroupBy()`
`void`	`testStreamWindowedAggregation()`
`void`	`testStructTypeAlias()`	Test case for: [CALCITE-2468] struct type alias should not cause IOOBE..
`void`	`testSubQueryAggregateFunctionFollowedBySimpleOperation()`	Test case for [CALCITE-695] SqlSingleValueAggFunction is created when it may not be needed.
`void`	`testSubQueryLimitOne()`	Test case for [CALCITE-695] SqlSingleValueAggFunction is created when it may not be needed.
`void`	`testSubQueryOr()`	Test case for [CALCITE-1799] "OR ..
`void`	`testSubQueryValues()`	Test case for [CALCITE-695] SqlSingleValueAggFunction is created when it may not be needed.
`void`	`testTableExpression()`
`void`	`testTableExtend()`
`void`	`testTableExtendExpression()`
`void`	`testTableExtendSubset()`
`void`	`testTableSubset()`
`void`	`testTumble()`
`void`	`testTumbleTable()`
`void`	`testTumbleTableRowtimeNotFirstColumn()`	As `testTumbleTable()` but on a table where "rowtime" is at position 1 not 0.
`void`	`testUncorrelatedScalarSubQueryInAggregateRex()`
`void`	`testUncorrelatedScalarSubQueryInGroupOrderRex()`
`void`	`testUncorrelatedScalarSubQueryInOrderRex()`
`void`	`testUnion()`
`void`	`testUnionAll()`
`void`	`testUnionInFrom()`
`void`	`testUnionSubQuery()`
`void`	`testUnionValues()`
`void`	`testUnnest()`
`void`	`testUnnestArray()`
`void`	`testUnnestArrayAggPlan()`
`void`	`testUnnestArrayPlan()`
`void`	`testUnnestArrayPlanAs()`
`void`	`testUnnestSelect()`
`void`	`testUnnestSelectRex()`
`void`	`testUnnestSubQuery()`
`void`	`testUnnestWithOrdinality()`
`void`	`testUpdate()`
`void`	`testUpdateBind()`
`void`	`testUpdateBind2()`
`void`	`testUpdateBindExtendedColumn()`
`void`	`testUpdateBindExtendedColumnModifiableView()`
`void`	`testUpdateExtendedColumn()`
`void`	`testUpdateExtendedColumnCaseSensitiveCollision()`
`void`	`testUpdateExtendedColumnCollision()`
`void`	`testUpdateExtendedColumnModifiableView()`
`void`	`testUpdateExtendedColumnModifiableViewCaseSensitiveCollision()`
`void`	`testUpdateExtendedColumnModifiableViewCollision()`
`void`	`testUpdateExtendedColumnModifiableViewExtendedCaseSensitiveCollision()`
`void`	`testUpdateExtendedColumnModifiableViewExtendedCollision()`
`void`	`testUpdateExtendedColumnModifiableViewUnderlyingCollision()`
`void`	`testUpdateModifiableView()`
`void`	`testUpdateSubQuery()`
`void`	`testUpdateWhere()`
`void`	`testUpdateWithCustomColumnResolving()`
`void`	`testUserDefinedOrderByOver()`	Test case for [CALCITE-2323] Validator should allow alternative nullCollations for ORDER BY in OVER.
`void`	`testValuesUsing()`	Test case for [CALCITE-801] NullPointerException using USING on table alias with column aliases.
`void`	`testWhereInCorrelated()`
`void`	`testWindowAggInSubQueryJoin()`	Test case for [CALCITE-770] variant involving join with sub-query that contains window function and GROUP BY.
`void`	`testWindowAggWithGroupBy()`	Test case for [CALCITE-770] window aggregate and ranking functions with grouped aggregates.
`void`	`testWindowAggWithGroupByAndHaving()`	Test case for [CALCITE-770] variant involving HAVING clause.
`void`	`testWindowAggWithGroupByAndJoin()`	Test case for [CALCITE-770] variant involving joins.
`void`	`testWindowAndGroupByWithDynamicStar()`
`void`	`testWindowAverageWithGroupBy()`	Test case for [CALCITE-847] AVG window function in GROUP BY gives AssertionError.
`void`	`testWindowOnDynamicStar()`	Test case for [CALCITE-1944] Window function applied to sub-query with dynamic star gets wrong plan.
`void`	`testWith()`
`void`	`testWithAlias()`
`void`	`testWithExists()`	Test case for [CALCITE-365] AssertionError while translating query with WITH and correlated sub-query.
`void`	`testWithinGroup1()`
`void`	`testWithinGroup2()`
`void`	`testWithinGroup3()`
`void`	`testWithInsideScalarSubQuery()`
`void`	`testWithInsideScalarSubQueryRex()`
`void`	`testWithInsideWhereExists()`
`void`	`testWithInsideWhereExistsDecorrelate()`
`void`	`testWithInsideWhereExistsDecorrelateRex()`
`void`	`testWithInsideWhereExistsRex()`
`void`	`testWithOrder()`	Test case for [CALCITE-309] WITH ...
`void`	`testWithUnion()`
`void`	`testWithUnionOrder()`

Methods inherited from class org.apache.calcite.test.SqlToRelTestBase
assertValid, createTester, createTester, getTesterWithDynamicTable

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - SqlToRelConverterTest
```
public SqlToRelConverterTest()
```
- Method Detail
  - getDiffRepos
```
protected DiffRepository getDiffRepos()
```
    Description copied from class: SqlToRelTestBase
    
    Returns the default diff repository for this test, or null if there is no repository.
    The default implementation returns null.
    Sub-classes that want to use a diff repository can override. Sub-sub-classes can override again, inheriting test cases and overriding selected test results.
    And individual test cases can override by providing a different tester object.
    
    Overrides:
    
    getDiffRepos in class SqlToRelTestBase
    
    Returns:
    
    Diff repository
  - sql
```
public final SqlToRelConverterTest.Sql sql(java.lang.String sql)
```
    Sets the SQL statement for a test.
  - check
```
protected final void check(java.lang.String sql,
                           java.lang.String plan)
```
  - testDotLiteralAfterNestedRow
```
public void testDotLiteralAfterNestedRow()
```
  - testDotLiteralAfterRow
```
public void testDotLiteralAfterRow()
```
  - testIntegerLiteral
```
public void testIntegerLiteral()
```
  - testIntervalLiteralYearToMonth
```
public void testIntervalLiteralYearToMonth()
```
  - testIntervalLiteralHourToMinute
```
public void testIntervalLiteralHourToMinute()
```
  - testAliasList
```
public void testAliasList()
```
  - testAliasList2
```
public void testAliasList2()
```
  - testStructTypeAlias
```
public void testStructTypeAlias()
```
    Test case for: [CALCITE-2468] struct type alias should not cause IOOBE..
  - testJoinUsingDynamicTable
```
public void testJoinUsingDynamicTable()
```
  - testMultiAnd
```
public void testMultiAnd()
```
    Tests that AND(x, AND(y, z)) gets flattened to AND(x, y, z).
  - testJoinOn
```
public void testJoinOn()
```
  - testConditionOffByOne
```
public void testConditionOffByOne()
```
    Test case for [CALCITE-245] Off-by-one translation of ON clause of JOIN.
  - testConditionOffByOneReversed
```
public void testConditionOffByOneReversed()
```
  - testJoinOnExpression
```
public void testJoinOnExpression()
```
  - testJoinOnIn
```
public void testJoinOnIn()
```
  - testJoinOnInSubQuery
```
public void testJoinOnInSubQuery()
```
  - testJoinOnExists
```
public void testJoinOnExists()
```
  - testJoinUsing
```
public void testJoinUsing()
```
  - testJoinUsingThreeWay
```
public void testJoinUsingThreeWay()
```
    Test case for [CALCITE-74] JOIN ... USING fails in 3-way join with UnsupportedOperationException.
  - testJoinUsingCompound
```
public void testJoinUsingCompound()
```
  - testValuesUsing
```
public void testValuesUsing()
```
    Test case for [CALCITE-801] NullPointerException using USING on table alias with column aliases.
  - testJoinNatural
```
public void testJoinNatural()
```
  - testJoinNaturalNoCommonColumn
```
public void testJoinNaturalNoCommonColumn()
```
  - testJoinNaturalMultipleCommonColumn
```
public void testJoinNaturalMultipleCommonColumn()
```
  - testJoinWithUnion
```
public void testJoinWithUnion()
```
  - testGroup
```
public void testGroup()
```
  - testGroupByAlias
```
public void testGroupByAlias()
```
  - testGroupByAliasOfSubExpressionsInProject
```
public void testGroupByAliasOfSubExpressionsInProject()
```
  - testGroupByAliasEqualToColumnName
```
public void testGroupByAliasEqualToColumnName()
```
  - testGroupByOrdinal
```
public void testGroupByOrdinal()
```
  - testGroupByContainsLiterals
```
public void testGroupByContainsLiterals()
```
  - testAliasInHaving
```
public void testAliasInHaving()
```
  - testGroupJustOneAgg
```
public void testGroupJustOneAgg()
```
  - testGroupExpressionsInsideAndOut
```
public void testGroupExpressionsInsideAndOut()
```
  - testAggregateNoGroup
```
public void testAggregateNoGroup()
```
  - testGroupEmpty
```
public void testGroupEmpty()
```
  - testSingletonGroupingSet
```
public void testSingletonGroupingSet()
```
  - testGroupingSets
```
public void testGroupingSets()
```
  - testGroupingSetsWithRollup
```
public void testGroupingSetsWithRollup()
```
    Test case for [CALCITE-2147] Incorrect plan in with with ROLLUP inside GROUPING SETS.
    Equivalence example:
    GROUP BY GROUPING SETS (ROLLUP(A, B), CUBE(C,D))
    
    is equal to
    GROUP BY GROUPING SETS ((A,B), (A), (), (C,D), (C), (D) )
  - testGroupingSetsWithCube
```
public void testGroupingSetsWithCube()
```
  - testGroupingSetsWithRollupCube
```
public void testGroupingSetsWithRollupCube()
```
  - testGroupingSetsProduct
```
public void testGroupingSetsProduct()
```
  - testGroupingFunctionWithGroupBy
```
public void testGroupingFunctionWithGroupBy()
```
    When the GROUPING function occurs with GROUP BY (effectively just one grouping set), we can translate it directly to 1.
  - testGroupingFunction
```
public void testGroupingFunction()
```
  - testGroupByWithDuplicates
```
public void testGroupByWithDuplicates()
```
    GROUP BY with duplicates.
    From SQL spec:
    NOTE 190 — That is, a simple group by clause that is not primitive may be transformed into a primitive group by clause by deleting all parentheses, and deleting extra commas as necessary for correct syntax. If there are no grouping columns at all (for example, GROUP BY (), ()), this is transformed to the canonical form GROUP BY ().
  - testDuplicateGroupingSets
```
public void testDuplicateGroupingSets()
```
    GROUP BY with duplicate (and heavily nested) GROUPING SETS.
  - testGroupingSetsCartesianProduct
```
public void testGroupingSetsCartesianProduct()
```
  - testGroupingSetsCartesianProduct2
```
public void testGroupingSetsCartesianProduct2()
```
  - testRollupSimple
```
public void testRollupSimple()
```
  - testRollup
```
public void testRollup()
```
  - testRollupTuples
```
public void testRollupTuples()
```
  - testCube
```
public void testCube()
```
  - testGroupingSetsWith
```
public void testGroupingSetsWith()
```
  - testHaving
```
public void testHaving()
```
  - testGroupBug281
```
public void testGroupBug281()
```
  - testGroupBug281b
```
public void testGroupBug281b()
```
  - testGroupByExpression
```
public void testGroupByExpression()
```
  - testAggDistinct
```
public void testAggDistinct()
```
  - testAggFilter
```
public void testAggFilter()
```
  - testAggFilterWithIn
```
public void testAggFilterWithIn()
```
  - testFakeStar
```
public void testFakeStar()
```
  - testSelectDistinct
```
public void testSelectDistinct()
```
  - testSelectOverDistinct
```
public void testSelectOverDistinct()
```
    Test case for [CALCITE-476] DISTINCT flag in windowed aggregates.
  - testSelectStreamPartitionDistinct
```
public void testSelectStreamPartitionDistinct()
```
    As testSelectOverDistinct() but for streaming queries.
  - testSelectDistinctGroup
```
public void testSelectDistinctGroup()
```
  - testSelectDistinctDup
```
public void testSelectDistinctDup()
```
    Tests that if the clause of SELECT DISTINCT contains duplicate expressions, they are only aggregated once.
  - testSelectWithoutFrom
```
public void testSelectWithoutFrom()
```
  - testDuplicateColumnsInSubQuery
```
public void testDuplicateColumnsInSubQuery()
```
    Tests referencing columns from a sub-query that has duplicate column names. I think the standard says that this is illegal. We roll with it, and rename the second column to "e0".
  - testOrder
```
public void testOrder()
```
  - testOrderBasedRepeatFields
```
public void testOrderBasedRepeatFields()
```
    Tests that if a column occurs twice in ORDER BY, only the first key is kept.
  - testOrderDescNullsLast
```
public void testOrderDescNullsLast()
```
  - testOrderByOrdinalDesc
```
public void testOrderByOrdinalDesc()
```
  - testOrderDistinct
```
public void testOrderDistinct()
```
  - testOrderByNegativeOrdinal
```
public void testOrderByNegativeOrdinal()
```
  - testOrderByOrdinalInExpr
```
public void testOrderByOrdinalInExpr()
```
  - testOrderByIdenticalExpr
```
public void testOrderByIdenticalExpr()
```
  - testOrderByAlias
```
public void testOrderByAlias()
```
  - testOrderByAliasInExpr
```
public void testOrderByAliasInExpr()
```
  - testOrderByAliasOverrides
```
public void testOrderByAliasOverrides()
```
  - testOrderByAliasDoesNotOverride
```
public void testOrderByAliasDoesNotOverride()
```
  - testOrderBySameExpr
```
public void testOrderBySameExpr()
```
  - testOrderUnion
```
public void testOrderUnion()
```
  - testOrderUnionOrdinal
```
public void testOrderUnionOrdinal()
```
  - testOrderUnionExprs
```
public void testOrderUnionExprs()
```
  - testOrderOffsetFetch
```
public void testOrderOffsetFetch()
```
  - testOrderOffsetFetchWithDynamicParameter
```
public void testOrderOffsetFetchWithDynamicParameter()
```
  - testOffsetFetch
```
public void testOffsetFetch()
```
  - testOffsetFetchWithDynamicParameter
```
public void testOffsetFetchWithDynamicParameter()
```
  - testOffset
```
public void testOffset()
```
  - testOffsetWithDynamicParameter
```
public void testOffsetWithDynamicParameter()
```
  - testFetch
```
public void testFetch()
```
  - testFetchWithDynamicParameter
```
public void testFetchWithDynamicParameter()
```
  - testGroupAlias
```
public void testGroupAlias()
```
    Test case for [CALCITE-439] SqlValidatorUtil.uniquify() may not terminate under some conditions.
  - testOrderGroup
```
public void testOrderGroup()
```
  - testCountNoGroup
```
public void testCountNoGroup()
```
  - testWith
```
public void testWith()
```
  - testWithOrder
```
public void testWithOrder()
```
    Test case for [CALCITE-309] WITH ... ORDER BY query gives AssertionError.
  - testWithUnionOrder
```
public void testWithUnionOrder()
```
  - testWithUnion
```
public void testWithUnion()
```
  - testWithAlias
```
public void testWithAlias()
```
  - testWithInsideWhereExists
```
public void testWithInsideWhereExists()
```
  - testWithInsideWhereExistsRex
```
public void testWithInsideWhereExistsRex()
```
  - testWithInsideWhereExistsDecorrelate
```
public void testWithInsideWhereExistsDecorrelate()
```
  - testWithInsideWhereExistsDecorrelateRex
```
public void testWithInsideWhereExistsDecorrelateRex()
```
  - testWithInsideScalarSubQuery
```
public void testWithInsideScalarSubQuery()
```
  - testWithInsideScalarSubQueryRex
```
public void testWithInsideScalarSubQueryRex()
```
  - testWithExists
```
public void testWithExists()
```
    Test case for [CALCITE-365] AssertionError while translating query with WITH and correlated sub-query.
  - testTableSubset
```
public void testTableSubset()
```
  - testTableExpression
```
public void testTableExpression()
```
  - testTableExtend
```
public void testTableExtend()
```
  - testTableExtendSubset
```
public void testTableExtendSubset()
```
  - testTableExtendExpression
```
public void testTableExtendExpression()
```
  - testModifiableViewExtend
```
public void testModifiableViewExtend()
```
  - testModifiableViewExtendSubset
```
public void testModifiableViewExtendSubset()
```
  - testModifiableViewExtendExpression
```
public void testModifiableViewExtendExpression()
```
  - testSelectViewExtendedColumnCollision
```
public void testSelectViewExtendedColumnCollision()
```
  - testSelectViewExtendedColumnCaseSensitiveCollision
```
public void testSelectViewExtendedColumnCaseSensitiveCollision()
```
  - testSelectViewExtendedColumnExtendedCollision
```
public void testSelectViewExtendedColumnExtendedCollision()
```
  - testSelectViewExtendedColumnCaseSensitiveExtendedCollision
```
public void testSelectViewExtendedColumnCaseSensitiveExtendedCollision()
```
  - testSelectViewExtendedColumnUnderlyingCollision
```
public void testSelectViewExtendedColumnUnderlyingCollision()
```
  - testSelectViewExtendedColumnCaseSensitiveUnderlyingCollision
```
public void testSelectViewExtendedColumnCaseSensitiveUnderlyingCollision()
```
  - testUpdateExtendedColumnCollision
```
public void testUpdateExtendedColumnCollision()
```
  - testUpdateExtendedColumnCaseSensitiveCollision
```
public void testUpdateExtendedColumnCaseSensitiveCollision()
```
  - testUpdateExtendedColumnModifiableViewCollision
```
public void testUpdateExtendedColumnModifiableViewCollision()
```
  - testUpdateExtendedColumnModifiableViewCaseSensitiveCollision
```
public void testUpdateExtendedColumnModifiableViewCaseSensitiveCollision()
```
  - testUpdateExtendedColumnModifiableViewExtendedCollision
```
public void testUpdateExtendedColumnModifiableViewExtendedCollision()
```
  - testUpdateExtendedColumnModifiableViewExtendedCaseSensitiveCollision
```
public void testUpdateExtendedColumnModifiableViewExtendedCaseSensitiveCollision()
```
  - testUpdateExtendedColumnModifiableViewUnderlyingCollision
```
public void testUpdateExtendedColumnModifiableViewUnderlyingCollision()
```
  - testSelectModifiableViewConstraint
```
public void testSelectModifiableViewConstraint()
```
  - testModifiableViewDdlExtend
```
public void testModifiableViewDdlExtend()
```
  - testExplicitTable
```
public void testExplicitTable()
```
  - testCollectionTable
```
public void testCollectionTable()
```
  - testCollectionTableWithLateral
```
public void testCollectionTableWithLateral()
```
  - testCollectionTableWithLateral2
```
public void testCollectionTableWithLateral2()
```
  - testCollectionTableWithLateral3
```
public void testCollectionTableWithLateral3()
```
    Test case for [CALCITE-1732] IndexOutOfBoundsException when using LATERAL TABLE with more than one field.
  - testSample
```
public void testSample()
```
  - testSampleQuery
```
public void testSampleQuery()
```
  - testSampleBernoulli
```
public void testSampleBernoulli()
```
  - testSampleBernoulliQuery
```
public void testSampleBernoulliQuery()
```
  - testSampleSystem
```
public void testSampleSystem()
```
  - testSampleSystemQuery
```
public void testSampleSystemQuery()
```
  - testCollectionTableWithCursorParam
```
public void testCollectionTableWithCursorParam()
```
  - testUnnest
```
public void testUnnest()
```
  - testUnnestSubQuery
```
public void testUnnestSubQuery()
```
  - testUnnestArrayAggPlan
```
public void testUnnestArrayAggPlan()
```
  - testUnnestArrayPlan
```
public void testUnnestArrayPlan()
```
  - testUnnestArrayPlanAs
```
public void testUnnestArrayPlanAs()
```
  - testArrayOfRecord
```
public void testArrayOfRecord()
```
  - testFlattenRecords
```
public void testFlattenRecords()
```
  - testUnnestArray
```
public void testUnnestArray()
```
  - testUnnestWithOrdinality
```
public void testUnnestWithOrdinality()
```
  - testMultisetSubQuery
```
public void testMultisetSubQuery()
```
  - testMultiset
```
public void testMultiset()
```
  - testMultisetOfColumns
```
public void testMultisetOfColumns()
```
  - testMultisetOfColumnsRex
```
public void testMultisetOfColumnsRex()
```
  - testCorrelationJoin
```
public void testCorrelationJoin()
```
  - testCorrelationJoinRex
```
public void testCorrelationJoinRex()
```
  - testCorrelatedSubQueryInJoin
```
public void testCorrelatedSubQueryInJoin()
```
    Test case for [CALCITE-864] Correlation variable has incorrect row type if it is populated by right side of a Join.
  - testExists
```
public void testExists()
```
  - testExistsCorrelated
```
public void testExistsCorrelated()
```
  - testNotExistsCorrelated
```
public void testNotExistsCorrelated()
```
  - testExistsCorrelatedDecorrelate
```
public void testExistsCorrelatedDecorrelate()
```
  - testExistsCorrelatedDecorrelateRex
```
public void testExistsCorrelatedDecorrelateRex()
```
  - testExistsCorrelatedLimit
```
public void testExistsCorrelatedLimit()
```
  - testExistsCorrelatedLimitDecorrelate
```
public void testExistsCorrelatedLimitDecorrelate()
```
  - testExistsCorrelatedLimitDecorrelateRex
```
public void testExistsCorrelatedLimitDecorrelateRex()
```
  - testInValueListShort
```
public void testInValueListShort()
```
  - testInValueListLong
```
public void testInValueListLong()
```
  - testInUncorrelatedSubQuery
```
public void testInUncorrelatedSubQuery()
```
  - testInUncorrelatedSubQueryRex
```
public void testInUncorrelatedSubQueryRex()
```
  - testCompositeInUncorrelatedSubQueryRex
```
public void testCompositeInUncorrelatedSubQueryRex()
```
  - testNotInUncorrelatedSubQuery
```
public void testNotInUncorrelatedSubQuery()
```
  - testAllValueList
```
public void testAllValueList()
```
  - testSomeValueList
```
public void testSomeValueList()
```
  - testSome
```
public void testSome()
```
  - testNotInUncorrelatedSubQueryRex
```
public void testNotInUncorrelatedSubQueryRex()
```
  - testNotCaseInThreeClause
```
public void testNotCaseInThreeClause()
```
  - testNotCaseInMoreClause
```
public void testNotCaseInMoreClause()
```
  - testNotCaseInWithoutElse
```
public void testNotCaseInWithoutElse()
```
  - testWhereInCorrelated
```
public void testWhereInCorrelated()
```
  - testInUncorrelatedSubQueryInSelect
```
public void testInUncorrelatedSubQueryInSelect()
```
  - testInUncorrelatedSubQueryInSelectRex
```
public void testInUncorrelatedSubQueryInSelectRex()
```
  - testInUncorrelatedSubQueryInHavingRex
```
public void testInUncorrelatedSubQueryInHavingRex()
```
  - testUncorrelatedScalarSubQueryInOrderRex
```
public void testUncorrelatedScalarSubQueryInOrderRex()
```
  - testUncorrelatedScalarSubQueryInGroupOrderRex
```
public void testUncorrelatedScalarSubQueryInGroupOrderRex()
```
  - testUncorrelatedScalarSubQueryInAggregateRex
```
public void testUncorrelatedScalarSubQueryInAggregateRex()
```
  - testNotInUncorrelatedSubQueryInSelect
```
public void testNotInUncorrelatedSubQueryInSelect()
```
    Plan should be as testInUncorrelatedSubQueryInSelect(), but with an extra NOT. Both queries require 3-valued logic.
  - testNotInUncorrelatedSubQueryInSelectRex
```
public void testNotInUncorrelatedSubQueryInSelectRex()
```
  - testNotInUncorrelatedSubQueryInSelectNotNull
```
public void testNotInUncorrelatedSubQueryInSelectNotNull()
```
    Since 'deptno NOT IN (SELECT deptno FROM dept)' can not be null, we generate a simpler plan.
  - testNotInUncorrelatedSubQueryInSelectMayBeNull
```
public void testNotInUncorrelatedSubQueryInSelectMayBeNull()
```
    Since 'deptno NOT IN (SELECT mgr FROM emp)' can be null, we need a more complex plan, including counts of null and not-null keys.
  - testNotInUncorrelatedSubQueryInSelectDeduceNotNull
```
public void testNotInUncorrelatedSubQueryInSelectDeduceNotNull()
```
    Even though "mgr" allows nulls, we can deduce from the WHERE clause that it will never be null. Therefore we can generate a simpler plan.
  - testNotInUncorrelatedSubQueryInSelectDeduceNotNull2
```
public void testNotInUncorrelatedSubQueryInSelectDeduceNotNull2()
```
    Similar to testNotInUncorrelatedSubQueryInSelectDeduceNotNull(), using IS NOT NULL.
  - testNotInUncorrelatedSubQueryInSelectDeduceNotNull3
```
public void testNotInUncorrelatedSubQueryInSelectDeduceNotNull3()
```
    Similar to testNotInUncorrelatedSubQueryInSelectDeduceNotNull(), using IN.
  - testNotInUncorrelatedSubQueryInSelectNotNullRex
```
public void testNotInUncorrelatedSubQueryInSelectNotNullRex()
```
  - testUnnestSelect
```
public void testUnnestSelect()
```
  - testUnnestSelectRex
```
public void testUnnestSelectRex()
```
  - testJoinUnnest
```
public void testJoinUnnest()
```
  - testJoinUnnestRex
```
public void testJoinUnnestRex()
```
  - testLateral
```
public void testLateral()
```
  - testLateralDecorrelate
```
public void testLateralDecorrelate()
```
  - testLateralDecorrelateRex
```
public void testLateralDecorrelateRex()
```
  - testLateralDecorrelateThetaRex
```
public void testLateralDecorrelateThetaRex()
```
  - testNestedCorrelations
```
public void testNestedCorrelations()
```
  - testNestedCorrelationsDecorrelated
```
public void testNestedCorrelationsDecorrelated()
```
  - testNestedCorrelationsDecorrelatedRex
```
public void testNestedCorrelationsDecorrelatedRex()
```
  - testElement
```
public void testElement()
```
  - testElementInValues
```
public void testElementInValues()
```
  - testUnionAll
```
public void testUnionAll()
```
  - testUnion
```
public void testUnion()
```
  - testUnionValues
```
public void testUnionValues()
```
  - testUnionSubQuery
```
public void testUnionSubQuery()
```
  - testIsDistinctFrom
```
public void testIsDistinctFrom()
```
  - testIsNotDistinctFrom
```
public void testIsNotDistinctFrom()
```
  - testNotLike
```
public void testNotLike()
```
  - testTumble
```
public void testTumble()
```
  - testNotNotIn
```
public void testNotNotIn()
```
  - testOverMultiple
```
public void testOverMultiple()
```
  - testNestedAggregates
```
public void testNestedAggregates()
```
    Test case for [CALCITE-750] Allow windowed aggregate on top of regular aggregate.
  - testCase
```
public void testCase()
```
    Test one of the custom conversions which is recognized by the class of the operator (in this case, SqlCaseOperator).
  - testCharLength
```
public void testCharLength()
```
    Tests one of the custom conversions which is recognized by the identity of the operator (in this case, SqlStdOperatorTable.CHARACTER_LENGTH).
  - testOverAvg
```
public void testOverAvg()
```
  - testOverAvg2
```
public void testOverAvg2()
```
  - testOverCountStar
```
public void testOverCountStar()
```
  - testOverOrderWindow
```
public void testOverOrderWindow()
```
    Tests that a window containing only ORDER BY is implicitly CURRENT ROW.
  - testOverOrderFollowingWindow
```
public void testOverOrderFollowingWindow()
```
    Tests that a window with a FOLLOWING bound becomes BETWEEN CURRENT ROW AND FOLLOWING.
  - testTumbleTable
```
public void testTumbleTable()
```
  - testTumbleTableRowtimeNotFirstColumn
```
public void testTumbleTableRowtimeNotFirstColumn()
```
    As testTumbleTable() but on a table where "rowtime" is at position 1 not 0.
  - testHopTable
```
public void testHopTable()
```
  - testSessionTable
```
public void testSessionTable()
```
  - testInterval
```
public void testInterval()
```
  - testStream
```
public void testStream()
```
  - testStreamGroupBy
```
public void testStreamGroupBy()
```
  - testStreamWindowedAggregation
```
public void testStreamWindowedAggregation()
```
  - testExplainAsXml
```
public void testExplainAsXml()
```
  - testSortWithTrim
```
public void testSortWithTrim()
```
    Test case for [CALCITE-412] RelFieldTrimmer: when trimming Sort, the collation and trait set don't match.
  - testOffset0
```
public void testOffset0()
```
  - testGroupByCaseSubQuery
```
public void testGroupByCaseSubQuery()
```
    Test group-by CASE expression involving a non-query IN
  - testAggCaseSubQuery
```
public void testAggCaseSubQuery()
```
    Test aggregate function on a CASE expression involving a non-query IN
  - testAggNoDuplicateColumnNames
```
public void testAggNoDuplicateColumnNames()
```
    Test case for [CALCITE-753] Test aggregate operators do not derive row types with duplicate column names.
  - testAggScalarSubQuery
```
public void testAggScalarSubQuery()
```
  - testAggCaseInSubQuery
```
public void testAggCaseInSubQuery()
```
    Test aggregate function on a CASE expression involving IN with a sub-query.
    Test case for [CALCITE-551] Sub-query inside aggregate function.
  - testCorrelatedSubQueryInAggregate
```
public void testCorrelatedSubQueryInAggregate()
```
  - testGroupByCaseIn
```
public void testGroupByCaseIn()
```
    Test case for [CALCITE-614] IN within CASE within GROUP BY gives AssertionError.
  - testInsert
```
public void testInsert()
```
  - testInsertSubset
```
public void testInsertSubset()
```
  - testInsertWithCustomInitializerExpressionFactory
```
public void testInsertWithCustomInitializerExpressionFactory()
```
  - testInsertSubsetWithCustomInitializerExpressionFactory
```
public void testInsertSubsetWithCustomInitializerExpressionFactory()
```
  - testInsertBind
```
public void testInsertBind()
```
  - testInsertBindSubset
```
public void testInsertBindSubset()
```
  - testInsertBindWithCustomInitializerExpressionFactory
```
public void testInsertBindWithCustomInitializerExpressionFactory()
```
  - testInsertBindSubsetWithCustomInitializerExpressionFactory
```
public void testInsertBindSubsetWithCustomInitializerExpressionFactory()
```
  - testInsertSubsetView
```
public void testInsertSubsetView()
```
  - testInsertExtendedColumn
```
public void testInsertExtendedColumn()
```
  - testInsertBindExtendedColumn
```
public void testInsertBindExtendedColumn()
```
  - testInsertExtendedColumnModifiableView
```
public void testInsertExtendedColumnModifiableView()
```
  - testInsertBindExtendedColumnModifiableView
```
public void testInsertBindExtendedColumnModifiableView()
```
  - testDelete
```
public void testDelete()
```
  - testDeleteWhere
```
public void testDeleteWhere()
```
  - testDeleteBind
```
public void testDeleteBind()
```
  - testDeleteBindExtendedColumn
```
public void testDeleteBindExtendedColumn()
```
  - testDeleteBindModifiableView
```
public void testDeleteBindModifiableView()
```
  - testDeleteBindExtendedColumnModifiableView
```
public void testDeleteBindExtendedColumnModifiableView()
```
  - testUpdate
```
public void testUpdate()
```
  - testUpdateSubQuery
```
public void testUpdateSubQuery()
```
  - testUpdateWhere
```
public void testUpdateWhere()
```
  - testUpdateModifiableView
```
public void testUpdateModifiableView()
```
  - testUpdateExtendedColumn
```
public void testUpdateExtendedColumn()
```
  - testUpdateExtendedColumnModifiableView
```
public void testUpdateExtendedColumnModifiableView()
```
  - testUpdateBind
```
public void testUpdateBind()
```
  - testUpdateBind2
```
public void testUpdateBind2()
```
  - testUpdateBindExtendedColumn
```
public void testUpdateBindExtendedColumn()
```
  - testUpdateBindExtendedColumnModifiableView
```
public void testUpdateBindExtendedColumnModifiableView()
```
  - testMerge
```
public void testMerge()
```
  - testSelectView
```
public void testSelectView()
```
  - testInsertView
```
public void testInsertView()
```
  - testInsertModifiableView
```
public void testInsertModifiableView()
```
  - testInsertSubsetModifiableView
```
public void testInsertSubsetModifiableView()
```
  - testInsertBindModifiableView
```
public void testInsertBindModifiableView()
```
  - testInsertBindSubsetModifiableView
```
public void testInsertBindSubsetModifiableView()
```
  - testInsertWithCustomColumnResolving
```
public void testInsertWithCustomColumnResolving()
```
  - testInsertWithCustomColumnResolving2
```
public void testInsertWithCustomColumnResolving2()
```
  - testInsertViewWithCustomColumnResolving
```
public void testInsertViewWithCustomColumnResolving()
```
  - testUpdateWithCustomColumnResolving
```
public void testUpdateWithCustomColumnResolving()
```
  - testSubQueryAggregateFunctionFollowedBySimpleOperation
```
public void testSubQueryAggregateFunctionFollowedBySimpleOperation()
```
    Test case for [CALCITE-695] SqlSingleValueAggFunction is created when it may not be needed.
  - testSubQueryOr
```
public void testSubQueryOr()
```
    Test case for [CALCITE-1799] "OR .. IN" sub-query conversion wrong.
    The problem is only fixed if you have expand = false.
  - testSubQueryValues
```
public void testSubQueryValues()
```
    Test case for [CALCITE-695] SqlSingleValueAggFunction is created when it may not be needed.
  - testSubQueryLimitOne
```
public void testSubQueryLimitOne()
```
    Test case for [CALCITE-695] SqlSingleValueAggFunction is created when it may not be needed.
  - testIdenticalExpressionInSubQuery
```
public void testIdenticalExpressionInSubQuery()
```
    Test case for [CALCITE-710] When look up sub-queries, perform the same logic as the way when ones were registered.
  - testHavingAggrFunctionIn
```
public void testHavingAggrFunctionIn()
```
    Test case for [CALCITE-694] Scan HAVING clause for sub-queries and IN-lists relating to IN.
  - testHavingInSubQueryWithAggrFunction
```
public void testHavingInSubQueryWithAggrFunction()
```
    Test case for [CALCITE-694] Scan HAVING clause for sub-queries and IN-lists, with a sub-query in the HAVING clause.
  - testAggregateAndScalarSubQueryInHaving
```
public void testAggregateAndScalarSubQueryInHaving()
```
    Test case for [CALCITE-716] Scalar sub-query and aggregate function in SELECT or HAVING clause gives AssertionError; variant involving HAVING clause.
  - testAggregateAndScalarSubQueryInSelect
```
public void testAggregateAndScalarSubQueryInSelect()
```
    Test case for [CALCITE-716] Scalar sub-query and aggregate function in SELECT or HAVING clause gives AssertionError; variant involving SELECT clause.
  - testWindowAggWithGroupBy
```
public void testWindowAggWithGroupBy()
```
    Test case for [CALCITE-770] window aggregate and ranking functions with grouped aggregates.
  - testWindowAverageWithGroupBy
```
public void testWindowAverageWithGroupBy()
```
    Test case for [CALCITE-847] AVG window function in GROUP BY gives AssertionError.
  - testWindowAggWithGroupByAndJoin
```
public void testWindowAggWithGroupByAndJoin()
```
    Test case for [CALCITE-770] variant involving joins.
  - testWindowAggWithGroupByAndHaving
```
public void testWindowAggWithGroupByAndHaving()
```
    Test case for [CALCITE-770] variant involving HAVING clause.
  - testWindowAggInSubQueryJoin
```
public void testWindowAggInSubQueryJoin()
```
    Test case for [CALCITE-770] variant involving join with sub-query that contains window function and GROUP BY.
  - testOrderByOver
```
public void testOrderByOver()
```
    Test case for [CALCITE-1313] Validator should derive type of expression in ORDER BY.
  - testCorrelationScalarAggAndFilter
```
public void testCorrelationScalarAggAndFilter()
```
    Test case (correlated scalar aggregate sub-query) for [CALCITE-714] When de-correlating, push join condition into sub-query.
  - testCorrelationMultiScalarAggregate
```
public void testCorrelationMultiScalarAggregate()
```
    Test case for [CALCITE-1543] Correlated scalar sub-query with multiple aggregates gives AssertionError.
  - testCorrelationScalarAggAndFilterRex
```
public void testCorrelationScalarAggAndFilterRex()
```
  - testCorrelationExistsAndFilter
```
public void testCorrelationExistsAndFilter()
```
    Test case (correlated EXISTS sub-query) for [CALCITE-714] When de-correlating, push join condition into sub-query.
  - testCorrelationExistsAndFilterRex
```
public void testCorrelationExistsAndFilterRex()
```
  - testCorrelationExistsAndFilterThetaRex
```
public void testCorrelationExistsAndFilterThetaRex()
```
    A theta join condition, unlike the equi-join condition in testCorrelationExistsAndFilterRex(), requires a value generator.
  - testCorrelationNotExistsAndFilter
```
public void testCorrelationNotExistsAndFilter()
```
    Test case (correlated NOT EXISTS sub-query) for [CALCITE-714] When de-correlating, push join condition into sub-query.
  - testCustomColumnResolving
```
public void testCustomColumnResolving()
```
  - testCustomColumnResolving2
```
public void testCustomColumnResolving2()
```
  - testCustomColumnResolving3
```
public void testCustomColumnResolving3()
```
  - testCustomColumnResolving4
```
public void testCustomColumnResolving4()
```
  - testCustomColumnResolving5
```
public void testCustomColumnResolving5()
```
  - testCustomColumnResolvingWithSelectStar
```
public void testCustomColumnResolvingWithSelectStar()
```
  - testCustomColumnResolvingWithSelectFieldNameDotStar
```
public void testCustomColumnResolvingWithSelectFieldNameDotStar()
```
  - testSelectFromDynamicTable
```
public void testSelectFromDynamicTable()
                                throws java.lang.Exception
```
    Test case for [CALCITE-1150] Dynamic Table / Dynamic Star support
    
    Throws:
    
    java.lang.Exception
  - testSelectStarFromDynamicTable
```
public void testSelectStarFromDynamicTable()
                                    throws java.lang.Exception
```
    Test case for Dynamic Table / Dynamic Star support [CALCITE-1150]
    
    Throws:
    
    java.lang.Exception
  - testNotInWithLiteral
```
public void testNotInWithLiteral()
```
    Test case for [CALCITE-2080] Query with NOT IN operator and literal fails throws AssertionError: 'Cast for just nullability not allowed'.
  - testReferDynamicStarInSelectOB
```
public void testReferDynamicStarInSelectOB()
                                    throws java.lang.Exception
```
    Test case for Dynamic Table / Dynamic Star support [CALCITE-1150]
    
    Throws:
    
    java.lang.Exception
  - testDynamicStarInTableJoin
```
public void testDynamicStarInTableJoin()
                                throws java.lang.Exception
```
    Test case for Dynamic Table / Dynamic Star support [CALCITE-1150]
    
    Throws:
    
    java.lang.Exception
  - testDynamicNestedColumn
```
public void testDynamicNestedColumn()
```
  - testDynamicSchemaUnnest
```
public void testDynamicSchemaUnnest()
```
  - testStarDynamicSchemaUnnest
```
public void testStarDynamicSchemaUnnest()
```
  - testStarDynamicSchemaUnnest2
```
public void testStarDynamicSchemaUnnest2()
```
  - testStarDynamicSchemaUnnestNestedSubQuery
```
public void testStarDynamicSchemaUnnestNestedSubQuery()
```
  - testReferDynamicStarInSelectWhereGB
```
public void testReferDynamicStarInSelectWhereGB()
                                         throws java.lang.Exception
```
    Test case for Dynamic Table / Dynamic Star support [CALCITE-1150]
    
    Throws:
    
    java.lang.Exception
  - testDynamicStarInJoinAndSubQ
```
public void testDynamicStarInJoinAndSubQ()
                                  throws java.lang.Exception
```
    Test case for Dynamic Table / Dynamic Star support [CALCITE-1150]
    
    Throws:
    
    java.lang.Exception
  - testStarJoinStaticDynTable
```
public void testStarJoinStaticDynTable()
                                throws java.lang.Exception
```
    Test case for Dynamic Table / Dynamic Star support [CALCITE-1150]
    
    Throws:
    
    java.lang.Exception
  - testGrpByColFromStarInSubQuery
```
public void testGrpByColFromStarInSubQuery()
                                    throws java.lang.Exception
```
    Test case for Dynamic Table / Dynamic Star support [CALCITE-1150]
    
    Throws:
    
    java.lang.Exception
  - testDynStarInExistSubQ
```
public void testDynStarInExistSubQ()
                            throws java.lang.Exception
```
    Test case for Dynamic Table / Dynamic Star support [CALCITE-1150]
    
    Throws:
    
    java.lang.Exception
  - testSelectDynamicStarOrderBy
```
public void testSelectDynamicStarOrderBy()
                                  throws java.lang.Exception
```
    Test case for [CALCITE-1150] Create the a new DynamicRecordType, avoiding star expansion when working with this type.
    
    Throws:
    
    java.lang.Exception
  - testInToSemiJoin
```
public void testInToSemiJoin()
```
    Test case for [CALCITE-1321] Configurable IN list size when converting IN clause to join.
  - testWindowOnDynamicStar
```
public void testWindowOnDynamicStar()
                             throws java.lang.Exception
```
    Test case for [CALCITE-1944] Window function applied to sub-query with dynamic star gets wrong plan.
    
    Throws:
    
    java.lang.Exception
  - testWindowAndGroupByWithDynamicStar
```
public void testWindowAndGroupByWithDynamicStar()
```
  - testAnyValueAggregateFunctionNoGroupBy
```
public void testAnyValueAggregateFunctionNoGroupBy()
                                            throws java.lang.Exception
```
    Test case for [CALCITE-2366] Add support for ANY_VALUE aggregate function.
    
    Throws:
    
    java.lang.Exception
  - testAnyValueAggregateFunctionGroupBy
```
public void testAnyValueAggregateFunctionGroupBy()
                                          throws java.lang.Exception
```
    Throws:
    
    java.lang.Exception
  - getExtendedTester
```
private SqlToRelTestBase.Tester getExtendedTester()
```
  - testLarge
```
public void testLarge()
```
  - testUnionInFrom
```
public void testUnionInFrom()
```
  - testMatchRecognize1
```
public void testMatchRecognize1()
```
  - testMatchRecognizeMeasures1
```
public void testMatchRecognizeMeasures1()
```
  - testMatchRecognizeMeasures2
```
public void testMatchRecognizeMeasures2()
```
    Test case for [CALCITE-1909] Output rowType of Match should include PARTITION BY and ORDER BY columns.
  - testMatchRecognizeMeasures3
```
public void testMatchRecognizeMeasures3()
```
  - testMatchRecognizePatternSkip1
```
public void testMatchRecognizePatternSkip1()
```
  - testMatchRecognizeSubset1
```
public void testMatchRecognizeSubset1()
```
  - testMatchRecognizePrevLast
```
public void testMatchRecognizePrevLast()
```
  - testMatchRecognizePrevDown
```
public void testMatchRecognizePrevDown()
```
  - testPrevClassifier
```
public void testPrevClassifier()
```
  - testUserDefinedOrderByOver
```
public void testUserDefinedOrderByOver()
```
    Test case for [CALCITE-2323] Validator should allow alternative nullCollations for ORDER BY in OVER.
  - testJsonExists
```
public void testJsonExists()
```
  - testJsonValue
```
public void testJsonValue()
```
  - testJsonQuery
```
public void testJsonQuery()
```
  - testJsonArray
```
public void testJsonArray()
```
  - testJsonArrayAgg
```
public void testJsonArrayAgg()
```
  - testJsonObject
```
public void testJsonObject()
```
  - testJsonObjectAgg
```
public void testJsonObjectAgg()
```
  - testJsonPredicate
```
public void testJsonPredicate()
```
  - testWithinGroup1
```
public void testWithinGroup1()
```
  - testWithinGroup2
```
public void testWithinGroup2()
```
  - testWithinGroup3
```
public void testWithinGroup3()
```

Class SqlToRelConverterTest

Nested Class Summary

Nested classes/interfaces inherited from class org.apache.calcite.test.SqlToRelTestBase

Field Summary

Fields inherited from class org.apache.calcite.test.SqlToRelTestBase

Constructor Summary

Method Summary

Methods inherited from class org.apache.calcite.test.SqlToRelTestBase

Methods inherited from class java.lang.Object

Constructor Detail

SqlToRelConverterTest

Method Detail

getDiffRepos

sql

check

testDotLiteralAfterNestedRow

testDotLiteralAfterRow

testIntegerLiteral

testIntervalLiteralYearToMonth

testIntervalLiteralHourToMinute

testAliasList

testAliasList2

testStructTypeAlias

testJoinUsingDynamicTable

testMultiAnd

testJoinOn

testConditionOffByOne

testConditionOffByOneReversed

testJoinOnExpression

testJoinOnIn

testJoinOnInSubQuery

testJoinOnExists

testJoinUsing

testJoinUsingThreeWay

testJoinUsingCompound

testValuesUsing

testJoinNatural

testJoinNaturalNoCommonColumn

testJoinNaturalMultipleCommonColumn

testJoinWithUnion

testGroup

testGroupByAlias

testGroupByAliasOfSubExpressionsInProject

testGroupByAliasEqualToColumnName

testGroupByOrdinal

testGroupByContainsLiterals

testAliasInHaving

testGroupJustOneAgg

testGroupExpressionsInsideAndOut

testAggregateNoGroup

testGroupEmpty

testSingletonGroupingSet

testGroupingSets

testGroupingSetsWithRollup

testGroupingSetsWithCube

testGroupingSetsWithRollupCube

testGroupingSetsProduct

testGroupingFunctionWithGroupBy

testGroupingFunction

testGroupByWithDuplicates

testDuplicateGroupingSets

testGroupingSetsCartesianProduct

testGroupingSetsCartesianProduct2

testRollupSimple

testRollup

testRollupTuples

testCube

testGroupingSetsWith

testHaving

testGroupBug281

testGroupBug281b

testGroupByExpression

testAggDistinct

testAggFilter

testAggFilterWithIn

testFakeStar

testSelectDistinct

testSelectOverDistinct

testSelectStreamPartitionDistinct

testSelectDistinctGroup