List<RexNode> rightJoinKeys = new ArrayList<RexNode>(); RexNode nonEquiConds = RelOptUtil.splitJoinCondition(sysFieldList, leftRel, rightRel, calciteJoinCond, leftJoinKeys, rightJoinKeys, null, null);
List<RexNode> rightJoinKeys = new ArrayList<RexNode>(); RexNode nonEquiConds = RelOptUtil.splitJoinCondition(sysFieldList, leftRel, rightRel, calciteJoinCond, leftJoinKeys, rightJoinKeys, null, null);
final List<Boolean> filterNulls = Lists.newArrayList(); RexNode nonEquiConj = RelOptUtil.splitJoinCondition(join.getLeft(), join.getRight(), join.getCondition(), leftKeys, rightKeys, filterNulls);
final List<Boolean> filterNulls = Lists.newArrayList(); RexNode nonEquiConj = RelOptUtil.splitJoinCondition(join.getLeft(), join.getRight(), join.getCondition(), leftKeys, rightKeys, filterNulls);
public NestedLoopJoinPrel(RelOptCluster cluster, RelTraitSet traits, RelNode left, RelNode right, RexNode condition, JoinRelType joinType) throws InvalidRelException { super(cluster, traits, left, right, condition, joinType); RelOptUtil.splitJoinCondition(left, right, condition, leftKeys, rightKeys, filterNulls); }
public DrillJoinRel(RelOptCluster cluster, RelTraitSet traits, RelNode left, RelNode right, RexNode condition, JoinRelType joinType, int joinControl) { super(cluster, traits, left, right, condition, joinType); assert traits.contains(DrillRel.DRILL_LOGICAL); RelOptUtil.splitJoinCondition(left, right, condition, leftKeys, rightKeys, filterNulls); this.joinControl = joinControl; }
/** Creates a JoinRel. * We do not throw InvalidRelException in Logical planning phase. It's up to the post-logical planning check or physical planning * to detect the unsupported join type, and throw exception. * */ public JoinRel(RelOptCluster cluster, RelTraitSet traits, RelNode left, RelNode right, RexNode condition, JoinRelType joinType) { super(cluster, traits, left, right, condition, joinType); assert traits.contains(Rel.LOGICAL); RelOptUtil.splitJoinCondition(left, right, condition, leftKeys, rightKeys, filterNulls); }
public DrillJoinRel(RelOptCluster cluster, RelTraitSet traits, RelNode left, RelNode right, RexNode condition, JoinRelType joinType) { super(cluster, traits, left, right, condition, joinType); assert traits.contains(DrillRel.DRILL_LOGICAL); RelOptUtil.splitJoinCondition(left, right, condition, leftKeys, rightKeys, filterNulls); }
public static JoinCategory getJoinCategory(RelNode left, RelNode right, RexNode condition, List<Integer> leftKeys, List<Integer> rightKeys, List<Boolean> filterNulls) { if (condition.isAlwaysTrue()) { return JoinCategory.CARTESIAN; } leftKeys.clear(); rightKeys.clear(); filterNulls.clear(); RexNode remaining = RelOptUtil.splitJoinCondition(left, right, condition, leftKeys, rightKeys, filterNulls); if (!remaining.isAlwaysTrue() || (leftKeys.size() == 0 || rightKeys.size() == 0) ) { // for practical purposes these cases could be treated as inequality return JoinCategory.INEQUALITY; } return JoinCategory.EQUALITY; }
public static JoinCategory getJoinCategory(RelNode left, RelNode right, RexNode condition, List<Integer> leftKeys, List<Integer> rightKeys, List<Boolean> filterNulls) { if (condition.isAlwaysTrue()) { return JoinCategory.CARTESIAN; } leftKeys.clear(); rightKeys.clear(); filterNulls.clear(); RexNode remaining = RelOptUtil.splitJoinCondition(left, right, condition, leftKeys, rightKeys, filterNulls); if (!remaining.isAlwaysTrue() || (leftKeys.size() == 0 || rightKeys.size() == 0) ) { // for practical purposes these cases could be treated as inequality return JoinCategory.INEQUALITY; } return JoinCategory.EQUALITY; }
public boolean apply(Join join, JoinRelType joinType, RexNode exp) { if (joinType != JoinRelType.INNER) { return true; } List<Integer> tmpLeftKeys = new ArrayList<>(); List<Integer> tmpRightKeys = new ArrayList<>(); List<Boolean> filterNulls = new ArrayList<>(); RexNode remaining = RelOptUtil.splitJoinCondition(join.getLeft(), join.getRight(), exp, tmpLeftKeys, tmpRightKeys, filterNulls); return remaining.isAlwaysTrue(); } };
public boolean apply(Join join, JoinRelType joinType, RexNode exp) { if (joinType != JoinRelType.INNER) { return true; // In OUTER join, we could not pull-up the filter. // All we can do is keep the filter with JOIN, and // then decide whether the filter could be pushed down // into LEFT/RIGHT. } List<RexNode> tmpLeftKeys = new ArrayList<>(); List<RexNode> tmpRightKeys = new ArrayList<>(); List<RelDataTypeField> sysFields = new ArrayList<>(); List<Integer> filterNulls = new ArrayList<>(); RexNode remaining = RelOptUtil.splitJoinCondition(sysFields, join.getLeft(), join.getRight(), exp, tmpLeftKeys, tmpRightKeys, filterNulls, null); return remaining.isAlwaysTrue(); } };
@Deprecated // to be removed before 2.0 public static boolean isEqui( RelNode left, RelNode right, RexNode condition) { final List<Integer> leftKeys = new ArrayList<>(); final List<Integer> rightKeys = new ArrayList<>(); final List<Boolean> filterNulls = new ArrayList<>(); final List<RexNode> nonEquiList = new ArrayList<>(); splitJoinCondition( left.getCluster().getRexBuilder(), left.getRowType().getFieldCount(), condition, leftKeys, rightKeys, filterNulls, nonEquiList); return nonEquiList.size() == 0; }
@Deprecated // to be removed before 2.0 public static boolean isEqui( RelNode left, RelNode right, RexNode condition) { final List<Integer> leftKeys = new ArrayList<>(); final List<Integer> rightKeys = new ArrayList<>(); final List<Boolean> filterNulls = new ArrayList<>(); final List<RexNode> nonEquiList = new ArrayList<>(); splitJoinCondition( left.getCluster().getRexBuilder(), left.getRowType().getFieldCount(), condition, leftKeys, rightKeys, filterNulls, nonEquiList); return nonEquiList.size() == 0; }
/** Creates a {@code JoinInfo} by analyzing a condition. */ public static JoinInfo of(RelNode left, RelNode right, RexNode condition) { final List<Integer> leftKeys = new ArrayList<>(); final List<Integer> rightKeys = new ArrayList<>(); final List<Boolean> filterNulls = new ArrayList<>(); RexNode remaining = RelOptUtil.splitJoinCondition(left, right, condition, leftKeys, rightKeys, filterNulls); if (remaining.isAlwaysTrue()) { return new EquiJoinInfo(ImmutableIntList.copyOf(leftKeys), ImmutableIntList.copyOf(rightKeys)); } else { return new NonEquiJoinInfo(ImmutableIntList.copyOf(leftKeys), ImmutableIntList.copyOf(rightKeys), remaining); } }
/** Creates a {@code JoinInfo} by analyzing a condition. */ public static JoinInfo of(RelNode left, RelNode right, RexNode condition) { final List<Integer> leftKeys = new ArrayList<>(); final List<Integer> rightKeys = new ArrayList<>(); final List<Boolean> filterNulls = new ArrayList<>(); RexNode remaining = RelOptUtil.splitJoinCondition(left, right, condition, leftKeys, rightKeys, filterNulls); if (remaining.isAlwaysTrue()) { return new EquiJoinInfo(ImmutableIntList.copyOf(leftKeys), ImmutableIntList.copyOf(rightKeys)); } else { return new NonEquiJoinInfo(ImmutableIntList.copyOf(leftKeys), ImmutableIntList.copyOf(rightKeys), remaining); } }
private static void splitJoinConditionHelper(RexNode joinCond, List<Integer> expLeftKeys, List<Integer> expRightKeys, List<Boolean> expFilterNulls, RexNode expRemaining) { List<Integer> actLeftKeys = new ArrayList<>(); List<Integer> actRightKeys = new ArrayList<>(); List<Boolean> actFilterNulls = new ArrayList<>(); RexNode actRemaining = RelOptUtil.splitJoinCondition(EMP_SCAN, DEPT_SCAN, joinCond, actLeftKeys, actRightKeys, actFilterNulls); assertEquals(expRemaining.toString(), actRemaining.toString()); assertEquals(expFilterNulls, actFilterNulls); assertEquals(expLeftKeys, actLeftKeys); assertEquals(expRightKeys, actRightKeys); } }
private static void splitJoinConditionHelper(RexNode joinCond, List<Integer> expLeftKeys, List<Integer> expRightKeys, List<Boolean> expFilterNulls, RexNode expRemaining) { List<Integer> actLeftKeys = new ArrayList<>(); List<Integer> actRightKeys = new ArrayList<>(); List<Boolean> actFilterNulls = new ArrayList<>(); RexNode actRemaining = RelOptUtil.splitJoinCondition(EMP_SCAN, DEPT_SCAN, joinCond, actLeftKeys, actRightKeys, actFilterNulls); assertEquals(expRemaining.toString(), actRemaining.toString()); assertEquals(expFilterNulls, actFilterNulls); assertEquals(expLeftKeys, actLeftKeys); assertEquals(expRightKeys, actRightKeys); } }
/** Test case for * <a href="https://issues.apache.org/jira/browse/CALCITE-833">[CALCITE-833] * RelOptUtil.splitJoinCondition attempts to split a Join-Condition which * has a remaining condition</a>. */ @Test public void testSplitJoinCondition() { final String sql = "select * \n" + "from emp a \n" + "INNER JOIN dept b \n" + "ON CAST(a.empno AS int) <> b.deptno"; final RelNode relNode = toRel(sql); final LogicalProject project = (LogicalProject) relNode; final LogicalJoin join = (LogicalJoin) project.getInput(0); final List<RexNode> leftJoinKeys = new ArrayList<>(); final List<RexNode> rightJoinKeys = new ArrayList<>(); final ArrayList<RelDataTypeField> sysFieldList = new ArrayList<>(); final RexNode remaining = RelOptUtil.splitJoinCondition(sysFieldList, join.getInputs().get(0), join.getInputs().get(1), join.getCondition(), leftJoinKeys, rightJoinKeys, null, null); assertThat(remaining.toString(), is("<>(CAST($0):INTEGER NOT NULL, $9)")); assertThat(leftJoinKeys.isEmpty(), is(true)); assertThat(rightJoinKeys.isEmpty(), is(true)); }
/** Test case for * <a href="https://issues.apache.org/jira/browse/CALCITE-833">[CALCITE-833] * RelOptUtil.splitJoinCondition attempts to split a Join-Condition which * has a remaining condition</a>. */ @Test public void testSplitJoinCondition() { final String sql = "select * \n" + "from emp a \n" + "INNER JOIN dept b \n" + "ON CAST(a.empno AS int) <> b.deptno"; final RelNode relNode = toRel(sql); final LogicalProject project = (LogicalProject) relNode; final LogicalJoin join = (LogicalJoin) project.getInput(0); final List<RexNode> leftJoinKeys = new ArrayList<>(); final List<RexNode> rightJoinKeys = new ArrayList<>(); final ArrayList<RelDataTypeField> sysFieldList = new ArrayList<>(); final RexNode remaining = RelOptUtil.splitJoinCondition(sysFieldList, join.getInputs().get(0), join.getInputs().get(1), join.getCondition(), leftJoinKeys, rightJoinKeys, null, null); assertThat(remaining.toString(), is("<>(CAST($0):INTEGER NOT NULL, $9)")); assertThat(leftJoinKeys.isEmpty(), is(true)); assertThat(rightJoinKeys.isEmpty(), is(true)); }