java.lang.Object
- org.apache.calcite.test.SqlToRelTestBase
- - org.apache.calcite.test.RelOptTestBase
  - - org.apache.calcite.test.RelOptRulesTest

```
public class RelOptRulesTest
extends RelOptTestBase
```
Unit test for rules in org.apache.calcite.rel and subpackages.
As input, the test supplies a SQL statement and a single rule; the SQL is translated into relational algebra and then fed into a HepPlanner. The planner fires the rule on every pattern match in a depth-first left-to-right pre-order traversal of the tree for as long as the rule continues to succeed in applying its transform. (For rules which call transformTo more than once, only the last result is used.) The plan before and after "optimization" is diffed against a .ref file using DiffRepository.
Procedure for adding a new test case:
1. Add a new public test method for your rule, following the existing examples. You'll have to come up with an SQL statement to which your rule will apply in a meaningful way. See SqlToRelTestBase class comments for details on the schema.
2. Run the test. It should fail. Inspect the output in target/surefire/.../RelOptRulesTest.xml. (If you are running using maven and this file does not exist, add a -X flag to the maven command line.)
3. Verify that the "planBefore" is the correct translation of your SQL, and that it contains the pattern on which your rule is supposed to fire. If all is well, replace src/test/resources/.../RelOptRulesTest.xml and with the new target/surefire/.../RelOptRulesTest.xml.
4. Run the test again. It should fail again, but this time it should contain a "planAfter" entry for your rule. Verify that your rule applied its transformation correctly, and then update the src/test/resources/.../RelOptRulesTest.xml file again.
5. Run the test one last time; this time it should pass.

Nested Class Summary
- Nested classes/interfaces inherited from class org.apache.calcite.test.RelOptTestBase
  RelOptTestBase.Sql
- Nested classes/interfaces inherited from class org.apache.calcite.test.SqlToRelTestBase
  SqlToRelTestBase.MockRelOptSchema, SqlToRelTestBase.Tester, SqlToRelTestBase.TesterImpl

Field Summary

Fields
Modifier and Type	Field	Description
`private static java.lang.String`	`NOT_STRONG_EXPR`
`private org.apache.calcite.rel.rules.PushProjector.ExprCondition`	`skipItem`
`private static java.lang.String`	`STRONG_EXPR`

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

Constructor Summary

Constructors
Constructor Description

