private void reduceNotNullableFilter(
RelOptRuleCall call, FilterRel filter, RexCall rexCall, boolean reverse) {
// If the expression is a IS [NOT] NULL on a non-nullable
// column, then we can either remove the filter or replace
// it with an EmptyRel.
SqlOperator op = rexCall.getOperator();
boolean alwaysTrue;
if (op == SqlStdOperatorTable.isNullOperator
|| op == SqlStdOperatorTable.isUnknownOperator) {
alwaysTrue = false;
} else if (op == SqlStdOperatorTable.isNotNullOperator) {
alwaysTrue = true;
} else {
return;
}
if (reverse) {
alwaysTrue = !alwaysTrue;
}
RexNode operand = rexCall.getOperands()[0];
if (operand instanceof RexInputRef) {
RexInputRef inputRef = (RexInputRef) operand;
if (!inputRef.getType().isNullable()) {
if (alwaysTrue) {
call.transformTo(filter.getChild());
} else {
call.transformTo(new EmptyRel(filter.getCluster(), filter.getRowType()));
}
}
}
}
public void onMatch(RelOptRuleCall call) {
CalcRel calc = (CalcRel) call.getRels()[0];
RexProgram program = calc.getProgram();
final List<RexNode> exprList = program.getExprList();
// Form a list of expressions with sub-expressions fully
// expanded.
final List<RexNode> expandedExprList = new ArrayList<RexNode>(exprList.size());
final RexShuttle shuttle =
new RexShuttle() {
public RexNode visitLocalRef(RexLocalRef localRef) {
return expandedExprList.get(localRef.getIndex());
}
};
for (RexNode expr : exprList) {
expandedExprList.add(expr.accept(shuttle));
}
if (reduceExpressions(calc, expandedExprList)) {
final RexProgramBuilder builder =
new RexProgramBuilder(
calc.getChild().getRowType(), calc.getCluster().getRexBuilder());
List<RexLocalRef> list = new ArrayList<RexLocalRef>();
for (RexNode expr : expandedExprList) {
list.add(builder.registerInput(expr));
}
if (program.getCondition() != null) {
final int conditionIndex = program.getCondition().getIndex();
final RexNode newConditionExp = expandedExprList.get(conditionIndex);
if (newConditionExp.isAlwaysTrue()) {
// condition is always TRUE - drop it
} else if ((newConditionExp instanceof RexLiteral)
|| RexUtil.isNullLiteral(newConditionExp, true)) {
// condition is always NULL or FALSE - replace calc
// with empty
call.transformTo(new EmptyRel(calc.getCluster(), calc.getRowType()));
return;
} else {
builder.addCondition(list.get(conditionIndex));
}
}
int k = 0;
for (RexLocalRef projectExpr : program.getProjectList()) {
final int index = projectExpr.getIndex();
builder.addProject(
list.get(index).getIndex(),
program.getOutputRowType().getFieldList().get(k++).getName());
}
call.transformTo(
new CalcRel(
calc.getCluster(),
calc.getTraits(),
calc.getChild(),
calc.getRowType(),
builder.getProgram(),
calc.getCollationList()));
// New plan is absolutely better than old plan.
call.getPlanner().setImportance(calc, 0.0);
}
}
public void onMatch(RelOptRuleCall call) {
UnionRel union = call.rel(0);
if (union.all) {
return; // nothing to do
}
UnionRel unionAll = new UnionRel(union.getCluster(), union.getInputs(), true);
call.transformTo(RelOptUtil.createDistinctRel(unionAll));
}
// implement RelOptRule
public void onMatch(RelOptRuleCall call) {
CalcRel calc = call.rel(0);
RexProgram program = calc.getProgram();
if (!program.isTrivial()) {
return;
}
RelNode child = calc.getInput(0);
child = call.getPlanner().register(child, calc);
call.transformTo(convert(child, calc.getTraitSet()));
}
// implement RelOptRule
public void onMatch(RelOptRuleCall call) {
ProjectRel origProj = call.rel(0);
JoinRel joinRel = call.rel(1);
// locate all fields referenced in the projection and join condition;
// determine which inputs are referenced in the projection and
// join condition; if all fields are being referenced and there are no
// special expressions, no point in proceeding any further
PushProjector pushProject =
new PushProjector(origProj, joinRel.getCondition(), joinRel, preserveExprCondition);
if (pushProject.locateAllRefs()) {
return;
}
// create left and right projections, projecting only those
// fields referenced on each side
RelNode leftProjRel = pushProject.createProjectRefsAndExprs(joinRel.getLeft(), true, false);
RelNode rightProjRel = pushProject.createProjectRefsAndExprs(joinRel.getRight(), true, true);
// convert the join condition to reference the projected columns
RexNode newJoinFilter = null;
int[] adjustments = pushProject.getAdjustments();
if (joinRel.getCondition() != null) {
List<RelDataTypeField> projJoinFieldList = new ArrayList<RelDataTypeField>();
projJoinFieldList.addAll(joinRel.getSystemFieldList());
projJoinFieldList.addAll(leftProjRel.getRowType().getFieldList());
projJoinFieldList.addAll(rightProjRel.getRowType().getFieldList());
newJoinFilter =
pushProject.convertRefsAndExprs(joinRel.getCondition(), projJoinFieldList, adjustments);
}
// create a new joinrel with the projected children
JoinRel newJoinRel =
new JoinRel(
joinRel.getCluster(),
leftProjRel,
rightProjRel,
newJoinFilter,
joinRel.getJoinType(),
Collections.<String>emptySet(),
joinRel.isSemiJoinDone(),
joinRel.getSystemFieldList());
// put the original project on top of the join, converting it to
// reference the modified projection list
ProjectRel topProject = pushProject.createNewProject(newJoinRel, adjustments);
call.transformTo(topProject);
}
public void onMatch(RelOptRuleCall call) {
JoinRel join = (JoinRel) call.rels[0];
List<RexNode> expList = new ArrayList<RexNode>(Arrays.asList(join.getChildExps()));
if (reduceExpressions(join, expList)) {
call.transformTo(
new JoinRel(
join.getCluster(),
join.getLeft(),
join.getRight(),
expList.get(0),
join.getJoinType(),
join.getVariablesStopped()));
// New plan is absolutely better than old plan.
call.getPlanner().setImportance(join, 0.0);
}
}
public void onMatch(RelOptRuleCall call) {
ProjectRel project = (ProjectRel) call.rels[0];
List<RexNode> expList = new ArrayList<RexNode>(Arrays.asList(project.getChildExps()));
if (reduceExpressions(project, expList)) {
call.transformTo(
new ProjectRel(
project.getCluster(),
project.getChild(),
expList.toArray(new RexNode[expList.size()]),
project.getRowType(),
ProjectRel.Flags.Boxed,
Collections.<RelCollation>emptyList()));
// New plan is absolutely better than old plan.
call.getPlanner().setImportance(project, 0.0);
}
}
// implement RelOptRule
public void onMatch(RelOptRuleCall call) {
FilterRel filterRel = call.rel(0);
MultiJoinRel multiJoinRel = call.rel(1);
MultiJoinRel newMultiJoinRel =
new MultiJoinRel(
multiJoinRel.getCluster(),
multiJoinRel.getInputs(),
multiJoinRel.getJoinFilter(),
multiJoinRel.getRowType(),
multiJoinRel.isFullOuterJoin(),
multiJoinRel.getOuterJoinConditions(),
multiJoinRel.getJoinTypes(),
multiJoinRel.getProjFields(),
multiJoinRel.getJoinFieldRefCountsMap(),
filterRel.getCondition());
call.transformTo(newMultiJoinRel);
}
// implement RelOptRule
public void onMatch(RelOptRuleCall call) {
final FilterRelBase filterRel = call.rel(0);
final ProjectRelBase projRel = call.rel(1);
// convert the filter to one that references the child of the project
RexNode newCondition = RelOptUtil.pushFilterPastProject(filterRel.getCondition(), projRel);
RelNode newFilterRel =
filterFactory == null
? filterRel.copy(filterRel.getTraitSet(), projRel.getChild(), newCondition)
: filterFactory.createFilter(projRel.getChild(), newCondition);
RelNode newProjRel =
projectFactory == null
? projRel.copy(
projRel.getTraitSet(), newFilterRel, projRel.getProjects(), projRel.getRowType())
: projectFactory.createProject(
newFilterRel, projRel.getProjects(), projRel.getRowType().getFieldNames());
call.transformTo(newProjRel);
}
// implement RelOptRule
public void onMatch(RelOptRuleCall call) {
CalcRel calcRel = (CalcRel) call.rels[0];
RexProgram program = calcRel.getProgram();
// check the projection
List<Integer> projOrdinals = new ArrayList<Integer>();
RelDataType outputRowType = isProjectSimple(calcRel, projOrdinals);
if (outputRowType == null) {
return;
}
RexLocalRef condition = program.getCondition();
CompOperatorEnum compOp = CompOperatorEnum.COMP_NOOP;
Integer[] filterOrdinals = {};
List<RexLiteral> filterLiterals = new ArrayList<RexLiteral>();
// check the condition
if (condition != null) {
RexNode filterExprs = program.expandLocalRef(condition);
List<Integer> filterList = new ArrayList<Integer>();
List<CompOperatorEnum> op = new ArrayList<CompOperatorEnum>();
if (!isConditionSimple(calcRel, filterExprs, filterList, filterLiterals, op)) {
return;
}
compOp = op.get(0);
filterOrdinals = filterList.toArray(new Integer[filterList.size()]);
}
RelNode fennelInput =
mergeTraitsAndConvert(
calcRel.getTraits(), FennelRel.FENNEL_EXEC_CONVENTION, calcRel.getChild());
if (fennelInput == null) {
return;
}
Integer[] projection = projOrdinals.toArray(new Integer[projOrdinals.size()]);
FennelReshapeRel reshapeRel =
new FennelReshapeRel(
calcRel.getCluster(),
fennelInput,
projection,
outputRowType,
compOp,
filterOrdinals,
filterLiterals,
new FennelRelParamId[] {},
new Integer[] {},
null);
call.transformTo(reshapeRel);
}
public void onMatch(RelOptRuleCall call) {
JoinRel origJoinRel = (JoinRel) call.rels[0];
RelNode left = call.rels[1];
RelNode right = call.rels[2];
// combine the children MultiJoinRel inputs into an array of inputs
// for the new MultiJoinRel
List<BitSet> projFieldsList = new ArrayList<BitSet>();
List<int[]> joinFieldRefCountsList = new ArrayList<int[]>();
RelNode[] newInputs =
combineInputs(origJoinRel, left, right, projFieldsList, joinFieldRefCountsList);
// combine the outer join information from the left and right
// inputs, and include the outer join information from the current
// join, if it's a left/right outer join
RexNode[] newOuterJoinConds = new RexNode[newInputs.length];
JoinRelType[] joinTypes = new JoinRelType[newInputs.length];
combineOuterJoins(origJoinRel, newInputs, left, right, newOuterJoinConds, joinTypes);
// pull up the join filters from the children MultiJoinRels and
// combine them with the join filter associated with this JoinRel to
// form the join filter for the new MultiJoinRel
RexNode newJoinFilter = combineJoinFilters(origJoinRel, left, right);
// add on the join field reference counts for the join condition
// associated with this JoinRel
Map<Integer, int[]> newJoinFieldRefCountsMap = new HashMap<Integer, int[]>();
addOnJoinFieldRefCounts(
newInputs,
origJoinRel.getRowType().getFieldCount(),
origJoinRel.getCondition(),
joinFieldRefCountsList,
newJoinFieldRefCountsMap);
RexNode newPostJoinFilter = combinePostJoinFilters(origJoinRel, left, right);
RelNode multiJoin =
new MultiJoinRel(
origJoinRel.getCluster(),
newInputs,
newJoinFilter,
origJoinRel.getRowType(),
(origJoinRel.getJoinType() == JoinRelType.FULL),
newOuterJoinConds,
joinTypes,
projFieldsList.toArray(new BitSet[projFieldsList.size()]),
newJoinFieldRefCountsMap,
newPostJoinFilter);
call.transformTo(multiJoin);
}
@Override
public void onMatch(RelOptRuleCall call) {
final JoinRel join = (JoinRel) call.rel(0);
final RelNode left = call.rel(1);
final RelNode right = call.rel(2);
final RelTraitSet traits = join.getTraitSet().plus(DrillRel.CONVENTION);
final RelNode convertedLeft = convert(left, traits);
final RelNode convertedRight = convert(right, traits);
try {
call.transformTo(
new DrillJoinRel(
join.getCluster(),
traits,
convertedLeft,
convertedRight,
join.getCondition(),
join.getJoinType()));
} catch (InvalidRelException e) {
tracer.warning(e.toString());
}
}
public void onMatch(RelOptRuleCall call) {
FilterRel filter = (FilterRel) call.rels[0];
List<RexNode> expList = new ArrayList<RexNode>(Arrays.asList(filter.getChildExps()));
RexNode newConditionExp;
boolean reduced;
if (reduceExpressions(filter, expList)) {
assert (expList.size() == 1);
newConditionExp = expList.get(0);
reduced = true;
} else {
// No reduction, but let's still test the original
// predicate to see if it was already a constant,
// in which case we don't need any runtime decision
// about filtering.
newConditionExp = filter.getChildExps()[0];
reduced = false;
}
if (newConditionExp.isAlwaysTrue()) {
call.transformTo(filter.getChild());
} else if ((newConditionExp instanceof RexLiteral)
|| RexUtil.isNullLiteral(newConditionExp, true)) {
call.transformTo(new EmptyRel(filter.getCluster(), filter.getRowType()));
} else if (reduced) {
call.transformTo(CalcRel.createFilter(filter.getChild(), expList.get(0)));
} else {
if (newConditionExp instanceof RexCall) {
RexCall rexCall = (RexCall) newConditionExp;
boolean reverse = (rexCall.getOperator() == SqlStdOperatorTable.notOperator);
if (reverse) {
rexCall = (RexCall) rexCall.getOperands()[0];
}
reduceNotNullableFilter(call, filter, rexCall, reverse);
}
return;
}
// New plan is absolutely better than old plan.
call.getPlanner().setImportance(filter, 0.0);
}
public void onMatch(RelOptRuleCall call) {
assert matches(call);
final JoinRel join = (JoinRel) call.rels[0];
final List<Integer> leftKeys = new ArrayList<Integer>();
final List<Integer> rightKeys = new ArrayList<Integer>();
RelNode right = join.getRight();
final RelNode left = join.getLeft();
RexNode remainingCondition =
RelOptUtil.splitJoinCondition(left, right, join.getCondition(), leftKeys, rightKeys);
assert leftKeys.size() == rightKeys.size();
final List<CorrelatorRel.Correlation> correlationList =
new ArrayList<CorrelatorRel.Correlation>();
if (leftKeys.size() > 0) {
final RelOptCluster cluster = join.getCluster();
final RexBuilder rexBuilder = cluster.getRexBuilder();
int k = 0;
RexNode condition = null;
for (Integer leftKey : leftKeys) {
Integer rightKey = rightKeys.get(k++);
final String dyn_inIdStr = cluster.getQuery().createCorrel();
final int dyn_inId = RelOptQuery.getCorrelOrdinal(dyn_inIdStr);
// Create correlation to say 'each row, set variable #id
// to the value of column #leftKey'.
correlationList.add(new CorrelatorRel.Correlation(dyn_inId, leftKey));
condition =
RelOptUtil.andJoinFilters(
rexBuilder,
condition,
rexBuilder.makeCall(
SqlStdOperatorTable.equalsOperator,
rexBuilder.makeInputRef(
right.getRowType().getFieldList().get(rightKey).getType(), rightKey),
rexBuilder.makeCorrel(
left.getRowType().getFieldList().get(leftKey).getType(), dyn_inIdStr)));
}
right = CalcRel.createFilter(right, condition);
}
RelNode newRel =
new CorrelatorRel(
join.getCluster(),
left,
right,
remainingCondition,
correlationList,
join.getJoinType());
call.transformTo(newRel);
}
public void onMatch(RelOptRuleCall call) {
AggregateRel aggRel = call.rel(0);
UnionRel unionRel = call.rel(1);
if (!unionRel.all) {
// This transformation is only valid for UNION ALL.
// Consider t1(i) with rows (5), (5) and t2(i) with
// rows (5), (10), and the query
// select sum(i) from (select i from t1) union (select i from t2).
// The correct answer is 15. If we apply the transformation,
// we get
// select sum(i) from
// (select sum(i) as i from t1) union (select sum(i) as i from t2)
// which yields 25 (incorrect).
return;
}
RelOptCluster cluster = unionRel.getCluster();
List<AggregateCall> transformedAggCalls =
transformAggCalls(
aggRel.getCluster().getTypeFactory(),
aggRel.getGroupSet().cardinality(),
aggRel.getAggCallList());
if (transformedAggCalls == null) {
// we've detected the presence of something like AVG,
// which we can't handle
return;
}
boolean anyTransformed = false;
// create corresponding aggs on top of each union child
List<RelNode> newUnionInputs = new ArrayList<RelNode>();
for (RelNode input : unionRel.getInputs()) {
boolean alreadyUnique = RelMdUtil.areColumnsDefinitelyUnique(input, aggRel.getGroupSet());
if (alreadyUnique) {
newUnionInputs.add(input);
} else {
anyTransformed = true;
newUnionInputs.add(
new AggregateRel(cluster, input, aggRel.getGroupSet(), aggRel.getAggCallList()));
}
}
if (!anyTransformed) {
// none of the children could benefit from the pushdown,
// so bail out (preventing the infinite loop to which most
// planners would succumb)
return;
}
// create a new union whose children are the aggs created above
UnionRel newUnionRel = new UnionRel(cluster, newUnionInputs, true);
AggregateRel newTopAggRel =
new AggregateRel(cluster, newUnionRel, aggRel.getGroupSet(), transformedAggCalls);
// In case we transformed any COUNT (which is always NOT NULL)
// to SUM (which is always NULLABLE), cast back to keep the
// planner happy.
RelNode castRel = RelOptUtil.createCastRel(newTopAggRel, aggRel.getRowType(), false);
call.transformTo(castRel);
}
private void onMatchRight(RelOptRuleCall call) {
final JoinRelBase topJoin = call.rel(0);
final JoinRelBase bottomJoin = call.rel(1);
final RelNode relC = call.rel(2);
final RelNode relA = bottomJoin.getLeft();
final RelNode relB = bottomJoin.getRight();
final RelOptCluster cluster = topJoin.getCluster();
// topJoin
// / \
// bottomJoin C
// / \
// A B
final int aCount = relA.getRowType().getFieldCount();
final int bCount = relB.getRowType().getFieldCount();
final int cCount = relC.getRowType().getFieldCount();
final BitSet bBitSet = BitSets.range(aCount, aCount + bCount);
// becomes
//
// newTopJoin
// / \
// newBottomJoin B
// / \
// A C
// If either join is not inner, we cannot proceed.
// (Is this too strict?)
if (topJoin.getJoinType() != JoinRelType.INNER
|| bottomJoin.getJoinType() != JoinRelType.INNER) {
return;
}
// Split the condition of topJoin into a conjunction. Each of the
// parts that does not use columns from B can be pushed down.
final List<RexNode> intersecting = new ArrayList<RexNode>();
final List<RexNode> nonIntersecting = new ArrayList<RexNode>();
split(topJoin.getCondition(), bBitSet, intersecting, nonIntersecting);
// If there's nothing to push down, it's not worth proceeding.
if (nonIntersecting.isEmpty()) {
return;
}
// Split the condition of bottomJoin into a conjunction. Each of the
// parts that use columns from B will need to be pulled up.
final List<RexNode> bottomIntersecting = new ArrayList<RexNode>();
final List<RexNode> bottomNonIntersecting = new ArrayList<RexNode>();
split(bottomJoin.getCondition(), bBitSet, bottomIntersecting, bottomNonIntersecting);
// target: | A | C |
// source: | A | B | C |
final Mappings.TargetMapping bottomMapping =
Mappings.createShiftMapping(
aCount + bCount + cCount, 0, 0, aCount, aCount, aCount + bCount, cCount);
List<RexNode> newBottomList = new ArrayList<RexNode>();
new RexPermuteInputsShuttle(bottomMapping, relA, relC)
.visitList(nonIntersecting, newBottomList);
final Mappings.TargetMapping bottomBottomMapping =
Mappings.createShiftMapping(aCount + bCount, 0, 0, aCount);
new RexPermuteInputsShuttle(bottomBottomMapping, relA, relC)
.visitList(bottomNonIntersecting, newBottomList);
final RexBuilder rexBuilder = cluster.getRexBuilder();
RexNode newBottomCondition = RexUtil.composeConjunction(rexBuilder, newBottomList, false);
final JoinRelBase newBottomJoin =
bottomJoin.copy(
bottomJoin.getTraitSet(), newBottomCondition, relA, relC, bottomJoin.getJoinType());
// target: | A | C | B |
// source: | A | B | C |
final Mappings.TargetMapping topMapping =
Mappings.createShiftMapping(
aCount + bCount + cCount,
0,
0,
aCount,
aCount + cCount,
aCount,
bCount,
aCount,
aCount + bCount,
cCount);
List<RexNode> newTopList = new ArrayList<RexNode>();
new RexPermuteInputsShuttle(topMapping, newBottomJoin, relB)
.visitList(intersecting, newTopList);
new RexPermuteInputsShuttle(topMapping, newBottomJoin, relB)
.visitList(bottomIntersecting, newTopList);
RexNode newTopCondition = RexUtil.composeConjunction(rexBuilder, newTopList, false);
@SuppressWarnings("SuspiciousNameCombination")
final JoinRelBase newTopJoin =
topJoin.copy(
topJoin.getTraitSet(), newTopCondition, newBottomJoin, relB, topJoin.getJoinType());
assert !Mappings.isIdentity(topMapping);
final RelNode newProject =
RelFactories.createProject(projectFactory, newTopJoin, Mappings.asList(topMapping));
call.transformTo(newProject);
}
// implement RelOptRule
public void onMatch(RelOptRuleCall call) {
call.transformTo(call.rels[0].getInput(0));
}
public void onMatch(RelOptRuleCall call) {
RelNode input = call.rel(1);
if (input.getTraitSet().contains(converter.getOutTrait())) {
converter.onMatch(call);
}
}
public void onMatch(RelOptRuleCall call) {
final TableAccessRel oldRel = call.rel(0);
RelNode newRel = oldRel.getTable().toRel(RelOptUtil.getContext(oldRel.getCluster()));
call.transformTo(newRel);
}