GH-48089: [C++][Parquet] Read statistics and other metadata when fuzzing

Author: pitrou

cpp/src/parquet/arrow/reader.cc

@@ -20,6 +20,7 @@
 #include <algorithm>
 #include <cstring>
 #include <memory>
+#include <random>
 #include <unordered_set>
 #include <utility>
 #include <vector>
@@ -40,7 +41,10 @@
 #include "arrow/util/parallel.h"
 #include "arrow/util/range.h"
 #include "arrow/util/tracing_internal.h"
+
 #include "parquet/arrow/reader_internal.h"
+#include "parquet/bloom_filter.h"
+#include "parquet/bloom_filter_reader.h"
 #include "parquet/column_reader.h"
 #include "parquet/exception.h"
 #include "parquet/file_reader.h"
@@ -1419,11 +1423,51 @@ Status FuzzReader(const uint8_t* data, int64_t size) {
   auto buffer = std::make_shared<::arrow::Buffer>(data, size);
   auto file = std::make_shared<::arrow::io::BufferReader>(buffer);
   auto pool = ::arrow::default_memory_pool();
+  auto reader_properties = default_reader_properties();
+  std::default_random_engine rng(/*seed*/ 42);
 
   // Read Parquet file metadata only once, which will reduce iteration time slightly
   std::shared_ptr<FileMetaData> pq_md;
-  BEGIN_PARQUET_CATCH_EXCEPTIONS
-  pq_md = ParquetFileReader::Open(file)->metadata();
+  int num_row_groups, num_columns;
+  BEGIN_PARQUET_CATCH_EXCEPTIONS {
+    // Read some additional metadata (often lazy-decoded, such as statistics)
+    pq_md = ParquetFileReader::Open(file)->metadata();
+    num_row_groups = pq_md->num_row_groups();
+    num_columns = pq_md->num_columns();
+    for (int i = 0; i < num_row_groups; ++i) {
+      auto rg = pq_md->RowGroup(i);
+      rg->sorting_columns();
+      for (int j = 0; j < num_columns; ++j) {
+        auto col = rg->ColumnChunk(j);
+        col->encoded_statistics();
+        col->statistics();
+        col->geo_statistics();
+        col->size_statistics();
+        col->key_value_metadata();
+        col->encodings();
+        col->encoding_stats();
+        // TODO read offset index
+        // TODO read column index
+      }
+    }
+  }
+  {
+    // Read and decode bloom filters
+    auto bloom_reader = BloomFilterReader::Make(file, pq_md, reader_properties);
+    std::uniform_int_distribution<uint64_t> hash_dist;
+    for (int i = 0; i < num_row_groups; ++i) {
+      auto bloom_rg = bloom_reader->RowGroup(i);
+      for (int j = 0; j < num_columns; ++j) {
+        auto bloom = bloom_rg->GetColumnBloomFilter(j);
+        // If the column has a bloom filter, find a bunch of random hashes
+        if (bloom != nullptr) {
+          for (int k = 0; k < 100; ++k) {
+            bloom->FindHash(hash_dist(rng));
+          }
+        }
+      }
+    }
+  }
   END_PARQUET_CATCH_EXCEPTIONS
 
   // Note that very small batch sizes probably make fuzzing slower
@@ -1435,7 +1479,7 @@ Status FuzzReader(const uint8_t* data, int64_t size) {
 
     std::unique_ptr<ParquetFileReader> pq_file_reader;
     BEGIN_PARQUET_CATCH_EXCEPTIONS
-    pq_file_reader = ParquetFileReader::Open(file, default_reader_properties(), pq_md);
+    pq_file_reader = ParquetFileReader::Open(file, reader_properties, pq_md);
     END_PARQUET_CATCH_EXCEPTIONS
 
     std::unique_ptr<FileReader> reader;

cpp/src/parquet/bloom_filter_reader.cc

@@ -60,6 +60,9 @@ std::unique_ptr<BloomFilter> RowGroupBloomFilterReaderImpl::GetColumnBloomFilter
     return nullptr;
   }
   PARQUET_ASSIGN_OR_THROW(auto file_size, input_->GetSize());
+  if (*bloom_filter_offset < 0) {
+    throw ParquetException("bloom_filter_offset less than 0");
+  }
   if (file_size <= *bloom_filter_offset) {
     throw ParquetException("file size less or equal than bloom offset");
   }
@@ -68,7 +71,7 @@ std::unique_ptr<BloomFilter> RowGroupBloomFilterReaderImpl::GetColumnBloomFilter
     if (*bloom_filter_length < 0) {
       throw ParquetException("bloom_filter_length less than 0");
     }
-    if (*bloom_filter_length + *bloom_filter_offset > file_size) {
+    if (*bloom_filter_length > file_size - *bloom_filter_offset) {
       throw ParquetException(
           "bloom filter length + bloom filter offset greater than file size");
     }