RelOptRulesTest()

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`private void`	`basePullConstantTroughAggregate()`
`private void`	`basePushAggThroughUnion()`
`private void`	`basePushFilterPastAggWithGroupingSets(boolean unchanged)`
`private void`	`checkPlanning(java.lang.String query)`
`private void`	`checkReduceNullableToNotNull(org.apache.calcite.rel.rules.ReduceExpressionsRule rule)`
`private RelOptTestBase.Sql`	`checkSubQuery(java.lang.String sql)`
`protected DiffRepository`	`getDiffRepos()`	Returns the default diff repository for this test, or null if there is no repository.
`void`	`testAddRedundantSemiJoinRule()`
`void`	`testAggregateConstantKeyRule()`	Test case for [CALCITE-1023] Planner rule that removes Aggregate keys that are constant.
`void`	`testAggregateConstantKeyRule2()`	Tests `AggregateProjectPullUpConstantsRule` where reduction is not possible because "deptno" is the only key.
`void`	`testAggregateConstantKeyRule3()`	Tests `AggregateProjectPullUpConstantsRule` where both keys are constants but only one can be removed.
`void`	`testAggregateExtractProjectRule()`
`void`	`testAggregateExtractProjectRuleWithFilter()`
`void`	`testAggregateExtractProjectRuleWithGroupingSets()`
`void`	`testAggregateExtractProjectRuleWithGroupingSets2()`	Test with column used in both grouping set and argument to aggregate function.
`void`	`testAggregateGroupingSetsProjectMerge()`
`void`	`testAggregateProjectMerge()`
`void`	`testAggregateProjectPullUpConstants()`
`void`	`testAggregateProjectPullUpConstants2()`
`void`	`testAll()`
`void`	`testAlreadyFalseEliminatesFilter()`
`void`	`testCasePushIsAlwaysWorking()`
`void`	`testCastInAggregateExpandDistinctAggregatesRule()`	Test case for [CALCITE-1621] Adding a cast around the null literal in aggregate rules.
`void`	`testCastInAggregateReduceFunctions()`	Test case for [CALCITE-1621] Adding a cast around the null literal in aggregate rules.
`void`	`testConvertMultiJoinRule()`
`void`	`testConvertMultiJoinRuleOuterJoins()`
`void`	`testConvertMultiJoinRuleOuterJoins2()`
`void`	`testConvertMultiJoinRuleOuterJoins3()`
`void`	`testConvertMultiJoinRuleOuterJoins4()`
`void`	`testCorrelationScalarAggAndFilter()`	Test case for [CALCITE-2110] ArrayIndexOutOfBoundsException in RexSimplify when using ReduceExpressionsRule.JOIN_INSTANCE.
`void`	`testCustomColumnResolvingInCorrelatedSubQuery()`
`void`	`testCustomColumnResolvingInCorrelatedSubQuery2()`
`void`	`testCustomColumnResolvingInNonCorrelatedSubQuery()`
`void`	`testDecorrelateExists()`
`void`	`testDecorrelateTwoExists()`	Test case for [CALCITE-1511] AssertionError while decorrelating query with two EXISTS sub-queries.
`void`	`testDecorrelateTwoIn()`	Test case for [CALCITE-1537] Unnecessary project expression in multi-sub-query plan.
`void`	`testDecorrelateTwoScalar()`	Test case for [CALCITE-1045] Decorrelate sub-queries in Project and Join, with the added complication that there are two sub-queries.
`void`	`testDecorrelateUncorrelatedInAndCorrelatedExists()`	Test case for [CALCITE-2028] Un-correlated IN sub-query should be converted into a Join, rather than a Correlate without correlation variables .
`void`	`testDistinctCount1()`
`void`	`testDistinctCount2()`
`void`	`testDistinctCount3()`	Test case for [CALCITE-1293] Bad code generated when argument to COUNT(DISTINCT) is a # GROUP BY column.
`void`	`testDistinctCountGroupingSets1()`
`void`	`testDistinctCountGroupingSets2()`
`void`	`testDistinctCountMixed()`
`void`	`testDistinctCountMixed2()`
`void`	`testDistinctCountMixedJoin()`
`void`	`testDistinctCountMultiple()`	Tests implementing multiple distinct count the new way, using GROUPING SETS.
`void`	`testDistinctCountMultipleNoGroup()`
`void`	`testDistinctCountMultipleViaJoin()`	Tests implementing multiple distinct count the old way, using a join.
`void`	`testDistinctCountWithoutGroupBy()`
`void`	`testDistinctNonDistinctAggregates()`
`void`	`testDistinctNonDistinctAggregatesWithGrouping1()`	Test case for [CALCITE-1558] AggregateExpandDistinctAggregatesRule gets field mapping wrong if groupKey is used in aggregate function.
`void`	`testDistinctNonDistinctAggregatesWithGrouping2()`
`void`	`testDistinctNonDistinctTwoAggregatesWithGrouping()`
`void`	`testDistinctWithGrouping()`
`void`	`testDistinctWithMultipleInputs()`
`void`	`testDistinctWithMultipleInputsAndGroupby()`
`void`	`testEmptyAggregate()`
`void`	`testEmptyAggregateEmptyKey()`
`void`	`testEmptyAggregateEmptyKeyWithAggregateValuesRule()`
`void`	`testEmptyFilterProjectUnion()`
`void`	`testEmptyIntersect()`
`void`	`testEmptyJoin()`
`void`	`testEmptyJoinLeft()`
`void`	`testEmptyJoinRight()`
`void`	`testEmptyMinus()`
`void`	`testEmptyMinus2()`
`void`	`testEmptyProject()`	Test case for [CALCITE-1488] ValuesReduceRule should ignore empty Values.
`void`	`testEmptyProject2()`	Same query as `testEmptyProject()`, and `PruneEmptyRules` is able to do the job that `ValuesReduceRule` cannot do.
`void`	`testEmptySort()`
`void`	`testEmptySortLimitZero()`
`void`	`testExpandFilterExists()`	An EXISTS filter that can be converted into true/false.
`void`	`testExpandFilterExistsSimple()`	An EXISTS filter that can be converted into a semi-join.
`void`	`testExpandFilterExistsSimpleAnd()`	An EXISTS filter that can be converted into a semi-join.
`void`	`testExpandFilterIn()`
`void`	`testExpandFilterIn3Value()`	An IN filter that requires full 3-value logic (true, false, unknown).
`void`	`testExpandFilterInComposite()`
`void`	`testExpandFilterScalar()`
`void`	`testExpandJoinExists()`
`void`	`testExpandJoinIn()`
`void`	`testExpandJoinInComposite()`
`void`	`testExpandJoinScalar()`
`void`	`testExpandProjectExists()`
`void`	`testExpandProjectIn()`
`void`	`testExpandProjectInComposite()`
`void`	`testExpandProjectInNullable()`
`void`	`testExpandProjectScalar()`	Tests expanding a sub-query, specifically an uncorrelated scalar sub-query in a project (SELECT clause).
`void`	`testExpandWhereComparisonCorrelated()`
`void`	`testExpressionInWindowFunction()`	Test case for [CALCITE-841] Redundant windows when window function arguments are expressions.
`void`	`testExtractJoinFilterRule()`
`void`	`testExtractYearMonthToRange()`
`void`	`testExtractYearToRange()`	Test case for [CALCITE-434] Converting predicates on date dimension columns into date ranges, specifically a rule that converts `EXTRACT(YEAR FROM ...) = constant` to a range.
`void`	`testFilterProjectTranspose()`	Tests a variant of `FilterProjectTransposeRule` that pushes a Filter that contains a correlating variable.
`void`	`testFilterProjectTransposePreventedByCorrelation()`	Tests that the default instance of `FilterProjectTransposeRule` does not push a Filter that contains a correlating variable.
`void`	`testFilterRemoveIsNotDistinctFromRule()`
`void`	`testFullOuterJoinSimplificationToInner()`
`void`	`testFullOuterJoinSimplificationToLeftOuter()`
`void`	`testFullOuterJoinSimplificationToRightOuter()`
`void`	`testHeterogeneousConversion()`
`void`	`testInferringPredicatesWithNotOperatorInJoinCondition()`	Test case for [CALCITE-2275] JoinPushTransitivePredicatesRule wrongly pushes down NOT condition.
`void`	`testIntersectToDistinct()`	Tests `IntersectToDistinctRule`, which rewrites an `Intersect` operator with 3 inputs.
`void`	`testIntersectToDistinctAll()`	Tests that `IntersectToDistinctRule` correctly ignores an `INTERSECT ALL`.
`void`	`testJoinProjectTranspose()`
`void`	`testJoinPushTransitivePredicatesRule()`	Test case for [CALCITE-2200] Infinite loop for JoinPushTransitivePredicatesRule.
`void`	`testJoinPushTransitivePredicatesRule2()`	Test case for [CALCITE-2205] One more infinite loop for JoinPushTransitivePredicatesRule.
`void`	`testLeftOuterJoinSimplificationToInner()`
`void`	`testMergeFilter()`	Tests that filters are combined if they are identical.
`void`	`testMergeFilterWithJoinCondition()`
`void`	`testMergeIntersect()`	Tests `UnionMergeRule.INTERSECT_INSTANCE`, which merges 2 `Intersect` operators into a single `Intersect` with 3 inputs.
`void`	`testMergeJoinFilter()`	Tests that a filters is combined are combined if they are identical, even if one of them originates in an ON clause of a JOIN.
`void`	`testMergeMinus()`	Tests `UnionMergeRule.MINUS_INSTANCE`, which merges 2 `Minus` operators into a single `Minus` with 3 inputs.
`void`	`testMergeMinusRightDeep()`	Tests `UnionMergeRule.MINUS_INSTANCE` does not merge `Minus(a, Minus(b, c))` into `Minus(a, b, c)`, which would be incorrect.
`void`	`testMergeSetOpMixed()`	Tests that `UnionMergeRule` does nothing if its arguments have are different set operators, `Union` and `Intersect`.
`void`	`testMergeUnionAll()`	Tests `UnionMergeRule`, which merges 2 `Union` operators into a single `Union` with 3 inputs.
`void`	`testMergeUnionDistinct()`	Tests `UnionMergeRule`, which merges 2 `Union` `DISTINCT` (not `ALL`) operators into a single `Union` with 3 inputs.
`void`	`testMergeUnionMixed()`	Tests that `UnionMergeRule` does nothing if its arguments have different `ALL` settings.
`void`	`testMergeUnionMixed2()`	Tests that `UnionMergeRule` converts all inputs to DISTINCT if the top one is DISTINCT.
`void`	`testMinusMergeRule()`
`void`	`testMultipleDistinctWithGrouping()`
`void`	`testNestedAggregates()`	Test case for [CALCITE-750] Allow windowed aggregate on top of regular aggregate.
`void`	`testNoOversimplificationBelowIsNull()`	Test case for [CALCITE-2726] ReduceExpressionRule may oversimplify filter conditions containing nulls.
`void`	`testOrAlwaysTrue()`
`void`	`testOrAlwaysTrue2()`
`void`	`testOversimplifiedCaseStatement()`
`void`	`testProjectCorrelateTranspose()`
`void`	`testProjectCorrelateTransposeDynamic()`
`void`	`testProjectCorrelateTransposeRuleAntiCorrelate()`
`void`	`testProjectCorrelateTransposeRuleLeftCorrelate()`
`void`	`testProjectCorrelateTransposeRuleSemiCorrelate()`
`void`	`testProjectCorrelateTransposeWithExprCond()`
`void`	`testProjectToWindowRuleForMultipleWindows()`
`void`	`testProjectWindowTransposeRule()`
`void`	`testProjectWindowTransposeRuleWithConstants()`
`void`	`testPullAggregateThroughUnion()`
`void`	`testPullAggregateThroughUnion2()`
`void`	`testPullConstantIntoFilter()`
`void`	`testPullConstantIntoJoin()`
`void`	`testPullConstantIntoJoin2()`
`void`	`testPullConstantIntoProject()`
`void`	`testPullConstantThroughAggregateAllConst()`
`void`	`testPullConstantThroughAggregateAllLiterals()`
`void`	`testPullConstantThroughAggregateConstGroupBy()`
`void`	`testPullConstantThroughAggregatePermuted()`
`void`	`testPullConstantThroughAggregatePermutedConstFirst()`
`void`	`testPullConstantThroughAggregatePermutedConstGroupBy()`
`void`	`testPullConstantThroughAggregateSimpleNonNullable()`
`void`	`testPullConstantThroughConstLast()`
`void`	`testPullConstantThroughUnion()`
`void`	`testPullConstantThroughUnion2()`
`void`	`testPullConstantThroughUnion3()`
`void`	`testPullFilterThroughAggregate()`
`void`	`testPullFilterThroughAggregateGroupingSets()`
`void`	`testPullNull()`
`void`	`testPushAggregateFunctionsThroughJoin()`	Push a variety of aggregate functions.
`void`	`testPushAggregateSumNoGroup()`	Push count(*) through join, no GROUP BY.
`void`	`testPushAggregateSumThroughJoin()`	SUM is the easiest aggregate function to split.
`void`	`testPushAggregateSumThroughJoinAfterAggregateReduce()`	Test case for [CALCITE-2108] AggregateJoinTransposeRule incorrectly splits a SUM0 call when Aggregate has no group keys.
`void`	`testPushAggregateSumWithoutGroupKeyThroughJoin()`	Test case for [CALCITE-2105] AggregateJoinTransposeRule incorrectly makes a SUM NOT NULL when Aggregate has no group keys.
`void`	`testPushAggregateThroughJoin1()`
`void`	`testPushAggregateThroughJoin2()`
`void`	`testPushAggregateThroughJoin3()`
`void`	`testPushAggregateThroughJoin4()`	Test case for [CALCITE-1544] AggregateJoinTransposeRule fails to preserve row type.
`void`	`testPushAggregateThroughJoin5()`
`void`	`testPushAggregateThroughJoin6()`	Test case for [CALCITE-2195] AggregateJoinTransposeRule fails to aggregate over unique column.
`void`	`testPushAggregateThroughJoinDistinct()`	Push a aggregate functions into a relation that is unique on the join key.
`void`	`testPushAggregateThroughJoinWithUniqueInput()`	Test case for [CALCITE-2278] AggregateJoinTransposeRule fails to split aggregate call if input contains an aggregate call and has distinct rows.
`void`	`testPushAvgGroupingSetsThroughUnion()`
`void`	`testPushAvgThroughUnion()`
`void`	`testPushCountFilterThroughUnion()`
`void`	`testPushCountNullableGroupingSetsThroughUnion()`
`void`	`testPushCountNullableThroughUnion()`
`void`	`testPushCountStarGroupingSetsThroughUnion()`
`void`	`testPushCountStarThroughUnion()`
`void`	`testPushFilterPastAgg()`
`void`	`testPushFilterPastAggFour()`	Test case for [CALCITE-1109] FilterAggregateTransposeRule pushes down incorrect condition.
`void`	`testPushFilterPastAggThree()`	Test case for [CALCITE-799] Incorrect result for `HAVING count(*) > 1`.
`void`	`testPushFilterPastAggTwo()`	Test case for [CALCITE-434] FilterAggregateTransposeRule loses conditions that cannot be pushed.
`void`	`testPushFilterPastAggWithGroupingSets1()`
`void`	`testPushFilterPastAggWithGroupingSets2()`
`void`	`testPushFilterPastProject()`	Test case for [CALCITE-448] FilterIntoJoinRule creates filters containing invalid RexInputRef.
`void`	`testPushFilterThroughSemiJoin()`	Test case for [CALCITE-438] Push predicates through SemiJoin.
`void`	`testPushFilterWithRank()`
`void`	`testPushFilterWithRankExpr()`
`void`	`testPushJoinCondDownToProject()`
`void`	`testPushJoinThroughUnionOnLeft()`
`void`	`testPushJoinThroughUnionOnRight()`
`void`	`testPushMaxNullableGroupingSetsThroughUnion()`
`void`	`testPushMaxNullableThroughUnion()`
`void`	`testPushMinGroupingSetsThroughUnion()`
`void`	`testPushMinThroughUnion()`
`void`	`testPushProjectPastFilter()`
`void`	`testPushProjectPastFilter2()`	Test case for [CALCITE-1778] Query with "WHERE CASE" throws AssertionError "Cast for just nullability not allowed".
`void`	`testPushProjectPastFullJoin()`
`void`	`testPushProjectPastFullJoinStrong()`
`void`	`testPushProjectPastInnerJoin()`	Test case for [CALCITE-1753] PushProjector should only preserve expressions if the expression is strong when pushing into the nullable-side of outer join.
`void`	`testPushProjectPastInnerJoinStrong()`
`void`	`testPushProjectPastJoin()`
`void`	`testPushProjectPastLeftJoin()`
`void`	`testPushProjectPastLeftJoinSwap()`
`void`	`testPushProjectPastLeftJoinSwapStrong()`
`void`	`testPushProjectPastRightJoin()`
`void`	`testPushProjectPastRightJoinStrong()`
`void`	`testPushProjectPastRightJoinSwap()`
`void`	`testPushProjectPastRightJoinSwapStrong()`
`void`	`testPushProjectPastSetOp()`
`void`	`testPushSemiJoinPastFilter()`
`void`	`testPushSemiJoinPastJoinRuleLeft()`
`void`	`testPushSemiJoinPastJoinRuleRight()`
`void`	`testPushSemiJoinPastProject()`
`void`	`testPushSumConstantGroupingSetsThroughUnion()`
`void`	`testPushSumConstantThroughUnion()`
`void`	`testPushSumCountStarGroupingSetsThroughUnion()`
`void`	`testPushSumCountStarThroughUnion()`
`void`	`testPushSumNullableGroupingSetsThroughUnion()`
`void`	`testPushSumNullableNOGBYThroughUnion()`
`void`	`testPushSumNullableThroughUnion()`
`void`	`testPushSumNullConstantGroupingSetsThroughUnion()`
`void`	`testPushSumNullConstantThroughUnion()`
`void`	`testReduceAverage()`
`void`	`testReduceCase()`	Test case for [CALCITE-1439] Handling errors during constant reduction.
`<T> void`	`testReduceCaseNullabilityChange()`
`void`	`testReduceCastAndConsts()`
`void`	`testReduceCasts()`
`void`	`testReduceCastsNullable()`
`void`	`testReduceCastTimeUnchanged()`	Tests that a cast from a TIME to a TIMESTAMP is not reduced.
`void`	`testReduceCompositeInSubQuery()`	Test case for [CALCITE-1479] AssertionError in ReduceExpressionsRule on multi-column IN sub-query.
`void`	`testReduceConstants()`
`void`	`testReduceConstants2()`
`void`	`testReduceConstants3()`
`void`	`testReduceConstantsCalc()`
`void`	`testReduceConstantsCaseEquals()`
`void`	`testReduceConstantsCaseEquals2()`
`void`	`testReduceConstantsCaseEquals3()`
`void`	`testReduceConstantsDup()`	Test case for [CALCITE-570] ReduceExpressionsRule throws "duplicate key" exception.
`void`	`testReduceConstantsDup2()`	Test case for [CALCITE-935] Improve how ReduceExpressionsRule handles duplicate constraints.
`void`	`testReduceConstantsDynamicFunction()`	Checks that constant reducer duplicates calls to dynamic functions, if appropriate.
`void`	`testReduceConstantsEliminatesFilter()`
`void`	`testReduceConstantsIsNotNull()`
`void`	`testReduceConstantsIsNull()`
`void`	`testReduceConstantsNegated()`
`void`	`testReduceConstantsNegatedInverted()`
`void`	`testReduceConstantsNonDeterministicFunction()`	Test case for [CALCITE-2638] Constant reducer must not duplicate calls to non-deterministic functions.
`void`	`testReduceConstantsNull()`	Test case for [CALCITE-1860] Duplicate null predicates cause NullPointerException in RexUtil.
`void`	`testReduceConstantsNullEqualsOne()`
`void`	`testReduceConstantsProjectNullable()`	Test case for [CALCITE-902] Match nullability when reducing expressions in a Project.
`void`	`testReduceConstantsRequiresExecutor()`	Test case for [CALCITE-566] ReduceExpressionsRule requires planner to have an Executor.
`void`	`testReduceExpressionsNot()`
`void`	`testReduceNestedCaseWhen()`
`void`	`testReduceNot()`
`void`	`testReduceNullableCase()`
`void`	`testReduceNullableCase2()`
`void`	`testReduceNullableToNotNull()`	Test case that reduces a nullable expression to a NOT NULL literal that is cast to nullable.
`void`	`testReduceNullableToNotNull2()`	Test case that reduces a nullable expression to a NOT NULL literal.
`void`	`testReduceOrCaseWhen()`
`void`	`testReduceValuesNull()`
`void`	`testReduceValuesToEmpty()`
`void`	`testReduceValuesUnderFilter()`
`void`	`testReduceValuesUnderProject()`
`void`	`testReduceValuesUnderProjectFilter()`
`void`	`testRemoveSemiJoin()`
`void`	`testRemoveSemiJoinRight()`
`void`	`testRemoveSemiJoinRightWithFilter()`
`void`	`testRemoveSemiJoinWithFilter()`
`void`	`testRightOuterJoinSimplificationToInner()`
`void`	`testSemiJoinReduceConstants()`	Test case for [CALCITE-571] ReduceExpressionsRule tries to reduce SemiJoin condition to non-equi condition.
`void`	`testSemiJoinRule()`
`void`	`testSemiJoinRuleExists()`
`void`	`testSemiJoinRuleFull()`	Similar to `testSemiJoinRuleRight()` but FULL.
`void`	`testSemiJoinRuleLeft()`	Similar to `testSemiJoinRule()` but LEFT.
`void`	`testSemiJoinRuleRight()`	Test case for [CALCITE-1495] SemiJoinRule should not apply to RIGHT and FULL JOIN.
`void`	`testSemiJoinTrim()`
`void`	`testSimplifyFilter()`	Test case for [CALCITE-1995] Remove predicates from Filter if they can be proved to be always true or false.
`void`	`testSkipReduceConstantsCaseEquals()`
`void`	`testSome()`
`void`	`testSortJoinTranspose1()`
`void`	`testSortJoinTranspose2()`
`void`	`testSortJoinTranspose3()`
`void`	`testSortJoinTranspose4()`	Test case for [CALCITE-931] Wrong collation trait in SortJoinTransposeRule for right joins.
`void`	`testSortJoinTranspose5()`	Test case for [CALCITE-1498] Avoid LIMIT with trivial ORDER BY being pushed through JOIN endlessly.
`void`	`testSortJoinTranspose6()`	Test case for [CALCITE-1507] OFFSET cannot be pushed through a JOIN if the non-preserved side of outer join is not count-preserving.
`void`	`testSortJoinTranspose7()`	Test case for [CALCITE-1507] OFFSET cannot be pushed through a JOIN if the non-preserved side of outer join is not count-preserving.
`void`	`testSortProjectTranspose1()`
`void`	`testSortProjectTranspose2()`
`void`	`testSortProjectTranspose3()`
`void`	`testSortRemovalAllKeysConstant()`
`void`	`testSortRemovalOneKeyConstant()`
`void`	`testSortUnionTranspose()`	Test case for [CALCITE-889] Implement SortUnionTransposeRule.
`void`	`testSortUnionTranspose2()`	Test case for [CALCITE-889] Implement SortUnionTransposeRule.
`void`	`testSortUnionTranspose3()`	Test case for [CALCITE-987] Push limit 0 will result in an infinite loop.
`void`	`testStrengthenJoinType()`
`void`	`testSwapOuterJoin()`
`void`	`testTransitiveInferenceAggregate()`
`void`	`testTransitiveInferenceComplexPredicate()`
`void`	`testTransitiveInferenceConjunctInPullUp()`
`void`	`testTransitiveInferenceConstantEquiPredicate()`
`void`	`testTransitiveInferenceFullOuterJoin()`
`void`	`testTransitiveInferenceJoin()`
`void`	`testTransitiveInferenceJoin3way()`
`void`	`testTransitiveInferenceJoin3wayAgg()`
`void`	`testTransitiveInferenceLeftOuterJoin()`
`void`	`testTransitiveInferenceNoPullUpExprs()`
`void`	`testTransitiveInferencePreventProjectPullUp()`
`void`	`testTransitiveInferenceProject()`
`void`	`testTransitiveInferencePullUpThruAlias()`
`void`	`testTransitiveInferenceRightOuterJoin()`
`void`	`testTransitiveInferenceUnion()`
`void`	`testTransitiveInferenceUnion3way()`
`void`	`testTransitiveInferenceUnion3wayOr()`
`void`	`testTransitiveInferenceUnionAlwaysTrue()`	Test case for [CALCITE-443] getPredicates from a union is not correct.
`void`	`testUnionMergeRule()`	Tests to see if the final branch of union is missed
`void`	`testUnionToDistinctRule()`
`void`	`testWhereExpressionInCorrelated()`
`void`	`testWhereExpressionInCorrelated2()`
`void`	`testWhereInCorrelated()`	Test case for [CALCITE-1494] Inefficient plan for correlated sub-queries.
`void`	`testWhereInJoinCorrelated()`
`void`	`testWhereNotInCorrelated()`	Test case for [CALCITE-1493] Wrong plan for NOT IN correlated queries.
`void`	`testWhereNotInCorrelated2()`
`void`	`testWhereOrSubQuery()`	Test case for [CALCITE-1546] Sub-queries connected by OR.
`void`	`testWindowFunctionOnAggregations()`	Test case for [CALCITE-2078] Aggregate functions in OVER clause.
`void`	`testWindowInParenthesis()`	Test case for [CALCITE-888] Overlay window loses PARTITION BY list.
`private void`	`transitiveInference(org.apache.calcite.plan.RelOptRule... extraRules)`

