Function MakeRunEndEncoded

cpp/src/arrow/ipc/test_common.cc:643–683

}  // namespace

Status MakeRunEndEncoded(std::shared_ptr<RecordBatch>* out) {
  const int64_t logical_length = 10000;
  const int64_t slice_offset = 2000;
  random::RandomArrayGenerator rand(/*seed =*/1);
  std::vector<std::shared_ptr<Array>> all_arrays;
  std::vector<std::shared_ptr<Field>> all_fields;
  for (const bool sliced : {false, true}) {
    const int64_t generate_length =
        sliced ? logical_length + 2 * slice_offset : logical_length;

    std::vector<std::shared_ptr<Array>> arrays = {
        rand.RunEndEncoded(int32(), generate_length, 0.5),
        rand.RunEndEncoded(int32(), generate_length, 0),
        rand.RunEndEncoded(utf8(), generate_length, 0.5),
        rand.RunEndEncoded(list(int32()), generate_length, 0.5),
    };
    std::vector<std::shared_ptr<Field>> fields = {
        field("ree_int32", run_end_encoded(int32(), int32())),
        field("ree_int32_not_null", run_end_encoded(int32(), int32()), false),
        field("ree_string", run_end_encoded(int32(), utf8())),
        field("ree_list", run_end_encoded(int32(), list(int32()))),
    };

    if (sliced) {
      for (auto& array : arrays) {
        ARROW_RETURN_NOT_OK(
            AddArtificialOffsetInChildArray(array->data().get(), slice_offset));
        array = array->Slice(slice_offset, logical_length);
      }
      for (auto& item : fields) {
        item = field(item->name() + "_sliced", item->type(), item->nullable(),
                     item->metadata());
      }
    }

    all_arrays.insert(all_arrays.end(), arrays.begin(), arrays.end());
    all_fields.insert(all_fields.end(), fields.begin(), fields.end());
  }
  *out = RecordBatch::Make(schema(all_fields), logical_length, all_arrays);
  return Status::OK();
}

Status MakeUnion(std::shared_ptr<RecordBatch>* out) {
  // Define schema