Java JoinRelType.LEFT属性代码示例

public JoinOutcome getOutcome() {
  if (!ok) {
    return JoinOutcome.FAILURE;
  }
  if (bothMatches(IterOutcome.NONE) ||
          (joinType == JoinRelType.INNER && eitherMatches(IterOutcome.NONE)) ||
          (joinType == JoinRelType.LEFT && lastLeft == IterOutcome.NONE) ||
          (joinType == JoinRelType.RIGHT && lastRight == IterOutcome.NONE)) {
    return JoinOutcome.NO_MORE_DATA;
  }
  if (bothMatches(IterOutcome.OK) ||
          (eitherMatches(IterOutcome.NONE) && eitherMatches(IterOutcome.OK))) {
    return JoinOutcome.BATCH_RETURNED;
  }
  if (eitherMatches(IterOutcome.OK_NEW_SCHEMA)) {
    return JoinOutcome.SCHEMA_CHANGED;
  }
  if (eitherMatches(IterOutcome.NOT_YET)) {
    return JoinOutcome.WAITING;
  }
  return JoinOutcome.FAILURE;
}
 

@Override
protected boolean checkPreconditions(JoinRel join, RelNode left, RelNode right,
    PlannerSettings settings) {
  JoinRelType type = join.getJoinType();

  if (! (type == JoinRelType.INNER || type == JoinRelType.LEFT)) {
    return false;
  }

  JoinCategory category = JoinUtils.getJoinCategory(left, right, join.getCondition(),
      Lists.<Integer>newArrayList(), Lists.<Integer>newArrayList(), Lists.<Boolean>newArrayList());
  if (category == JoinCategory.EQUALITY
      && (settings.isHashJoinEnabled() || settings.isMergeJoinEnabled())) {
    return false;
  }

  if (settings.isNlJoinForScalarOnly()) {
    if (JoinUtils.isScalarSubquery(left) || JoinUtils.isScalarSubquery(right)) {
      return true;
    } else {
      return false;
    }
  }

  return true;
}
 

@Override
public void noMoreToConsumeRight() throws Exception {
  state.is(State.CAN_CONSUME_R);

  if (table.size() == 0 && !(joinType == JoinRelType.LEFT || joinType == JoinRelType.FULL)) {
    // nothing needs to be read on the left side as right side is empty
    state = State.DONE;
    return;
  }

  this.probe = new VectorizedProbe(
      context.getAllocator(),
      hyperContainer,
      left,
      probeOutputs,
      buildOutputs,
      config.getJoinType(),
      buildInfoList,
      startIndices,
      table,
      probePivot,
      context.getTargetBatchSize(),
      comparator);
  state = State.CAN_CONSUME_L;
}
 

@Override
protected boolean checkPreconditions(DrillJoinRel join, RelNode left, RelNode right,
    PlannerSettings settings) {
  JoinRelType type = join.getJoinType();

  if (! (type == JoinRelType.INNER || type == JoinRelType.LEFT)) {
    return false;
  }

  List<Integer> leftKeys = Lists.newArrayList();
  List<Integer> rightKeys = Lists.newArrayList() ;
  JoinCategory category = JoinUtils.getJoinCategory(left, right, join.getCondition(), leftKeys, rightKeys);
  if (category == JoinCategory.EQUALITY
      && (settings.isHashJoinEnabled() || settings.isMergeJoinEnabled())) {
    return false;
  }

  if (settings.isNlJoinForScalarOnly()) {
    if (JoinUtils.isScalarSubquery(left) || JoinUtils.isScalarSubquery(right)) {
      return true;
    } else {
      return false;
    }
  }

  return true;
}
 

protected boolean checkBroadcastConditions(RelOptPlanner planner, DrillJoinRel join, RelNode left, RelNode right) {

    double estimatedRightRowCount = RelMetadataQuery.getRowCount(right);
    if (estimatedRightRowCount < PrelUtil.getSettings(join.getCluster()).getBroadcastThreshold()
        && ! left.getTraitSet().getTrait(DrillDistributionTraitDef.INSTANCE).equals(DrillDistributionTrait.SINGLETON)
        && (join.getJoinType() == JoinRelType.INNER || join.getJoinType() == JoinRelType.LEFT)
        ) {
      return true;
    }
    return false;
  }
 