Methods inherited from class org.apache.calcite.test.RelOptTestBase
checkPlanning, checkPlanning, checkPlanning, checkPlanning, checkPlanning, checkPlanningDynamic, checkPlanningDynamic, checkPlanUnchanged, createDynamicTester, createTester, sql

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

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

Field Detail

skipItem

private final org.apache.calcite.rel.rules.PushProjector.ExprCondition skipItem

NOT_STRONG_EXPR

private static final java.lang.String NOT_STRONG_EXPR

See Also:: Constant Field Values

STRONG_EXPR

private static final java.lang.String STRONG_EXPR

See Also:: Constant Field Values

Constructor Detail
- RelOptRulesTest
```
public RelOptRulesTest()
```

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

testReduceNot
```
public void testReduceNot()
```

testReduceNestedCaseWhen

public void testReduceNestedCaseWhen()

testReduceCompositeInSubQuery
```
public void testReduceCompositeInSubQuery()
```
Test case for [CALCITE-1479] AssertionError in ReduceExpressionsRule on multi-column IN sub-query.

testReduceOrCaseWhen
```
public void testReduceOrCaseWhen()
```

testReduceNullableCase
```
public void testReduceNullableCase()
```

testReduceNullableCase2
```
public void testReduceNullableCase2()
```

testProjectToWindowRuleForMultipleWindows

