Java JoinNode类代码示例

import org.apache.tajo.engine.planner.logical.JoinNode; //导入依赖的package包/类
@Test
public final void testRightOuterMergeJoin0() throws IOException, PlanningException {
  Expr expr = analyzer.parse(QUERIES[0]);
  LogicalNode plan = planner.createPlan(expr).getRootBlock().getRoot();
  JoinNode joinNode = PlannerUtil.findTopNode(plan, NodeType.JOIN);
  Enforcer enforcer = new Enforcer();
  enforcer.enforceJoinAlgorithm(joinNode.getPID(), JoinAlgorithm.MERGE_JOIN);

  FileFragment[] emp3Frags = StorageManager.splitNG(conf, "emp3", emp3.getMeta(), emp3.getPath(), Integer.MAX_VALUE);
  FileFragment[] dep3Frags = StorageManager.splitNG(conf, "dep3", dep3.getMeta(), dep3.getPath(), Integer.MAX_VALUE);
  FileFragment[] merged = TUtil.concat(emp3Frags, dep3Frags);

  Path workDir = CommonTestingUtil.getTestDir("target/test-data/testRightOuterMergeJoin0");
  TaskAttemptContext ctx = new TaskAttemptContext(conf,
      LocalTajoTestingUtility.newQueryUnitAttemptId(), merged, workDir);
  ctx.setEnforcer(enforcer);

  PhysicalPlanner phyPlanner = new PhysicalPlannerImpl(conf,sm);
  PhysicalExec exec = phyPlanner.createPlan(ctx, plan);

  ProjectionExec proj = (ProjectionExec) exec;
  assertTrue(proj.getChild() instanceof RightOuterMergeJoinExec);

  int count = 0;
  exec.init();
  while (exec.next() != null) {
    //TODO check contents
    count = count + 1;
  }
  assertNull(exec.next());
  exec.close();
  assertEquals(12, count);
}
 

import org.apache.tajo.engine.planner.logical.JoinNode; //导入依赖的package包/类
public NLLeftOuterJoinExec(TaskAttemptContext context, JoinNode plan, PhysicalExec leftChild,
                           PhysicalExec rightChild) {
  super(context, plan.getInSchema(), plan.getOutSchema(), leftChild, rightChild);
  this.plan = plan;

  if (plan.hasJoinQual()) {
    this.joinQual = plan.getJoinQual();
  }

  // for projection
  projector = new Projector(inSchema, outSchema, plan.getTargets());

  // for join
  needNextRightTuple = true;
  frameTuple = new FrameTuple();
  outTuple = new VTuple(outSchema.size());

  foundAtLeastOneMatch = false;
  rightNumCols = rightChild.getSchema().size();
}
 

import org.apache.tajo.engine.planner.logical.JoinNode; //导入依赖的package包/类
public NLJoinExec(TaskAttemptContext context, JoinNode plan, PhysicalExec outer,
    PhysicalExec inner) {
  super(context, plan.getInSchema(), plan.getOutSchema(), outer, inner);
  this.plan = plan;

  if (plan.hasJoinQual()) {
    this.joinQual = plan.getJoinQual();
  }

  // for projection
  projector = new Projector(inSchema, outSchema, plan.getTargets());

  // for join
  needNewOuter = true;
  frameTuple = new FrameTuple();
  outTuple = new VTuple(outSchema.size());
}
 

