Uses of Package org.apache.calcite.rel.rules (Calcite Core 1.2.0-incubating API)

Packages that use org.apache.calcite.rel.rules
Package	Description
org.apache.calcite.plan	Defines interfaces for constructing rule-based optimizers of relational expressions.
org.apache.calcite.rel.rules	Provides a core set of planner rules.

Classes in org.apache.calcite.rel.rules used by org.apache.calcite.plan
Class and Description
MultiJoin A MultiJoin represents a join of N inputs, whereas regular Joins represent strictly binary joins.

Classes in org.apache.calcite.rel.rules used by org.apache.calcite.rel.rules
Class and 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`.
CalcRemoveRule Planner rule that removes a trivial `LogicalCalc`.
CalcSplitRule Planner rule that converts a `Calc` to a `Project` and `Filter`.
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.Predicate Predicate that returns whether a filter is valid in the ON clause of a join for this particular kind of join.
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.
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.
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.
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.
PushProjector.ExprCondition A functor that replies true or false for a given expression.
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`.

Uses of Packageorg.apache.calcite.rel.rules

Uses of Package
org.apache.calcite.rel.rules