/
DrillJoinRule.java
122 lines (108 loc) · 5.2 KB
/
DrillJoinRule.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.drill.exec.planner.logical;
import java.util.List;
import java.util.logging.Logger;
import org.apache.calcite.rel.InvalidRelException;
import org.apache.calcite.rel.core.JoinRelType;
import org.apache.calcite.rel.RelNode;
import org.apache.calcite.plan.Convention;
import org.apache.calcite.plan.RelOptRule;
import org.apache.calcite.plan.RelOptRuleCall;
import org.apache.calcite.plan.RelOptUtil;
import org.apache.calcite.plan.RelTraitSet;
import org.apache.calcite.rel.logical.LogicalJoin;
import org.apache.calcite.rel.type.RelDataTypeField;
import org.apache.calcite.rex.RexBuilder;
import org.apache.calcite.rex.RexNode;
import org.apache.calcite.rex.RexUtil;
import org.apache.calcite.sql.fun.SqlStdOperatorTable;
import org.apache.calcite.util.trace.CalciteTrace;
import com.google.common.collect.Lists;
/**
* Rule that converts a {@link org.apache.calcite.rel.logical.LogicalJoin} to a {@link DrillJoinRel}, which is implemented by Drill "join" operation.
*/
public class DrillJoinRule extends RelOptRule {
public static final RelOptRule INSTANCE = new DrillJoinRule();
protected static final Logger tracer = CalciteTrace.getPlannerTracer();
private DrillJoinRule() {
super(
RelOptHelper.any(LogicalJoin.class, Convention.NONE),
"DrillJoinRule");
}
@Override
public void onMatch(RelOptRuleCall call) {
final LogicalJoin join = (LogicalJoin) call.rel(0);
final RelNode left = join.getLeft();
final RelNode right = join.getRight();
final RelTraitSet traits = join.getTraitSet().plus(DrillRel.DRILL_LOGICAL);
final RelNode convertedLeft = convert(left, left.getTraitSet().plus(DrillRel.DRILL_LOGICAL));
final RelNode convertedRight = convert(right, right.getTraitSet().plus(DrillRel.DRILL_LOGICAL));
List<Integer> leftKeys = Lists.newArrayList();
List<Integer> rightKeys = Lists.newArrayList();
int numLeftFields = convertedLeft.getRowType().getFieldCount();
boolean addFilter = false;
RexNode origJoinCondition = join.getCondition();
RexNode newJoinCondition = origJoinCondition;
RexNode remaining = RelOptUtil.splitJoinCondition(convertedLeft, convertedRight, origJoinCondition, leftKeys, rightKeys);
boolean hasEquijoins = (leftKeys.size() == rightKeys.size() && leftKeys.size() > 0) ? true : false;
// If the join involves equijoins and non-equijoins, then we can process the non-equijoins through
// a filter right after the join
// DRILL-1337: We can only pull up a non-equivjoin filter for INNER join.
// For OUTER join, pulling up a non-eqivjoin filter will lead to incorrectly discarding qualified rows.
if (! remaining.isAlwaysTrue()) {
if (hasEquijoins && join.getJoinType()== JoinRelType.INNER) {
addFilter = true;
List<RexNode> equijoinList = Lists.newArrayList();
List<RelDataTypeField> leftTypes = convertedLeft.getRowType().getFieldList();
List<RelDataTypeField> rightTypes = convertedRight.getRowType().getFieldList();
RexBuilder builder = join.getCluster().getRexBuilder();
for (int i=0; i < leftKeys.size(); i++) {
int leftKeyOrdinal = leftKeys.get(i).intValue();
int rightKeyOrdinal = rightKeys.get(i).intValue();
equijoinList.add(builder.makeCall(
SqlStdOperatorTable.EQUALS,
builder.makeInputRef(leftTypes.get(leftKeyOrdinal).getType(), leftKeyOrdinal),
builder.makeInputRef(rightTypes.get(rightKeyOrdinal).getType(), rightKeyOrdinal + numLeftFields)
) );
}
newJoinCondition = RexUtil.composeConjunction(builder, equijoinList, false);
} else {
// tracer.warning("Non-equijoins are only supported in the presence of an equijoin.");
// return;
}
}
//else {
//
// return;
// }
try {
if (!addFilter) {
RelNode joinRel = new DrillJoinRel(join.getCluster(), traits, convertedLeft, convertedRight, origJoinCondition,
join.getJoinType(), leftKeys, rightKeys);
call.transformTo(joinRel);
} else {
RelNode joinRel = new DrillJoinRel(join.getCluster(), traits, convertedLeft, convertedRight, newJoinCondition,
join.getJoinType(), leftKeys, rightKeys);
call.transformTo(new DrillFilterRel(join.getCluster(), traits, joinRel, remaining));
}
} catch (InvalidRelException e) {
tracer.warning(e.toString());
}
}
}