public void testProjectToWindowRuleForMultipleWindows()

testUnionToDistinctRule
```
public void testUnionToDistinctRule()
```

testExtractJoinFilterRule

public void testExtractJoinFilterRule()

testAddRedundantSemiJoinRule

public void testAddRedundantSemiJoinRule()

testStrengthenJoinType
```
public void testStrengthenJoinType()
```

testFullOuterJoinSimplificationToLeftOuter

public void testFullOuterJoinSimplificationToLeftOuter()

testFullOuterJoinSimplificationToRightOuter

public void testFullOuterJoinSimplificationToRightOuter()

testFullOuterJoinSimplificationToInner

public void testFullOuterJoinSimplificationToInner()

testLeftOuterJoinSimplificationToInner

public void testLeftOuterJoinSimplificationToInner()

testRightOuterJoinSimplificationToInner

public void testRightOuterJoinSimplificationToInner()

testPushFilterPastAgg
```
public void testPushFilterPastAgg()
```

basePushFilterPastAggWithGroupingSets

private void basePushFilterPastAggWithGroupingSets(boolean unchanged)
                                            throws java.lang.Exception

Throws:: java.lang.Exception

testPushFilterPastAggWithGroupingSets1

public void testPushFilterPastAggWithGroupingSets1()
                                            throws java.lang.Exception

Throws:: java.lang.Exception

testPushFilterPastAggWithGroupingSets2

public void testPushFilterPastAggWithGroupingSets2()
                                            throws java.lang.Exception

Throws:: java.lang.Exception

testPushFilterPastAggTwo
```
public void testPushFilterPastAggTwo()
```
Test case for [CALCITE-434] FilterAggregateTransposeRule loses conditions that cannot be pushed.

testPushFilterPastAggThree
```
public void testPushFilterPastAggThree()
```
Test case for [CALCITE-799] Incorrect result for HAVING count(*) > 1.

testPushFilterPastAggFour
```
public void testPushFilterPastAggFour()
```
Test case for [CALCITE-1109] FilterAggregateTransposeRule pushes down incorrect condition.

testPushFilterPastProject
```
public void testPushFilterPastProject()
```
Test case for [CALCITE-448] FilterIntoJoinRule creates filters containing invalid RexInputRef.

testJoinProjectTranspose

public void testJoinProjectTranspose()

testSortUnionTranspose
```
public void testSortUnionTranspose()
```
Test case for [CALCITE-889] Implement SortUnionTransposeRule.

testSortUnionTranspose2
```
public void testSortUnionTranspose2()
```
Test case for [CALCITE-889] Implement SortUnionTransposeRule.

testSortUnionTranspose3
```
public void testSortUnionTranspose3()
```
Test case for [CALCITE-987] Push limit 0 will result in an infinite loop.

testSortRemovalAllKeysConstant

public void testSortRemovalAllKeysConstant()

testSortRemovalOneKeyConstant

public void testSortRemovalOneKeyConstant()

testSemiJoinRuleExists
```
public void testSemiJoinRuleExists()
```

testSemiJoinRule
```
public void testSemiJoinRule()
```

testSemiJoinRuleRight
```
public void testSemiJoinRuleRight()
```
Test case for [CALCITE-1495] SemiJoinRule should not apply to RIGHT and FULL JOIN.

testSemiJoinRuleFull
```
public void testSemiJoinRuleFull()
```
Similar to testSemiJoinRuleRight() but FULL.

testSemiJoinRuleLeft
```
public void testSemiJoinRuleLeft()
```
Similar to testSemiJoinRule() but LEFT.

testPushFilterThroughSemiJoin
```
public void testPushFilterThroughSemiJoin()
```
Test case for [CALCITE-438] Push predicates through SemiJoin.

testSemiJoinReduceConstants
```
public void testSemiJoinReduceConstants()
```
Test case for [CALCITE-571] ReduceExpressionsRule tries to reduce SemiJoin condition to non-equi condition.

testSemiJoinTrim

public void testSemiJoinTrim()
                      throws java.lang.Exception

Throws:: java.lang.Exception

testReduceAverage
```
public void testReduceAverage()
```

testCastInAggregateReduceFunctions
```
public void testCastInAggregateReduceFunctions()
```
Test case for [CALCITE-1621] Adding a cast around the null literal in aggregate rules.

testDistinctCountWithoutGroupBy

public void testDistinctCountWithoutGroupBy()

testDistinctCount1
```
public void testDistinctCount1()
```

testDistinctCount2
```
public void testDistinctCount2()
```

testDistinctCount3
```
public void testDistinctCount3()
```
Test case for [CALCITE-1293] Bad code generated when argument to COUNT(DISTINCT) is a # GROUP BY column.

testDistinctCountMultipleViaJoin
```
public void testDistinctCountMultipleViaJoin()
```
Tests implementing multiple distinct count the old way, using a join.

testDistinctCountMultiple
```
public void testDistinctCountMultiple()
```
Tests implementing multiple distinct count the new way, using GROUPING SETS.

testDistinctCountMultipleNoGroup

public void testDistinctCountMultipleNoGroup()

testDistinctCountMixedJoin

public void testDistinctCountMixedJoin()

testDistinctCountMixed
```
public void testDistinctCountMixed()
```

testDistinctCountMixed2
```
public void testDistinctCountMixed2()
```

testDistinctCountGroupingSets1

public void testDistinctCountGroupingSets1()

testDistinctCountGroupingSets2

public void testDistinctCountGroupingSets2()

testDistinctNonDistinctAggregates

public void testDistinctNonDistinctAggregates()

testCastInAggregateExpandDistinctAggregatesRule
```
public void testCastInAggregateExpandDistinctAggregatesRule()
```
Test case for [CALCITE-1621] Adding a cast around the null literal in aggregate rules.

testDistinctNonDistinctAggregatesWithGrouping1
```
public void testDistinctNonDistinctAggregatesWithGrouping1()
```
Test case for [CALCITE-1558] AggregateExpandDistinctAggregatesRule gets field mapping wrong if groupKey is used in aggregate function.

testDistinctNonDistinctAggregatesWithGrouping2

public void testDistinctNonDistinctAggregatesWithGrouping2()

testDistinctNonDistinctTwoAggregatesWithGrouping

public void testDistinctNonDistinctTwoAggregatesWithGrouping()

testDistinctWithGrouping

public void testDistinctWithGrouping()

testMultipleDistinctWithGrouping

public void testMultipleDistinctWithGrouping()

testDistinctWithMultipleInputs

public void testDistinctWithMultipleInputs()

testDistinctWithMultipleInputsAndGroupby

public void testDistinctWithMultipleInputsAndGroupby()

testPushProjectPastFilter

public void testPushProjectPastFilter()

testPushProjectPastFilter2
```
public void testPushProjectPastFilter2()
```
Test case for [CALCITE-1778] Query with "WHERE CASE" throws AssertionError "Cast for just nullability not allowed".

testPushProjectPastJoin
```
public void testPushProjectPastJoin()
```

testProjectCorrelateTransposeDynamic

public void testProjectCorrelateTransposeDynamic()

testProjectCorrelateTransposeRuleLeftCorrelate

public void testProjectCorrelateTransposeRuleLeftCorrelate()

testProjectCorrelateTransposeRuleSemiCorrelate

public void testProjectCorrelateTransposeRuleSemiCorrelate()

testProjectCorrelateTransposeRuleAntiCorrelate

public void testProjectCorrelateTransposeRuleAntiCorrelate()

testProjectCorrelateTransposeWithExprCond

public void testProjectCorrelateTransposeWithExprCond()

testProjectCorrelateTranspose

public void testProjectCorrelateTranspose()

testFilterProjectTransposePreventedByCorrelation
```
public void testFilterProjectTransposePreventedByCorrelation()
```
Tests that the default instance of FilterProjectTransposeRule does not push a Filter that contains a correlating variable.

See Also:

testFilterProjectTranspose()

testFilterProjectTranspose
```
public void testFilterProjectTranspose()
```
Tests a variant of FilterProjectTransposeRule that pushes a Filter that contains a correlating variable.

testPushProjectPastInnerJoin
```
public void testPushProjectPastInnerJoin()
```
Test case for [CALCITE-1753] PushProjector should only preserve expressions if the expression is strong when pushing into the nullable-side of outer join.

testPushProjectPastInnerJoinStrong

public void testPushProjectPastInnerJoinStrong()

testPushProjectPastLeftJoin

public void testPushProjectPastLeftJoin()

testPushProjectPastLeftJoinSwap

public void testPushProjectPastLeftJoinSwap()

testPushProjectPastLeftJoinSwapStrong

public void testPushProjectPastLeftJoinSwapStrong()

testPushProjectPastRightJoin

public void testPushProjectPastRightJoin()

testPushProjectPastRightJoinStrong

public void testPushProjectPastRightJoinStrong()

testPushProjectPastRightJoinSwap

public void testPushProjectPastRightJoinSwap()

testPushProjectPastRightJoinSwapStrong

public void testPushProjectPastRightJoinSwapStrong()

testPushProjectPastFullJoin

public void testPushProjectPastFullJoin()

testPushProjectPastFullJoinStrong

public void testPushProjectPastFullJoinStrong()

testPushProjectPastSetOp

public void testPushProjectPastSetOp()

testPushJoinThroughUnionOnLeft

public void testPushJoinThroughUnionOnLeft()

testPushJoinThroughUnionOnRight

public void testPushJoinThroughUnionOnRight()

testMergeFilterWithJoinCondition

public void testMergeFilterWithJoinCondition()
                                      throws java.lang.Exception