public HashJoinPOP flipIfRight(){
    if(joinType == JoinRelType.RIGHT){
        List<JoinCondition> flippedConditions = Lists.newArrayList();
        for(JoinCondition c : conditions){
            flippedConditions.add(c.flip());
        }
        return new HashJoinPOP(right, left, flippedConditions, JoinRelType.LEFT);
    }else{
        return this;
    }
}
 

public MergeJoinPOP flipIfRight(){
  if(joinType == JoinRelType.RIGHT){
    List<JoinCondition> flippedConditions = Lists.newArrayList();
    for(JoinCondition c : conditions){
      flippedConditions.add(c.flip());
    }
    return new MergeJoinPOP(right, left, flippedConditions, JoinRelType.LEFT);
  }else{
    return this;
  }

}
 

protected boolean checkBroadcastConditions(RelOptPlanner planner, JoinRel join, RelNode left, RelNode right) {
  final RelMetadataQuery mq = join.getCluster().getMetadataQuery();
  // right node is the one that is being considered to be broadcasted
  final double rightRowCount = mq.getRowCount(right);
  if (rightRowCount < PrelUtil.getSettings(join.getCluster()).getBroadcastThreshold()
      && ! left.getTraitSet().getTrait(DistributionTraitDef.INSTANCE).equals(DistributionTrait.SINGLETON)
      && (join.getJoinType() == JoinRelType.INNER || join.getJoinType() == JoinRelType.LEFT)) {
    // DX-3862:  For broadcast joins, the cost should not just consider the traits and join type.  If the broadcast table is small enough,
    // we shouldn't need to worry too much and allow broadcast join and see what the planner picks.
    final PlannerSettings plannerSettings = PrelUtil.getSettings(join.getCluster());
    if (rightRowCount <= plannerSettings.getOptions().getOption(PlannerSettings.BROADCAST_MIN_THRESHOLD)) {
      logger.debug("Enable broadcast plan? true (rightRowCount %d smaller than minimum broadcast threshold)", rightRowCount);
      return true;
    }

    // In this case, the broadcast table is big-ish.  So, we should check to see if it is reasonable to do broadcast.
    // The broadcasted table will be sent at most (numEndPoints * maxWidthPerNode) times, (rightRowCount) rows.  We add a
    // penalty to broadcast (broadcastFactor).
    final double broadcastFactor = plannerSettings.getBroadcastFactor();
    final double leftRowCount = mq.getRowCount(left);

    final int numEndPoints = plannerSettings.numEndPoints();
    final long maxWidthPerNode = plannerSettings.getNumCoresPerExecutor();
    final long maxWidthPerQuery = plannerSettings.getOptions().getOption(ExecConstants.MAX_WIDTH_GLOBAL);
    final long sliceTarget = plannerSettings.getSliceTarget();
    final double minFactor = Doubles.min(leftRowCount * 1.0 / sliceTarget, numEndPoints * maxWidthPerNode, maxWidthPerQuery);
    final boolean enableBroadCast = (minFactor * broadcastFactor < leftRowCount);
    logger.debug("Enable broadcast plan? %s minFactor %d (numEndPoints %d, maxWidthPerNode %d, rightRowCount %d, broadcastFactor %d, leftRowCount %d, sliceTarget %d, maxWidthPerQuery %d)",
        enableBroadCast, minFactor, numEndPoints, maxWidthPerNode, rightRowCount, broadcastFactor, leftRowCount, sliceTarget, maxWidthPerQuery);
    return enableBroadCast;
  }
  return false;
}
 

