CoreRules (Apache Calcite API)

java.lang.Object
- org.apache.calcite.rel.rules.CoreRules

```
public class CoreRules
extends Object
```
Rules that perform logical transformations on relational expressions.

See Also:

MaterializedViewRules

Field Summary

Fields
Modifier and Type	Field and Description
`static AggregateProjectPullUpConstantsRule`	`AGGREGATE_ANY_PULL_UP_CONSTANTS` More general form of `AGGREGATE_PROJECT_PULL_UP_CONSTANTS` that matches any relational expression.
`static AggregateCaseToFilterRule`	`AGGREGATE_CASE_TO_FILTER` Rule that converts CASE-style filtered aggregates into true filtered aggregates.
`static AggregateExpandDistinctAggregatesRule`	`AGGREGATE_EXPAND_DISTINCT_AGGREGATES` Rule that expands distinct aggregates (such as `COUNT(DISTINCT x)`) from a `Aggregate`.
`static AggregateExpandDistinctAggregatesRule`	`AGGREGATE_EXPAND_DISTINCT_AGGREGATES_TO_JOIN` As `AGGREGATE_EXPAND_DISTINCT_AGGREGATES` but generates a Join.
`static AggregateExpandWithinDistinctRule`	`AGGREGATE_EXPAND_WITHIN_DISTINCT` Rule that rewrites a `LogicalAggregate` that contains `WITHIN DISTINCT` aggregate functions to one that does not.
`static AggregateFilterTransposeRule`	`AGGREGATE_FILTER_TRANSPOSE` Rule that matches an `Aggregate` on a `Filter` and transposes them, pushing the aggregate below the filter.
`static AggregateJoinJoinRemoveRule`	`AGGREGATE_JOIN_JOIN_REMOVE` Rule that matches an `Aggregate` on a `Join` and removes the left input of the join provided that the left input is also a left join if possible.
`static AggregateJoinRemoveRule`	`AGGREGATE_JOIN_REMOVE` Rule that matches an `Aggregate` on a `Join` and removes the join provided that the join is a left join or right join and it computes no aggregate functions or all the aggregate calls have distinct.
`static AggregateJoinTransposeRule`	`AGGREGATE_JOIN_TRANSPOSE` Rule that pushes an `Aggregate` past a `Join`.
`static AggregateJoinTransposeRule`	`AGGREGATE_JOIN_TRANSPOSE_EXTENDED` As `AGGREGATE_JOIN_TRANSPOSE`, but extended to push down aggregate functions.
`static AggregateMergeRule`	`AGGREGATE_MERGE` Rule that matches an `Aggregate` on an `Aggregate`, and merges into a single Aggregate if the top aggregate's group key is a subset of the lower aggregate's group key, and the aggregates are expansions of rollups.
`static AggregateProjectMergeRule`	`AGGREGATE_PROJECT_MERGE` Rule that recognizes an `Aggregate` on top of a `Project` and if possible aggregates through the Project or removes the Project.
`static AggregateProjectPullUpConstantsRule`	`AGGREGATE_PROJECT_PULL_UP_CONSTANTS` Rule that removes constant keys from an `Aggregate`.
`static AggregateProjectStarTableRule`	`AGGREGATE_PROJECT_STAR_TABLE` Variant of `AGGREGATE_STAR_TABLE` that accepts a `Project` between the `Aggregate` and its `StarTable.StarTableScan` input.
`static AggregateReduceFunctionsRule`	`AGGREGATE_REDUCE_FUNCTIONS` Rule that reduces aggregate functions in an `Aggregate` to simpler forms.
`static AggregateRemoveRule`	`AGGREGATE_REMOVE` Rule that removes an `Aggregate` if it computes no aggregate functions (that is, it is implementing `SELECT DISTINCT`), or all the aggregate functions are splittable, and the underlying relational expression is already distinct.
`static AggregateStarTableRule`	`AGGREGATE_STAR_TABLE` Rule that matches an `Aggregate` on a `StarTable.StarTableScan`.
`static AggregateUnionAggregateRule`	`AGGREGATE_UNION_AGGREGATE` Rule that matches an `Aggregate` whose input is a `Union` one of whose inputs is an `Aggregate`.
`static AggregateUnionAggregateRule`	`AGGREGATE_UNION_AGGREGATE_FIRST` As `AGGREGATE_UNION_AGGREGATE`, but matches an `Aggregate` only as the left input of the `Union`.
`static AggregateUnionAggregateRule`	`AGGREGATE_UNION_AGGREGATE_SECOND` As `AGGREGATE_UNION_AGGREGATE`, but matches an `Aggregate` only as the right input of the `Union`.
`static AggregateUnionTransposeRule`	`AGGREGATE_UNION_TRANSPOSE` Rule that pushes an `Aggregate` past a non-distinct `Union`.
`static AggregateValuesRule`	`AGGREGATE_VALUES` Rule that applies an `Aggregate` to a `Values` (currently just an empty `Values`).
`static CalcMergeRule`	`CALC_MERGE` Rule that merges a `Calc` onto a `Calc`.
`static ReduceDecimalsRule`	`CALC_REDUCE_DECIMALS` Rule that reduces operations on the DECIMAL type, such as casts or arithmetic, into operations involving more primitive types such as BIGINT and DOUBLE.
`static ReduceExpressionsRule.CalcReduceExpressionsRule`	`CALC_REDUCE_EXPRESSIONS` Rule that reduces constants inside a `LogicalCalc`.
`static CalcRemoveRule`	`CALC_REMOVE` Rule that removes a trivial `LogicalCalc`.
`static CalcSplitRule`	`CALC_SPLIT` Rule that converts a `Calc` to a `Project` and `Filter`.
`static ProjectToWindowRule.CalcToWindowRule`	`CALC_TO_WINDOW` Rule that transforms a `Calc` that contains windowed aggregates to a mixture of `LogicalWindow` and `Calc`.
`static CoerceInputsRule`	`COERCE_INPUTS` Rule that pre-casts inputs to a particular type.
`static ExchangeRemoveConstantKeysRule`	`EXCHANGE_REMOVE_CONSTANT_KEYS` Rule that removes constants inside a `LogicalExchange`.
`static FilterAggregateTransposeRule`	`FILTER_AGGREGATE_TRANSPOSE` Rule that pushes a `Filter` past an `Aggregate`.
`static FilterCalcMergeRule`	`FILTER_CALC_MERGE` Rule that merges a `Filter` and a `LogicalCalc`.
`static FilterCorrelateRule`	`FILTER_CORRELATE` Rule that pushes a `Filter` above a `Correlate` into the inputs of the `Correlate`.
`static FilterRemoveIsNotDistinctFromRule`	`FILTER_EXPAND_IS_NOT_DISTINCT_FROM` Rule that replaces `IS NOT DISTINCT FROM` in a `Filter` with logically equivalent operations.
`static FilterTableScanRule`	`FILTER_INTERPRETER_SCAN` Rule that matches a `Filter` on an `EnumerableInterpreter` on a `TableScan`.
`static FilterJoinRule.FilterIntoJoinRule`	`FILTER_INTO_JOIN` Rule that tries to push filter expressions into a join condition and into the inputs of the join.
`static FilterJoinRule.FilterIntoJoinRule`	`FILTER_INTO_JOIN_DUMB` Dumber version of `FILTER_INTO_JOIN`.
`static FilterMergeRule`	`FILTER_MERGE` Rule that combines two `LogicalFilter`s.
`static FilterMultiJoinMergeRule`	`FILTER_MULTI_JOIN_MERGE` Rule that merges a `Filter` into a `MultiJoin`, creating a richer `MultiJoin`.
`static FilterProjectTransposeRule`	`FILTER_PROJECT_TRANSPOSE` The default instance of `FilterProjectTransposeRule`.
`static ReduceExpressionsRule.FilterReduceExpressionsRule`	`FILTER_REDUCE_EXPRESSIONS` Rule that reduces constants inside a `LogicalFilter`.
`static FilterTableScanRule`	`FILTER_SCAN` Rule that matches a `Filter` on a `TableScan`.
`static FilterSetOpTransposeRule`	`FILTER_SET_OP_TRANSPOSE` Rule that pushes a `Filter` past a `SetOp`.
`static SubQueryRemoveRule`	`FILTER_SUB_QUERY_TO_CORRELATE` Rule that converts a sub-queries from filter expressions into `Correlate` instances.
`static FilterTableFunctionTransposeRule`	`FILTER_TABLE_FUNCTION_TRANSPOSE` Rule that pushes a `LogicalFilter` past a `LogicalTableFunctionScan`.
`static FilterToCalcRule`	`FILTER_TO_CALC` Rule that converts a `LogicalFilter` to a `LogicalCalc`.
`static ValuesReduceRule`	`FILTER_VALUES_MERGE` Rule that merges a `Filter` onto an underlying `LogicalValues`, resulting in a `Values` with potentially fewer rows.
`static UnionMergeRule`	`INTERSECT_MERGE` Rule that flattens an `Intersect` on an `Intersect` into a single `Intersect`.
`static IntersectToDistinctRule`	`INTERSECT_TO_DISTINCT` Rule that translates a distinct `Intersect` into a group of operators composed of `Union`, `Aggregate`, etc.
`static JoinAddRedundantSemiJoinRule`	`JOIN_ADD_REDUNDANT_SEMI_JOIN` Rule to add a semi-join into a `Join`.
`static JoinAssociateRule`	`JOIN_ASSOCIATE` Rule that changes a join based on the associativity rule, ((a JOIN b) JOIN c) → (a JOIN (b JOIN c)).
`static JoinCommuteRule`	`JOIN_COMMUTE` Rule that permutes the inputs to an inner `Join`.
`static JoinCommuteRule`	`JOIN_COMMUTE_OUTER` As `JOIN_COMMUTE` but swaps outer joins as well as inner joins.
`static FilterJoinRule.JoinConditionPushRule`	`JOIN_CONDITION_PUSH` Rule that pushes predicates in a Join into the inputs to the join.
`static JoinDeriveIsNotNullFilterRule`	`JOIN_DERIVE_IS_NOT_NULL_FILTER_RULE` Rule that derives IS NOT NULL predicates from a inner `Join` and creates `Filter`s with those predicates as new inputs of the `Join`.
`static JoinExtractFilterRule`	`JOIN_EXTRACT_FILTER` Rule to convert an `inner join` to a `filter` on top of a `cartesian inner join`.
`static JoinUnionTransposeRule`	`JOIN_LEFT_UNION_TRANSPOSE` Rule that pushes a `Join` past a non-distinct `Union` as its left input.
`static SemiJoinRule.JoinOnUniqueToSemiJoinRule`	`JOIN_ON_UNIQUE_TO_SEMI_JOIN` Rule that creates a `semi-join` from a `Join`, and it's right keys are unique in its right input.
`static JoinProjectTransposeRule`	`JOIN_PROJECT_BOTH_TRANSPOSE` Rule that matches a `LogicalJoin` whose inputs are `LogicalProject`s, and pulls the project expressions up.
`static JoinProjectTransposeRule`	`JOIN_PROJECT_BOTH_TRANSPOSE_INCLUDE_OUTER` As `JOIN_PROJECT_BOTH_TRANSPOSE` but match outer as well as inner join.
`static JoinProjectTransposeRule`	`JOIN_PROJECT_LEFT_TRANSPOSE` As `JOIN_PROJECT_BOTH_TRANSPOSE` but only the left input is a `LogicalProject`.
`static JoinProjectTransposeRule`	`JOIN_PROJECT_LEFT_TRANSPOSE_INCLUDE_OUTER` As `JOIN_PROJECT_LEFT_TRANSPOSE` but match outer as well as inner join.
`static JoinProjectTransposeRule`	`JOIN_PROJECT_RIGHT_TRANSPOSE` As `JOIN_PROJECT_BOTH_TRANSPOSE` but only the right input is a `LogicalProject`.
`static JoinProjectTransposeRule`	`JOIN_PROJECT_RIGHT_TRANSPOSE_INCLUDE_OUTER` As `JOIN_PROJECT_RIGHT_TRANSPOSE` but match outer as well as inner join.
`static JoinPushExpressionsRule`	`JOIN_PUSH_EXPRESSIONS` Rule that matches a `Join` and pushes down expressions on either side of "equal" conditions.
`static JoinPushTransitivePredicatesRule`	`JOIN_PUSH_TRANSITIVE_PREDICATES` Rule that infers predicates from on a `Join` and creates `Filter`s if those predicates can be pushed to its inputs.
`static ReduceExpressionsRule.JoinReduceExpressionsRule`	`JOIN_REDUCE_EXPRESSIONS` Rule that reduces constants inside a `Join`.
`static JoinUnionTransposeRule`	`JOIN_RIGHT_UNION_TRANSPOSE` Rule that pushes a `Join` past a non-distinct `Union` as its right input.
`static SubQueryRemoveRule`	`JOIN_SUB_QUERY_TO_CORRELATE` Rule that converts sub-queries from join expressions into `Correlate` instances.
`static JoinToCorrelateRule`	`JOIN_TO_CORRELATE` Rule that converts a `LogicalJoin` into a `LogicalCorrelate`.
`static JoinToMultiJoinRule`	`JOIN_TO_MULTI_JOIN` Rule that flattens a tree of `LogicalJoin`s into a single `MultiJoin` with N inputs.
`static SemiJoinRule.JoinToSemiJoinRule`	`JOIN_TO_SEMI_JOIN` Rule that creates a `semi-join` from a `Join` with an empty `Aggregate` as its right input.
`static MatchRule`	`MATCH` Rule that converts a `LogicalMatch` to the result of calling `LogicalMatch.copy(org.apache.calcite.plan.RelTraitSet, java.util.List<org.apache.calcite.rel.RelNode>)`.
`static UnionMergeRule`	`MINUS_MERGE` Rule that flattens a `Minus` on a `Minus` into a single `Minus`.
`static MultiJoinProjectTransposeRule`	`MULTI_JOIN_BOTH_PROJECT` Rule that matches a `LogicalJoin` whose inputs are both a `MultiJoin` with intervening `LogicalProject`s, and pulls the Projects up above the Join.
`static MultiJoinProjectTransposeRule`	`MULTI_JOIN_LEFT_PROJECT` As `MULTI_JOIN_BOTH_PROJECT` but only the left input has an intervening Project.
`static LoptOptimizeJoinRule`	`MULTI_JOIN_OPTIMIZE` Rule that re-orders a `Join` using a heuristic planner.
`static MultiJoinOptimizeBushyRule`	`MULTI_JOIN_OPTIMIZE_BUSHY` Rule that finds an approximately optimal ordering for join operators using a heuristic algorithm and can handle bushy joins.
`static MultiJoinProjectTransposeRule`	`MULTI_JOIN_RIGHT_PROJECT` As `MULTI_JOIN_BOTH_PROJECT` but only the right input has an intervening Project.
`static ProjectAggregateMergeRule`	`PROJECT_AGGREGATE_MERGE` Rule that matches a `Project` on an `Aggregate`, projecting away aggregate calls that are not used.
`static ProjectCalcMergeRule`	`PROJECT_CALC_MERGE` Rule that merges a `LogicalProject` and a `LogicalCalc`.
`static ProjectCorrelateTransposeRule`	`PROJECT_CORRELATE_TRANSPOSE` Rule that matches a `Project` on a `Correlate` and pushes the projections to the Correlate's left and right inputs.
`static ProjectFilterTransposeRule`	`PROJECT_FILTER_TRANSPOSE` Rule that pushes a `Project` past a `Filter`.
`static ProjectFilterTransposeRule`	`PROJECT_FILTER_TRANSPOSE_WHOLE_EXPRESSIONS` As `PROJECT_FILTER_TRANSPOSE`, but pushes down project and filter expressions whole, not field references.
`static ProjectFilterTransposeRule`	`PROJECT_FILTER_TRANSPOSE_WHOLE_PROJECT_EXPRESSIONS` As `PROJECT_FILTER_TRANSPOSE`, pushes down field references for filters, but pushes down project expressions whole.
`static ValuesReduceRule`	`PROJECT_FILTER_VALUES_MERGE` Rule that merges a `Project` on top of a `Filter` onto an underlying `LogicalValues`, resulting in a `Values` with different columns and potentially fewer rows.
`static ProjectTableScanRule`	`PROJECT_INTERPRETER_TABLE_SCAN` As `PROJECT_TABLE_SCAN`, but with an intervening `EnumerableInterpreter`.
`static ProjectJoinJoinRemoveRule`	`PROJECT_JOIN_JOIN_REMOVE` Rule that matches an `Project` on a `Join` and removes the left input of the join provided that the left input is also a left join.
`static ProjectJoinRemoveRule`	`PROJECT_JOIN_REMOVE` Rule that matches an `Project` on a `Join` and removes the join provided that the join is a left join or right join and the join keys are unique.
`static ProjectJoinTransposeRule`	`PROJECT_JOIN_TRANSPOSE` Rule that pushes a `LogicalProject` past a `LogicalJoin` by splitting the projection into a projection on top of each child of the join.
`static ProjectMergeRule`	`PROJECT_MERGE` Rule that merges a `Project` into another `Project`, provided the projects are not projecting identical sets of input references.
`static ProjectMultiJoinMergeRule`	`PROJECT_MULTI_JOIN_MERGE` Rule that pushes a `Project` into a `MultiJoin`, creating a richer `MultiJoin`.
`static ReduceExpressionsRule.ProjectReduceExpressionsRule`	`PROJECT_REDUCE_EXPRESSIONS` Rule that reduces constants inside a `LogicalProject`.
`static ProjectRemoveRule`	`PROJECT_REMOVE` Rule that, given a `Project` node that merely returns its input, converts the node into its input.
`static ProjectSetOpTransposeRule`	`PROJECT_SET_OP_TRANSPOSE` Rule that pushes a `LogicalProject` past a `SetOp`.
`static SubQueryRemoveRule`	`PROJECT_SUB_QUERY_TO_CORRELATE` Rule that converts sub-queries from project expressions into `Correlate` instances.
`static ProjectTableScanRule`	`PROJECT_TABLE_SCAN` Rule that converts a `Project` on a `TableScan` of a `ProjectableFilterableTable` to a `Bindables.BindableTableScan`.
`static ProjectToCalcRule`	`PROJECT_TO_CALC` Rule that converts a `LogicalProject` to a `LogicalCalc`.
`static ProjectToWindowRule.ProjectToLogicalProjectAndWindowRule`	`PROJECT_TO_LOGICAL_PROJECT_AND_WINDOW` Rule that transforms a `Project` into a mixture of `LogicalProject` and `LogicalWindow`.
`static SemiJoinRule.ProjectToSemiJoinRule`	`PROJECT_TO_SEMI_JOIN` Rule that creates a `semi-join` from a `Project` on top of a `Join` with an `Aggregate` as its right input.
`static ValuesReduceRule`	`PROJECT_VALUES_MERGE` Rule that merges a `Project` onto an underlying `LogicalValues`, resulting in a `Values` with different columns.
`static ProjectWindowTransposeRule`	`PROJECT_WINDOW_TRANSPOSE` Rule that pushes a `LogicalProject` past a `LogicalWindow`.
`static SemiJoinFilterTransposeRule`	`SEMI_JOIN_FILTER_TRANSPOSE` Rule that pushes a `semi-join` down in a tree past a `Filter`.
`static SemiJoinJoinTransposeRule`	`SEMI_JOIN_JOIN_TRANSPOSE` Rule that pushes a `semi-join` down in a tree past a `Join`.
`static SemiJoinProjectTransposeRule`	`SEMI_JOIN_PROJECT_TRANSPOSE` Rule that pushes a `semi-join` down in a tree past a `Project`.
`static SemiJoinRemoveRule`	`SEMI_JOIN_REMOVE` Rule that removes a `semi-join` from a join tree.
`static ExchangeRemoveConstantKeysRule`	`SORT_EXCHANGE_REMOVE_CONSTANT_KEYS` Rule that removes constants inside a `LogicalSortExchange`.
`static SortJoinCopyRule`	`SORT_JOIN_COPY` Rule that copies a `Sort` past a `Join` without its limit and offset.
`static SortJoinTransposeRule`	`SORT_JOIN_TRANSPOSE` Rule that pushes a `Sort` past a `Join`.
`static SortProjectTransposeRule`	`SORT_PROJECT_TRANSPOSE` Rule that pushes a `Sort` past a `Project`.
`static SortRemoveRule`	`SORT_REMOVE` Rule that removes a `Sort` if its input is already sorted.
`static SortRemoveConstantKeysRule`	`SORT_REMOVE_CONSTANT_KEYS` Rule that removes keys from a `Sort` if those keys are known to be constant, or removes the entire Sort if all keys are constant.
`static SortUnionTransposeRule`	`SORT_UNION_TRANSPOSE` Rule that pushes a `Sort` past a `Union`.
`static SortUnionTransposeRule`	`SORT_UNION_TRANSPOSE_MATCH_NULL_FETCH` As `SORT_UNION_TRANSPOSE`, but for a Union implementation that preserves the ordering of its inputs.
`static UnionMergeRule`	`UNION_MERGE` Rule that flattens a `Union` on a `Union` into a single `Union`.
`static UnionPullUpConstantsRule`	`UNION_PULL_UP_CONSTANTS` Rule that pulls up constants through a Union operator.
`static UnionEliminatorRule`	`UNION_REMOVE` Rule that removes a `Union` if it has only one input.
`static UnionToDistinctRule`	`UNION_TO_DISTINCT` Rule that translates a distinct `Union` (`all` = `false`) into an `Aggregate` on top of a non-distinct `Union` (`all` = `true`).
`static ReduceExpressionsRule.WindowReduceExpressionsRule`	`WINDOW_REDUCE_EXPRESSIONS` Rule that reduces constants inside a `LogicalWindow`.

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

