Method makeValueIdsDecoded

bolt/exec/VectorHasher.cpp:251–308

template <typename T, bool mayHaveNulls>
bool VectorHasher::makeValueIdsDecoded(
    const SelectivityVector& rows,
    uint64_t* result) {
  auto indices = decoded_.indices();
  auto values = decoded_.data<T>();
  bool success = true;

  if (rows.countSelected() <= decoded_.base()->size()) {
    // Cache is not beneficial in this case and we don't use them.
    auto* nulls = decoded_.nulls(&rows);
    rows.applyToSelected([&](vector_size_t row) INLINE_LAMBDA {
      makeValueIdForOneRow<T, mayHaveNulls>(
          nulls, row, values, indices[row], result, success);
    });
    return success;
  }

  cachedHashes_.resize(decoded_.base()->size());
  std::fill(cachedHashes_.begin(), cachedHashes_.end(), 0);

  int numCachedHashes = 0;
  rows.testSelected([&](vector_size_t row) INLINE_LAMBDA {
    if constexpr (mayHaveNulls) {
      if (decoded_.isNullAt(row)) {
        if (multiplier_ == 1) {
          result[row] = 0;
        }
        return true;
      }
    }

    auto baseIndex = indices[row];
    uint64_t& id = cachedHashes_[baseIndex];

    if (success) {
      if (id == 0) {
        T value = values[baseIndex];
        id = valueId(value);
        numCachedHashes++;
        if (id == kUnmappable) {
          analyzeValue(value);
          success = false;
        }
      }
      result[row] = multiplier_ == 1 ? id : result[row] + multiplier_ * id;
    } else {
      if (id == 0) {
        id = kUnmappable;
        numCachedHashes++;
        analyzeValue(values[baseIndex]);
      }
    }

    return success || numCachedHashes < cachedHashes_.size();
  });

  return success;
}