import org.apache.tajo.engine.planner.logical.JoinNode; //导入依赖的package包/类
public Collection<EvalNode> addJoin(LogicalPlan plan, LogicalPlan.QueryBlock block,
                                    JoinNode joinNode) throws PlanningException {
  Set<EvalNode> cnf = Sets.newHashSet(AlgebraicUtil.toConjunctiveNormalFormArray(joinNode.getJoinQual()));
  Set<EvalNode> nonJoinQuals = Sets.newHashSet();
  for (EvalNode singleQual : cnf) {
    if (PlannerUtil.isJoinQual(singleQual)) {

      String [] relations = guessRelationsFromJoinQual(block, singleQual);
      String leftExprRelName = relations[0];
      String rightExprRelName = relations[1];

      Collection<String> leftLineage = PlannerUtil.getRelationLineageWithinQueryBlock(plan, joinNode.getLeftChild());

      boolean isLeftExprForLeftTable = leftLineage.contains(leftExprRelName);
      JoinEdge edge;
      edge = getEdge(leftExprRelName, rightExprRelName);

      if (edge != null) {
        edge.addJoinQual(singleQual);
      } else {
        if (isLeftExprForLeftTable) {
          edge = new JoinEdge(joinNode.getJoinType(),
              block.getRelation(leftExprRelName), block.getRelation(rightExprRelName), singleQual);
          addEdge(leftExprRelName, rightExprRelName, edge);
        } else {
          edge = new JoinEdge(joinNode.getJoinType(),
              block.getRelation(rightExprRelName), block.getRelation(leftExprRelName), singleQual);
          addEdge(rightExprRelName, leftExprRelName, edge);
        }
      }
    } else {
      nonJoinQuals.add(singleQual);
    }
  }
  cnf.retainAll(nonJoinQuals);
  return cnf;
}
 

import org.apache.tajo.engine.planner.logical.JoinNode; //导入依赖的package包/类
public MergeFullOuterJoinExec(TaskAttemptContext context, JoinNode plan, PhysicalExec leftChild,
                              PhysicalExec rightChild, SortSpec[] leftSortKey, SortSpec[] rightSortKey) {
  super(context, plan.getInSchema(), plan.getOutSchema(), leftChild, rightChild);
  Preconditions.checkArgument(plan.hasJoinQual(), "Sort-merge join is only used for the equi-join, " +
      "but there is no join condition");
  this.joinNode = plan;
  this.joinQual = plan.getJoinQual();

  this.leftTupleSlots = new ArrayList<Tuple>(INITIAL_TUPLE_SLOT);
  this.rightTupleSlots = new ArrayList<Tuple>(INITIAL_TUPLE_SLOT);
  SortSpec[][] sortSpecs = new SortSpec[2][];
  sortSpecs[0] = leftSortKey;
  sortSpecs[1] = rightSortKey;

  this.joincomparator = new JoinTupleComparator(leftChild.getSchema(),
      rightChild.getSchema(), sortSpecs);
  this.tupleComparator = PlannerUtil.getComparatorsFromJoinQual(
      plan.getJoinQual(), leftChild.getSchema(), rightChild.getSchema());

  // for projection
  this.projector = new Projector(inSchema, outSchema, plan.getTargets());

  // for join
  frameTuple = new FrameTuple();
  outTuple = new VTuple(outSchema.size());

  leftNumCols = leftChild.getSchema().size();
  rightNumCols = rightChild.getSchema().size();
}
 

import org.apache.tajo.engine.planner.logical.JoinNode; //导入依赖的package包/类
public RightOuterMergeJoinExec(TaskAttemptContext context, JoinNode plan, PhysicalExec outer,
                               PhysicalExec inner, SortSpec[] outerSortKey, SortSpec[] innerSortKey) {
  super(context, plan.getInSchema(), plan.getOutSchema(), outer, inner);
  Preconditions.checkArgument(plan.hasJoinQual(), "Sort-merge join is only used for the equi-join, " +
      "but there is no join condition");
  this.joinNode = plan;
  this.joinQual = plan.getJoinQual();

  this.leftTupleSlots = new ArrayList<Tuple>(INITIAL_TUPLE_SLOT);
  this.innerTupleSlots = new ArrayList<Tuple>(INITIAL_TUPLE_SLOT);
  SortSpec[][] sortSpecs = new SortSpec[2][];
  sortSpecs[0] = outerSortKey;
  sortSpecs[1] = innerSortKey;

  this.joinComparator = new JoinTupleComparator(outer.getSchema(), inner.getSchema(), sortSpecs);
  this.tupleComparator = PlannerUtil.getComparatorsFromJoinQual(
      plan.getJoinQual(), outer.getSchema(), inner.getSchema());

  // for projection
  this.projector = new Projector(inSchema, outSchema, plan.getTargets());

  // for join
  frameTuple = new FrameTuple();
  outTuple = new VTuple(outSchema.size());

  leftNumCols = outer.getSchema().size();
}
 