Throws:: java.lang.Exception

testMergeFilter
```
public void testMergeFilter()
                     throws java.lang.Exception
```
Tests that filters are combined if they are identical.

Throws:

java.lang.Exception

testUnionMergeRule
```
public void testUnionMergeRule()
                        throws java.lang.Exception
```
Tests to see if the final branch of union is missed

Throws:

java.lang.Exception

testMinusMergeRule

public void testMinusMergeRule()
                        throws java.lang.Exception

Throws:: java.lang.Exception

testMergeJoinFilter
```
public void testMergeJoinFilter()
                         throws java.lang.Exception
```
Tests that a filters is combined are combined if they are identical, even if one of them originates in an ON clause of a JOIN.

Throws:

java.lang.Exception

testMergeUnionAll
```
public void testMergeUnionAll()
                       throws java.lang.Exception
```
Tests UnionMergeRule, which merges 2 Union operators into a single Union with 3 inputs.

Throws:

java.lang.Exception

testMergeUnionDistinct
```
public void testMergeUnionDistinct()
                            throws java.lang.Exception
```
Tests UnionMergeRule, which merges 2 Union DISTINCT (not ALL) operators into a single Union with 3 inputs.

Throws:

java.lang.Exception

testMergeUnionMixed
```
public void testMergeUnionMixed()
                         throws java.lang.Exception
```
Tests that UnionMergeRule does nothing if its arguments have different ALL settings.

Throws:

java.lang.Exception

testMergeUnionMixed2
```
public void testMergeUnionMixed2()
                          throws java.lang.Exception
```
Tests that UnionMergeRule converts all inputs to DISTINCT if the top one is DISTINCT. (Since UNION is left-associative, the "top one" is the rightmost.)

Throws:

java.lang.Exception

testMergeSetOpMixed
```
public void testMergeSetOpMixed()
                         throws java.lang.Exception
```
Tests that UnionMergeRule does nothing if its arguments have are different set operators, Union and Intersect.

Throws:

java.lang.Exception

testMergeIntersect
```
public void testMergeIntersect()
                        throws java.lang.Exception
```
Tests UnionMergeRule.INTERSECT_INSTANCE, which merges 2 Intersect operators into a single Intersect with 3 inputs.

Throws:

java.lang.Exception

testIntersectToDistinct
```
public void testIntersectToDistinct()
                             throws java.lang.Exception
```
Tests IntersectToDistinctRule, which rewrites an Intersect operator with 3 inputs.

Throws:

java.lang.Exception

testIntersectToDistinctAll
```
public void testIntersectToDistinctAll()
                                throws java.lang.Exception
```
Tests that IntersectToDistinctRule correctly ignores an INTERSECT ALL. It can only handle INTERSECT DISTINCT.

Throws:

java.lang.Exception

testMergeMinus
```
public void testMergeMinus()
                    throws java.lang.Exception
```
Tests UnionMergeRule.MINUS_INSTANCE, which merges 2 Minus operators into a single Minus with 3 inputs.

Throws:

java.lang.Exception

testMergeMinusRightDeep
```
public void testMergeMinusRightDeep()
                             throws java.lang.Exception
```
Tests UnionMergeRule.MINUS_INSTANCE does not merge Minus(a, Minus(b, c)) into Minus(a, b, c), which would be incorrect.

Throws:

java.lang.Exception

testHeterogeneousConversion

public void testHeterogeneousConversion()
                                 throws java.lang.Exception

Throws:: java.lang.Exception

testPushSemiJoinPastJoinRuleLeft

public void testPushSemiJoinPastJoinRuleLeft()
                                      throws java.lang.Exception

Throws:: java.lang.Exception

testPushSemiJoinPastJoinRuleRight

public void testPushSemiJoinPastJoinRuleRight()
                                       throws java.lang.Exception

Throws:: java.lang.Exception

testPushSemiJoinPastFilter

public void testPushSemiJoinPastFilter()
                                throws java.lang.Exception

Throws:: java.lang.Exception

testConvertMultiJoinRule

public void testConvertMultiJoinRule()
                              throws java.lang.Exception

Throws:: java.lang.Exception

testReduceConstants

public void testReduceConstants()
                         throws java.lang.Exception

Throws:: java.lang.Exception

testReduceConstantsDup
```
public void testReduceConstantsDup()
                            throws java.lang.Exception
```
Test case for [CALCITE-570] ReduceExpressionsRule throws "duplicate key" exception.

Throws:

java.lang.Exception

testReduceConstantsDup2
```
public void testReduceConstantsDup2()
                             throws java.lang.Exception
```
Test case for [CALCITE-935] Improve how ReduceExpressionsRule handles duplicate constraints.

Throws:

java.lang.Exception

testPullNull

public void testPullNull()
                  throws java.lang.Exception

Throws:: java.lang.Exception

testOrAlwaysTrue
```
public void testOrAlwaysTrue()
```

testOrAlwaysTrue2
```
public void testOrAlwaysTrue2()
```

testReduceConstants2

public void testReduceConstants2()
                          throws java.lang.Exception

Throws:: java.lang.Exception

testReduceConstants3

public void testReduceConstants3()
                          throws java.lang.Exception

Throws:: java.lang.Exception

testReduceConstantsProjectNullable
```
public void testReduceConstantsProjectNullable()
                                        throws java.lang.Exception
```
Test case for [CALCITE-902] Match nullability when reducing expressions in a Project.

Throws:

java.lang.Exception

testReduceConstantsNullEqualsOne

public void testReduceConstantsNullEqualsOne()
                                      throws java.lang.Exception

Throws:: java.lang.Exception

testReduceConstantsCaseEquals

public void testReduceConstantsCaseEquals()
                                   throws java.lang.Exception

Throws:: java.lang.Exception

testReduceConstantsCaseEquals2

public void testReduceConstantsCaseEquals2()
                                    throws java.lang.Exception

Throws:: java.lang.Exception

testReduceConstantsCaseEquals3

public void testReduceConstantsCaseEquals3()
                                    throws java.lang.Exception

Throws:: java.lang.Exception

testSkipReduceConstantsCaseEquals

public void testSkipReduceConstantsCaseEquals()
                                       throws java.lang.Exception

Throws:: java.lang.Exception

testReduceConstantsEliminatesFilter

public void testReduceConstantsEliminatesFilter()
                                         throws java.lang.Exception

Throws:: java.lang.Exception

testReduceConstantsNull
```
public void testReduceConstantsNull()
                             throws java.lang.Exception
```
Test case for [CALCITE-1860] Duplicate null predicates cause NullPointerException in RexUtil.

Throws:

java.lang.Exception

testReduceConstantsRequiresExecutor
```
public void testReduceConstantsRequiresExecutor()
                                         throws java.lang.Exception
```
Test case for [CALCITE-566] ReduceExpressionsRule requires planner to have an Executor.

Throws:

java.lang.Exception

testAlreadyFalseEliminatesFilter

public void testAlreadyFalseEliminatesFilter()
                                      throws java.lang.Exception

Throws:: java.lang.Exception

testReduceConstantsCalc

public void testReduceConstantsCalc()
                             throws java.lang.Exception

Throws:: java.lang.Exception

testRemoveSemiJoin

public void testRemoveSemiJoin()
                        throws java.lang.Exception

Throws:: java.lang.Exception

testRemoveSemiJoinWithFilter

public void testRemoveSemiJoinWithFilter()
                                  throws java.lang.Exception

Throws:: java.lang.Exception

testRemoveSemiJoinRight

public void testRemoveSemiJoinRight()
                             throws java.lang.Exception

Throws:: java.lang.Exception

testRemoveSemiJoinRightWithFilter

public void testRemoveSemiJoinRightWithFilter()
                                       throws java.lang.Exception

Throws:: java.lang.Exception

checkPlanning

private void checkPlanning(java.lang.String query)
                    throws java.lang.Exception

Throws:: java.lang.Exception

testConvertMultiJoinRuleOuterJoins

public void testConvertMultiJoinRuleOuterJoins()
                                        throws java.lang.Exception

Throws:: java.lang.Exception

testConvertMultiJoinRuleOuterJoins2

public void testConvertMultiJoinRuleOuterJoins2()
                                         throws java.lang.Exception

Throws:: java.lang.Exception

testConvertMultiJoinRuleOuterJoins3

public void testConvertMultiJoinRuleOuterJoins3()
                                         throws java.lang.Exception

Throws:: java.lang.Exception

testConvertMultiJoinRuleOuterJoins4

public void testConvertMultiJoinRuleOuterJoins4()
                                         throws java.lang.Exception

Throws:: java.lang.Exception

testPushSemiJoinPastProject

public void testPushSemiJoinPastProject()
                                 throws java.lang.Exception

Throws:: java.lang.Exception

testReduceValuesUnderFilter

public void testReduceValuesUnderFilter()
                                 throws java.lang.Exception

Throws:: java.lang.Exception

testReduceValuesUnderProject

public void testReduceValuesUnderProject()
                                  throws java.lang.Exception

Throws:: java.lang.Exception

testReduceValuesUnderProjectFilter

public void testReduceValuesUnderProjectFilter()
                                        throws java.lang.Exception

Throws:: java.lang.Exception

testReduceCase
```
public void testReduceCase()
                    throws java.lang.Exception
```
Test case for [CALCITE-1439] Handling errors during constant reduction.

Throws:

java.lang.Exception

checkReduceNullableToNotNull

private void checkReduceNullableToNotNull(org.apache.calcite.rel.rules.ReduceExpressionsRule rule)

testReduceNullableToNotNull
```
public void testReduceNullableToNotNull()
                                 throws java.lang.Exception
```
Test case that reduces a nullable expression to a NOT NULL literal that is cast to nullable.

Throws:

java.lang.Exception

testReduceNullableToNotNull2
```
public void testReduceNullableToNotNull2()
                                  throws java.lang.Exception
```
Test case that reduces a nullable expression to a NOT NULL literal.