- Field Detail
  - AGGREGATE_PROJECT_MERGE
```
public static final AggregateProjectMergeRule AGGREGATE_PROJECT_MERGE
```
    Rule that recognizes an Aggregate on top of a Project and if possible aggregates through the Project or removes the Project.
  - AGGREGATE_PROJECT_PULL_UP_CONSTANTS
```
public static final AggregateProjectPullUpConstantsRule AGGREGATE_PROJECT_PULL_UP_CONSTANTS
```
    Rule that removes constant keys from an Aggregate.
  - AGGREGATE_ANY_PULL_UP_CONSTANTS
```
public static final AggregateProjectPullUpConstantsRule AGGREGATE_ANY_PULL_UP_CONSTANTS
```
    More general form of AGGREGATE_PROJECT_PULL_UP_CONSTANTS that matches any relational expression.
  - AGGREGATE_STAR_TABLE
```
public static final AggregateStarTableRule AGGREGATE_STAR_TABLE
```
    Rule that matches an Aggregate on a StarTable.StarTableScan.
  - AGGREGATE_PROJECT_STAR_TABLE
```
public static final AggregateProjectStarTableRule AGGREGATE_PROJECT_STAR_TABLE
```
    Variant of AGGREGATE_STAR_TABLE that accepts a Project between the Aggregate and its StarTable.StarTableScan input.
  - AGGREGATE_REDUCE_FUNCTIONS
