GH-48545: [C++][Parquet][CI] Add more encodings to fuzzing seed corpus

Author: pitrou

cpp/src/parquet/arrow/generate_fuzz_corpus.cc

@@ -22,6 +22,7 @@
 #include <cstdlib>
 #include <functional>
 #include <iostream>
+#include <limits>
 #include <memory>
 #include <sstream>
 #include <string>
@@ -49,6 +50,7 @@ using ::arrow::internal::CreateDir;
 using ::arrow::internal::PlatformFilename;
 using ::arrow::util::Float16;
 using ::parquet::ArrowWriterProperties;
+using ::parquet::Encoding;
 using ::parquet::WriterProperties;
 
 struct WriteConfig {
@@ -74,6 +76,13 @@ struct Column {
   }
 };
 
+using EncodingVector = std::vector<Encoding::type>;
+
+struct ColumnWithEncodings {
+  Column column;
+  EncodingVector encodings;
+};
+
 std::shared_ptr<Field> FieldForArray(const std::shared_ptr<Array>& array,
                                      std::string name) {
   return field(std::move(name), array->type(), /*nullable=*/array->null_count() != 0);
@@ -369,6 +378,100 @@ Result<std::vector<Column>> ExampleColumns(int32_t length, double null_probabili
   return columns;
 }
 
+template <typename T>
+constexpr auto kMin = std::numeric_limits<T>::lowest();
+template <typename T>
+constexpr auto kMax = std::numeric_limits<T>::max();
+
+// Generate columns for physical types along with their supported encodings
+Result<std::vector<ColumnWithEncodings>> AllColumnsWithEncodings(
+    int32_t length, double null_probability = 0.2) {
+  const EncodingVector kIntEncodings = {Encoding::PLAIN, Encoding::RLE_DICTIONARY,
+                                        Encoding::DELTA_BINARY_PACKED,
+                                        Encoding::BYTE_STREAM_SPLIT};
+  const EncodingVector kFloatEncodings = {Encoding::PLAIN, Encoding::RLE_DICTIONARY,
+                                          Encoding::BYTE_STREAM_SPLIT};
+  const EncodingVector kBooleanEncodings = {Encoding::PLAIN, Encoding::RLE};
+  const EncodingVector kByteArrayEncodings = {Encoding::PLAIN, Encoding::RLE_DICTIONARY,
+                                              Encoding::DELTA_LENGTH_BYTE_ARRAY,
+                                              Encoding::DELTA_BYTE_ARRAY};
+  const EncodingVector kFixedLenByteArrayEncodings = {
+      Encoding::PLAIN, Encoding::RLE_DICTIONARY, Encoding::DELTA_BYTE_ARRAY,
+      Encoding::BYTE_STREAM_SPLIT};
+
+  std::vector<ColumnWithEncodings> columns;
+
+  random::RandomArrayGenerator gen(42);
+  auto name_gen = Column::NameGenerator();
+
+  for (const double true_probability : {0.0, 0.001, 0.01, 0.5, 0.999}) {
+    columns.push_back(
+        {{name_gen(), gen.Boolean(length, true_probability, null_probability)},
+         kBooleanEncodings});
+  }
+
+  columns.push_back(
+      {{name_gen(), gen.Int32(length, -100, 100, null_probability)}, kIntEncodings});
+  columns.push_back(
+      {{name_gen(), gen.Int32(length, kMin<int32_t>, kMax<int32_t>, null_probability)},
+       kIntEncodings});
+  columns.push_back({{name_gen(), gen.Int64(length, -100'000, 100'000, null_probability)},
+                     kIntEncodings});
+  columns.push_back(
+      {{name_gen(), gen.Int64(length, kMin<int64_t>, kMax<int64_t>, null_probability)},
+       kIntEncodings});
+
+  // XXX should we add INT96? It's deprecated, only supports PLAIN and is featured in
+  // the parquet-testing files.
+
+  // NOTE: will need to vary NaNs if there are encodings for which that matters (ALP?)
+  columns.push_back(
+      {{name_gen(), gen.Float32(length, -1.0, 1.0, null_probability)}, kFloatEncodings});
+  columns.push_back(
+      {{name_gen(), gen.Float32(length, kMin<float>, kMax<float>, null_probability)},
+       kFloatEncodings});
+  columns.push_back(
+      {{name_gen(), gen.Float64(length, -1.0, 1.0, null_probability)}, kFloatEncodings});
+  columns.push_back(
+      {{name_gen(), gen.Float64(length, kMin<double>, kMax<double>, null_probability)},
+       kFloatEncodings});
+
+  columns.push_back(
+      {{name_gen(), gen.Float16(length, Float16(-1.0), Float16(1.0), null_probability)},
+       kFixedLenByteArrayEncodings});
+
+  columns.push_back({{name_gen(), gen.String(length, /*min_length=*/0,
+                                             /*max_length=*/20, null_probability)},
+                     kByteArrayEncodings});
+  columns.push_back({{name_gen(), gen.String(length, /*min_length=*/12,
+                                             /*max_length=*/14, null_probability)},
+                     kByteArrayEncodings});
+  columns.push_back({{name_gen(), gen.String(length, /*min_length=*/100,
+                                             /*max_length=*/200, null_probability)},
+                     kByteArrayEncodings});
+  columns.push_back({{name_gen(), gen.StringWithRepeats(
+                                      length, /*unique=*/length / 50, /*min_length=*/0,
+                                      /*max_length=*/20, null_probability)},
+                     kByteArrayEncodings});
+  columns.push_back({{name_gen(), gen.StringWithRepeats(
+                                      length, /*unique=*/length / 100, /*min_length=*/12,
+                                      /*max_length=*/14, null_probability)},
+                     kByteArrayEncodings});
+
+  return columns;
+}
+
+Result<std::vector<ColumnWithEncodings>> AllColumnsWithEncodings() {
+  std::vector<ColumnWithEncodings> all_columns;
+
+  for (const double null_probability : {0.0, 0.01, 0.5, 1.0}) {
+    ARROW_ASSIGN_OR_RAISE(auto columns,
+                          AllColumnsWithEncodings(/*length=*/1'000, null_probability));
+    all_columns.insert(all_columns.end(), columns.begin(), columns.end());
+  }
+  return all_columns;
+}
+
 Result<std::shared_ptr<RecordBatch>> BatchFromColumns(const std::vector<Column>& columns,
                                                       int64_t num_rows) {
   FieldVector fields;
@@ -443,7 +546,7 @@ Status DoMain(const std::string& out_dir) {
   };
 
   {
-    // 1. Unencrypted files
+    // 1. Unencrypted files for various write configurations
     // Write a cardinal product of example batches x write configurations
     ARROW_ASSIGN_OR_RAISE(auto batches, Batches());
     auto write_configs = GetWriteConfigurations();
@@ -458,7 +561,34 @@ Status DoMain(const std::string& out_dir) {
     }
   }
   {
-    // 2. Encrypted files
+    // 2. Unencrypted files for various column encodings
+    // Write one file per (column, encoding) pair.
+    ARROW_ASSIGN_OR_RAISE(auto columns, AllColumnsWithEncodings());
+
+    for (const auto& column : columns) {
+      RETURN_NOT_OK(column.column.array->ValidateFull());
+      ARROW_ASSIGN_OR_RAISE(
+          auto batch, BatchFromColumn(column.column, column.column.array->length()));
+      ARROW_ASSIGN_OR_RAISE(auto table, Table::FromRecordBatches({batch}));
+
+      for (const auto encoding : column.encodings) {
+        auto w_props_builder = MakePropertiesBuilder();
+        if (encoding == Encoding::RLE_DICTIONARY) {
+          // RLE_DICTIONARY is enabled through enable_dictionary() rather than
+          // encoding(), also increase the dictionary page size limit as we
+          // generate data with a typically high cardinality.
+          w_props_builder.enable_dictionary()->dictionary_pagesize_limit(1'000'000);
+        } else {
+          w_props_builder.disable_dictionary()->encoding(encoding);
+        }
+        auto w_props = w_props_builder.build();
+        auto a_props = MakeArrowPropertiesBuilder().build();
+        RETURN_NOT_OK(write_sample(table, WriteConfig{w_props, a_props}));
+      }
+    }
+  }
+  {
+    // 3. Encrypted files
     // Use a single batch and write it using different configurations
     ARROW_ASSIGN_OR_RAISE(auto batch, BatchForEncryption());
     auto write_configs = GetEncryptedWriteConfigurations(*batch->schema());