org.apache.calcite.rel.rules (Calcite Core 1.16.0 API)

Interface Summary
Interface	Description
FilterJoinRule.Predicate	Predicate that returns whether a filter is valid in the ON clause of a join for this particular kind of join.
PushProjector.ExprCondition	A functor that replies true or false for a given expression.

Class Summary
Class	Description
AbstractJoinExtractFilterRule	Rule to convert an `inner join` to a `filter` on top of a `cartesian inner join`.
AbstractMaterializedViewRule	Planner rule that converts a `Project` followed by `Aggregate` or an `Aggregate` to a scan (and possibly other operations) over a materialized view.
AbstractMaterializedViewRule.Edge	Edge for graph
AbstractMaterializedViewRule.EquivalenceClasses	Class representing an equivalence class, i.e., a set of equivalent columns
AbstractMaterializedViewRule.MaterializedViewAggregateRule	Materialized view rewriting for aggregate
AbstractMaterializedViewRule.MaterializedViewJoinRule	Materialized view rewriting for join
AbstractMaterializedViewRule.MaterializedViewOnlyAggregateRule	Rule that matches Aggregate.
AbstractMaterializedViewRule.MaterializedViewOnlyFilterRule	Rule that matches Filter.
AbstractMaterializedViewRule.MaterializedViewOnlyJoinRule	Rule that matches Join.
AbstractMaterializedViewRule.MaterializedViewProjectAggregateRule	Rule that matches Project on Aggregate.
AbstractMaterializedViewRule.MaterializedViewProjectFilterRule	Rule that matches Project on Filter.
AbstractMaterializedViewRule.MaterializedViewProjectJoinRule	Rule that matches Project on Join.
AbstractMaterializedViewRule.NodeLineage	Class to encapsulate expression lineage details
AbstractMaterializedViewRule.ViewPartialRewriting	View partitioning result
AggregateExpandDistinctAggregatesRule	Planner rule that expands distinct aggregates (such as `COUNT(DISTINCT x)`) from a `Aggregate`.
AggregateExtractProjectRule	Rule to extract a `Project` from an `Aggregate` and push it down towards the input.
AggregateFilterTransposeRule	Planner rule that matches an `Aggregate` on a `Filter` and transposes them, pushing the aggregate below the filter.
AggregateJoinTransposeRule	Planner rule that pushes an `Aggregate` past a `Join`.
AggregateJoinTransposeRule.Side	Work space for an input to a join.
AggregateProjectMergeRule	Planner rule that recognizes a `Aggregate` on top of a `Project` and if possible aggregate through the project or removes the project.
AggregateProjectPullUpConstantsRule	Planner rule that removes constant keys from an `Aggregate`.
AggregateReduceFunctionsRule	Planner rule that reduces aggregate functions in `Aggregate`s to simpler forms.
AggregateRemoveRule	Planner rule that removes a `Aggregate` if it computes no aggregate functions (that is, it is implementing `SELECT DISTINCT`) and the underlying relational expression is already distinct.
AggregateStarTableRule	Planner rule that matches an `Aggregate` on top of a `StarTable.StarTableScan`.
AggregateUnionAggregateRule	Planner rule that matches `Aggregate`s beneath a `Union` and pulls them up, so that a single `Aggregate` removes duplicates.
AggregateUnionTransposeRule	Planner rule that pushes an `Aggregate` past a non-distinct `Union`.
AggregateValuesRule	Rule that applies `Aggregate` to a `Values` (currently just an empty `Value`s).
CalcMergeRule	Planner rule that merges a `LogicalCalc` onto a `LogicalCalc`.
CalcRelSplitter	CalcRelSplitter operates on a `Calc` with multiple `RexCall` sub-expressions that cannot all be implemented by a single concrete `RelNode`.
CalcRelSplitter.HighestUsageFinder	Builds an array of the highest level which contains an expression which uses each expression as an input.
CalcRelSplitter.ImplementTester	Visitor which returns whether an expression can be implemented in a given type of relational expression.
CalcRelSplitter.InputToCommonExprConverter	Shuttle which converts every reference to an input field in an expression to a reference to a common sub-expression.
CalcRelSplitter.MaxInputFinder	Finds the highest level used by any of the inputs of a given expression.
CalcRelSplitter.RelType	Type of relational expression.
CalcRemoveRule	Planner rule that removes a trivial `LogicalCalc`.
CalcSplitRule	Planner rule that converts a `Calc` to a `Project` and `Filter`.
CoerceInputsRule	CoerceInputsRule pre-casts inputs to a particular type.
DateRangeRules	Collection of planner rules that convert `EXTRACT(timeUnit FROM dateTime) = constant`, `FLOOR(dateTime to timeUnit` = constant} and `CEIL(dateTime to timeUnit` = constant} to `dateTime BETWEEN lower AND upper`.
DateRangeRules.ExtractFinder	Visitor that searches for calls to `EXTRACT`, `FLOOR` or `CEIL`, building a list of distinct time units.
DateRangeRules.ExtractShuttle	Walks over an expression, replacing calls to `EXTRACT`, `FLOOR` and `CEIL` with date ranges.
DateRangeRules.FilterDateRangeRule	Rule that converts EXTRACT, FLOOR and CEIL in a `Filter` into a date range.
EquiJoin	Deprecated Use `EquiJoin in 'core' package`
FilterAggregateTransposeRule	Planner rule that pushes a `Filter` past a `Aggregate`.
FilterCalcMergeRule	Planner rule that merges a `LogicalFilter` and a `LogicalCalc`.
FilterCorrelateRule	Planner rule that pushes a `Filter` above a `Correlate` into the inputs of the Correlate.
FilterJoinRule	Planner rule that pushes filters above and within a join node into the join node and/or its children nodes.
FilterJoinRule.FilterIntoJoinRule	Rule that tries to push filter expressions into a join condition and into the inputs of the join.
FilterJoinRule.JoinConditionPushRule	Rule that pushes parts of the join condition to its inputs.
FilterMergeRule	Planner rule that combines two `LogicalFilter`s.
FilterMultiJoinMergeRule	Planner rule that merges a `LogicalFilter` into a `MultiJoin`, creating a richer `MultiJoin`.
FilterProjectTransposeRule	Planner rule that pushes a `LogicalFilter` past a `LogicalProject`.
FilterRemoveIsNotDistinctFromRule	Planner rule that replaces `IS NOT DISTINCT FROM` in a `LogicalFilter` with logically equivalent operations.
FilterSetOpTransposeRule	Planner rule that pushes a `Filter` past a `SetOp`.
FilterTableFunctionTransposeRule	Planner rule that pushes a `LogicalFilter` past a `LogicalTableFunctionScan`.
FilterTableScanRule	Planner rule that converts a `Filter` on a `TableScan` of a `FilterableTable` or a `ProjectableFilterableTable` to a `Bindables.BindableTableScan`.
FilterToCalcRule	Planner rule that converts a `LogicalFilter` to a `LogicalCalc`.
IntersectToDistinctRule	Planner rule that translates a distinct `Intersect` (`all` = `false`) into a group of operators composed of `Union`, `Aggregate`, etc.
JoinAddRedundantSemiJoinRule	Rule to add a semi-join into a join.
JoinAssociateRule	Planner rule that changes a join based on the associativity rule.
JoinCommuteRule	Planner rule that permutes the inputs to a `Join`.
JoinCommuteRule.VariableReplacer	Walks over an expression, replacing references to fields of the left and right inputs.
JoinExtractFilterRule	Rule to convert an `inner join` to a `filter` on top of a `cartesian inner join`.
JoinProjectTransposeRule	Planner rule that matches a `Join` one of whose inputs is a `LogicalProject`, and pulls the project up.
JoinPushExpressionsRule	Planner rule that pushes down expressions in "equal" join condition.
JoinPushThroughJoinRule	Rule that pushes the right input of a join into through the left input of the join, provided that the left input is also a join.
JoinPushTransitivePredicatesRule	Planner rule that infers predicates from on a `Join` and creates `Filter`s if those predicates can be pushed to its inputs.
JoinToCorrelateRule	Rule that converts a `LogicalJoin` into a `LogicalCorrelate`, which can then be implemented using nested loops.
JoinToMultiJoinRule	Planner rule to flatten a tree of `LogicalJoin`s into a single `MultiJoin` with N inputs.
JoinUnionTransposeRule	Planner rule that pushes a `Join` past a non-distinct `Union`.
LoptJoinTree	Utility class used to store a `Join` tree and the factors that make up the tree.
LoptJoinTree.BinaryTree	Simple binary tree class that stores an id in the leaf nodes and keeps track of the parent LoptJoinTree object associated with the binary tree.
LoptJoinTree.Leaf	Binary tree node that has no children.
LoptJoinTree.Node	Binary tree node that has two children.
LoptMultiJoin	Utility class that keeps track of the join factors that make up a `MultiJoin`.
LoptMultiJoin.Edge	Information about a join-condition.
LoptOptimizeJoinRule	Planner rule that implements the heuristic planner for determining optimal join orderings.
LoptSemiJoinOptimizer	Implements the logic for determining the optimal semi-joins to be used in processing joins in a query.
LoptSemiJoinOptimizer.FemLocalIndex	Dummy class to allow code to compile.
LoptSemiJoinOptimizer.LcsIndexOptimizer	Dummy class to allow code to compile.
LoptSemiJoinOptimizer.LcsTable	Dummy class to allow code to compile.
LoptSemiJoinOptimizer.LcsTableScan	Dummy class to allow code to compile.
LoptSemiJoinOptimizer.LucidDbSpecialOperators	Dummy class to allow code to compile.
MaterializedViewFilterScanRule	Planner rule that converts a `Filter` on a `TableScan` to a `Filter` on Materialized View
MultiJoin	A MultiJoin represents a join of N inputs, whereas regular Joins represent strictly binary joins.
MultiJoinOptimizeBushyRule	Planner rule that finds an approximately optimal ordering for join operators using a heuristic algorithm.
MultiJoinOptimizeBushyRule.JoinVertex	Participant in a join which is itself a join.
MultiJoinOptimizeBushyRule.LeafVertex	Relation participating in a join.
MultiJoinOptimizeBushyRule.Vertex	Participant in a join (relation or join).
MultiJoinProjectTransposeRule	MultiJoinProjectTransposeRule implements the rule for pulling `LogicalProject`s that are on top of a `MultiJoin` and beneath a `LogicalJoin` so the `LogicalProject` appears above the `LogicalJoin`.
ProjectCalcMergeRule	Planner rule which merges a `LogicalProject` and a `LogicalCalc`.
ProjectFilterTransposeRule	Planner rule that pushes a `Project` past a `Filter`.
ProjectJoinTransposeRule	Planner rule that pushes a `Project` past a `Join` by splitting the projection into a projection on top of each child of the join.
ProjectMergeRule	ProjectMergeRule merges a `Project` into another `Project`, provided the projects aren't projecting identical sets of input references.
ProjectMultiJoinMergeRule	Planner rule that pushes `Project` into a `MultiJoin`, creating a richer `MultiJoin`.
ProjectRemoveRule	Planner rule that, given a `Project` node that merely returns its input, converts the node into its child.
ProjectSetOpTransposeRule	Planner rule that pushes a `LogicalProject` past a `SetOp`.
ProjectSortTransposeRule	Planner rule that pushes a `Project` past a `Sort`.
ProjectTableScanRule	Planner rule that converts a `Project` on a `TableScan` of a `ProjectableFilterableTable` to a `Bindables.BindableTableScan`.
ProjectToCalcRule	Rule to convert a `LogicalProject` to a `LogicalCalc`
ProjectToWindowRule	Planner rule that slices a `Project` into sections which contain windowed aggregate functions and sections which do not.
ProjectToWindowRule.CalcToWindowRule	Instance of the rule that applies to a `Calc` that contains windowed aggregates and converts it into a mixture of `LogicalWindow` and `Calc`.
ProjectToWindowRule.ProjectToLogicalProjectAndWindowRule	Instance of the rule that can be applied to a `Project` and that produces, in turn, a mixture of `LogicalProject` and `LogicalWindow`.
ProjectToWindowRule.WindowedAggRelSplitter	Splitter that distinguishes between windowed aggregation expressions (calls to `RexOver`) and ordinary expressions.
ProjectWindowTransposeRule	Planner rule that pushes a `LogicalProject` past a `LogicalWindow`.
PruneEmptyRules	Collection of rules which remove sections of a query plan known never to produce any rows.
PruneEmptyRules.RemoveEmptySingleRule	Planner rule that converts a single-rel (e.g.
PushProjector	PushProjector is a utility class used to perform operations used in push projection rules.
PushProjector.ExprConditionImpl	Implementation of `PushProjector.ExprCondition`.
ReduceDecimalsRule	ReduceDecimalsRule is a rule which reduces decimal operations (such as casts or arithmetic) into operations involving more primitive types (such as longs and doubles).
ReduceExpressionsRule	Collection of planner rules that apply various simplifying transformations on RexNode trees.
ReduceExpressionsRule.CalcReduceExpressionsRule	Rule that reduces constants inside a `Calc`.
ReduceExpressionsRule.CaseShuttle	Shuttle that pushes predicates into a CASE.
ReduceExpressionsRule.FilterReduceExpressionsRule	Rule that reduces constants inside a `Filter`.
ReduceExpressionsRule.JoinReduceExpressionsRule	Rule that reduces constants inside a `Join`.
ReduceExpressionsRule.ProjectReduceExpressionsRule	Rule that reduces constants inside a `Project`.
ReduceExpressionsRule.ReducibleExprLocator	Helper class used to locate expressions that either can be reduced to literals or contain redundant casts.
ReduceExpressionsRule.RexReplacer	Replaces expressions with their reductions.
SemiJoinFilterTransposeRule	Planner rule that pushes `SemiJoin`s down in a tree past a `Filter`.
SemiJoinJoinTransposeRule	Planner rule that pushes a `SemiJoin` down in a tree past a `Join` in order to trigger other rules that will convert `SemiJoin`s.
SemiJoinProjectTransposeRule	Planner rule that pushes a `SemiJoin` down in a tree past a `Project`.
SemiJoinRemoveRule	Planner rule that removes a `SemiJoin`s from a join tree.
SemiJoinRule	Planner rule that creates a `SemiJoinRule` from a `Join` on top of a `LogicalAggregate`.
SemiJoinRule.JoinToSemiJoinRule	SemiJoinRule that matches a Join with an empty Aggregate as its right child.
SemiJoinRule.ProjectToSemiJoinRule	SemiJoinRule that matches a Project on top of a Join with an Aggregate as its right child.
SortJoinTransposeRule	Planner rule that pushes a `Sort` past a `Join`.
SortProjectTransposeRule	Planner rule that pushes a `Sort` past a `Project`.
SortRemoveRule	Planner rule that removes a `Sort` if its input is already sorted.
SortUnionTransposeRule	Planner rule that pushes a `Sort` past a `Union`.
SubQueryRemoveRule	Transform that converts IN, EXISTS and scalar sub-queries into joins.
SubQueryRemoveRule.ReplaceSubQueryShuttle	Shuttle that replaces occurrences of a given `RexSubQuery` with a replacement expression.
TableScanRule	Planner rule that converts a `LogicalTableScan` to the result of calling `RelOptTable.toRel(org.apache.calcite.plan.RelOptTable.ToRelContext)`.
UnionEliminatorRule	`UnionEliminatorRule` checks to see if its possible to optimize a Union call by eliminating the Union operator altogether in the case the call consists of only one input.
UnionMergeRule	UnionMergeRule implements the rule for combining two non-distinct `SetOp`s into a single `SetOp`.
UnionPullUpConstantsRule	Planner rule that pulls up constants through a Union operator.
UnionToDistinctRule	Planner rule that translates a distinct `Union` (`all` = `false`) into an `Aggregate` on top of a non-distinct `Union` (`all` = `true`).
ValuesReduceRule	Planner rule that folds projections and filters into an underlying `LogicalValues`.
ValuesReduceRule.MyRexShuttle	Shuttle that converts inputs to literals.

Enum Summary
Enum	Description
AbstractMaterializedViewRule.MatchModality	Complete, view partial, or query partial.
ReduceExpressionsRule.ReducibleExprLocator.Constancy	Whether an expression is constant, and if so, whether it can be reduced to a simpler constant.

Exception Summary
Exception Description

CalcRelSplitter.CannotImplement
Control exception for CalcRelSplitter.ImplementTester.

Exception Summary
Exception	Description
CalcRelSplitter.CannotImplement	Control exception for `CalcRelSplitter.ImplementTester`.

Package org.apache.calcite.rel.rules Description

Provides a core set of planner rules.

Consider this package to be the "standard library" of planner rules. Most of the common rewrites that you would want to perform on logical relational expressions, or generically on any data source, are present, and have been well tested.

Of course, the library is never complete, and contributions are welcome.

Not present are rules specific to a particular data source: look in that data source's adapter.

Also out of the scope of this package are rules that support a particular operation, such as decorrelation or recognizing materialized views. Those are defined along with the algorithm.

For

Related packages and classes

Packageorg.apache.calcite.sql is an object model for SQL expressions
Packageorg.apache.calcite.rex is an object model for relational row expressions
Packageorg.apache.calcite.plan provides an optimizer interface.