Function ChunkedArray__from_list

r/src/chunkedarray.cpp:100–146

[[arrow::export]]

// [[arrow::export]]
std::shared_ptr<arrow::ChunkedArray> ChunkedArray__from_list(cpp11::list chunks,
                                                             SEXP s_type) {
  std::vector<std::shared_ptr<arrow::Array>> vec;

  // the type might be NULL, in which case we need to infer it from the data
  // we keep track of whether it was inferred or supplied
  bool type_inferred = Rf_isNull(s_type);
  R_xlen_t n = XLENGTH(chunks);

  std::shared_ptr<arrow::DataType> type;
  if (type_inferred) {
    if (n == 0) {
      cpp11::stop("type must be specified for empty list");
    }
    type = arrow::r::InferArrowType(VECTOR_ELT(chunks, 0));
  } else {
    type = cpp11::as_cpp<std::shared_ptr<arrow::DataType>>(s_type);
  }

  if (n == 0) {
    std::shared_ptr<arrow::Array> array;
    std::unique_ptr<arrow::ArrayBuilder> type_builder;
    StopIfNotOk(arrow::MakeBuilder(gc_memory_pool(), type, &type_builder));
    StopIfNotOk(type_builder->Finish(&array));
    vec.push_back(array);
  } else {
    // the first - might differ from the rest of the loop
    // because we might have inferred the type from the first element of the list
    //
    // this only really matters for dictionary arrays
    auto chunked_array =
        arrow::r::vec_to_arrow_ChunkedArray(chunks[0], type, type_inferred);
    for (const auto& chunk : chunked_array->chunks()) {
      vec.push_back(chunk);
    }

    for (R_xlen_t i = 1; i < n; i++) {
      chunked_array = arrow::r::vec_to_arrow_ChunkedArray(chunks[i], type, false);
      for (const auto& chunk : chunked_array->chunks()) {
        vec.push_back(chunk);
      }
    }
  }

  // Use Make so we validate that chunk types are all the same
  return ValueOrStop(arrow::ChunkedArray::Make(std::move(vec)));
}

// [[arrow::export]]
r_vec_size ChunkedArray__ReferencedBufferSize(