```
public static final AggregateReduceFunctionsRule AGGREGATE_REDUCE_FUNCTIONS
```
    Rule that reduces aggregate functions in an Aggregate to simpler forms.
  - AGGREGATE_MERGE
```
public static final AggregateMergeRule AGGREGATE_MERGE
```
    Rule that matches an Aggregate on an Aggregate, and merges into a single Aggregate if the top aggregate's group key is a subset of the lower aggregate's group key, and the aggregates are expansions of rollups.
  - AGGREGATE_REMOVE
```
public static final AggregateRemoveRule AGGREGATE_REMOVE
```
    Rule that removes an Aggregate if it computes no aggregate functions (that is, it is implementing SELECT DISTINCT), or all the aggregate functions are splittable, and the underlying relational expression is already distinct.
  - AGGREGATE_EXPAND_DISTINCT_AGGREGATES
```
public static final AggregateExpandDistinctAggregatesRule AGGREGATE_EXPAND_DISTINCT_AGGREGATES
```
    Rule that expands distinct aggregates (such as COUNT(DISTINCT x)) from a Aggregate. This instance operates only on logical expressions.
  - AGGREGATE_EXPAND_DISTINCT_AGGREGATES_TO_JOIN
```
public static final AggregateExpandDistinctAggregatesRule AGGREGATE_EXPAND_DISTINCT_AGGREGATES_TO_JOIN
```
    As AGGREGATE_EXPAND_DISTINCT_AGGREGATES but generates a Join.
  - AGGREGATE_EXPAND_WITHIN_DISTINCT
