Class SimpleRecordBatch

cpp/src/arrow/record_batch.cc:66–216

\class SimpleRecordBatch \brief A basic, non-lazy in-memory record batch

/// \class SimpleRecordBatch
/// \brief A basic, non-lazy in-memory record batch
class SimpleRecordBatch : public RecordBatch {
 public:
  SimpleRecordBatch(std::shared_ptr<Schema> schema, int64_t num_rows,
                    std::vector<std::shared_ptr<Array>> columns,
                    std::shared_ptr<Device::SyncEvent> sync_event = nullptr)
      : RecordBatch(std::move(schema), num_rows),
        boxed_columns_(std::move(columns)),
        device_type_(DeviceAllocationType::kCPU),
        sync_event_(std::move(sync_event)) {
    if (boxed_columns_.size() > 0) {
      device_type_ = boxed_columns_[0]->device_type();
    }

    columns_.resize(boxed_columns_.size());
    for (size_t i = 0; i < columns_.size(); ++i) {
      columns_[i] = boxed_columns_[i]->data();
      DCHECK_EQ(device_type_, columns_[i]->device_type());
    }
  }

  SimpleRecordBatch(std::shared_ptr<Schema> schema, int64_t num_rows,
                    std::vector<std::shared_ptr<ArrayData>> columns,
                    DeviceAllocationType device_type = DeviceAllocationType::kCPU,
                    std::shared_ptr<Device::SyncEvent> sync_event = nullptr)
      : RecordBatch(std::move(schema), num_rows),
        columns_(std::move(columns)),
        device_type_(device_type),
        sync_event_(std::move(sync_event)) {
    boxed_columns_.resize(schema_->num_fields());
  }

  const std::vector<std::shared_ptr<Array>>& columns() const override {
    std::lock_guard lock(mutex_);
    for (int i = 0; i < num_columns(); ++i) {
      if (!boxed_columns_[i]) {
        boxed_columns_[i] = MakeArray(columns_[i]);
      }
    }
    return boxed_columns_;
  }

  std::shared_ptr<Array> column(int i) const override {
    std::lock_guard lock(mutex_);
    if (!boxed_columns_[i]) {
      boxed_columns_[i] = MakeArray(columns_[i]);
    }
    return boxed_columns_[i];
  }

  std::shared_ptr<ArrayData> column_data(int i) const override { return columns_[i]; }

  const ArrayDataVector& column_data() const override { return columns_; }

  Result<std::shared_ptr<RecordBatch>> AddColumn(
      int i, const std::shared_ptr<Field>& field,
      const std::shared_ptr<Array>& column) const override {
    ARROW_CHECK(field != nullptr);
    ARROW_CHECK(column != nullptr);