import org.apache.tajo.engine.planner.logical.JoinNode; //导入依赖的package包/类
public HashJoinExec(TaskAttemptContext context, JoinNode plan, PhysicalExec leftExec,
    PhysicalExec rightExec) {
  super(context, SchemaUtil.merge(leftExec.getSchema(), rightExec.getSchema()), plan.getOutSchema(),
      leftExec, rightExec);
  this.plan = plan;
  this.joinQual = plan.getJoinQual();
  this.tupleSlots = new HashMap<Tuple, List<Tuple>>(10000);

  this.joinKeyPairs = PlannerUtil.getJoinKeyPairs(joinQual,
      leftExec.getSchema(), rightExec.getSchema());

  leftKeyList = new int[joinKeyPairs.size()];
  rightKeyList = new int[joinKeyPairs.size()];

  for (int i = 0; i < joinKeyPairs.size(); i++) {
    leftKeyList[i] = leftExec.getSchema().getColumnId(joinKeyPairs.get(i)[0].getQualifiedName());
  }

  for (int i = 0; i < joinKeyPairs.size(); i++) {
    rightKeyList[i] = rightExec.getSchema().getColumnId(joinKeyPairs.get(i)[1].getQualifiedName());
  }

  // for projection
  this.projector = new Projector(inSchema, outSchema, plan.getTargets());

  // for join
  frameTuple = new FrameTuple();
  outTuple = new VTuple(outSchema.size());
  leftKeyTuple = new VTuple(leftKeyList.length);
}
 

import org.apache.tajo.engine.planner.logical.JoinNode; //导入依赖的package包/类
public HashLeftSemiJoinExec(TaskAttemptContext context, JoinNode plan, PhysicalExec fromSideChild,
                            PhysicalExec inSideChild) {
  super(context, plan, fromSideChild, inSideChild);
  // NUll Tuple
  rightNullTuple = new VTuple(leftChild.outColumnNum);
  for (int i = 0; i < leftChild.outColumnNum; i++) {
    rightNullTuple.put(i, NullDatum.get());
  }
}
 

import org.apache.tajo.engine.planner.logical.JoinNode; //导入依赖的package包/类
public BNLJoinExec(final TaskAttemptContext context, final JoinNode plan,
                   final PhysicalExec leftExec, PhysicalExec rightExec) {
  super(context, plan.getInSchema(), plan.getOutSchema(), leftExec, rightExec);
  this.plan = plan;
  this.joinQual = plan.getJoinQual();
  if (joinQual != null) { // if join type is not 'cross join'
    hasJoinQual = true;
  } else {
    hasJoinQual = false;
  }
  this.leftTupleSlots = new ArrayList<Tuple>(TUPLE_SLOT_SIZE);
  this.rightTupleSlots = new ArrayList<Tuple>(TUPLE_SLOT_SIZE);
  this.leftIterator = leftTupleSlots.iterator();
  this.rightIterator = rightTupleSlots.iterator();
  this.rightEnd = false;
  this.leftEnd = false;

  // for projection
  if (!plan.hasTargets()) {
    plan.setTargets(PlannerUtil.schemaToTargets(outSchema));
  }

  projector = new Projector(inSchema, outSchema, plan.getTargets());

  // for join
  frameTuple = new FrameTuple();
  outputTuple = new VTuple(outSchema.size());
}
 

import org.apache.tajo.engine.planner.logical.JoinNode; //导入依赖的package包/类
public HashLeftOuterJoinExec(TaskAttemptContext context, JoinNode plan, PhysicalExec leftChild,
                             PhysicalExec rightChild) {
  super(context, SchemaUtil.merge(leftChild.getSchema(), rightChild.getSchema()),
      plan.getOutSchema(), leftChild, rightChild);
  this.plan = plan;
  this.joinQual = plan.getJoinQual();
  this.tupleSlots = new HashMap<Tuple, List<Tuple>>(10000);

  this.joinKeyPairs = PlannerUtil.getJoinKeyPairs(joinQual, leftChild.getSchema(), rightChild.getSchema());

  leftKeyList = new int[joinKeyPairs.size()];
  rightKeyList = new int[joinKeyPairs.size()];

  for (int i = 0; i < joinKeyPairs.size(); i++) {
    leftKeyList[i] = leftChild.getSchema().getColumnId(joinKeyPairs.get(i)[0].getQualifiedName());
  }

  for (int i = 0; i < joinKeyPairs.size(); i++) {
    rightKeyList[i] = rightChild.getSchema().getColumnId(joinKeyPairs.get(i)[1].getQualifiedName());
  }

  // for projection
  this.projector = new Projector(inSchema, outSchema, plan.getTargets());

  // for join
  frameTuple = new FrameTuple();
  outTuple = new VTuple(outSchema.size());
  leftKeyTuple = new VTuple(leftKeyList.length);

  rightNumCols = rightChild.getSchema().size();
}
 

