Method Prepare

be/src/exec/hbase/hbase-scan-node.cc:65–131

}

Status HBaseScanNode::Prepare(RuntimeState* state) {
  RETURN_IF_ERROR(ScanNode::Prepare(state));
  hbase_read_timer_ = PROFILE_TotalRawHBaseReadTime.Instantiate(runtime_profile());
  AddBytesReadCounters();

  hbase_scanner_.reset(
      new HBaseTableScanner(this, ExecEnv::GetInstance()->htable_factory(), state));

  tuple_desc_ = state->desc_tbl().GetTupleDescriptor(tuple_id_);
  if (tuple_desc_ == NULL) {
    // TODO: make sure we print all available diagnostic output to our error log
    return Status("Failed to get tuple descriptor.");
  }
  // The data retrieved from HBase via result_.raw() is sorted by family/qualifier.
  // Here, we re-order the slots from the query by family/qualifier, exploiting the
  // known sort order of the columns retrieved from HBase, to avoid family/qualifier
  // comparisons.
  hbase_table_ = static_cast<const HBaseTableDescriptor*>(tuple_desc_->table_desc());
  const vector<HBaseTableDescriptor::HBaseColumnDescriptor>& cols = hbase_table_->cols();
  const vector<SlotDescriptor*>& slots = tuple_desc_->slots();
  sorted_non_key_slots_.reserve(slots.size());
  for (int i = 0; i < slots.size(); ++i) {
    const HBaseTableDescriptor::HBaseColumnDescriptor& col = cols[slots[i]->col_pos()];
    if (col.family == ":key") {
      row_key_slot_ = slots[i];
      row_key_binary_encoded_ = col.binary_encoded;
    } else {
      sorted_non_key_slots_.push_back(slots[i]);
    }
  }
  // This is not needed if flag use_hms_column_order_for_hbase_tables=false as the columns
  // will be already ordered in the FE, but sort it anyway to avoid relying on this.
  sort(sorted_non_key_slots_.begin(), sorted_non_key_slots_.end(),
      [&](const SlotDescriptor* a, const SlotDescriptor* b) -> bool {
        const HBaseTableDescriptor::HBaseColumnDescriptor& cola = cols[a->col_pos()];
        const HBaseTableDescriptor::HBaseColumnDescriptor& colb = cols[b->col_pos()];
        return cola.family == colb.family
            ? cola.qualifier < colb.qualifier : cola.family < colb.family;
      });

  // Create list of family/qualifier pointers in same sort order as sorted_non_key_slots_.
  sorted_cols_.reserve(sorted_non_key_slots_.size());
  for (int i = 0; i < sorted_non_key_slots_.size(); ++i) {
    sorted_cols_.push_back(&cols[sorted_non_key_slots_[i]->col_pos()]);
  }

  // TODO(marcel): add int tuple_idx_[] indexed by TupleId somewhere in runtime-state.h
  tuple_idx_ = 0;

  // Convert ScanRangeParamsPB to ScanRanges
  DCHECK(scan_range_params_ != NULL)
      << "Must call SetScanRanges() before calling Prepare()";
  for (const ScanRangeParamsPB& params : *scan_range_params_) {
    DCHECK(params.scan_range().has_hbase_key_range());
    const HBaseKeyRangePB& key_range = params.scan_range().hbase_key_range();
    scan_range_vector_.push_back(HBaseTableScanner::ScanRange());
    HBaseTableScanner::ScanRange& sr = scan_range_vector_.back();
    if (key_range.has_startkey()) {