Throws:

java.lang.Exception

testReduceConstantsIsNull

public void testReduceConstantsIsNull()
                               throws java.lang.Exception

Throws:: java.lang.Exception

testReduceConstantsIsNotNull

public void testReduceConstantsIsNotNull()
                                  throws java.lang.Exception

Throws:: java.lang.Exception

testReduceConstantsNegated

public void testReduceConstantsNegated()
                                throws java.lang.Exception

Throws:: java.lang.Exception

testReduceConstantsNegatedInverted

public void testReduceConstantsNegatedInverted()
                                        throws java.lang.Exception

Throws:: java.lang.Exception

testReduceConstantsNonDeterministicFunction
```
public void testReduceConstantsNonDeterministicFunction()
```
Test case for [CALCITE-2638] Constant reducer must not duplicate calls to non-deterministic functions.

testReduceConstantsDynamicFunction
```
public void testReduceConstantsDynamicFunction()
```
Checks that constant reducer duplicates calls to dynamic functions, if appropriate. CURRENT_TIMESTAMP is a dynamic function.

testCasePushIsAlwaysWorking

public void testCasePushIsAlwaysWorking()
                                 throws java.lang.Exception

Throws:: java.lang.Exception

testReduceValuesNull

public void testReduceValuesNull()
                          throws java.lang.Exception

Throws:: java.lang.Exception

testReduceValuesToEmpty

public void testReduceValuesToEmpty()
                             throws java.lang.Exception

Throws:: java.lang.Exception

testEmptyFilterProjectUnion

public void testEmptyFilterProjectUnion()
                                 throws java.lang.Exception

Throws:: java.lang.Exception

testEmptyProject
```
public void testEmptyProject()
                      throws java.lang.Exception
```
Test case for [CALCITE-1488] ValuesReduceRule should ignore empty Values.

Throws:

java.lang.Exception

testEmptyProject2
```
public void testEmptyProject2()
                       throws java.lang.Exception
```
Same query as testEmptyProject(), and PruneEmptyRules is able to do the job that ValuesReduceRule cannot do.

Throws:

java.lang.Exception

testEmptyIntersect

public void testEmptyIntersect()
                        throws java.lang.Exception

Throws:: java.lang.Exception

testEmptyMinus

public void testEmptyMinus()
                    throws java.lang.Exception

Throws:: java.lang.Exception

testEmptyMinus2

public void testEmptyMinus2()
                     throws java.lang.Exception

Throws:: java.lang.Exception

testEmptyJoin
```
public void testEmptyJoin()
```

testEmptyJoinLeft
```
public void testEmptyJoinLeft()
```

testEmptyJoinRight
```
public void testEmptyJoinRight()
```

testEmptySort
```
public void testEmptySort()
```

testEmptySortLimitZero
```
public void testEmptySortLimitZero()
```

testEmptyAggregate
```
public void testEmptyAggregate()
```

testEmptyAggregateEmptyKey

public void testEmptyAggregateEmptyKey()

testEmptyAggregateEmptyKeyWithAggregateValuesRule

public void testEmptyAggregateEmptyKeyWithAggregateValuesRule()

testReduceCasts

public void testReduceCasts()
                     throws java.lang.Exception

Throws:: java.lang.Exception

testReduceCastTimeUnchanged
```
public void testReduceCastTimeUnchanged()
                                 throws java.lang.Exception
```
Tests that a cast from a TIME to a TIMESTAMP is not reduced. It is not constant because the result depends upon the current date.

Throws:

java.lang.Exception

testReduceCastAndConsts

public void testReduceCastAndConsts()
                             throws java.lang.Exception

Throws:: java.lang.Exception

testReduceCaseNullabilityChange

public <T> void testReduceCaseNullabilityChange()
                                         throws java.lang.Exception

Throws:: java.lang.Exception

testReduceCastsNullable

public void testReduceCastsNullable()
                             throws java.lang.Exception

Throws:: java.lang.Exception

basePushAggThroughUnion

private void basePushAggThroughUnion()
                              throws java.lang.Exception

Throws:: java.lang.Exception

testPushSumConstantThroughUnion

public void testPushSumConstantThroughUnion()
                                     throws java.lang.Exception

Throws:: java.lang.Exception

testPushSumNullConstantThroughUnion

public void testPushSumNullConstantThroughUnion()
                                         throws java.lang.Exception

Throws:: java.lang.Exception

testPushSumNullableThroughUnion

public void testPushSumNullableThroughUnion()
                                     throws java.lang.Exception

Throws:: java.lang.Exception

testPushSumNullableNOGBYThroughUnion

public void testPushSumNullableNOGBYThroughUnion()
                                          throws java.lang.Exception

Throws:: java.lang.Exception

testPushCountStarThroughUnion

public void testPushCountStarThroughUnion()
                                   throws java.lang.Exception

Throws:: java.lang.Exception

testPushCountNullableThroughUnion

public void testPushCountNullableThroughUnion()
                                       throws java.lang.Exception

Throws:: java.lang.Exception

testPushMaxNullableThroughUnion

public void testPushMaxNullableThroughUnion()
                                     throws java.lang.Exception

Throws:: java.lang.Exception

testPushMinThroughUnion

public void testPushMinThroughUnion()
                             throws java.lang.Exception

Throws:: java.lang.Exception

testPushAvgThroughUnion

public void testPushAvgThroughUnion()
                             throws java.lang.Exception

Throws:: java.lang.Exception

testPushSumCountStarThroughUnion

public void testPushSumCountStarThroughUnion()
                                      throws java.lang.Exception

Throws:: java.lang.Exception

testPushSumConstantGroupingSetsThroughUnion

public void testPushSumConstantGroupingSetsThroughUnion()
                                                 throws java.lang.Exception

Throws:: java.lang.Exception

testPushSumNullConstantGroupingSetsThroughUnion

public void testPushSumNullConstantGroupingSetsThroughUnion()
                                                     throws java.lang.Exception

Throws:: java.lang.Exception

testPushSumNullableGroupingSetsThroughUnion

public void testPushSumNullableGroupingSetsThroughUnion()
                                                 throws java.lang.Exception

Throws:: java.lang.Exception

testPushCountStarGroupingSetsThroughUnion

public void testPushCountStarGroupingSetsThroughUnion()
                                               throws java.lang.Exception

Throws:: java.lang.Exception

testPushCountNullableGroupingSetsThroughUnion

public void testPushCountNullableGroupingSetsThroughUnion()
                                                   throws java.lang.Exception

Throws:: java.lang.Exception

testPushMaxNullableGroupingSetsThroughUnion

public void testPushMaxNullableGroupingSetsThroughUnion()
                                                 throws java.lang.Exception

Throws:: java.lang.Exception

testPushMinGroupingSetsThroughUnion

public void testPushMinGroupingSetsThroughUnion()
                                         throws java.lang.Exception

Throws:: java.lang.Exception

testPushAvgGroupingSetsThroughUnion

public void testPushAvgGroupingSetsThroughUnion()
                                         throws java.lang.Exception

Throws:: java.lang.Exception

testPushSumCountStarGroupingSetsThroughUnion

public void testPushSumCountStarGroupingSetsThroughUnion()
                                                  throws java.lang.Exception

Throws:: java.lang.Exception

testPushCountFilterThroughUnion

public void testPushCountFilterThroughUnion()
                                     throws java.lang.Exception

Throws:: java.lang.Exception

testPullFilterThroughAggregate

public void testPullFilterThroughAggregate()
                                    throws java.lang.Exception

Throws:: java.lang.Exception

testPullFilterThroughAggregateGroupingSets

public void testPullFilterThroughAggregateGroupingSets()
                                                throws java.lang.Exception

Throws:: java.lang.Exception

basePullConstantTroughAggregate

private void basePullConstantTroughAggregate()
                                      throws java.lang.Exception

Throws:: java.lang.Exception

testPullConstantThroughConstLast

public void testPullConstantThroughConstLast()
                                      throws java.lang.Exception

Throws:: java.lang.Exception

testPullConstantThroughAggregateSimpleNonNullable

public void testPullConstantThroughAggregateSimpleNonNullable()
                                                       throws java.lang.Exception

Throws:: java.lang.Exception

testPullConstantThroughAggregatePermuted

public void testPullConstantThroughAggregatePermuted()
                                              throws java.lang.Exception

Throws:: java.lang.Exception

testPullConstantThroughAggregatePermutedConstFirst

public void testPullConstantThroughAggregatePermutedConstFirst()
                                                        throws java.lang.Exception

Throws:: java.lang.Exception

testPullConstantThroughAggregatePermutedConstGroupBy

public void testPullConstantThroughAggregatePermutedConstGroupBy()
                                                          throws java.lang.Exception

Throws:: java.lang.Exception

testPullConstantThroughAggregateConstGroupBy

public void testPullConstantThroughAggregateConstGroupBy()
                                                  throws java.lang.Exception

Throws:: java.lang.Exception

testPullConstantThroughAggregateAllConst

public void testPullConstantThroughAggregateAllConst()
                                              throws java.lang.Exception

Throws:: java.lang.Exception

testPullConstantThroughAggregateAllLiterals

public void testPullConstantThroughAggregateAllLiterals()
                                                 throws java.lang.Exception

Throws:: java.lang.Exception

testPullConstantThroughUnion

public void testPullConstantThroughUnion()
                                  throws java.lang.Exception

Throws:: java.lang.Exception

testPullConstantThroughUnion2

public void testPullConstantThroughUnion2()
                                   throws java.lang.Exception

Throws:: java.lang.Exception

testPullConstantThroughUnion3

public void testPullConstantThroughUnion3()
                                   throws java.lang.Exception

Throws:: java.lang.Exception

testAggregateProjectMerge

public void testAggregateProjectMerge()

