Method addToOutputForRightJoin

bolt/exec/MergeJoin.cpp:699–780

    loadColumns(currentLeft_, *operatorCtx_->execCtx());
  }
  return outputSize_ == outputBatchSize_;
}

bool MergeJoin::addToOutputForRightJoin() {
  size_t firstRightBatch;
  vector_size_t rightStartIndex;
  if (rightMatch_->cursor) {
    firstRightBatch = rightMatch_->cursor->batchIndex;
    rightStartIndex = rightMatch_->cursor->index;
  } else {
    firstRightBatch = 0;
    rightStartIndex = rightMatch_->startIndex;
  }

  size_t numRights = rightMatch_->inputs.size();
  for (size_t r = firstRightBatch; r < numRights; ++r) {
    auto right = rightMatch_->inputs[r];
    auto rightStart = r == firstRightBatch ? rightStartIndex : 0;
    auto rightEnd = r == numRights - 1 ? rightMatch_->endIndex : right->size();

    for (auto i = rightStart; i < rightEnd; ++i) {
      auto firstLeftBatch =
          (r == firstRightBatch && i == rightStart && leftMatch_->cursor)
          ? leftMatch_->cursor->batchIndex
          : 0;

      auto leftStartIndex =
          (r == firstRightBatch && i == rightStart && leftMatch_->cursor)
          ? leftMatch_->cursor->index
          : leftMatch_->startIndex;

      auto numLefts = leftMatch_->inputs.size();
      for (size_t l = firstLeftBatch; l < numLefts; ++l) {
        auto left = leftMatch_->inputs[l];
        auto leftStart = l == firstLeftBatch ? leftStartIndex : 0;
        auto leftEnd = l == numLefts - 1 ? leftMatch_->endIndex : left->size();

        if (prepareOutput(left, right)) {
          output_->resize(outputSize_);
          leftMatch_->setCursor(l, leftStart);
          rightMatch_->setCursor(r, i);
          return true;
        }

        // TODO: Since semi joins only require determining if there is at least
        // one match on the other side, we could explore specialized algorithms
        // or data structures that short-circuit the join process once a match
        // is found.
        if (isRightSemiFilterJoin(joinType_) && !filter_) {
          // RightSemiFilter produce each row from the right at most once.
          leftEnd = leftStart + 1;
        }

        for (auto j = leftStart; j < leftEnd; ++j) {
          if (outputSize_ == outputBatchSize_) {
            // If we run out of space in the current output_, we will need to
            // produce a buffer and continue processing left later. In this
            // case, we cannot leave left as a lazy vector, since we cannot have