assertChildren(join, ancestorSource, descendantSource);
}
@Test
public void shouldHaveBestRuleSetJoinAlgorithmToMergeIfConditionIsNotDescendantNode() {
PlanNode join = new PlanNode(Type.JOIN, selector("Parent"), selector("Child"));
PlanNode parentSource = new PlanNode(Type.SOURCE, join, selector("Parent"));
PlanNode childSource = new PlanNode(Type.SOURCE, join, selector("Child"));
// Set the join type and condition ...
JoinCondition joinCondition = new ChildNodeJoinCondition(selector("Parent"), selector("Child"));
join.setProperty(Property.JOIN_CONDITION, joinCondition);
join.setProperty(Property.JOIN_TYPE, JoinType.INNER);
// Execute the rule ...
PlanNode result = bestRule.execute(context, join, new LinkedList<OptimizerRule>());
assertThat(result, is(sameInstance(join)));
assertThat(join.getProperty(Property.JOIN_TYPE, JoinType.class), is(JoinType.INNER));
assertThat(join.getProperty(Property.JOIN_ALGORITHM, JoinAlgorithm.class), is(JoinAlgorithm.MERGE));
assertThat(join.getProperty(Property.JOIN_CONDITION, JoinCondition.class), is(sameInstance(joinCondition)));
PlanNode leftDup = join.getFirstChild();
assertThat(leftDup.getType(), is(Type.DUP_REMOVE));
assertSelectors(leftDup, "Parent");
PlanNode leftSort = leftDup.getFirstChild();
assertThat(leftSort.getType(), is(Type.SORT));
assertSortOrderBy(leftSort, "Parent");
assertSelectors(leftSort, "Parent");
assertChildren(leftDup, leftSort);
assertChildren(leftSort, parentSource);
PlanNode rightDup = join.getLastChild();
assertThat(rightDup.getType(), is(Type.DUP_REMOVE));
assertSelectors(rightDup, "Child");
PlanNode rightSort = rightDup.getLastChild();
assertThat(rightSort.getType(), is(Type.SORT));
assertSortOrderBy(rightSort, "Child");
assertSelectors(rightSort, "Child");
assertChildren(rightDup, rightSort);
assertChildren(rightSort, childSource);