Method initialize

bolt/exec/HashProbe.cpp:209–267

}

void HashProbe::initialize() {
  Operator::initialize();
  auto jitRowEqVectors =
      operatorCtx_->driverCtx()->queryConfig().enableJitRowEqVectors();
  BOLT_CHECK(hashers_.empty());
  hashers_ = createVectorHashers(probeType_, joinNode_->leftKeys());

  const auto numKeys = hashers_.size();
  keyChannels_.reserve(numKeys);
  for (auto& hasher : hashers_) {
    keyChannels_.push_back(hasher->channel());
  }

  BOLT_CHECK_NULL(lookup_);
  lookup_ = std::make_unique<HashLookup>(hashers_, jitRowEqVectors);
  auto buildType = joinNode_->sources()[1]->outputType();
  auto tableType =
      makeTableType(buildType.get(), joinNode_->rightKeys(), joinNode_);
  if (joinNode_->filter()) {
    initializeFilter(joinNode_->filter(), probeType_, tableType);
  }

  size_t numIdentityProjections = 0;
  for (auto i = 0; i < probeType_->size(); ++i) {
    auto& name = probeType_->nameOf(i);
    auto outIndex = outputType_->getChildIdxIfExists(name);
    if (!outIndex.has_value()) {
      continue;
    }
    projectedInputColumns_.emplace_back(i, *outIndex);
    if (!isRightJoin(joinType_) && !isFullJoin(joinType_)) {
      identityProjections_.emplace_back(i, *outIndex);
      if (*outIndex == i) {
        ++numIdentityProjections;
      }
    }
  }

  for (column_index_t i = 0; i < outputType_->size(); ++i) {
    auto tableChannel = tableType->getChildIdxIfExists(outputType_->nameOf(i));
    if (tableChannel.has_value()) {
      tableOutputProjections_.emplace_back(tableChannel.value(), i);
      if (!hitSampling_ &&
          (outputType_->childAt(i)->kind() == TypeKind::VARCHAR ||
           outputType_->childAt(i)->kind() == TypeKind::VARBINARY)) {
        hitSampling_ = true;
      }
    }
  }

  if (numIdentityProjections == probeType_->size() &&
      tableOutputProjections_.empty()) {
    isIdentityProjection_ = true;
  }

  if (nullAware_) {
    filterTableResult_.resize(1);
  }