public class AggregateReduceFunctionsRule extends RelOptRule
Aggregate
s to simpler forms.
Rewrites:
Since many of these rewrites introduce multiple occurrences of simpler
forms like COUNT(x)
, the rule gathers common sub-expressions as it
goes.
Modifier and Type | Field and Description |
---|---|
private java.util.EnumSet<SqlKind> |
functionsToReduce |
static AggregateReduceFunctionsRule |
INSTANCE
The singleton.
|
description, operands, relBuilderFactory
Constructor and Description |
---|
AggregateReduceFunctionsRule(java.lang.Class<? extends Aggregate> aggregateClass,
RelBuilderFactory relBuilderFactory,
java.util.EnumSet<SqlKind> functionsToReduce)
Creates an AggregateReduceFunctionsRule with client
provided information on which specific functions will
be reduced by this rule
|
AggregateReduceFunctionsRule(RelOptRuleOperand operand,
RelBuilderFactory relBuilderFactory)
Creates an AggregateReduceFunctionsRule to reduce all functions
handled by this rule
|
Modifier and Type | Method and Description |
---|---|
private void |
addDefaultSetOfFunctionsToReduce() |
private boolean |
containsAvgStddevVarCall(java.util.List<AggregateCall> aggCallList)
Returns whether any of the aggregates are calls to AVG, STDDEV_*, VAR_*.
|
private AggregateCall |
createAggregateCallWithBinding(RelDataTypeFactory typeFactory,
SqlAggFunction aggFunction,
RelDataType operandType,
Aggregate oldAggRel,
AggregateCall oldCall,
int argOrdinal,
int filter) |
private RelDataType |
getFieldType(RelNode relNode,
int i) |
private RexNode |
getRegrCountRexNode(Aggregate oldAggRel,
AggregateCall oldCall,
java.util.List<AggregateCall> newCalls,
java.util.Map<AggregateCall,RexNode> aggCallMapping,
ImmutableIntList argOrdinals,
com.google.common.collect.ImmutableList<RelDataType> operandTypes,
int filterArg) |
private RexNode |
getSumAggregatedRexNode(Aggregate oldAggRel,
AggregateCall oldCall,
java.util.List<AggregateCall> newCalls,
java.util.Map<AggregateCall,RexNode> aggCallMapping,
RexBuilder rexBuilder,
int argOrdinal,
int filterArg) |
private RexNode |
getSumAggregatedRexNodeWithBinding(Aggregate oldAggRel,
AggregateCall oldCall,
java.util.List<AggregateCall> newCalls,
java.util.Map<AggregateCall,RexNode> aggCallMapping,
RelDataType operandType,
int argOrdinal,
int filter) |
private boolean |
isReducible(SqlKind kind)
Returns whether the aggregate call is a reducible function
|
private static <T> int |
lookupOrAdd(java.util.List<T> list,
T element)
Finds the ordinal of an element in a list, or adds it.
|
boolean |
matches(RelOptRuleCall call)
Returns whether this rule could possibly match the given operands.
|
protected void |
newAggregateRel(RelBuilder relBuilder,
Aggregate oldAggregate,
java.util.List<AggregateCall> newCalls)
Do a shallow clone of oldAggRel and update aggCalls.
|
protected void |
newCalcRel(RelBuilder relBuilder,
RelDataType rowType,
java.util.List<RexNode> exprs)
Add a calc with the expressions to compute the original agg calls from the
decomposed ones.
|
void |
onMatch(RelOptRuleCall ruleCall)
Receives notification about a rule match.
|
private RexNode |
reduceAgg(Aggregate oldAggRel,
AggregateCall oldCall,
java.util.List<AggregateCall> newCalls,
java.util.Map<AggregateCall,RexNode> aggCallMapping,
java.util.List<RexNode> inputExprs) |
private void |
reduceAggs(RelOptRuleCall ruleCall,
Aggregate oldAggRel)
Reduces calls to functions AVG, SUM, STDDEV_POP, STDDEV_SAMP, VAR_POP,
VAR_SAMP, COVAR_POP, COVAR_SAMP, REGR_SXX, REGR_SYY if the function is
present in
functionsToReduce |
private RexNode |
reduceAvg(Aggregate oldAggRel,
AggregateCall oldCall,
java.util.List<AggregateCall> newCalls,
java.util.Map<AggregateCall,RexNode> aggCallMapping,
java.util.List<RexNode> inputExprs) |
private RexNode |
reduceCovariance(Aggregate oldAggRel,
AggregateCall oldCall,
boolean biased,
java.util.List<AggregateCall> newCalls,
java.util.Map<AggregateCall,RexNode> aggCallMapping,
java.util.List<RexNode> inputExprs) |
private RexNode |
reduceRegrSzz(Aggregate oldAggRel,
AggregateCall oldCall,
java.util.List<AggregateCall> newCalls,
java.util.Map<AggregateCall,RexNode> aggCallMapping,
java.util.List<RexNode> inputExprs,
int xIndex,
int yIndex,
int nullFilterIndex) |
private RexNode |
reduceStddev(Aggregate oldAggRel,
AggregateCall oldCall,
boolean biased,
boolean sqrt,
java.util.List<AggregateCall> newCalls,
java.util.Map<AggregateCall,RexNode> aggCallMapping,
java.util.List<RexNode> inputExprs) |
private RexNode |
reduceSum(Aggregate oldAggRel,
AggregateCall oldCall,
java.util.List<AggregateCall> newCalls,
java.util.Map<AggregateCall,RexNode> aggCallMapping) |
any, convert, convert, convertList, convertOperand, convertOperand, equals, equals, getOperand, getOperands, getOutConvention, getOutTrait, hashCode, none, operand, operand, operand, operand, operand, operandJ, operandJ, some, toString, unordered
public static final AggregateReduceFunctionsRule INSTANCE
private final java.util.EnumSet<SqlKind> functionsToReduce
public AggregateReduceFunctionsRule(RelOptRuleOperand operand, RelBuilderFactory relBuilderFactory)
operand
- operand to determine if rule can be appliedrelBuilderFactory
- builder for relational expressionspublic AggregateReduceFunctionsRule(java.lang.Class<? extends Aggregate> aggregateClass, RelBuilderFactory relBuilderFactory, java.util.EnumSet<SqlKind> functionsToReduce)
aggregateClass
- aggregate classrelBuilderFactory
- builder for relational expressionsfunctionsToReduce
- client provided information
on which specific functions
will be reduced by this ruleprivate void addDefaultSetOfFunctionsToReduce()
public boolean matches(RelOptRuleCall call)
RelOptRule
This method is an opportunity to apply side-conditions to a rule. The
RelOptPlanner
calls this method after matching all operands of
the rule, and before calling RelOptRule.onMatch(RelOptRuleCall)
.
In implementations of RelOptPlanner
which may queue up a
matched RelOptRuleCall
for a long time before calling
RelOptRule.onMatch(RelOptRuleCall)
, this method is beneficial because it
allows the planner to discard rules earlier in the process.
The default implementation of this method returns true
.
It is acceptable for any implementation of this method to give a false
positives, that is, to say that the rule matches the operands but have
RelOptRule.onMatch(RelOptRuleCall)
subsequently not generate any
successors.
The following script is useful to identify rules which commonly produce no successors. You should override this method for these rules:
awk ' /Apply rule/ {rule=$4; ruleCount[rule]++;} /generated 0 successors/ {ruleMiss[rule]++;} END { printf "%-30s %s %s\n", "Rule", "Fire", "Miss"; for (i in ruleCount) { printf "%-30s %5d %5d\n", i, ruleCount[i], ruleMiss[i]; } } ' FarragoTrace.log
matches
in class RelOptRule
call
- Rule call which has been determined to match all operands of
this rulepublic void onMatch(RelOptRuleCall ruleCall)
RelOptRule
call.rels
holds the set of relational
expressions which match the operands to the rule;
call.rels[0]
is the root expression.
Typically a rule would check that the nodes are valid matches, creates
a new expression, then calls back RelOptRuleCall.transformTo(org.apache.calcite.rel.RelNode, java.util.Map<org.apache.calcite.rel.RelNode, org.apache.calcite.rel.RelNode>)
to
register the expression.
onMatch
in class RelOptRule
ruleCall
- Rule callRelOptRule.matches(RelOptRuleCall)
private boolean containsAvgStddevVarCall(java.util.List<AggregateCall> aggCallList)
aggCallList
- List of aggregate callsprivate boolean isReducible(SqlKind kind)
private void reduceAggs(RelOptRuleCall ruleCall, Aggregate oldAggRel)
functionsToReduce
It handles newly generated common subexpressions since this was done at the sql2rel stage.
private RexNode reduceAgg(Aggregate oldAggRel, AggregateCall oldCall, java.util.List<AggregateCall> newCalls, java.util.Map<AggregateCall,RexNode> aggCallMapping, java.util.List<RexNode> inputExprs)
private AggregateCall createAggregateCallWithBinding(RelDataTypeFactory typeFactory, SqlAggFunction aggFunction, RelDataType operandType, Aggregate oldAggRel, AggregateCall oldCall, int argOrdinal, int filter)
private RexNode reduceAvg(Aggregate oldAggRel, AggregateCall oldCall, java.util.List<AggregateCall> newCalls, java.util.Map<AggregateCall,RexNode> aggCallMapping, java.util.List<RexNode> inputExprs)
private RexNode reduceSum(Aggregate oldAggRel, AggregateCall oldCall, java.util.List<AggregateCall> newCalls, java.util.Map<AggregateCall,RexNode> aggCallMapping)
private RexNode reduceStddev(Aggregate oldAggRel, AggregateCall oldCall, boolean biased, boolean sqrt, java.util.List<AggregateCall> newCalls, java.util.Map<AggregateCall,RexNode> aggCallMapping, java.util.List<RexNode> inputExprs)
private RexNode getSumAggregatedRexNode(Aggregate oldAggRel, AggregateCall oldCall, java.util.List<AggregateCall> newCalls, java.util.Map<AggregateCall,RexNode> aggCallMapping, RexBuilder rexBuilder, int argOrdinal, int filterArg)
private RexNode getSumAggregatedRexNodeWithBinding(Aggregate oldAggRel, AggregateCall oldCall, java.util.List<AggregateCall> newCalls, java.util.Map<AggregateCall,RexNode> aggCallMapping, RelDataType operandType, int argOrdinal, int filter)
private RexNode getRegrCountRexNode(Aggregate oldAggRel, AggregateCall oldCall, java.util.List<AggregateCall> newCalls, java.util.Map<AggregateCall,RexNode> aggCallMapping, ImmutableIntList argOrdinals, com.google.common.collect.ImmutableList<RelDataType> operandTypes, int filterArg)
private RexNode reduceRegrSzz(Aggregate oldAggRel, AggregateCall oldCall, java.util.List<AggregateCall> newCalls, java.util.Map<AggregateCall,RexNode> aggCallMapping, java.util.List<RexNode> inputExprs, int xIndex, int yIndex, int nullFilterIndex)
private RexNode reduceCovariance(Aggregate oldAggRel, AggregateCall oldCall, boolean biased, java.util.List<AggregateCall> newCalls, java.util.Map<AggregateCall,RexNode> aggCallMapping, java.util.List<RexNode> inputExprs)
private static <T> int lookupOrAdd(java.util.List<T> list, T element)
T
- Element typelist
- Listelement
- Element to lookup or addprotected void newAggregateRel(RelBuilder relBuilder, Aggregate oldAggregate, java.util.List<AggregateCall> newCalls)
relBuilder
- Builder of relational expressions; at the top of its
stack is its inputoldAggregate
- LogicalAggregate to clone.newCalls
- New list of AggregateCallsprotected void newCalcRel(RelBuilder relBuilder, RelDataType rowType, java.util.List<RexNode> exprs)
relBuilder
- Builder of relational expressions; at the top of its
stack is its inputrowType
- The output row type of the original aggregate.exprs
- The expressions to compute the original agg calls.private RelDataType getFieldType(RelNode relNode, int i)
Copyright © 2012–2019 The Apache Software Foundation. All rights reserved.