testAggregateGroupingSetsProjectMerge

public void testAggregateGroupingSetsProjectMerge()

testAggregateExtractProjectRule

public void testAggregateExtractProjectRule()

testAggregateExtractProjectRuleWithGroupingSets

public void testAggregateExtractProjectRuleWithGroupingSets()

testAggregateExtractProjectRuleWithGroupingSets2
```
public void testAggregateExtractProjectRuleWithGroupingSets2()
```
Test with column used in both grouping set and argument to aggregate function.

testAggregateExtractProjectRuleWithFilter

public void testAggregateExtractProjectRuleWithFilter()

testPullAggregateThroughUnion

public void testPullAggregateThroughUnion()

testPullAggregateThroughUnion2

public void testPullAggregateThroughUnion2()

transitiveInference

private void transitiveInference(org.apache.calcite.plan.RelOptRule... extraRules)
                          throws java.lang.Exception

Throws:: java.lang.Exception

testTransitiveInferenceJoin

public void testTransitiveInferenceJoin()
                                 throws java.lang.Exception

Throws:: java.lang.Exception

testTransitiveInferenceProject

public void testTransitiveInferenceProject()
                                    throws java.lang.Exception

Throws:: java.lang.Exception

testTransitiveInferenceAggregate

public void testTransitiveInferenceAggregate()
                                      throws java.lang.Exception

Throws:: java.lang.Exception

testTransitiveInferenceUnion

public void testTransitiveInferenceUnion()
                                  throws java.lang.Exception

Throws:: java.lang.Exception

testTransitiveInferenceJoin3way

public void testTransitiveInferenceJoin3way()
                                     throws java.lang.Exception

Throws:: java.lang.Exception

testTransitiveInferenceJoin3wayAgg

public void testTransitiveInferenceJoin3wayAgg()
                                        throws java.lang.Exception

Throws:: java.lang.Exception

testTransitiveInferenceLeftOuterJoin

public void testTransitiveInferenceLeftOuterJoin()
                                          throws java.lang.Exception

Throws:: java.lang.Exception

testTransitiveInferenceRightOuterJoin

public void testTransitiveInferenceRightOuterJoin()
                                           throws java.lang.Exception

Throws:: java.lang.Exception

testTransitiveInferenceFullOuterJoin

public void testTransitiveInferenceFullOuterJoin()
                                          throws java.lang.Exception

Throws:: java.lang.Exception

testTransitiveInferencePreventProjectPullUp

public void testTransitiveInferencePreventProjectPullUp()
                                                 throws java.lang.Exception

Throws:: java.lang.Exception

testTransitiveInferencePullUpThruAlias

public void testTransitiveInferencePullUpThruAlias()
                                            throws java.lang.Exception

Throws:: java.lang.Exception

testTransitiveInferenceConjunctInPullUp

public void testTransitiveInferenceConjunctInPullUp()
                                             throws java.lang.Exception

Throws:: java.lang.Exception

testTransitiveInferenceNoPullUpExprs

public void testTransitiveInferenceNoPullUpExprs()
                                          throws java.lang.Exception

Throws:: java.lang.Exception

testTransitiveInferenceUnion3way

public void testTransitiveInferenceUnion3way()
                                      throws java.lang.Exception

Throws:: java.lang.Exception

testTransitiveInferenceUnion3wayOr

public void testTransitiveInferenceUnion3wayOr()
                                        throws java.lang.Exception

Throws:: java.lang.Exception

testTransitiveInferenceUnionAlwaysTrue
```
public void testTransitiveInferenceUnionAlwaysTrue()
                                            throws java.lang.Exception
```
Test case for [CALCITE-443] getPredicates from a union is not correct.

Throws:

java.lang.Exception

testTransitiveInferenceConstantEquiPredicate

public void testTransitiveInferenceConstantEquiPredicate()
                                                  throws java.lang.Exception

Throws:: java.lang.Exception

testTransitiveInferenceComplexPredicate

public void testTransitiveInferenceComplexPredicate()
                                             throws java.lang.Exception

Throws:: java.lang.Exception

testPullConstantIntoProject

public void testPullConstantIntoProject()
                                 throws java.lang.Exception

Throws:: java.lang.Exception

testPullConstantIntoFilter

public void testPullConstantIntoFilter()
                                throws java.lang.Exception

Throws:: java.lang.Exception

testSimplifyFilter
```
public void testSimplifyFilter()
                        throws java.lang.Exception
```
Test case for [CALCITE-1995] Remove predicates from Filter if they can be proved to be always true or false.

Throws:

java.lang.Exception

testPullConstantIntoJoin

public void testPullConstantIntoJoin()
                              throws java.lang.Exception

Throws:: java.lang.Exception

testPullConstantIntoJoin2

public void testPullConstantIntoJoin2()
                               throws java.lang.Exception

Throws:: java.lang.Exception

testCorrelationScalarAggAndFilter
```
public void testCorrelationScalarAggAndFilter()
```
Test case for [CALCITE-2110] ArrayIndexOutOfBoundsException in RexSimplify when using ReduceExpressionsRule.JOIN_INSTANCE.

testProjectWindowTransposeRule

public void testProjectWindowTransposeRule()

testProjectWindowTransposeRuleWithConstants

public void testProjectWindowTransposeRuleWithConstants()

testAggregateProjectPullUpConstants

public void testAggregateProjectPullUpConstants()

testAggregateProjectPullUpConstants2

public void testAggregateProjectPullUpConstants2()

testPushFilterWithRank

public void testPushFilterWithRank()
                            throws java.lang.Exception

Throws:: java.lang.Exception

testPushFilterWithRankExpr

public void testPushFilterWithRankExpr()
                                throws java.lang.Exception

Throws:: java.lang.Exception

testExpressionInWindowFunction
```
public void testExpressionInWindowFunction()
```
Test case for [CALCITE-841] Redundant windows when window function arguments are expressions.

testWindowInParenthesis
```
public void testWindowInParenthesis()
```
Test case for [CALCITE-888] Overlay window loses PARTITION BY list.

testNestedAggregates
```
public void testNestedAggregates()
```
Test case for [CALCITE-750] Allow windowed aggregate on top of regular aggregate.

testWindowFunctionOnAggregations
```
public void testWindowFunctionOnAggregations()
```
Test case for [CALCITE-2078] Aggregate functions in OVER clause.

testPushAggregateThroughJoin1

public void testPushAggregateThroughJoin1()

testPushAggregateThroughJoin2

public void testPushAggregateThroughJoin2()

testPushAggregateThroughJoin3

public void testPushAggregateThroughJoin3()

testPushAggregateThroughJoin4
```
public void testPushAggregateThroughJoin4()
```
Test case for [CALCITE-1544] AggregateJoinTransposeRule fails to preserve row type.

testPushAggregateThroughJoin5

public void testPushAggregateThroughJoin5()

testJoinPushTransitivePredicatesRule
```
public void testJoinPushTransitivePredicatesRule()
```
Test case for [CALCITE-2200] Infinite loop for JoinPushTransitivePredicatesRule.

testJoinPushTransitivePredicatesRule2
```
public void testJoinPushTransitivePredicatesRule2()
```
Test case for [CALCITE-2205] One more infinite loop for JoinPushTransitivePredicatesRule.

testInferringPredicatesWithNotOperatorInJoinCondition
```
public void testInferringPredicatesWithNotOperatorInJoinCondition()
```
Test case for [CALCITE-2275] JoinPushTransitivePredicatesRule wrongly pushes down NOT condition.

testPushAggregateThroughJoin6
```
public void testPushAggregateThroughJoin6()
```
Test case for [CALCITE-2195] AggregateJoinTransposeRule fails to aggregate over unique column.

testPushAggregateThroughJoinWithUniqueInput
```
public void testPushAggregateThroughJoinWithUniqueInput()
```
Test case for [CALCITE-2278] AggregateJoinTransposeRule fails to split aggregate call if input contains an aggregate call and has distinct rows.

testPushAggregateSumThroughJoin
```
public void testPushAggregateSumThroughJoin()
```
SUM is the easiest aggregate function to split.

testPushAggregateSumWithoutGroupKeyThroughJoin
```
public void testPushAggregateSumWithoutGroupKeyThroughJoin()
```
Test case for [CALCITE-2105] AggregateJoinTransposeRule incorrectly makes a SUM NOT NULL when Aggregate has no group keys.

testPushAggregateSumThroughJoinAfterAggregateReduce
```
public void testPushAggregateSumThroughJoinAfterAggregateReduce()
```
Test case for [CALCITE-2108] AggregateJoinTransposeRule incorrectly splits a SUM0 call when Aggregate has no group keys.
Similar to testPushAggregateSumThroughJoin(), but also uses AggregateReduceFunctionsRule.

testPushAggregateFunctionsThroughJoin
```
public void testPushAggregateFunctionsThroughJoin()
```
Push a variety of aggregate functions.

testPushAggregateThroughJoinDistinct
```
public void testPushAggregateThroughJoinDistinct()
```
Push a aggregate functions into a relation that is unique on the join key.

testPushAggregateSumNoGroup
```
public void testPushAggregateSumNoGroup()
```
Push count(*) through join, no GROUP BY.

testSwapOuterJoin
```
public void testSwapOuterJoin()
```

testPushJoinCondDownToProject

public void testPushJoinCondDownToProject()

testSortJoinTranspose1
```
public void testSortJoinTranspose1()
```

testSortJoinTranspose2
```
public void testSortJoinTranspose2()
```

testSortJoinTranspose3
```
public void testSortJoinTranspose3()
```

testSortJoinTranspose4
```
public void testSortJoinTranspose4()
```
Test case for [CALCITE-931] Wrong collation trait in SortJoinTransposeRule for right joins.

testSortJoinTranspose5
```
public void testSortJoinTranspose5()
```
Test case for [CALCITE-1498] Avoid LIMIT with trivial ORDER BY being pushed through JOIN endlessly.

