org.apache.calcite.rel.rules (Calcite Core 1.2.0-incubating 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
AggregateExpandDistinctAggregatesRule	Planner rule that expands distinct aggregates (such as `COUNT(DISTINCT x)`) from a `LogicalAggregate`.
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`.
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 expressions from the group list of an `LogicalAggregate`.
AggregateReduceFunctionsRule	Planner rule that reduces aggregate functions in `Aggregate`s to simpler forms.
AggregateRemoveRule	Planner rule that removes a `LogicalAggregate` 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`.
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.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 precasts inputs to a particular type.
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`.
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`.
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`.
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.
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 `LogicalJoin` past a non-distinct `LogicalUnion`.
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`.
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.
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.
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 `LogicalProject` 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.
PruneEmptyRules	Collection of rules which remove sections of a query plan known never to produce any rows.
PushProjector	PushProjector is a utility class used to perform operations used in push projection rules.
PushProjector.OperatorExprCondition	An expression condition that evaluates to true if the expression is a call to one of a set of operators.
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.
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`.
SortProjectTransposeRule	Planner rule that pushes a `Sort` past a `LogicalProject`.
SortRemoveRule	Planner rule that removes a `Sort` if its input is already sorted.
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 `Union`s into a single `Union`.
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`.

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.