Method TestWriteAndRead

cpp/src/parquet/reader_test.cc:2025–2079

  }

  void TestWriteAndRead(std::shared_ptr<const LogicalType> type, bool write_arrow) {
    ASSERT_NO_FATAL_FAILURE(WriteTestData(type, write_arrow));

    auto in_file = std::make_shared<::arrow::io::BufferReader>(file_buf);

    ReaderProperties reader_props;
    reader_props.enable_buffered_stream();
    reader_props.set_buffer_size(64);
    auto file_reader = ParquetFileReader::Open(in_file, reader_props);

    // Check that the geometry statistics are correctly written and read
    auto metadata = file_reader->metadata();
    ASSERT_TRUE(type->Equals(*metadata->schema()->Column(0)->logical_type()));

    auto page_index_reader = file_reader->GetPageIndexReader();
    int num_row_groups = metadata->num_row_groups();
    int64_t start_index = 0;
    for (int i = 0; i < num_row_groups; i++) {
      auto row_group_metadata = metadata->RowGroup(i);
      auto column_chunk_metadata = row_group_metadata->ColumnChunk(0);
      auto geo_stats = column_chunk_metadata->geo_statistics();
      ASSERT_NO_FATAL_FAILURE(CheckGeoStatistics(type, geo_stats, start_index,
                                                 row_group_metadata->num_rows()));
      start_index += row_group_metadata->num_rows();
    }

    // Check the geometry values
    int64_t total_values_read = 0;
    for (int i = 0; i < num_row_groups; i++) {
      auto row_group = file_reader->RowGroup(i);
      std::shared_ptr<ByteArrayReader> reader =
          std::static_pointer_cast<ByteArrayReader>(row_group->Column(0));
      while (reader->HasNext()) {
        std::vector<ByteArray> out(kNumRows);
        int64_t values_read = 0;
        int64_t levels_read =
            reader->ReadBatch(kNumRows, nullptr, nullptr, out.data(), &values_read);
        ASSERT_GE(levels_read, 1);
        ASSERT_GE(values_read, 1);

        // Check the batch
        for (int64_t i = 0; i < values_read; i++) {
          const ByteArray& value = out[i];
          auto xy = test::GetWKBPointCoordinateXY(value);
          EXPECT_TRUE(xy.has_value());
          auto expected_x = static_cast<double>(i + total_values_read);
          auto expected_y = static_cast<double>(i + 1 + total_values_read);
          EXPECT_EQ(*xy, (std::pair<double, double>(expected_x, expected_y)));
        }

        total_values_read += values_read;
      }
    }
    EXPECT_EQ(kNumRows, total_values_read);
  }

  void CheckGeoStatistics(std::shared_ptr<const LogicalType> type,
                          std::shared_ptr<geospatial::GeoStatistics> geom_stats,