Function from_record_batches

matlab/src/cpp/arrow/matlab/tabular/proxy/table.cc:121–156

}

libmexclass::proxy::MakeResult from_record_batches(const mda::StructArray& opts) {
  using RecordBatchProxy = arrow::matlab::tabular::proxy::RecordBatch;
  using TableProxy = arrow::matlab::tabular::proxy::Table;

  size_t num_rows = 0;
  const mda::TypedArray<uint64_t> record_batch_proxy_ids = opts[0]["RecordBatchProxyIDs"];

  std::vector<std::shared_ptr<arrow::RecordBatch>> record_batches;
  // Retrieve all of the Arrow RecordBatch Proxy instances from the libmexclass
  // ProxyManager.
  for (const auto& proxy_id : record_batch_proxy_ids) {
    auto proxy = libmexclass::proxy::ProxyManager::getProxy(proxy_id);
    auto record_batch_proxy = std::static_pointer_cast<RecordBatch>(proxy);
    auto record_batch = record_batch_proxy->unwrap();
    record_batches.push_back(record_batch);
    num_rows += record_batches.back()->num_rows();
  }

  // The MATLAB client code that calls this function is responsible for pre-validating
  // that this function is called with at least one RecordBatch.
  auto schema = record_batches[0]->schema();
  size_t num_columns = schema->num_fields();
  std::vector<std::shared_ptr<ChunkedArray>> columns(num_columns);

  size_t num_batches = record_batches.size();

  for (size_t i = 0; i < num_columns; ++i) {
    std::vector<std::shared_ptr<Array>> column_arrays(num_batches);
    for (size_t j = 0; j < num_batches; ++j) {
      column_arrays[j] = record_batches[j]->column(i);
    }
    columns[i] = std::make_shared<ChunkedArray>(column_arrays, schema->field(i)->type());
  }
  const auto table = arrow::Table::Make(std::move(schema), std::move(columns), num_rows);
  return std::make_shared<TableProxy>(table);
}
}  // anonymous namespace

libmexclass::proxy::MakeResult Table::make(