```
public static final AggregateExpandWithinDistinctRule AGGREGATE_EXPAND_WITHIN_DISTINCT
```
    Rule that rewrites a LogicalAggregate that contains WITHIN DISTINCT aggregate functions to one that does not.
  - AGGREGATE_FILTER_TRANSPOSE
```
public static final AggregateFilterTransposeRule AGGREGATE_FILTER_TRANSPOSE
```
    Rule that matches an Aggregate on a Filter and transposes them, pushing the aggregate below the filter.
  - AGGREGATE_JOIN_JOIN_REMOVE
```
public static final AggregateJoinJoinRemoveRule AGGREGATE_JOIN_JOIN_REMOVE
```
    Rule that matches an Aggregate on a Join and removes the left input of the join provided that the left input is also a left join if possible.
  - AGGREGATE_JOIN_REMOVE
```
public static final AggregateJoinRemoveRule AGGREGATE_JOIN_REMOVE
```
    Rule that matches an Aggregate on a Join and removes the join provided that the join is a left join or right join and it computes no aggregate functions or all the aggregate calls have distinct.
  - AGGREGATE_JOIN_TRANSPOSE
```
public static final AggregateJoinTransposeRule AGGREGATE_JOIN_TRANSPOSE
```
    Rule that pushes an Aggregate past a Join.
  - AGGREGATE_JOIN_TRANSPOSE_EXTENDED
```
public static final AggregateJoinTransposeRule AGGREGATE_JOIN_TRANSPOSE_EXTENDED
```
    As AGGREGATE_JOIN_TRANSPOSE, but extended to push down aggregate functions.
  - AGGREGATE_UNION_TRANSPOSE
```
public static final AggregateUnionTransposeRule AGGREGATE_UNION_TRANSPOSE
```
    Rule that pushes an Aggregate past a non-distinct Union.
  - AGGREGATE_UNION_AGGREGATE
```
public static final AggregateUnionAggregateRule AGGREGATE_UNION_AGGREGATE
```
    Rule that matches an Aggregate whose input is a Union one of whose inputs is an Aggregate.
    Because it matches RelNode for each input of Union, it will create O(N ^ 2) matches, which may cost too much during the popMatch phase in VolcanoPlanner. If efficiency is a concern, we recommend that you use AGGREGATE_UNION_AGGREGATE_FIRST and AGGREGATE_UNION_AGGREGATE_SECOND instead.
  - AGGREGATE_UNION_AGGREGATE_FIRST
```
public static final AggregateUnionAggregateRule AGGREGATE_UNION_AGGREGATE_FIRST
```
    As AGGREGATE_UNION_AGGREGATE, but matches an Aggregate only as the left input of the Union.
  - AGGREGATE_UNION_AGGREGATE_SECOND
```
public static final AggregateUnionAggregateRule AGGREGATE_UNION_AGGREGATE_SECOND
```
    As AGGREGATE_UNION_AGGREGATE, but matches an Aggregate only as the right input of the Union.
  - AGGREGATE_CASE_TO_FILTER
```
public static final AggregateCaseToFilterRule AGGREGATE_CASE_TO_FILTER
```
    Rule that converts CASE-style filtered aggregates into true filtered aggregates.
  - CALC_MERGE
```
public static final CalcMergeRule CALC_MERGE
```
    Rule that merges a Calc onto a Calc.
  - CALC_REMOVE
```
public static final CalcRemoveRule CALC_REMOVE
```
    Rule that removes a trivial LogicalCalc.
  - CALC_REDUCE_DECIMALS
```
public static final ReduceDecimalsRule CALC_REDUCE_DECIMALS
```
    Rule that reduces operations on the DECIMAL type, such as casts or arithmetic, into operations involving more primitive types such as BIGINT and DOUBLE.
  - CALC_REDUCE_EXPRESSIONS
```
public static final ReduceExpressionsRule.CalcReduceExpressionsRule CALC_REDUCE_EXPRESSIONS
```
    Rule that reduces constants inside a LogicalCalc.
    
    See Also:
    
    FILTER_REDUCE_EXPRESSIONS
  - CALC_SPLIT
