Method TryConvertChunk

cpp/src/arrow/csv/column_builder.cc:269–328

}

Status InferringColumnBuilder::TryConvertChunk(int64_t chunk_index) {
  std::unique_lock<std::mutex> lock(mutex_);
  std::shared_ptr<Converter> converter = converter_;
  std::shared_ptr<BlockParser> parser = parsers_[chunk_index];
  InferKind kind = infer_status_.kind();

  if (chunks_[chunk_index] && chunk_kinds_[chunk_index] == kind) {
    // Already tried, nothing to do
    return Status::OK();
  }

  DCHECK_NE(parser, nullptr) << " for chunk_index " << chunk_index;

  lock.unlock();
  auto maybe_array = converter->Convert(*parser, col_index_);
  lock.lock();

  if (kind != infer_status_.kind()) {
    // infer_kind_ was changed by another task, reconvert
    lock.unlock();
    ScheduleConvertChunk(chunk_index);
    return Status::OK();
  }

  if (maybe_array.ok() || !infer_status_.can_loosen_type()) {
    // Conversion succeeded, or failed definitively
    if (!infer_status_.can_loosen_type()) {
      // We won't try to reconvert anymore
      parsers_[chunk_index].reset();
    }
    chunk_kinds_[chunk_index] = kind;
    return SetChunkUnlocked(chunk_index, maybe_array);
  }

  // Conversion failed, try another type
  infer_status_.LoosenType(maybe_array.status());
  RETURN_NOT_OK(UpdateType());
  kind = infer_status_.kind();

  // Reconvert past finished chunks
  // (unfinished chunks will notice by themselves if they need reconverting)
  const auto nchunks = static_cast<int64_t>(chunks_.size());
  std::vector<int64_t> chunks_to_reconvert;
  for (int64_t i = 0; i < nchunks; ++i) {
    if (i != chunk_index && chunks_[i] && chunk_kinds_[i] != kind) {
      // That chunk was converted using the wrong type
      chunks_[i].reset();
      chunk_kinds_[i].reset();
      chunks_to_reconvert.push_back(i);
    }
  }
  // Reconvert this chunk too
  chunks_to_reconvert.push_back(chunk_index);

  lock.unlock();
  for (auto i : chunks_to_reconvert) {
    ScheduleConvertChunk(i);
  }