Function TEST

cpp/src/arrow/dataset/scanner_test.cc:74–114

}

TEST(BasicEvolution, MissingColumn) {
  std::unique_ptr<DatasetEvolutionStrategy> strategy =
      MakeBasicDatasetEvolutionStrategy();

  std::shared_ptr<Schema> dataset_schema =
      schema({field("A", int32()), field("B", int16()), field("C", int64())});
  std::unique_ptr<Dataset> dataset = MakeDatasetFromSchema(dataset_schema);
  std::unique_ptr<Fragment> fragment = MakeSomeFragment(std::move(dataset_schema));

  InspectedFragment inspected{{"A", "B"}};
  std::unique_ptr<FragmentEvolutionStrategy> fragment_strategy =
      strategy->GetStrategy(*dataset, *fragment, inspected);

  compute::Expression filter = equal(field_ref("C"), literal(INT64_C(7)));
  // If, after simplification, a filter somehow still references a missing field
  // then it is an error.
  ASSERT_RAISES(Invalid, fragment_strategy->DevolveFilter(filter));
  std::vector<FieldPath> selection{FieldPath({0}), FieldPath({2})};
  // Basic strategy should provide is_null guarantee for missing fields
  compute::Expression expected_guarantee = is_null(field_ref(2));
  ASSERT_OK_AND_ASSIGN(compute::Expression guarantee,
                       fragment_strategy->GetGuarantee(selection));
  ASSERT_EQ(expected_guarantee, guarantee);

  // Basic strategy should drop missing fields from selection
  ASSERT_OK_AND_ASSIGN(std::unique_ptr<FragmentSelection> devolved_selection,
                       fragment_strategy->DevolveSelection(selection));
  ASSERT_EQ(1, devolved_selection->columns().size());
  ASSERT_EQ(FieldPath({0}), devolved_selection->columns()[0].path);
  ASSERT_EQ(*int32(), *devolved_selection->columns()[0].requested_type);

  // Basic strategy should append null column to batches for missing column
  std::shared_ptr<RecordBatch> devolved_batch =
      RecordBatchFromJSON(schema({field("A", int32())}), R"([[1], [2], [3]])");
  ASSERT_OK_AND_ASSIGN(
      compute::ExecBatch evolved_batch,
      fragment_strategy->EvolveBatch(devolved_batch, selection, *devolved_selection));
  ASSERT_EQ(2, evolved_batch.values.size());
  AssertArraysEqual(*devolved_batch->column(0), *evolved_batch[0].make_array());
  ASSERT_EQ(*MakeNullScalar(int64()), *evolved_batch.values[1].scalar());
}

TEST(BasicEvolution, ReorderedColumns) {
  std::unique_ptr<DatasetEvolutionStrategy> strategy =