```
public static final CalcSplitRule CALC_SPLIT
```
    Rule that converts a Calc to a Project and Filter.
  - CALC_TO_WINDOW
```
public static final ProjectToWindowRule.CalcToWindowRule CALC_TO_WINDOW
```
    Rule that transforms a Calc that contains windowed aggregates to a mixture of LogicalWindow and Calc.
  - COERCE_INPUTS
```
public static final CoerceInputsRule COERCE_INPUTS
```
    Rule that pre-casts inputs to a particular type. This can assist operator implementations that impose requirements on their input types.
  - EXCHANGE_REMOVE_CONSTANT_KEYS
```
public static final ExchangeRemoveConstantKeysRule EXCHANGE_REMOVE_CONSTANT_KEYS
```
    Rule that removes constants inside a LogicalExchange.
  - SORT_EXCHANGE_REMOVE_CONSTANT_KEYS
```
public static final ExchangeRemoveConstantKeysRule SORT_EXCHANGE_REMOVE_CONSTANT_KEYS
```
    Rule that removes constants inside a LogicalSortExchange.
  - FILTER_INTO_JOIN
```
public static final FilterJoinRule.FilterIntoJoinRule FILTER_INTO_JOIN
```
    Rule that tries to push filter expressions into a join condition and into the inputs of the join.
  - FILTER_INTO_JOIN_DUMB
```
public static final FilterJoinRule.FilterIntoJoinRule FILTER_INTO_JOIN_DUMB
```
    Dumber version of FILTER_INTO_JOIN. Not intended for production use, but keeps some tests working for which FILTER_INTO_JOIN is too smart.
  - FILTER_MERGE
```
public static final FilterMergeRule FILTER_MERGE
```
    Rule that combines two LogicalFilters.
  - FILTER_CALC_MERGE
```
public static final FilterCalcMergeRule FILTER_CALC_MERGE
```
    Rule that merges a Filter and a LogicalCalc. The result is a LogicalCalc whose filter condition is the logical AND of the two.
    
    See Also:
    
    PROJECT_CALC_MERGE
  - FILTER_TO_CALC
```
public static final FilterToCalcRule FILTER_TO_CALC
```
    Rule that converts a LogicalFilter to a LogicalCalc.
    
    See Also:
    
    PROJECT_TO_CALC
  - FILTER_AGGREGATE_TRANSPOSE
```
public static final FilterAggregateTransposeRule FILTER_AGGREGATE_TRANSPOSE
```
    Rule that pushes a Filter past an Aggregate.
    
    See Also:
    
    AGGREGATE_FILTER_TRANSPOSE
  - FILTER_PROJECT_TRANSPOSE
```
public static final FilterProjectTransposeRule FILTER_PROJECT_TRANSPOSE
```
    The default instance of FilterProjectTransposeRule.
    It does not allow a Filter to be pushed past the Project if there is a correlation condition) anywhere in the Filter, since in some cases it can prevent a Correlate from being de-correlated.
  - FILTER_TABLE_FUNCTION_TRANSPOSE
```
public static final FilterTableFunctionTransposeRule FILTER_TABLE_FUNCTION_TRANSPOSE
```
    Rule that pushes a LogicalFilter past a LogicalTableFunctionScan.
  - FILTER_SCAN
```
public static final FilterTableScanRule FILTER_SCAN
```
    Rule that matches a Filter on a TableScan.
  - FILTER_INTERPRETER_SCAN
```
public static final FilterTableScanRule FILTER_INTERPRETER_SCAN
```
    Rule that matches a Filter on an EnumerableInterpreter on a TableScan.
  - FILTER_CORRELATE
```
public static final FilterCorrelateRule FILTER_CORRELATE
```
    Rule that pushes a Filter above a Correlate into the inputs of the Correlate.
  - FILTER_MULTI_JOIN_MERGE
```
public static final FilterMultiJoinMergeRule FILTER_MULTI_JOIN_MERGE
```
    Rule that merges a Filter into a MultiJoin, creating a richer MultiJoin.
    
    See Also:
    
    PROJECT_MULTI_JOIN_MERGE
  - FILTER_EXPAND_IS_NOT_DISTINCT_FROM
```
public static final FilterRemoveIsNotDistinctFromRule FILTER_EXPAND_IS_NOT_DISTINCT_FROM
```
    Rule that replaces IS NOT DISTINCT FROM in a Filter with logically equivalent operations.
  - FILTER_SET_OP_TRANSPOSE
```
public static final FilterSetOpTransposeRule FILTER_SET_OP_TRANSPOSE
```
    Rule that pushes a Filter past a SetOp.
  - FILTER_REDUCE_EXPRESSIONS
```
public static final ReduceExpressionsRule.FilterReduceExpressionsRule FILTER_REDUCE_EXPRESSIONS
```
    Rule that reduces constants inside a LogicalFilter.
    
    See Also:
    
    JOIN_REDUCE_EXPRESSIONS, PROJECT_REDUCE_EXPRESSIONS, CALC_REDUCE_EXPRESSIONS, WINDOW_REDUCE_EXPRESSIONS
  - INTERSECT_MERGE
```
public static final UnionMergeRule INTERSECT_MERGE
```
    Rule that flattens an Intersect on an Intersect into a single Intersect.
  - INTERSECT_TO_DISTINCT
```
public static final IntersectToDistinctRule INTERSECT_TO_DISTINCT
```
    Rule that translates a distinct Intersect into a group of operators composed of Union, Aggregate, etc.
  - MATCH
```
public static final MatchRule MATCH
```
    Rule that converts a LogicalMatch to the result of calling LogicalMatch.copy(org.apache.calcite.plan.RelTraitSet, java.util.List<org.apache.calcite.rel.RelNode>).
  - MINUS_MERGE
```
public static final UnionMergeRule MINUS_MERGE
```
    Rule that flattens a Minus on a Minus into a single Minus.
  - PROJECT_AGGREGATE_MERGE
```
public static final ProjectAggregateMergeRule PROJECT_AGGREGATE_MERGE
```
    Rule that matches a Project on an Aggregate, projecting away aggregate calls that are not used.
  - PROJECT_CALC_MERGE
```
public static final ProjectCalcMergeRule PROJECT_CALC_MERGE
```
    Rule that merges a LogicalProject and a LogicalCalc.
    
    See Also:
    
    FILTER_CALC_MERGE
  - PROJECT_CORRELATE_TRANSPOSE
```
public static final ProjectCorrelateTransposeRule PROJECT_CORRELATE_TRANSPOSE
```
    Rule that matches a Project on a Correlate and pushes the projections to the Correlate's left and right inputs.
  - PROJECT_FILTER_TRANSPOSE
```
public static final ProjectFilterTransposeRule PROJECT_FILTER_TRANSPOSE
```
    Rule that pushes a Project past a Filter.
    
    See Also:
    
    PROJECT_FILTER_TRANSPOSE_WHOLE_PROJECT_EXPRESSIONS, PROJECT_FILTER_TRANSPOSE_WHOLE_EXPRESSIONS
  - PROJECT_FILTER_TRANSPOSE_WHOLE_EXPRESSIONS
```
public static final ProjectFilterTransposeRule PROJECT_FILTER_TRANSPOSE_WHOLE_EXPRESSIONS
```
    As PROJECT_FILTER_TRANSPOSE, but pushes down project and filter expressions whole, not field references.
  - PROJECT_FILTER_TRANSPOSE_WHOLE_PROJECT_EXPRESSIONS
