Method addToOutputForLeftJoin

bolt/exec/MergeJoin.cpp:620–697

  } else {
    return addToOutputForLeftJoin();
  }
}

bool MergeJoin::addToOutputForLeftJoin() {
  size_t firstLeftBatch;
  vector_size_t leftStartIndex;
  if (leftMatch_->cursor) {
    firstLeftBatch = leftMatch_->cursor->batchIndex;
    leftStartIndex = leftMatch_->cursor->index;
  } else {
    firstLeftBatch = 0;
    leftStartIndex = leftMatch_->startIndex;
  }

  size_t 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();

    for (auto i = leftStart; i < leftEnd; ++i) {
      auto firstRightBatch =
          (l == firstLeftBatch && i == leftStart && rightMatch_->cursor)
          ? rightMatch_->cursor->batchIndex
          : 0;

      auto rightStartIndex =
          (l == firstLeftBatch && i == leftStart && rightMatch_->cursor)
          ? rightMatch_->cursor->index
          : rightMatch_->startIndex;

      auto 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();

        if (prepareOutput(left, right)) {
          output_->resize(outputSize_);
          leftMatch_->setCursor(l, i);
          rightMatch_->setCursor(r, rightStart);
          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 (isLeftSemiFilterJoin(joinType_) && !filter_) {
          // LeftSemiFilter produce each row from the left at most once.
          rightEnd = rightStart + 1;
        }

        for (auto j = rightStart; j < rightEnd; ++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