@Override
public void setupHashJoinProbe(
    FunctionContext functionContext,
    VectorAccessible buildBatch,
    VectorAccessible probeBatch,
    VectorAccessible outgoing,
    HashTable hashTable,
    JoinRelType joinRelType,
    List<BuildInfo> buildInfos,
    List<ArrowBuf> startIndices,
    int targetRecordsPerBatch) {

  links = new ArrowBuf[buildInfos.size()];
  matches = new BitSet[buildInfos.size()];
  matchMaxes = new int[buildInfos.size()];

  for (int i =0; i < links.length; i++) {
    links[i] = buildInfos.get(i).getLinks();
    matches[i] = buildInfos.get(i).getKeyMatchBitVector();
    matchMaxes[i] = buildInfos.get(i).getRecordCount();
  }

  starts = new ArrowBuf[startIndices.size()];
  for (int i = 0; i < starts.length; i++) {
    starts[i] = startIndices.get(i);
  }

  this.probeBatch = probeBatch;
  this.projectUnmatchedProbe = joinRelType == JoinRelType.LEFT || joinRelType == JoinRelType.FULL;
  this.projectUnmatchedBuild = joinRelType == JoinRelType.RIGHT || joinRelType == JoinRelType.FULL;
  this.hashTable = hashTable;
  this.targetRecordsPerBatch = targetRecordsPerBatch;

  doSetup(functionContext, buildBatch, probeBatch, outgoing);
}
 

@Override
public void noMoreToConsumeRight() throws Exception {
  state.is(State.CAN_CONSUME_R);

  if (hashTable.size() == 0 && !(joinType == JoinRelType.LEFT || joinType == JoinRelType.FULL)) {
    // nothing needs to be read on the left side as right side is empty
    state = State.DONE;
    return;
  }
  this.hashJoinProbe = setupHashJoinProbe();
  state = State.CAN_CONSUME_L;
}
 

public VectorizedProbe(
    BufferAllocator allocator,
    final ExpandableHyperContainer buildBatch,
    final VectorAccessible probeBatch,
    final List<FieldVector> probeOutputs,
    final List<FieldVector> buildOutputs,
    JoinRelType joinRelType,
    List<BuildInfo> buildInfos,
    List<ArrowBuf> startIndices,
    JoinTable table,
    PivotDef pivot,
    int targetRecordsPerBatch,
    final NullComparator nullMask){

  this.nullMask = nullMask;
  this.pivot = pivot;
  this.allocator = allocator;
  this.table = table;
  this.links = new ArrowBuf[buildInfos.size()];
  this.matches = new BitSet[buildInfos.size()];
  this.matchMaxes = new int[buildInfos.size()];

  for (int i =0; i < links.length; i++) {
    links[i] = buildInfos.get(i).getLinks();
    matches[i] = buildInfos.get(i).getKeyMatchBitVector();
    matchMaxes[i] = buildInfos.get(i).getRecordCount();
  }

  this.starts = new ArrowBuf[startIndices.size()];
  for (int i = 0; i < starts.length; i++) {
    starts[i] = startIndices.get(i);
  }

  this.projectUnmatchedBuild = joinRelType == JoinRelType.RIGHT || joinRelType == JoinRelType.FULL;
  this.projectUnmatchedProbe = joinRelType == JoinRelType.LEFT || joinRelType == JoinRelType.FULL;
  this.targetRecordsPerBatch = targetRecordsPerBatch;
  this.projectProbeSv2 = allocator.buffer(targetRecordsPerBatch * 2);
  this.probeSv2Addr = projectProbeSv2.memoryAddress();
  // first 4 bytes (int) are for batch index and rest 2 bytes are offset within the batch
  this.projectBuildOffsetBuf = allocator.buffer(targetRecordsPerBatch * BUILD_RECORD_LINK_SIZE);
  this.projectBuildOffsetAddr = projectBuildOffsetBuf.memoryAddress();

  if(table.size() > 0){
    this.buildCopiers = projectUnmatchedProbe  ?
        ConditionalFieldBufferCopier6.getFourByteCopiers(VectorContainer.getHyperFieldVectors(buildBatch), buildOutputs) :
        FieldBufferCopier6.getFourByteCopiers(VectorContainer.getHyperFieldVectors(buildBatch), buildOutputs);
  }else {
    this.buildCopiers = Collections.emptyList();
  }

  this.probeCopiers = FieldBufferCopier.getCopiers(VectorContainer.getFieldVectors(probeBatch), probeOutputs);
}