Method Prepare

be/src/exec/blocking-join-node.cc:74–139

}

Status BlockingJoinNode::Prepare(RuntimeState* state) {
  DCHECK_EQ(UseSeparateBuild(state->query_options()) ? 1 : 2, children_.size());
  SCOPED_TIMER(runtime_profile_->total_time_counter());
  RETURN_IF_ERROR(ExecNode::Prepare(state));

  probe_timer_ = ADD_TIMER(runtime_profile(), "ProbeTime");
  probe_row_counter_ = ADD_COUNTER(runtime_profile(), "ProbeRows", TUnit::UNIT);

  // The right child (if present) must match the build row layout.
  DCHECK(children_.size() == 1 || build_row_desc().Equals(*children_[1]->row_desc()))
      << build_row_desc().DebugString() << " " << children_[1]->row_desc()->DebugString();
  // Validate the row desc layout is what we expect because the current join
  // implementation relies on it to enable some optimizations.
  int num_probe_tuples = probe_row_desc().tuple_descriptors().size();
  int num_build_tuples = build_row_desc().tuple_descriptors().size();

#ifndef NDEBUG
  switch (join_op_) {
    case TJoinOp::LEFT_ANTI_JOIN:
    case TJoinOp::LEFT_SEMI_JOIN:
    case TJoinOp::NULL_AWARE_LEFT_ANTI_JOIN:
    case TJoinOp::ICEBERG_DELETE_JOIN: {
      // Only return the surviving probe-side tuples.
      DCHECK(row_desc()->Equals(probe_row_desc()));
      break;
    }
    case TJoinOp::RIGHT_ANTI_JOIN:
    case TJoinOp::RIGHT_SEMI_JOIN: {
      // Only return the surviving build-side tuples.
      DCHECK(row_desc()->Equals(build_row_desc()));
      break;
    }
    default: {
      // The join node returns a row that is a concatenation of the left side and build
      // side row desc's. For example if the probe row had 1 tuple and the build row had
      // 2, the resulting row desc of the join node would have 3 tuples with:
      //   result[0] = left[0]
      //   result[1] = build[0]
      //   result[2] = build[1]
      for (int i = 0; i < num_probe_tuples; ++i) {
        TupleDescriptor* desc = probe_row_desc().tuple_descriptors()[i];
        DCHECK_EQ(i, row_desc()->GetTupleIdx(desc->id()));
      }
      for (int i = 0; i < num_build_tuples; ++i) {
        TupleDescriptor* desc = build_row_desc().tuple_descriptors()[i];
        DCHECK_EQ(num_probe_tuples + i, row_desc()->GetTupleIdx(desc->id()))
            << row_desc()->DebugString() << "\n" << probe_row_desc().DebugString() << "\n"
            << build_row_desc().DebugString();
      }
      break;
    }
  }
#endif

  probe_tuple_row_size_ = num_probe_tuples * sizeof(Tuple*);
  build_tuple_row_size_ = num_build_tuples * sizeof(Tuple*);

  if (IsSemiJoin(join_op_)) {