import org.apache.tajo.engine.planner.logical.JoinNode; //导入依赖的package包/类
public MergeJoinExec(TaskAttemptContext context, JoinNode plan, PhysicalExec outer,
    PhysicalExec inner, SortSpec[] outerSortKey, SortSpec[] innerSortKey) {
  super(context, plan.getInSchema(), plan.getOutSchema(), outer, inner);
  Preconditions.checkArgument(plan.hasJoinQual(), "Sort-merge join is only used for the equi-join, " +
      "but there is no join condition");
  this.joinNode = plan;
  this.joinQual = plan.getJoinQual();

  this.outerTupleSlots = new ArrayList<Tuple>(INITIAL_TUPLE_SLOT);
  this.innerTupleSlots = new ArrayList<Tuple>(INITIAL_TUPLE_SLOT);
  SortSpec[][] sortSpecs = new SortSpec[2][];
  sortSpecs[0] = outerSortKey;
  sortSpecs[1] = innerSortKey;

  this.joincomparator = new JoinTupleComparator(outer.getSchema(),
      inner.getSchema(), sortSpecs);
  this.tupleComparator = PlannerUtil.getComparatorsFromJoinQual(
      plan.getJoinQual(), outer.getSchema(), inner.getSchema());
  this.outerIterator = outerTupleSlots.iterator();
  this.innerIterator = innerTupleSlots.iterator();
  
  // for projection
  this.projector = new Projector(inSchema, outSchema, plan.getTargets());

  // for join
  frameTuple = new FrameTuple();
  outTuple = new VTuple(outSchema.size());
}
 

import org.apache.tajo.engine.planner.logical.JoinNode; //导入依赖的package包/类
public HashFullOuterJoinExec(TaskAttemptContext context, JoinNode plan, PhysicalExec outer,
                             PhysicalExec inner) {
  super(context, SchemaUtil.merge(outer.getSchema(), inner.getSchema()),
      plan.getOutSchema(), outer, inner);
  this.plan = plan;
  this.joinQual = plan.getJoinQual();
  this.tupleSlots = new HashMap<Tuple, List<Tuple>>(10000);

  // this hashmap mirrors the evolution of the tupleSlots, with the same keys. For each join key,
  // we have a boolean flag, initially false (whether this join key had at least one match on the left operand)
  this.matched = new HashMap<Tuple, Boolean>(10000);

  this.joinKeyPairs = PlannerUtil.getJoinKeyPairs(joinQual,
      outer.getSchema(), inner.getSchema());

  leftKeyList = new int[joinKeyPairs.size()];
  rightKeyList = new int[joinKeyPairs.size()];

  for (int i = 0; i < joinKeyPairs.size(); i++) {
    leftKeyList[i] = outer.getSchema().getColumnId(joinKeyPairs.get(i)[0].getQualifiedName());
  }

  for (int i = 0; i < joinKeyPairs.size(); i++) {
    rightKeyList[i] = inner.getSchema().getColumnId(joinKeyPairs.get(i)[1].getQualifiedName());
  }

  // for projection
  this.projector = new Projector(inSchema, outSchema, plan.getTargets());

  // for join
  frameTuple = new FrameTuple();
  outTuple = new VTuple(outSchema.size());
  leftKeyTuple = new VTuple(leftKeyList.length);

  leftNumCols = outer.getSchema().size();
  rightNumCols = inner.getSchema().size();
}
 

