Method listJoinResultsInternal

bolt/exec/HashTable.cpp:1928–1994

template <bool ignoreNullKeys>
template <bool hasMatchFlags>
int32_t HashTable<ignoreNullKeys>::listJoinResultsInternal(
    JoinResultIterator& iter,
    bool includeMisses,
    folly::Range<vector_size_t*> inputRows,
    folly::Range<char**> hits,
    const BaseVector* matchFlags) {
  BOLT_CHECK_LE(inputRows.size(), hits.size());

  if constexpr (!hasMatchFlags) {
    if (!hasDuplicates_) {
      return listJoinResultsNoDuplicates(iter, includeMisses, inputRows, hits);
    }
  }
  const FlatVector<bool>* flags = nullptr;
  if constexpr (hasMatchFlags) {
    flags = matchFlags->as<FlatVector<bool>>();
  }

  size_t numOut = 0;
  auto maxOut = inputRows.size();
  while (iter.lastRowIndex < iter.rows->size()) {
    if (!iter.nextHit) {
      auto row = (*iter.rows)[iter.lastRowIndex];
      iter.nextHit = (*iter.hits)[row]; // NOLINT
      if (!iter.nextHit) {
        ++iter.lastRowIndex;
        if (includeMisses) {
          if constexpr (hasMatchFlags) {
            // the probe side has ever matched with build side
            // do not include it
            if (flags->valueAtFast(row)) {
              continue;
            }
          }
          inputRows[numOut] = row; // NOLINT
          hits[numOut] = nullptr;
          ++numOut;
          if (numOut >= maxOut) {
            return numOut;
          }
        }
        continue;
      }
    }

    while (iter.nextHit) {
      char* next = nullptr;
      if (nextOffset_) {
        next = nextRow(iter.nextHit);
        if (next) {
          __builtin_prefetch(reinterpret_cast<char*>(next) + nextOffset_);
        }
      }
      inputRows[numOut] = (*iter.rows)[iter.lastRowIndex]; // NOLINT
      hits[numOut] = iter.nextHit;
      ++numOut;
      iter.nextHit = next;
      if (!iter.nextHit) {