```
public static final ProjectFilterTransposeRule PROJECT_FILTER_TRANSPOSE_WHOLE_PROJECT_EXPRESSIONS
```
    As PROJECT_FILTER_TRANSPOSE, pushes down field references for filters, but pushes down project expressions whole.
  - PROJECT_REDUCE_EXPRESSIONS
```
public static final ReduceExpressionsRule.ProjectReduceExpressionsRule PROJECT_REDUCE_EXPRESSIONS
```
    Rule that reduces constants inside a LogicalProject.
    
    See Also:
    
    FILTER_REDUCE_EXPRESSIONS
  - PROJECT_SUB_QUERY_TO_CORRELATE
```
public static final SubQueryRemoveRule PROJECT_SUB_QUERY_TO_CORRELATE
```
    Rule that converts sub-queries from project expressions into Correlate instances.
    
    See Also:
    
    FILTER_SUB_QUERY_TO_CORRELATE, JOIN_SUB_QUERY_TO_CORRELATE
  - FILTER_SUB_QUERY_TO_CORRELATE
```
public static final SubQueryRemoveRule FILTER_SUB_QUERY_TO_CORRELATE
```
    Rule that converts a sub-queries from filter expressions into Correlate instances.
    
    See Also:
    
    PROJECT_SUB_QUERY_TO_CORRELATE, JOIN_SUB_QUERY_TO_CORRELATE
  - JOIN_SUB_QUERY_TO_CORRELATE
```
public static final SubQueryRemoveRule JOIN_SUB_QUERY_TO_CORRELATE
```
    Rule that converts sub-queries from join expressions into Correlate instances.
    
    See Also:
    
    PROJECT_SUB_QUERY_TO_CORRELATE, FILTER_SUB_QUERY_TO_CORRELATE
  - PROJECT_TO_LOGICAL_PROJECT_AND_WINDOW
```
public static final ProjectToWindowRule.ProjectToLogicalProjectAndWindowRule PROJECT_TO_LOGICAL_PROJECT_AND_WINDOW
```
    Rule that transforms a Project into a mixture of LogicalProject and LogicalWindow.
  - PROJECT_TO_SEMI_JOIN
```
public static final SemiJoinRule.ProjectToSemiJoinRule PROJECT_TO_SEMI_JOIN
```
    Rule that creates a semi-join from a Project on top of a Join with an Aggregate as its right input.
    
    See Also:
    
    JOIN_TO_SEMI_JOIN
  - PROJECT_JOIN_JOIN_REMOVE
```
public static final ProjectJoinJoinRemoveRule PROJECT_JOIN_JOIN_REMOVE
```
    Rule that matches an Project on a Join and removes the left input of the join provided that the left input is also a left join.
  - PROJECT_JOIN_REMOVE
```
public static final ProjectJoinRemoveRule PROJECT_JOIN_REMOVE
```
    Rule that matches an Project on a Join and removes the join provided that the join is a left join or right join and the join keys are unique.
  - PROJECT_JOIN_TRANSPOSE
```
public static final ProjectJoinTransposeRule PROJECT_JOIN_TRANSPOSE
```
    Rule that pushes a LogicalProject past a LogicalJoin by splitting the projection into a projection on top of each child of the join.
  - PROJECT_MERGE
```
public static final ProjectMergeRule PROJECT_MERGE
```
    Rule that merges a Project into another Project, provided the projects are not projecting identical sets of input references.
  - PROJECT_SET_OP_TRANSPOSE
```
public static final ProjectSetOpTransposeRule PROJECT_SET_OP_TRANSPOSE
```
    Rule that pushes a LogicalProject past a SetOp.
    The children of the SetOp will project only the RexInputRefs referenced in the original LogicalProject.
  - PROJECT_MULTI_JOIN_MERGE
```
public static final ProjectMultiJoinMergeRule PROJECT_MULTI_JOIN_MERGE
```
    Rule that pushes a Project into a MultiJoin, creating a richer MultiJoin.
    
    See Also:
    
    FILTER_MULTI_JOIN_MERGE
  - PROJECT_REMOVE
```
public static final ProjectRemoveRule PROJECT_REMOVE
```
    Rule that, given a Project node that merely returns its input, converts the node into its input.
  - PROJECT_TABLE_SCAN
```
public static final ProjectTableScanRule PROJECT_TABLE_SCAN
```
    Rule that converts a Project on a TableScan of a ProjectableFilterableTable to a Bindables.BindableTableScan.
    
    See Also:
    
    PROJECT_INTERPRETER_TABLE_SCAN
  - PROJECT_INTERPRETER_TABLE_SCAN
```
public static final ProjectTableScanRule PROJECT_INTERPRETER_TABLE_SCAN
```
    As PROJECT_TABLE_SCAN, but with an intervening EnumerableInterpreter.
  - PROJECT_TO_CALC
```
public static final ProjectToCalcRule PROJECT_TO_CALC
```
    Rule that converts a LogicalProject to a LogicalCalc.
    
    See Also:
    
    FILTER_TO_CALC
  - PROJECT_WINDOW_TRANSPOSE
```
public static final ProjectWindowTransposeRule PROJECT_WINDOW_TRANSPOSE
```
    Rule that pushes a LogicalProject past a LogicalWindow.
  - JOIN_CONDITION_PUSH
```
public static final FilterJoinRule.JoinConditionPushRule JOIN_CONDITION_PUSH
```
    Rule that pushes predicates in a Join into the inputs to the join.
  - JOIN_ADD_REDUNDANT_SEMI_JOIN
```
public static final JoinAddRedundantSemiJoinRule JOIN_ADD_REDUNDANT_SEMI_JOIN
```
    Rule to add a semi-join into a Join.
  - JOIN_ASSOCIATE
```
public static final JoinAssociateRule JOIN_ASSOCIATE
```
    Rule that changes a join based on the associativity rule, ((a JOIN b) JOIN c) → (a JOIN (b JOIN c)).
  - JOIN_COMMUTE
```
public static final JoinCommuteRule JOIN_COMMUTE
```
    Rule that permutes the inputs to an inner Join.
  - JOIN_COMMUTE_OUTER
```
public static final JoinCommuteRule JOIN_COMMUTE_OUTER
```
    As JOIN_COMMUTE but swaps outer joins as well as inner joins.
  - JOIN_EXTRACT_FILTER
```
public static final JoinExtractFilterRule JOIN_EXTRACT_FILTER
```
    Rule to convert an inner join to a filter on top of a cartesian inner join.
  - JOIN_PROJECT_BOTH_TRANSPOSE
```
public static final JoinProjectTransposeRule JOIN_PROJECT_BOTH_TRANSPOSE
```
    Rule that matches a LogicalJoin whose inputs are LogicalProjects, and pulls the project expressions up.
  - JOIN_PROJECT_LEFT_TRANSPOSE
```
public static final JoinProjectTransposeRule JOIN_PROJECT_LEFT_TRANSPOSE
```
    As JOIN_PROJECT_BOTH_TRANSPOSE but only the left input is a LogicalProject.
  - JOIN_PROJECT_RIGHT_TRANSPOSE