import org.apache.tajo.engine.planner.logical.JoinNode; //导入依赖的package包/类
public HashLeftAntiJoinExec(TaskAttemptContext context, JoinNode plan, PhysicalExec fromSideChild,
                            PhysicalExec notInSideChild) {
  super(context, plan, fromSideChild, notInSideChild);
  // NUll Tuple
  rightNullTuple = new VTuple(leftChild.outColumnNum);
  for (int i = 0; i < leftChild.outColumnNum; i++) {
    rightNullTuple.put(i, NullDatum.get());
  }
}
 

import org.apache.tajo.engine.planner.logical.JoinNode; //导入依赖的package包/类
@Test
public void testEquals() {
  Schema schema = new Schema();
  schema.addColumn("id", Type.INT4);
  schema.addColumn("name", Type.TEXT);
  schema.addColumn("age", Type.INT2);
  GroupbyNode groupbyNode = new GroupbyNode(0);
  groupbyNode.setGroupingColumns(new Column[]{schema.getColumn(1), schema.getColumn(2)});
  ScanNode scanNode = new ScanNode(0);
  scanNode.init(CatalogUtil.newTableDesc("in", schema, CatalogUtil.newTableMeta(StoreType.CSV), new Path("in")));

  GroupbyNode groupbyNode2 = new GroupbyNode(0);
  groupbyNode2.setGroupingColumns(new Column[]{schema.getColumn(1), schema.getColumn(2)});
  JoinNode joinNode = new JoinNode(0);
  ScanNode scanNode2 = new ScanNode(0);
  scanNode2.init(CatalogUtil.newTableDesc("in2", schema, CatalogUtil.newTableMeta(StoreType.CSV), new Path("in2")));

  groupbyNode.setChild(scanNode);
  groupbyNode2.setChild(joinNode);
  joinNode.setLeftChild(scanNode);
  joinNode.setRightChild(scanNode2);

  assertTrue(groupbyNode.equals(groupbyNode2));
  assertFalse(groupbyNode.deepEquals(groupbyNode2));

  ScanNode scanNode3 = new ScanNode(0);
  scanNode3.init(CatalogUtil.newTableDesc("in", schema, CatalogUtil.newTableMeta(StoreType.CSV), new Path("in")));
  groupbyNode2.setChild(scanNode3);

  assertTrue(groupbyNode.equals(groupbyNode2));
  assertTrue(groupbyNode.deepEquals(groupbyNode2));
}
 

import org.apache.tajo.engine.planner.logical.JoinNode; //导入依赖的package包/类
@Test
public final void testFullOuterHashJoinExec0() throws IOException, PlanningException {
  Expr expr = analyzer.parse(QUERIES[0]);
  LogicalNode plan = planner.createPlan(expr).getRootBlock().getRoot();
  JoinNode joinNode = PlannerUtil.findTopNode(plan, NodeType.JOIN);
  Enforcer enforcer = new Enforcer();
  enforcer.enforceJoinAlgorithm(joinNode.getPID(), JoinAlgorithm.IN_MEMORY_HASH_JOIN);

  FileFragment[] dep3Frags = StorageManager.splitNG(conf, "dep3", dep3.getMeta(), dep3.getPath(), Integer.MAX_VALUE);
  FileFragment[] emp3Frags = StorageManager.splitNG(conf, "emp3", emp3.getMeta(), emp3.getPath(), Integer.MAX_VALUE);
  FileFragment[] merged = TUtil.concat(dep3Frags, emp3Frags);

  Path workDir = CommonTestingUtil.getTestDir("target/test-data/TestFullOuterHashJoinExec0");
  TaskAttemptContext ctx = new TaskAttemptContext(conf,
      LocalTajoTestingUtility.newQueryUnitAttemptId(), merged, workDir);
  ctx.setEnforcer(enforcer);

  PhysicalPlanner phyPlanner = new PhysicalPlannerImpl(conf, sm);
  PhysicalExec exec = phyPlanner.createPlan(ctx, plan);

  ProjectionExec proj = (ProjectionExec) exec;
  assertTrue(proj.getChild() instanceof HashFullOuterJoinExec);

  int count = 0;
  exec.init();

  while (exec.next() != null) {
    //TODO check contents
    count = count + 1;
  }
  assertNull(exec.next());
  exec.close();
  assertEquals(12, count);

}