testSortJoinTranspose6
```
public void testSortJoinTranspose6()
```
Test case for [CALCITE-1507] OFFSET cannot be pushed through a JOIN if the non-preserved side of outer join is not count-preserving.

testSortJoinTranspose7
```
public void testSortJoinTranspose7()
```
Test case for [CALCITE-1507] OFFSET cannot be pushed through a JOIN if the non-preserved side of outer join is not count-preserving.

testSortProjectTranspose1

public void testSortProjectTranspose1()

testSortProjectTranspose2

public void testSortProjectTranspose2()

testSortProjectTranspose3

public void testSortProjectTranspose3()

testAggregateConstantKeyRule
```
public void testAggregateConstantKeyRule()
```
Test case for [CALCITE-1023] Planner rule that removes Aggregate keys that are constant.

testAggregateConstantKeyRule2
```
public void testAggregateConstantKeyRule2()
```
Tests AggregateProjectPullUpConstantsRule where reduction is not possible because "deptno" is the only key.

testAggregateConstantKeyRule3
```
public void testAggregateConstantKeyRule3()
```
Tests AggregateProjectPullUpConstantsRule where both keys are constants but only one can be removed.

testReduceExpressionsNot

public void testReduceExpressionsNot()

checkSubQuery

private RelOptTestBase.Sql checkSubQuery(java.lang.String sql)

testExpandProjectScalar
```
public void testExpandProjectScalar()
                             throws java.lang.Exception
```
Tests expanding a sub-query, specifically an uncorrelated scalar sub-query in a project (SELECT clause).

Throws:

java.lang.Exception

testWhereNotInCorrelated
```
public void testWhereNotInCorrelated()
```
Test case for [CALCITE-1493] Wrong plan for NOT IN correlated queries.

testWhereNotInCorrelated2

public void testWhereNotInCorrelated2()

testAll
```
public void testAll()
```

testSome
```
public void testSome()
```

testWhereOrSubQuery
```
public void testWhereOrSubQuery()
```
Test case for [CALCITE-1546] Sub-queries connected by OR.

testExpandProjectIn

public void testExpandProjectIn()
                         throws java.lang.Exception

Throws:: java.lang.Exception

testExpandProjectInNullable

public void testExpandProjectInNullable()
                                 throws java.lang.Exception

Throws:: java.lang.Exception

testExpandProjectInComposite

public void testExpandProjectInComposite()
                                  throws java.lang.Exception

Throws:: java.lang.Exception

testExpandProjectExists

public void testExpandProjectExists()
                             throws java.lang.Exception

Throws:: java.lang.Exception

testExpandFilterScalar

public void testExpandFilterScalar()
                            throws java.lang.Exception

Throws:: java.lang.Exception

testExpandFilterIn

public void testExpandFilterIn()
                        throws java.lang.Exception

Throws:: java.lang.Exception

testExpandFilterInComposite

public void testExpandFilterInComposite()
                                 throws java.lang.Exception

Throws:: java.lang.Exception

testExpandFilterIn3Value
```
public void testExpandFilterIn3Value()
                              throws java.lang.Exception
```
An IN filter that requires full 3-value logic (true, false, unknown).

Throws:

java.lang.Exception

testExpandFilterExists
```
public void testExpandFilterExists()
                            throws java.lang.Exception
```
An EXISTS filter that can be converted into true/false.

Throws:

java.lang.Exception

testExpandFilterExistsSimple
```
public void testExpandFilterExistsSimple()
                                  throws java.lang.Exception
```
An EXISTS filter that can be converted into a semi-join.

Throws:

java.lang.Exception

testExpandFilterExistsSimpleAnd
```
public void testExpandFilterExistsSimpleAnd()
                                     throws java.lang.Exception
```
An EXISTS filter that can be converted into a semi-join.

Throws:

java.lang.Exception

testExpandJoinScalar

public void testExpandJoinScalar()
                          throws java.lang.Exception

Throws:: java.lang.Exception

testExpandJoinIn

public void testExpandJoinIn()
                      throws java.lang.Exception

Throws:: java.lang.Exception

testExpandJoinInComposite

public void testExpandJoinInComposite()
                               throws java.lang.Exception

Throws:: java.lang.Exception

testExpandJoinExists

public void testExpandJoinExists()
                          throws java.lang.Exception

Throws:: java.lang.Exception

testDecorrelateExists

public void testDecorrelateExists()
                           throws java.lang.Exception

Throws:: java.lang.Exception

testDecorrelateTwoExists
```
public void testDecorrelateTwoExists()
                              throws java.lang.Exception
```
Test case for [CALCITE-1511] AssertionError while decorrelating query with two EXISTS sub-queries.

Throws:

java.lang.Exception

testDecorrelateUncorrelatedInAndCorrelatedExists
```
public void testDecorrelateUncorrelatedInAndCorrelatedExists()
                                                      throws java.lang.Exception
```
Test case for [CALCITE-2028] Un-correlated IN sub-query should be converted into a Join, rather than a Correlate without correlation variables .

Throws:

java.lang.Exception

testDecorrelateTwoIn
```
public void testDecorrelateTwoIn()
                          throws java.lang.Exception
```
Test case for [CALCITE-1537] Unnecessary project expression in multi-sub-query plan.

Throws:

java.lang.Exception

testDecorrelateTwoScalar
```
public void testDecorrelateTwoScalar()
                              throws java.lang.Exception
```
Test case for [CALCITE-1045] Decorrelate sub-queries in Project and Join, with the added complication that there are two sub-queries.

Throws:

java.lang.Exception

testWhereInJoinCorrelated

public void testWhereInJoinCorrelated()

testWhereInCorrelated
```
public void testWhereInCorrelated()
```
Test case for [CALCITE-1494] Inefficient plan for correlated sub-queries. In "planAfter", there must be only one scan each of emp and dept. We don't need a separate value-generator for emp.job.

testWhereExpressionInCorrelated

public void testWhereExpressionInCorrelated()

testWhereExpressionInCorrelated2

public void testWhereExpressionInCorrelated2()

testExpandWhereComparisonCorrelated

public void testExpandWhereComparisonCorrelated()
                                         throws java.lang.Exception

Throws:: java.lang.Exception

testCustomColumnResolvingInNonCorrelatedSubQuery

public void testCustomColumnResolvingInNonCorrelatedSubQuery()

testCustomColumnResolvingInCorrelatedSubQuery

public void testCustomColumnResolvingInCorrelatedSubQuery()

testCustomColumnResolvingInCorrelatedSubQuery2

public void testCustomColumnResolvingInCorrelatedSubQuery2()

testExtractYearToRange
```
public void testExtractYearToRange()
```
Test case for [CALCITE-434] Converting predicates on date dimension columns into date ranges, specifically a rule that converts EXTRACT(YEAR FROM ...) = constant to a range.

testExtractYearMonthToRange

public void testExtractYearMonthToRange()

testFilterRemoveIsNotDistinctFromRule

public void testFilterRemoveIsNotDistinctFromRule()

testOversimplifiedCaseStatement

public void testOversimplifiedCaseStatement()

testNoOversimplificationBelowIsNull
```
public void testNoOversimplificationBelowIsNull()
```
Test case for [CALCITE-2726] ReduceExpressionRule may oversimplify filter conditions containing nulls.

Class RelOptRulesTest

Nested Class Summary

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

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.RelOptTestBase

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

Methods inherited from class java.lang.Object

Field Detail

skipItem

NOT_STRONG_EXPR

STRONG_EXPR

Constructor Detail

RelOptRulesTest

Method Detail

getDiffRepos

testReduceNot

testReduceNestedCaseWhen

testReduceCompositeInSubQuery

testReduceOrCaseWhen

testReduceNullableCase

testReduceNullableCase2

testProjectToWindowRuleForMultipleWindows

testUnionToDistinctRule

testExtractJoinFilterRule

testAddRedundantSemiJoinRule

testStrengthenJoinType

testFullOuterJoinSimplificationToLeftOuter

testFullOuterJoinSimplificationToRightOuter

testFullOuterJoinSimplificationToInner

testLeftOuterJoinSimplificationToInner

testRightOuterJoinSimplificationToInner

testPushFilterPastAgg

basePushFilterPastAggWithGroupingSets

testPushFilterPastAggWithGroupingSets1

testPushFilterPastAggWithGroupingSets2

testPushFilterPastAggTwo

testPushFilterPastAggThree

testPushFilterPastAggFour

testPushFilterPastProject

testJoinProjectTranspose

testSortUnionTranspose

testSortUnionTranspose2

testSortUnionTranspose3

testSortRemovalAllKeysConstant

testSortRemovalOneKeyConstant

testSemiJoinRuleExists

testSemiJoinRule

testSemiJoinRuleRight

testSemiJoinRuleFull

testSemiJoinRuleLeft

testPushFilterThroughSemiJoin

testSemiJoinReduceConstants

testSemiJoinTrim

testReduceAverage

testCastInAggregateReduceFunctions

testDistinctCountWithoutGroupBy

testDistinctCount1

testDistinctCount2

testDistinctCount3

testDistinctCountMultipleViaJoin

testDistinctCountMultiple

testDistinctCountMultipleNoGroup

testDistinctCountMixedJoin

testDistinctCountMixed

testDistinctCountMixed2

testDistinctCountGroupingSets1

testDistinctCountGroupingSets2

testDistinctNonDistinctAggregates

testCastInAggregateExpandDistinctAggregatesRule

testDistinctNonDistinctAggregatesWithGrouping1

testDistinctNonDistinctAggregatesWithGrouping2

testDistinctNonDistinctTwoAggregatesWithGrouping

testDistinctWithGrouping

testMultipleDistinctWithGrouping

testDistinctWithMultipleInputs

testDistinctWithMultipleInputsAndGroupby