```
public static final JoinProjectTransposeRule JOIN_PROJECT_RIGHT_TRANSPOSE
```
    As JOIN_PROJECT_BOTH_TRANSPOSE but only the right input is a LogicalProject.
  - JOIN_PROJECT_BOTH_TRANSPOSE_INCLUDE_OUTER
```
public static final JoinProjectTransposeRule JOIN_PROJECT_BOTH_TRANSPOSE_INCLUDE_OUTER
```
    As JOIN_PROJECT_BOTH_TRANSPOSE but match outer as well as inner join.
  - JOIN_PROJECT_LEFT_TRANSPOSE_INCLUDE_OUTER
```
public static final JoinProjectTransposeRule JOIN_PROJECT_LEFT_TRANSPOSE_INCLUDE_OUTER
```
    As JOIN_PROJECT_LEFT_TRANSPOSE but match outer as well as inner join.
  - JOIN_PROJECT_RIGHT_TRANSPOSE_INCLUDE_OUTER
```
public static final JoinProjectTransposeRule JOIN_PROJECT_RIGHT_TRANSPOSE_INCLUDE_OUTER
```
    As JOIN_PROJECT_RIGHT_TRANSPOSE but match outer as well as inner join.
  - JOIN_PUSH_EXPRESSIONS
```
public static final JoinPushExpressionsRule JOIN_PUSH_EXPRESSIONS
```
    Rule that matches a Join and pushes down expressions on either side of "equal" conditions.
  - JOIN_PUSH_TRANSITIVE_PREDICATES
```
public static final JoinPushTransitivePredicatesRule JOIN_PUSH_TRANSITIVE_PREDICATES
```
    Rule that infers predicates from on a Join and creates Filters if those predicates can be pushed to its inputs.
  - JOIN_DERIVE_IS_NOT_NULL_FILTER_RULE
```
public static final JoinDeriveIsNotNullFilterRule JOIN_DERIVE_IS_NOT_NULL_FILTER_RULE
```
    Rule that derives IS NOT NULL predicates from a inner Join and creates Filters with those predicates as new inputs of the Join.
  - JOIN_REDUCE_EXPRESSIONS
```
public static final ReduceExpressionsRule.JoinReduceExpressionsRule JOIN_REDUCE_EXPRESSIONS
```
    Rule that reduces constants inside a Join.
    
    See Also:
    
    FILTER_REDUCE_EXPRESSIONS, PROJECT_REDUCE_EXPRESSIONS
  - JOIN_ON_UNIQUE_TO_SEMI_JOIN
```
public static final SemiJoinRule.JoinOnUniqueToSemiJoinRule JOIN_ON_UNIQUE_TO_SEMI_JOIN
```
    Rule that creates a semi-join from a Join, and it's right keys are unique in its right input.
  - JOIN_TO_CORRELATE
```
public static final JoinToCorrelateRule JOIN_TO_CORRELATE
```
    Rule that converts a LogicalJoin into a LogicalCorrelate.
  - JOIN_TO_MULTI_JOIN
```
public static final JoinToMultiJoinRule JOIN_TO_MULTI_JOIN
```
    Rule that flattens a tree of LogicalJoins into a single MultiJoin with N inputs.
  - JOIN_TO_SEMI_JOIN
```
public static final SemiJoinRule.JoinToSemiJoinRule JOIN_TO_SEMI_JOIN
```
    Rule that creates a semi-join from a Join with an empty Aggregate as its right input.
    
    See Also:
    
    PROJECT_TO_SEMI_JOIN
  - JOIN_LEFT_UNION_TRANSPOSE
```
public static final JoinUnionTransposeRule JOIN_LEFT_UNION_TRANSPOSE
```
    Rule that pushes a Join past a non-distinct Union as its left input.
  - JOIN_RIGHT_UNION_TRANSPOSE
```
public static final JoinUnionTransposeRule JOIN_RIGHT_UNION_TRANSPOSE
```
    Rule that pushes a Join past a non-distinct Union as its right input.
  - MULTI_JOIN_OPTIMIZE
```
public static final LoptOptimizeJoinRule MULTI_JOIN_OPTIMIZE
```
    Rule that re-orders a Join using a heuristic planner.
    It is triggered by the pattern LogicalProject (MultiJoin).
    
    See Also:
    
    JOIN_TO_MULTI_JOIN, MULTI_JOIN_OPTIMIZE_BUSHY
  - MULTI_JOIN_OPTIMIZE_BUSHY
```
public static final MultiJoinOptimizeBushyRule MULTI_JOIN_OPTIMIZE_BUSHY
```
    Rule that finds an approximately optimal ordering for join operators using a heuristic algorithm and can handle bushy joins.
    It is triggered by the pattern LogicalProject (MultiJoin).
    
    See Also:
    
    MULTI_JOIN_OPTIMIZE
  - MULTI_JOIN_BOTH_PROJECT
```
public static final MultiJoinProjectTransposeRule MULTI_JOIN_BOTH_PROJECT
```
    Rule that matches a LogicalJoin whose inputs are both a MultiJoin with intervening LogicalProjects, and pulls the Projects up above the Join.
  - MULTI_JOIN_LEFT_PROJECT
```
public static final MultiJoinProjectTransposeRule MULTI_JOIN_LEFT_PROJECT
```
    As MULTI_JOIN_BOTH_PROJECT but only the left input has an intervening Project.
  - MULTI_JOIN_RIGHT_PROJECT
```
public static final MultiJoinProjectTransposeRule MULTI_JOIN_RIGHT_PROJECT
```
    As MULTI_JOIN_BOTH_PROJECT but only the right input has an intervening Project.
  - SEMI_JOIN_FILTER_TRANSPOSE
```
public static final SemiJoinFilterTransposeRule SEMI_JOIN_FILTER_TRANSPOSE
```
    Rule that pushes a semi-join down in a tree past a Filter.
    
    See Also:
    
    SEMI_JOIN_PROJECT_TRANSPOSE, SEMI_JOIN_JOIN_TRANSPOSE
  - SEMI_JOIN_PROJECT_TRANSPOSE
```
public static final SemiJoinProjectTransposeRule SEMI_JOIN_PROJECT_TRANSPOSE
```
    Rule that pushes a semi-join down in a tree past a Project.
    
    See Also:
    
    SEMI_JOIN_FILTER_TRANSPOSE, SEMI_JOIN_JOIN_TRANSPOSE
  - SEMI_JOIN_JOIN_TRANSPOSE
```
public static final SemiJoinJoinTransposeRule SEMI_JOIN_JOIN_TRANSPOSE
```
    Rule that pushes a semi-join down in a tree past a Join.
    
    See Also:
    
    SEMI_JOIN_FILTER_TRANSPOSE, SEMI_JOIN_PROJECT_TRANSPOSE
  - SEMI_JOIN_REMOVE
```
public static final SemiJoinRemoveRule SEMI_JOIN_REMOVE
```
    Rule that removes a semi-join from a join tree.
  - SORT_UNION_TRANSPOSE
```
public static final SortUnionTransposeRule SORT_UNION_TRANSPOSE
```
    Rule that pushes a Sort past a Union.
    This rule instance is for a Union implementation that does not preserve the ordering of its inputs. Thus, it makes no sense to match this rule if the Sort does not have a limit, i.e., Sort.fetch is null.
    
    See Also:
    
    SORT_UNION_TRANSPOSE_MATCH_NULL_FETCH
  - SORT_UNION_TRANSPOSE_MATCH_NULL_FETCH
