Function MinimalEndToEndScan

cpp/src/arrow/dataset/scanner_benchmark.cc:101–141

size_t GetBytesForSchema() { return sizeof(int32_t) + sizeof(bool); }

void MinimalEndToEndScan(
    size_t num_batches, size_t batch_size, const std::string& factory_name,
    std::function<Result<std::shared_ptr<acero::ExecNodeOptions>>(size_t, size_t)>
        options_factory) {
  // ensure arrow::dataset node factories are in the registry
  ::arrow::dataset::internal::Initialize();

  // A ScanNode is constructed from a Dataset (whose batches will be scanned), and
  // ScanOptions (to specify a filter for predicate pushdown, a projection to skip
  // materialization of unnecessary columns,
  // ...)
  RecordBatchVector batches = GetBatches(num_batches, batch_size);

  std::shared_ptr<Dataset> dataset =
      std::make_shared<InMemoryDataset>(GetSchema(), batches);

  ASSERT_OK_AND_ASSIGN(std::shared_ptr<acero::ExecNodeOptions> node_options,
                       options_factory(num_batches, batch_size));

  // construct the scan node
  acero::Declaration scan(factory_name, std::move(node_options));

  // pipe the scan node into a filter node
  compute::Expression b_is_true = equal(field_ref("b"), literal(true));
  acero::Declaration filter("filter", {std::move(scan)},
                            acero::FilterNodeOptions{b_is_true});

  // pipe the filter node into a project node
  // NB: we're using the project node factory which preserves fragment/batch index
  // tagging, so we *can* reorder later if we choose. The tags will not appear in
  // our output.
  compute::Expression a_times_2 = call("multiply", {field_ref("a"), literal(2)});
  acero::Declaration project("project", {std::move(filter)},
                             acero::ProjectNodeOptions{{a_times_2}, {"a*2"}});

  // Consume the plan and transform into a table
  ASSERT_OK_AND_ASSIGN(std::shared_ptr<Table> collected,
                       acero::DeclarationToTable(std::move(project)));

  ASSERT_GT(collected->num_rows(), 0);
}

void ScanOnly(
    size_t num_batches, size_t batch_size, const std::string& factory_name,