```
public static final SortUnionTransposeRule SORT_UNION_TRANSPOSE_MATCH_NULL_FETCH
```
    As SORT_UNION_TRANSPOSE, but for a Union implementation that preserves the ordering of its inputs. It is still worth applying this rule even if the Sort does not have a limit, for the merge of already sorted inputs that the Union can do is usually cheap.
  - SORT_JOIN_COPY
```
public static final SortJoinCopyRule SORT_JOIN_COPY
```
    Rule that copies a Sort past a Join without its limit and offset. The original Sort is preserved but can potentially be removed by SORT_REMOVE if redundant.
  - SORT_REMOVE
```
public static final SortRemoveRule SORT_REMOVE
```
    Rule that removes a Sort if its input is already sorted.
  - SORT_REMOVE_CONSTANT_KEYS
```
public static final SortRemoveConstantKeysRule SORT_REMOVE_CONSTANT_KEYS
```
    Rule that removes keys from a Sort if those keys are known to be constant, or removes the entire Sort if all keys are constant.
  - SORT_JOIN_TRANSPOSE
```
public static final SortJoinTransposeRule SORT_JOIN_TRANSPOSE
```
    Rule that pushes a Sort past a Join.
  - SORT_PROJECT_TRANSPOSE
```
public static final SortProjectTransposeRule SORT_PROJECT_TRANSPOSE
```
    Rule that pushes a Sort past a Project.
  - UNION_MERGE
```
public static final UnionMergeRule UNION_MERGE
```
    Rule that flattens a Union on a Union into a single Union.
  - UNION_REMOVE
```
public static final UnionEliminatorRule UNION_REMOVE
```
    Rule that removes a Union if it has only one input.
    
    See Also:
    
    PruneEmptyRules.UNION_INSTANCE
  - UNION_PULL_UP_CONSTANTS
```
public static final UnionPullUpConstantsRule UNION_PULL_UP_CONSTANTS
```
    Rule that pulls up constants through a Union operator.
  - UNION_TO_DISTINCT
```
public static final UnionToDistinctRule UNION_TO_DISTINCT
```
    Rule that translates a distinct Union (all = false) into an Aggregate on top of a non-distinct Union (all = true).
  - AGGREGATE_VALUES
```
public static final AggregateValuesRule AGGREGATE_VALUES
```
    Rule that applies an Aggregate to a Values (currently just an empty Values).
  - FILTER_VALUES_MERGE
```
public static final ValuesReduceRule FILTER_VALUES_MERGE
```
    Rule that merges a Filter onto an underlying LogicalValues, resulting in a Values with potentially fewer rows.
  - PROJECT_VALUES_MERGE
```
public static final ValuesReduceRule PROJECT_VALUES_MERGE
```
    Rule that merges a Project onto an underlying LogicalValues, resulting in a Values with different columns.
  - PROJECT_FILTER_VALUES_MERGE
```
public static final ValuesReduceRule PROJECT_FILTER_VALUES_MERGE
```
    Rule that merges a Project on top of a Filter onto an underlying LogicalValues, resulting in a Values with different columns and potentially fewer rows.
  - WINDOW_REDUCE_EXPRESSIONS
```
public static final ReduceExpressionsRule.WindowReduceExpressionsRule WINDOW_REDUCE_EXPRESSIONS
```
    Rule that reduces constants inside a LogicalWindow.
    
    See Also:
    
    FILTER_REDUCE_EXPRESSIONS

Class CoreRules

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

AGGREGATE_PROJECT_MERGE

AGGREGATE_PROJECT_PULL_UP_CONSTANTS

AGGREGATE_ANY_PULL_UP_CONSTANTS

AGGREGATE_STAR_TABLE

AGGREGATE_PROJECT_STAR_TABLE

AGGREGATE_REDUCE_FUNCTIONS

AGGREGATE_MERGE

AGGREGATE_REMOVE

AGGREGATE_EXPAND_DISTINCT_AGGREGATES

AGGREGATE_EXPAND_DISTINCT_AGGREGATES_TO_JOIN

AGGREGATE_EXPAND_WITHIN_DISTINCT

AGGREGATE_FILTER_TRANSPOSE

AGGREGATE_JOIN_JOIN_REMOVE

AGGREGATE_JOIN_REMOVE

AGGREGATE_JOIN_TRANSPOSE

AGGREGATE_JOIN_TRANSPOSE_EXTENDED

AGGREGATE_UNION_TRANSPOSE

AGGREGATE_UNION_AGGREGATE

AGGREGATE_UNION_AGGREGATE_FIRST

AGGREGATE_UNION_AGGREGATE_SECOND

AGGREGATE_CASE_TO_FILTER

CALC_MERGE

CALC_REMOVE

CALC_REDUCE_DECIMALS

CALC_REDUCE_EXPRESSIONS

CALC_SPLIT

CALC_TO_WINDOW

COERCE_INPUTS

EXCHANGE_REMOVE_CONSTANT_KEYS

SORT_EXCHANGE_REMOVE_CONSTANT_KEYS

FILTER_INTO_JOIN

FILTER_INTO_JOIN_DUMB

FILTER_MERGE

FILTER_CALC_MERGE

FILTER_TO_CALC

FILTER_AGGREGATE_TRANSPOSE

FILTER_PROJECT_TRANSPOSE

FILTER_TABLE_FUNCTION_TRANSPOSE

FILTER_SCAN

FILTER_INTERPRETER_SCAN

FILTER_CORRELATE

FILTER_MULTI_JOIN_MERGE

FILTER_EXPAND_IS_NOT_DISTINCT_FROM

FILTER_SET_OP_TRANSPOSE

FILTER_REDUCE_EXPRESSIONS

INTERSECT_MERGE

INTERSECT_TO_DISTINCT

MATCH

MINUS_MERGE

PROJECT_AGGREGATE_MERGE

PROJECT_CALC_MERGE

PROJECT_CORRELATE_TRANSPOSE

PROJECT_FILTER_TRANSPOSE

PROJECT_FILTER_TRANSPOSE_WHOLE_EXPRESSIONS

PROJECT_FILTER_TRANSPOSE_WHOLE_PROJECT_EXPRESSIONS

PROJECT_REDUCE_EXPRESSIONS

PROJECT_SUB_QUERY_TO_CORRELATE

FILTER_SUB_QUERY_TO_CORRELATE

JOIN_SUB_QUERY_TO_CORRELATE

PROJECT_TO_LOGICAL_PROJECT_AND_WINDOW

PROJECT_TO_SEMI_JOIN

PROJECT_JOIN_JOIN_REMOVE

PROJECT_JOIN_REMOVE

PROJECT_JOIN_TRANSPOSE

PROJECT_MERGE

PROJECT_SET_OP_TRANSPOSE

PROJECT_MULTI_JOIN_MERGE

PROJECT_REMOVE

PROJECT_TABLE_SCAN

PROJECT_INTERPRETER_TABLE_SCAN

PROJECT_TO_CALC

PROJECT_WINDOW_TRANSPOSE

JOIN_CONDITION_PUSH

JOIN_ADD_REDUNDANT_SEMI_JOIN

JOIN_ASSOCIATE