diff --git a/cpp/src/parquet/chunker_internal_test.cc b/cpp/src/parquet/chunker_internal_test.cc new file mode 100644 --- /dev/null +++ b/cpp/src/parquet/chunker_internal_test.cc @@ -0,0 +1,1704 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "arrow/extension/json.h" +#include "arrow/table.h" +#include "arrow/testing/generator.h" +#include "arrow/type_fwd.h" +#include "arrow/util/float16.h" +#include "parquet/arrow/reader.h" +#include "parquet/arrow/reader_internal.h" +#include "parquet/arrow/test_util.h" +#include "parquet/arrow/writer.h" +#include "parquet/chunker_internal.h" +#include "parquet/column_writer.h" +#include "parquet/file_writer.h" + +namespace parquet::internal { + +using ::arrow::Array; +using ::arrow::ChunkedArray; +using ::arrow::ConcatenateTables; +using ::arrow::DataType; +using ::arrow::default_memory_pool; +using ::arrow::Field; +using ::arrow::Result; +using ::arrow::Schema; +using ::arrow::Table; +using ::arrow::internal::checked_cast; +using ::arrow::io::BufferReader; +using ::parquet::arrow::FileReader; +using ::parquet::arrow::FileReaderBuilder; +using ::parquet::arrow::MakeSimpleTable; +using ::parquet::arrow::NonNullArray; +using ::parquet::arrow::WriteTable; + +using ::testing::Bool; +using ::testing::Combine; +using ::testing::Values; + +// generate determinisic and platform-independent data +inline uint64_t hash(uint64_t seed, uint64_t index) { + uint64_t h = (index + seed) * 0xc4ceb9fe1a85ec53ull; + h ^= h >> 33; + h *= 0xff51afd7ed558ccdull; + h ^= h >> 33; + h *= 0xc4ceb9fe1a85ec53ull; + h ^= h >> 33; + return h; +} + +template +Result> GenerateArray(const std::shared_ptr& type, + bool nullable, int64_t length, uint64_t seed, + ValueFunc value_func) { + BuilderType builder(type, default_memory_pool()); + + if (nullable) { + for (int64_t i = 0; i < length; ++i) { + uint64_t val = hash(seed, i); + if (val % 10 == 0) { + RETURN_NOT_OK(builder.AppendNull()); + } else { + RETURN_NOT_OK(builder.Append(value_func(val))); + } + } + } else { + for (int64_t i = 0; i < length; ++i) { + uint64_t val = hash(seed, i); + RETURN_NOT_OK(builder.Append(value_func(val))); + } + } + + std::shared_ptr array; + RETURN_NOT_OK(builder.Finish(&array)); + RETURN_NOT_OK(array->ValidateFull()); + return array; +} + +#define GENERATE_CASE(TYPE_ID, BUILDER_TYPE, VALUE_EXPR) \ + case ::arrow::Type::TYPE_ID: { \ + auto value_func = [](uint64_t val) { return VALUE_EXPR; }; \ + return GenerateArray(type, nullable, length, seed, value_func); \ + } + +Result> GenerateArray(const std::shared_ptr& field, + int64_t length, int64_t seed) { + const std::shared_ptr& type = field->type(); + bool nullable = field->nullable(); + + switch (type->id()) { + GENERATE_CASE(BOOL, ::arrow::BooleanBuilder, (val % 2 == 0)) + + // Numeric types. + GENERATE_CASE(INT8, ::arrow::Int8Builder, static_cast(val)) + GENERATE_CASE(INT16, ::arrow::Int16Builder, static_cast(val)) + GENERATE_CASE(INT32, ::arrow::Int32Builder, static_cast(val)) + GENERATE_CASE(INT64, ::arrow::Int64Builder, static_cast(val)) + GENERATE_CASE(UINT8, ::arrow::UInt8Builder, static_cast(val)) + GENERATE_CASE(UINT16, ::arrow::UInt16Builder, static_cast(val)) + GENERATE_CASE(UINT32, ::arrow::UInt32Builder, static_cast(val)) + GENERATE_CASE(UINT64, ::arrow::UInt64Builder, static_cast(val)) + GENERATE_CASE(HALF_FLOAT, ::arrow::HalfFloatBuilder, + static_cast(val % 1000)) + GENERATE_CASE(FLOAT, ::arrow::FloatBuilder, static_cast(val % 1000) / 1000.0f) + GENERATE_CASE(DOUBLE, ::arrow::DoubleBuilder, + static_cast(val % 100000) / 1000.0) + case ::arrow::Type::DECIMAL128: { + const auto& decimal_type = checked_cast(*type); + // Limit the value to fit within the specified precision + int32_t max_exponent = decimal_type.precision() - decimal_type.scale(); + int64_t max_value = static_cast(std::pow(10, max_exponent) - 1); + auto value_func = [&](uint64_t val) { + return ::arrow::Decimal128(val % max_value); + }; + return GenerateArray<::arrow::Decimal128Builder>(type, nullable, length, seed, + value_func); + } + case ::arrow::Type::DECIMAL256: { + const auto& decimal_type = checked_cast(*type); + // Limit the value to fit within the specified precision, capped at 9 to avoid + // int64_t overflow + int32_t max_exponent = std::min(9, decimal_type.precision() - decimal_type.scale()); + int64_t max_value = static_cast(std::pow(10, max_exponent) - 1); + auto value_func = [&](uint64_t val) { + return ::arrow::Decimal256(val % max_value); + }; + return GenerateArray<::arrow::Decimal256Builder>(type, nullable, length, seed, + value_func); + } + + // Temporal types + GENERATE_CASE(DATE32, ::arrow::Date32Builder, static_cast(val)) + GENERATE_CASE(TIME32, ::arrow::Time32Builder, + std::abs(static_cast(val) % 86400000)) + GENERATE_CASE(TIME64, ::arrow::Time64Builder, + std::abs(static_cast(val) % 86400000000)) + GENERATE_CASE(TIMESTAMP, ::arrow::TimestampBuilder, static_cast(val)) + GENERATE_CASE(DURATION, ::arrow::DurationBuilder, static_cast(val)) + + // Binary and string types. + GENERATE_CASE(STRING, ::arrow::StringBuilder, + std::string("str_") + std::to_string(val)) + GENERATE_CASE(LARGE_STRING, ::arrow::LargeStringBuilder, + std::string("str_") + std::to_string(val)) + GENERATE_CASE(BINARY, ::arrow::BinaryBuilder, + std::string("bin_") + std::to_string(val)) + GENERATE_CASE(LARGE_BINARY, ::arrow::LargeBinaryBuilder, + std::string("bin_") + std::to_string(val)) + case ::arrow::Type::FIXED_SIZE_BINARY: { + auto size = + checked_cast(type.get())->byte_width(); + auto value_func = [size](uint64_t val) { + return std::string("bin_") + std::to_string(val).substr(0, size - 4); + }; + return GenerateArray<::arrow::FixedSizeBinaryBuilder>(type, nullable, length, seed, + value_func); + } + + case ::arrow::Type::STRUCT: { + auto struct_type = checked_cast(type.get()); + std::vector> child_arrays; + for (auto i = 0; i < struct_type->num_fields(); i++) { + ARROW_ASSIGN_OR_RAISE(auto child_array, GenerateArray(struct_type->field(i), + length, seed + i * 10)); + child_arrays.push_back(child_array); + } + auto struct_array = + std::make_shared<::arrow::StructArray>(type, length, child_arrays); + return struct_array; + } + + case ::arrow::Type::LIST: { + // Repeat the same pattern in the list array: + // null, empty list, list of 1 element, list of 3 elements + if (length % 4 != 0) { + return Status::Invalid( + "Length must be divisible by 4 when generating list arrays, but got: ", + length); + } + auto values_array_length = length * 4; + auto list_type = checked_cast(type.get()); + auto value_field = ::arrow::field("item", list_type->value_type()); + ARROW_ASSIGN_OR_RAISE(auto values_array, + GenerateArray(value_field, values_array_length, seed)); + auto offset_builder = ::arrow::Int32Builder(); + auto bitmap_builder = ::arrow::TypedBufferBuilder(); + + RETURN_NOT_OK(offset_builder.Reserve(length + 1)); + RETURN_NOT_OK(bitmap_builder.Reserve(length)); + + int32_t num_nulls = 0; + RETURN_NOT_OK(offset_builder.Append(0)); + for (auto offset = 0; offset < length; offset += 4) { + if (nullable) { + // add a null + RETURN_NOT_OK(bitmap_builder.Append(false)); + RETURN_NOT_OK(offset_builder.Append(offset)); + num_nulls += 1; + } else { + // add an empty list + RETURN_NOT_OK(bitmap_builder.Append(true)); + RETURN_NOT_OK(offset_builder.Append(offset)); + } + // add an empty list + RETURN_NOT_OK(bitmap_builder.Append(true)); + RETURN_NOT_OK(offset_builder.Append(offset)); + // add a list of 1 element + RETURN_NOT_OK(bitmap_builder.Append(true)); + RETURN_NOT_OK(offset_builder.Append(offset + 1)); + // add a list of 3 elements + RETURN_NOT_OK(bitmap_builder.Append(true)); + RETURN_NOT_OK(offset_builder.Append(offset + 4)); + } + + std::shared_ptr offsets_array; + RETURN_NOT_OK(offset_builder.Finish(&offsets_array)); + std::shared_ptr bitmap_buffer; + RETURN_NOT_OK(bitmap_builder.Finish(&bitmap_buffer)); + ARROW_ASSIGN_OR_RAISE( + auto list_array, ::arrow::ListArray::FromArrays( + type, *offsets_array, *values_array, default_memory_pool(), + bitmap_buffer, num_nulls)); + RETURN_NOT_OK(list_array->ValidateFull()); + return list_array; + } + + case ::arrow::Type::EXTENSION: { + auto extension_type = checked_cast(type.get()); + auto storage_type = extension_type->storage_type(); + auto storage_field = ::arrow::field("storage", storage_type, true); + ARROW_ASSIGN_OR_RAISE(auto storage_array, + GenerateArray(storage_field, length, seed)); + return ::arrow::ExtensionType::WrapArray(type, storage_array); + } + + default: + return ::arrow::Status::NotImplemented("Unsupported data type " + type->ToString()); + } +} + +TEST(TestGenerateArray, Integer) { + auto field = ::arrow::field("a", ::arrow::int32()); + ASSERT_OK_AND_ASSIGN(auto array, GenerateArray(field, /*length=*/10, /*seed=*/0)); + ASSERT_OK(array->ValidateFull()); + ASSERT_EQ(array->length(), 10); + ASSERT_TRUE(array->type()->Equals(::arrow::int32())); + ASSERT_EQ(array->null_count(), 1); +} + +TEST(TestGenerateArray, ListOfInteger) { + auto field = ::arrow::field("a", ::arrow::list(::arrow::int32())); + auto length = 12; + ASSERT_OK_AND_ASSIGN(auto array, GenerateArray(field, length, /*seed=*/0)); + ASSERT_OK(array->ValidateFull()); + ASSERT_EQ(array->length(), length); + + for (size_t i = 0; i < 12; i += 4) { + // Assert the first element is null + ASSERT_TRUE(array->IsNull(i)); + + // Assert the second element is an empty list + ASSERT_TRUE(array->IsValid(i + 1)); + auto list_array = std::static_pointer_cast<::arrow::ListArray>(array); + ASSERT_EQ(list_array->value_length(i + 1), 0); + + // Assert the third element has length 1 + ASSERT_TRUE(array->IsValid(i + 2)); + ASSERT_EQ(list_array->value_length(i + 2), 1); + + // Assert the fourth element has length 3 + ASSERT_TRUE(array->IsValid(i + 3)); + ASSERT_EQ(list_array->value_length(i + 3), 3); + } + + ASSERT_NOT_OK(GenerateArray(field, 3, /*seed=*/0)); + ASSERT_OK(GenerateArray(field, 8, /*seed=*/0)); +} + +Result> GenerateTable( + const std::shared_ptr<::arrow::Schema>& schema, int64_t size, int64_t seed = 0) { + std::vector> arrays; + for (const auto& field : schema->fields()) { + ARROW_ASSIGN_OR_RAISE(auto array, GenerateArray(field, size, ++seed)); + arrays.push_back(array); + } + return Table::Make(schema, arrays, size); +} + +Result> ConcatAndCombine( + const std::vector>& parts) { + // Concatenate and combine chunks so the table doesn't carry information about + // the modification points + ARROW_ASSIGN_OR_RAISE(auto table, ConcatenateTables(parts)); + return table->CombineChunks(); +} + +Result> ReadTableFromBuffer(const std::shared_ptr& data) { + std::shared_ptr result; + FileReaderBuilder builder; + std::unique_ptr reader; + auto props = default_arrow_reader_properties(); + props.set_arrow_extensions_enabled(true); + + RETURN_NOT_OK(builder.Open(std::make_shared(data))); + RETURN_NOT_OK(builder.memory_pool(::arrow::default_memory_pool()) + ->properties(props) + ->Build(&reader)); + RETURN_NOT_OK(reader->ReadTable(&result)); + return result; +} + +Result> WriteTableToBuffer( + const std::shared_ptr
& table, int64_t min_chunk_size, int64_t max_chunk_size, + int64_t row_group_length = 1024 * 1024, bool enable_dictionary = false, + ParquetDataPageVersion data_page_version = ParquetDataPageVersion::V1) { + auto sink = CreateOutputStream(); + + auto builder = WriterProperties::Builder(); + builder.enable_content_defined_chunking()->content_defined_chunking_options( + {min_chunk_size, max_chunk_size, /*norm_level=*/0}); + builder.data_page_version(data_page_version); + if (enable_dictionary) { + builder.enable_dictionary(); + } else { + builder.disable_dictionary(); + } + auto write_props = builder.build(); + auto arrow_props = ArrowWriterProperties::Builder().store_schema()->build(); + RETURN_NOT_OK(WriteTable(*table, default_memory_pool(), sink, row_group_length, + write_props, arrow_props)); + ARROW_ASSIGN_OR_RAISE(auto buffer, sink->Finish()); + + // validate that the data correctly roundtrips + ARROW_ASSIGN_OR_RAISE(auto readback, ReadTableFromBuffer(buffer)); + RETURN_NOT_OK(readback->ValidateFull()); + ARROW_RETURN_IF(!readback->Equals(*table), + Status::Invalid("Readback table not equal to original")); + + return buffer; +} + +// Type to represent a list of chunks where each element is the size of the chunk. +using ChunkList = std::vector; + +// Type to represent the sizes and lengths of the data pages in a column. + +struct ColumnInfo { + ChunkList page_lengths; + ChunkList page_sizes; + bool has_dictionary_page = false; +}; + +using ParquetInfo = std::vector; + +ParquetInfo GetColumnParquetInfo(const std::shared_ptr& data, int column_index) { + // Read the parquet data out of the buffer and get the sizes and lengths of the + // data pages in given column. We assert on the sizes and lengths of the pages + // to ensure that the chunking is done correctly. + ParquetInfo result; + + auto buffer_reader = std::make_shared(data); + auto parquet_reader = ParquetFileReader::Open(std::move(buffer_reader)); + + auto metadata = parquet_reader->metadata(); + for (int rg = 0; rg < metadata->num_row_groups(); rg++) { + auto page_reader = parquet_reader->RowGroup(rg)->GetColumnPageReader(column_index); + ColumnInfo column_info; + while (auto page = page_reader->NextPage()) { + if (page->type() == PageType::DATA_PAGE || page->type() == PageType::DATA_PAGE_V2) { + auto data_page = static_cast(page.get()); + column_info.page_sizes.push_back(data_page->uncompressed_size()); + column_info.page_lengths.push_back(data_page->num_values()); + } else if (page->type() == PageType::DICTIONARY_PAGE) { + column_info.has_dictionary_page = true; + } + } + result.push_back(column_info); + } + + return result; +} + +// A git-hunk like side-by-side data structure to represent the differences between two +// vectors of uint64_t values. +using ChunkDiff = std::pair; + +/** + * Finds the differences between two sequences of chunk lengths or sizes. + * Uses a longest common subsequence algorithm to identify matching elements + * and extract the differences between the sequences. + * + * @param first The first sequence of chunk values + * @param second The second sequence of chunk values + * @return A vector of differences, where each difference is a pair of + * subsequences (one from each input) that differ + */ +std::vector FindDifferences(const ChunkList& first, const ChunkList& second) { + // Compute the longest common subsequence using dynamic programming + size_t n = first.size(), m = second.size(); + std::vector> dp(n + 1, std::vector(m + 1, 0)); + + // Fill the dynamic programming table + for (size_t i = 0; i < n; i++) { + for (size_t j = 0; j < m; j++) { + if (first[i] == second[j]) { + // If current elements match, extend the LCS + dp[i + 1][j + 1] = dp[i][j] + 1; + } else { + // If current elements don't match, take the best option + dp[i + 1][j + 1] = std::max(dp[i + 1][j], dp[i][j + 1]); + } + } + } + + // Backtrack through the dynamic programming table to reconstruct the common + // parts and their positions in the original sequences + std::vector> common; + for (size_t i = n, j = m; i > 0 && j > 0;) { + if (first[i - 1] == second[j - 1]) { + // Found a common element, add to common list + common.emplace_back(i - 1, j - 1); + i--, j--; + } else if (dp[i - 1][j] >= dp[i][j - 1]) { + // Move in the direction of the larger LCS value + i--; + } else { + j--; + } + } + // Reverse to get indices in ascending order + std::reverse(common.begin(), common.end()); + + // Build the differences by finding sequences between common elements + std::vector result; + size_t last_i = 0, last_j = 0; + for (auto& c : common) { + auto ci = c.first; + auto cj = c.second; + // If there's a gap between the last common element and this one, + // record the difference + if (ci > last_i || cj > last_j) { + result.push_back({{first.begin() + last_i, first.begin() + ci}, + {second.begin() + last_j, second.begin() + cj}}); + } + // Move past this common element + last_i = ci + 1; + last_j = cj + 1; + } + + // Handle any remaining elements after the last common element + if (last_i < n || last_j < m) { + result.push_back( + {{first.begin() + last_i, first.end()}, {second.begin() + last_j, second.end()}}); + } + + // Post-process: merge adjacent diffs to avoid splitting single changes into multiple + // parts + std::vector merged; + for (auto& diff : result) { + if (!merged.empty()) { + auto& prev = merged.back(); + // Check if we can merge with the previous diff + bool can_merge_a = prev.first.empty() && diff.second.empty(); + bool can_merge_b = prev.second.empty() && diff.first.empty(); + if (can_merge_a) { + // Combine into one diff: keep prev's second, use diff's first + prev.first = std::move(diff.first); + continue; + } else if (can_merge_b) { + // Combine into one diff: keep prev's first, use diff's second + prev.second = std::move(diff.second); + continue; + } + } + // If we can't merge, add this diff to the result + merged.push_back(std::move(diff)); + } + return merged; +} + +void PrintDifferences(const ChunkList& original, const ChunkList& modified, + const std::vector& diffs) { + // Utility function to print the original and modified sequences, and the diffs + // between them. Used in case of failing assertions to display the differences. + std::cout << "Original: "; + for (const auto& val : original) { + std::cout << val << " "; + } + std::cout << std::endl; + + std::cout << "Modified: "; + for (const auto& val : modified) { + std::cout << val << " "; + } + std::cout << std::endl; + + for (const auto& diff : diffs) { + std::cout << "First: "; + for (const auto& val : diff.first) { + std::cout << val << " "; + } + std::cout << std::endl; + + std::cout << "Second: "; + for (const auto& val : diff.second) { + std::cout << val << " "; + } + std::cout << std::endl; + } +} + +TEST(TestFindDifferences, Basic) { + ChunkList first = {1, 2, 3, 4, 5}; + ChunkList second = {1, 7, 8, 4, 5}; + + auto diffs = FindDifferences(first, second); + + ASSERT_EQ(diffs.size(), 1); + ASSERT_EQ(diffs[0].first, ChunkList({2, 3})); + ASSERT_EQ(diffs[0].second, ChunkList({7, 8})); +} + +TEST(TestFindDifferences, MultipleDifferences) { + ChunkList first = {1, 2, 3, 4, 5, 6, 7}; + ChunkList second = {1, 8, 9, 4, 10, 6, 11}; + auto diffs = FindDifferences(first, second); + + ASSERT_EQ(diffs.size(), 3); + + ASSERT_EQ(diffs[0].first, ChunkList({2, 3})); + ASSERT_EQ(diffs[0].second, ChunkList({8, 9})); + + ASSERT_EQ(diffs[1].first, ChunkList({5})); + ASSERT_EQ(diffs[1].second, ChunkList({10})); + + ASSERT_EQ(diffs[2].first, ChunkList({7})); + ASSERT_EQ(diffs[2].second, ChunkList({11})); +} + +TEST(TestFindDifferences, DifferentLengths) { + ChunkList first = {1, 2, 3}; + ChunkList second = {1, 2, 3, 4, 5}; + auto diffs = FindDifferences(first, second); + + ASSERT_EQ(diffs.size(), 1); + ASSERT_TRUE(diffs[0].first.empty()); + ASSERT_EQ(diffs[0].second, ChunkList({4, 5})); +} + +TEST(TestFindDifferences, ChangesAtBothEnds) { + ChunkList first = {1, 2, 3, 4, 5, 6, 7, 8, 9}; + ChunkList second = {0, 0, 2, 3, 4, 5, 7, 7, 8}; + auto diffs = FindDifferences(first, second); + + ASSERT_EQ(diffs.size(), 3); + ASSERT_EQ(diffs[0].first, ChunkList({1})); + ASSERT_EQ(diffs[0].second, ChunkList({0, 0})); + + ASSERT_EQ(diffs[1].first, ChunkList({6})); + ASSERT_EQ(diffs[1].second, ChunkList({7})); + + ASSERT_EQ(diffs[2].first, ChunkList({9})); + ASSERT_EQ(diffs[2].second, ChunkList({})); +} + +TEST(TestFindDifferences, EmptyArrays) { + ChunkList first = {}; + ChunkList second = {}; + auto diffs = FindDifferences(first, second); + ASSERT_TRUE(diffs.empty()); +} + +TEST(TestFindDifferences, LongSequenceWithSingleDifference) { + ChunkList first = { + 1994, 2193, 2700, 1913, 2052, + }; + ChunkList second = {2048, 43, 2080, 2700, 1913, 2052}; + auto diffs = FindDifferences(first, second); + + ASSERT_EQ(diffs.size(), 1); + ASSERT_EQ(diffs[0].first, ChunkList({1994, 2193})); + ASSERT_EQ(diffs[0].second, ChunkList({2048, 43, 2080})); +} + +TEST(TestFindDifferences, LongSequenceWithMiddleChanges) { + ChunkList first = {2169, 1976, 2180, 2147, 1934, 1772, + 1914, 2075, 2154, 1940, 1934, 1970}; + ChunkList second = {2169, 1976, 2180, 2147, 2265, 1804, + 1717, 1925, 2122, 1940, 1934, 1970}; + auto diffs = FindDifferences(first, second); + + ASSERT_EQ(diffs.size(), 1); + ASSERT_EQ(diffs[0].first, ChunkList({1934, 1772, 1914, 2075, 2154})); + ASSERT_EQ(diffs[0].second, ChunkList({2265, 1804, 1717, 1925, 2122})); +} + +TEST(TestFindDifferences, AdditionalCase) { + ChunkList original = {445, 312, 393, 401, 410, 138, 558, 457}; + ChunkList modified = {445, 312, 393, 393, 410, 138, 558, 457}; + + auto diffs = FindDifferences(original, modified); + ASSERT_EQ(diffs.size(), 1); + + ASSERT_EQ(diffs[0].first, ChunkList({401})); + ASSERT_EQ(diffs[0].second, ChunkList({393})); +} + +void AssertPageLengthDifferences(const ColumnInfo& original, const ColumnInfo& modified, + int32_t exact_number_of_equal_diffs, + int32_t exact_number_of_larger_diffs, + int32_t exact_number_of_smaller_diffs, + const std::shared_ptr& edit_array) { + // Asserts that the differences between the original and modified page lengths + // are as expected. A longest common subsequence diff is calculated on the original + // and modified sequences of page lengths. The exact_number_of_equal_diffs, + // exact_number_of_larger_diffs, and exact_number_of_smaller_diffs parameters specify + // the expected number of differences with equal, larger, and smaller sums of the page + // lengths respectively. The edit_length parameter is used to verify that the page + // lenght differences are exactly equal to the edit_length. + auto diffs = FindDifferences(original.page_lengths, modified.page_lengths); + + // Note, the assertion function assumes that all edits are made using the same edit + // array, this could be improved by passing a list of edit arrays to the function + // and calculating the edit length for each edit array. + int64_t edit_length = edit_array->length(); + if (::arrow::is_list_like(edit_array->type()->id())) { + // add null and empty lists to the edit length because the page length corresponds to + // the number of def/rep levels rather than the number of elements in the array + for (auto chunk : edit_array->chunks()) { + auto list_array = checked_cast(chunk.get()); + for (int i = 0; i < list_array->length(); i++) { + if (list_array->IsNull(i) || (list_array->value_length(i) == 0)) { + edit_length++; + } + } + } + } + + size_t expected_number_of_diffs = exact_number_of_equal_diffs + + exact_number_of_larger_diffs + + exact_number_of_smaller_diffs; + if (diffs.size() != expected_number_of_diffs) { + PrintDifferences(original.page_lengths, modified.page_lengths, diffs); + } + if (diffs.size() == 0) { + // no differences found, the arrays are equal + ASSERT_TRUE(original.page_lengths == modified.page_lengths); + } + ASSERT_EQ(diffs.size(), expected_number_of_diffs); + + int32_t equal_diffs = 0; + int32_t larger_diffs = 0; + int32_t smaller_diffs = 0; + for (const auto& diff : diffs) { + int64_t original_sum = 0, modified_sum = 0; + for (const auto& val : diff.first) original_sum += val; + for (const auto& val : diff.second) modified_sum += val; + + if (original_sum == modified_sum) { + equal_diffs++; + } else if (original_sum < modified_sum) { + larger_diffs++; + ASSERT_EQ(original_sum + edit_length, modified_sum); + } else if (original_sum > modified_sum) { + smaller_diffs++; + ASSERT_EQ(original_sum, modified_sum + edit_length); + } + } + + ASSERT_EQ(equal_diffs, exact_number_of_equal_diffs); + ASSERT_EQ(larger_diffs, exact_number_of_larger_diffs); + ASSERT_EQ(smaller_diffs, exact_number_of_smaller_diffs); +} + +void AssertPageLengthDifferences(const ColumnInfo& original, const ColumnInfo& modified, + int32_t max_number_of_equal_diffs) { + // A less restrictive version of the above assertion function mainly used to + // assert the update case. + auto diffs = FindDifferences(original.page_lengths, modified.page_lengths); + if (diffs.size() > static_cast(max_number_of_equal_diffs)) { + PrintDifferences(original.page_lengths, modified.page_lengths, diffs); + } + ASSERT_LE(diffs.size(), static_cast(max_number_of_equal_diffs)); + + for (const auto& diff : diffs) { + int64_t left_sum = 0, right_sum = 0; + for (const auto& val : diff.first) left_sum += val; + for (const auto& val : diff.second) right_sum += val; + // This is only used from the UpdateOnce and UpdateTwice test cases where the edit(s) + // don't change the length of the original array, only update the value. This happens + // to apply to the list types as well because of the consistent array data generation. + ASSERT_EQ(left_sum, right_sum); + } + + if (diffs.size() == 0) { + // no differences found, the arrays are equal + ASSERT_TRUE(original.page_lengths == modified.page_lengths); + } +} + +Result CalculateCdcSize(const std::shared_ptr& array, bool nullable) { + // calculate the CDC chunk size based on the array elements belonging to a parquet page + auto type_id = array->type()->id(); + + int64_t result = 0; + if (::arrow::is_fixed_width(type_id)) { + int64_t element_size; + if (array->type()->id() == ::arrow::Type::BOOL) { + // the CDC chunker increments the chunk size by 1 for each boolean element + element_size = 1; + } else { + element_size = array->type()->byte_width(); + } + auto valid_elements = array->length() - array->null_count(); + result = valid_elements * element_size; + } else if (::arrow::is_binary_like(type_id)) { + auto binary_array = checked_cast(array.get()); + result += binary_array->total_values_length(); + } else if (::arrow::is_large_binary_like(type_id)) { + auto binary_array = checked_cast(array.get()); + result += binary_array->total_values_length(); + } else { + return Status::NotImplemented("CDC size calculation for type ", + array->type()->ToString(), " is not implemented"); + } + + if (nullable) { + // in case of nullable types chunk size is calculated from def_levels and + // the valid values + return result + array->length() * sizeof(uint16_t); + } else { + // for non-nullable types the chunk size is calculated purely from the values + return result; + } +} + +Result CalculateCdcSize(const std::shared_ptr<::arrow::ChunkedArray>& array, + bool nullable) { + int64_t result = 0; + for (int i = 0; i < array->num_chunks(); i++) { + ARROW_ASSIGN_OR_RAISE(auto chunk_size, CalculateCdcSize(array->chunk(i), nullable)); + result += chunk_size; + } + return result; +} + +void AssertContentDefinedChunkSizes(const std::shared_ptr<::arrow::ChunkedArray>& array, + const ColumnInfo& column_info, bool nullable, + int64_t min_chunk_size, int64_t max_chunk_size, + bool expect_dictionary_page) { + // check that the chunk sizes are within the expected range + + // the test tables are combined in the test cases so we expect only a single chunk + auto type_id = array->type()->id(); + + // check for the dictionary page if expected + if (type_id == ::arrow::Type::BOOL) { + ASSERT_FALSE(column_info.has_dictionary_page); + } else { + ASSERT_EQ(column_info.has_dictionary_page, expect_dictionary_page); + ASSERT_EQ(column_info.has_dictionary_page, expect_dictionary_page); + } + + if (::arrow::is_fixed_width(type_id) || ::arrow::is_base_binary_like(type_id)) { + int64_t offset = 0; + + auto page_lengths = column_info.page_lengths; + for (size_t i = 0; i < page_lengths.size() - 1; i++) { + // since CDC chunking is applied on the logical values before any parquet encoding + // we first slice the array to get the logical array and then calculate the CDC + // chunk size based on that + auto page_length = page_lengths[i]; + auto array_chunk = array->Slice(offset, page_length); + offset += page_length; + + ASSERT_OK_AND_ASSIGN(auto cdc_chunk_size, CalculateCdcSize(array_chunk, nullable)); + ASSERT_GE(cdc_chunk_size, min_chunk_size); + ASSERT_LE(cdc_chunk_size, max_chunk_size); + } + + auto last_page_length = page_lengths.back(); + auto last_array_chunk = array->Slice(offset, last_page_length); + ASSERT_OK_AND_ASSIGN(auto last_cdc_chunk_size, + CalculateCdcSize(last_array_chunk, nullable)); + // min chunk size is not guaranteed for the last chunk, only check that it is not + // larger than the max chunk size + ASSERT_LE(last_cdc_chunk_size, max_chunk_size); + + // the sum of the page lengths should be equal to the length of the array + offset += last_page_length; + ASSERT_EQ(offset, array->length()); + } + + // TODO(kszucs): have approximate size assertions for variable length types because + // we cannot calculate accurate CDC chunk sizes for list-like types without actually + // scanning the data and reimplementing the logic from the CDC chunker +} + +class TestCDC : public ::testing::Test { + protected: + static constexpr int64_t kMinChunkSize = 4 * 1024; + static constexpr int64_t kMaxChunkSize = 16 * 1024; + uint64_t GetRollingHashMask(const ContentDefinedChunker& cdc) const { + return cdc.GetRollingHashMask(); + } +}; + +TEST_F(TestCDC, ChunkSizeParameterValidation) { + // Test that constructor validates min/max chunk size parameters + auto li = LevelInfo(); + + ASSERT_NO_THROW(ContentDefinedChunker(li, 256 * 1024, 1024 * 1024)); + + // with norm_level=0 the difference between min and max chunk size must be + // at least 16 + ASSERT_THROW(ContentDefinedChunker(li, 0, -1), ParquetException); + ASSERT_THROW(ContentDefinedChunker(li, 1024, 512), ParquetException); + + ASSERT_THROW(ContentDefinedChunker(li, -1, 0), ParquetException); + ASSERT_THROW(ContentDefinedChunker(li, 0, 0), ParquetException); + ASSERT_THROW(ContentDefinedChunker(li, 0, 16), ParquetException); + ASSERT_NO_THROW(ContentDefinedChunker(li, 0, 32)); + ASSERT_THROW(ContentDefinedChunker(li, -16, -16), ParquetException); + ASSERT_THROW(ContentDefinedChunker(li, 16, 0), ParquetException); + ASSERT_THROW(ContentDefinedChunker(li, 32, 32), ParquetException); + ASSERT_THROW(ContentDefinedChunker(li, 32, 48), ParquetException); + ASSERT_NO_THROW(ContentDefinedChunker(li, 32, 64)); + ASSERT_NO_THROW(ContentDefinedChunker(li, 1024 * 1024, 2 * 1024 * 1024)); + ASSERT_NO_THROW( + ContentDefinedChunker(li, 1024 * 1024 * 1024L, 2LL * 1024 * 1024 * 1024L)); + + // with norm_level=1 the difference between min and max chunk size must be + // at least 64 + ASSERT_THROW(ContentDefinedChunker(li, 1, -1, 1), ParquetException); + ASSERT_THROW(ContentDefinedChunker(li, -1, 1, 1), ParquetException); + ASSERT_THROW(ContentDefinedChunker(li, 1, 1, 1), ParquetException); + ASSERT_THROW(ContentDefinedChunker(li, 1, 32, 1), ParquetException); + ASSERT_THROW(ContentDefinedChunker(li, 1, 33, 1), ParquetException); + ASSERT_NO_THROW(ContentDefinedChunker(li, 1, 65, 1)); + + // with norm_level=2 the difference between min and max chunk size must be + // at least 128 + ASSERT_THROW(ContentDefinedChunker(li, 0, 123, 2), ParquetException); + ASSERT_NO_THROW(ContentDefinedChunker(li, 0, 128, 2)); +} + +TEST_F(TestCDC, RollingHashMaskCalculation) { + auto le = LevelInfo(); + auto min_size = 256 * 1024; + auto max_size = 1024 * 1024; + + auto cdc0 = ContentDefinedChunker(le, min_size, max_size, 0); + ASSERT_EQ(GetRollingHashMask(cdc0), 0xFFFE000000000000); + + auto cdc1 = ContentDefinedChunker(le, min_size, max_size, 1); + ASSERT_EQ(GetRollingHashMask(cdc1), 0xFFFC000000000000); + + auto cdc2 = ContentDefinedChunker(le, min_size, max_size, 2); + ASSERT_EQ(GetRollingHashMask(cdc2), 0xFFF8000000000000); + + auto cdc3 = ContentDefinedChunker(le, min_size, max_size, 3); + ASSERT_EQ(GetRollingHashMask(cdc3), 0xFFF0000000000000); + + auto cdc4 = ContentDefinedChunker(le, min_size, max_size, -1); + ASSERT_EQ(GetRollingHashMask(cdc4), 0xFFFF000000000000); + + // check that mask bits are between 1 and 63 after adjusting with the 8 hash tables + ASSERT_THROW(ContentDefinedChunker(le, 0, 16, 0), ParquetException); + + auto cdc5 = ContentDefinedChunker(le, 0, 32, 0); + ASSERT_EQ(GetRollingHashMask(cdc5), 0x8000000000000000); + ASSERT_THROW(ContentDefinedChunker(le, 0, 32, 1), ParquetException); + + auto cdc6 = ContentDefinedChunker(le, 0, 64, 0); + ASSERT_EQ(GetRollingHashMask(cdc6), 0xC000000000000000); + + auto cdc7 = ContentDefinedChunker(le, 0, 16, -1); + ASSERT_EQ(GetRollingHashMask(cdc7), 0x8000000000000000); + + // another unrealistic case, checking for the validation + ASSERT_THROW(ContentDefinedChunker(le, 128, 384, -60), ParquetException); + auto cdc8 = ContentDefinedChunker(le, 128, 384, -59); + ASSERT_EQ(GetRollingHashMask(cdc8), 0xFFFFFFFFFFFFFFFE); +} + +TEST_F(TestCDC, WriteSingleColumnParquetFile) { + // Define the schema with a single column "number" + auto schema = std::dynamic_pointer_cast(schema::GroupNode::Make( + "root", Repetition::REQUIRED, + {schema::PrimitiveNode::Make("number", Repetition::REQUIRED, Type::INT32)})); + + auto sink = CreateOutputStream(); + auto builder = WriterProperties::Builder(); + auto props = builder.enable_content_defined_chunking()->build(); + + auto writer = ParquetFileWriter::Open(sink, schema, props); + auto row_group_writer = writer->AppendRowGroup(); + + // Create a column writer for the "number" column + auto column_writer = row_group_writer->NextColumn(); + auto& int_column_writer = dynamic_cast(*column_writer); + + std::vector numbers = {1, 2, 3, 4, 5}; + std::vector valid_bits = {1, 0, 1, 0, 1}; + + auto expected_msg = ::testing::Property( + &ParquetException::what, + ::testing::HasSubstr("" + "")); + EXPECT_THROW_THAT( + [&]() { + int_column_writer.WriteBatch(numbers.size(), nullptr, nullptr, numbers.data()); + }, + ParquetException, expected_msg); + EXPECT_THROW_THAT( + [&]() { + int_column_writer.WriteBatchSpaced(numbers.size(), nullptr, nullptr, + valid_bits.data(), 0, numbers.data()); + }, + ParquetException, expected_msg); +} + +TEST_F(TestCDC, LastChunkDoesntTriggerAddDataPage) { + // Define the schema with a single column "number" + auto schema = std::dynamic_pointer_cast(schema::GroupNode::Make( + "root", Repetition::REQUIRED, + {schema::PrimitiveNode::Make("number", Repetition::REQUIRED, Type::INT32)})); + + auto sink = CreateOutputStream(); + auto builder = WriterProperties::Builder(); + auto props = builder.enable_content_defined_chunking() + ->content_defined_chunking_options({kMinChunkSize, kMaxChunkSize, 0}) + ->disable_dictionary() + ->build(); + + auto writer = ParquetFileWriter::Open(sink, schema, props); + auto row_group_writer = writer->AppendRowGroup(); + + // Create a column writer for the "number" column + auto column_writer = row_group_writer->NextColumn(); + auto& int_column_writer = dynamic_cast(*column_writer); + + ASSERT_OK_AND_ASSIGN(auto array, ::arrow::gen::Step()->Generate(8000)); + auto arrow_props = default_arrow_writer_properties(); + auto arrow_ctx = ArrowWriteContext(default_memory_pool(), arrow_props.get()); + + // Calling WriteArrow twice, we expect that the first call doesn't add a new data page + // at the end allowing subsequent calls to append to the same page + ASSERT_OK(int_column_writer.WriteArrow(nullptr, nullptr, array->length(), *array, + &arrow_ctx, false)); + ASSERT_OK(int_column_writer.WriteArrow(nullptr, nullptr, array->length(), *array, + &arrow_ctx, false)); + + int_column_writer.Close(); + writer->Close(); + ASSERT_OK_AND_ASSIGN(auto buffer, sink->Finish()); + + auto info = GetColumnParquetInfo(buffer, /*column_index=*/0); + ASSERT_EQ(info.size(), 1); + + ASSERT_OK_AND_ASSIGN(auto chunked_array, ChunkedArray::Make({array, array})); + AssertContentDefinedChunkSizes(chunked_array, info.front(), /*nullable=*/false, + kMinChunkSize, kMaxChunkSize, + /*expect_dictionary_page=*/false); +} + +struct CaseConfig { + // Arrow data type to generate the testing data for + std::shared_ptr<::arrow::DataType> dtype; + // Whether the data type is nullable + bool is_nullable; + // Data page version to use + ParquetDataPageVersion data_page_version = ParquetDataPageVersion::V1; +}; + +// Define PrintTo for MyStruct +void PrintTo(const CaseConfig& param, std::ostream* os) { + *os << "{ " << param.dtype->ToString(); + if (param.is_nullable) { + *os << " nullable"; + } + *os << " }"; +} + +class TestCDCSingleRowGroup : public ::testing::TestWithParam { + protected: + static constexpr int64_t kPartSize = 128 * 1024; + static constexpr int64_t kEditSize = 128; + static constexpr int64_t kMinChunkSize = 4 * 1024; + static constexpr int64_t kMaxChunkSize = 16 * 1024; + static constexpr int64_t kRowGroupLength = 1024 * 1024; + + // Column random table parts for testing + std::shared_ptr field_; + std::shared_ptr
part1_, part2_, part3_, part4_, part5_, part6_, part7_; + + void SetUp() override { + const auto& param = GetParam(); + auto field_ = ::arrow::field("f0", param.dtype, param.is_nullable); + auto schema = ::arrow::schema({field_}); + + // since the chunk sizes are constant we derive the number of records to generate + // from the size of the data type unless it is nested or variable length where + // we use a hand picked value to avoid generating too large tables + int64_t bytes_per_record; + if (param.dtype->byte_width() > 0) { + bytes_per_record = param.dtype->byte_width(); + if (param.is_nullable) { + bytes_per_record += sizeof(uint16_t); + } + } else { + // for variable length types we use the size of the first element + bytes_per_record = 16; + } + + auto part_length = kPartSize / bytes_per_record; + auto edit_length = kEditSize / bytes_per_record; + + ASSERT_OK_AND_ASSIGN(part1_, GenerateTable(schema, part_length, /*seed=*/0)); + ASSERT_OK_AND_ASSIGN(part2_, GenerateTable(schema, edit_length, /*seed=*/1)); + ASSERT_OK_AND_ASSIGN(part3_, + GenerateTable(schema, part_length, /*seed=*/part_length)); + ASSERT_OK_AND_ASSIGN(part4_, GenerateTable(schema, edit_length, /*seed=*/2)); + ASSERT_OK_AND_ASSIGN(part5_, + GenerateTable(schema, part_length, /*seed=*/2 * part_length)); + ASSERT_OK_AND_ASSIGN(part6_, GenerateTable(schema, edit_length, /*seed=*/3)); + ASSERT_OK_AND_ASSIGN(part7_, GenerateTable(schema, edit_length, /*seed=*/4)); + } +}; + +TEST_P(TestCDCSingleRowGroup, DeleteOnce) { + const auto& param = GetParam(); + + ASSERT_OK_AND_ASSIGN(auto base, ConcatAndCombine({part1_, part2_, part3_})); + ASSERT_OK_AND_ASSIGN(auto modified, ConcatAndCombine({part1_, part3_})); + ASSERT_FALSE(base->Equals(*modified)); + + for (bool enable_dictionary : {false, true}) { + ASSERT_OK_AND_ASSIGN( + auto base_parquet, + WriteTableToBuffer(base, kMinChunkSize, kMaxChunkSize, kRowGroupLength, + enable_dictionary, param.data_page_version)); + ASSERT_OK_AND_ASSIGN( + auto modified_parquet, + WriteTableToBuffer(modified, kMinChunkSize, kMaxChunkSize, kRowGroupLength, + enable_dictionary, param.data_page_version)); + + auto base_info = GetColumnParquetInfo(base_parquet, /*column_index=*/0); + auto modified_info = GetColumnParquetInfo(modified_parquet, /*column_index=*/0); + + // assert that there is only one row group + ASSERT_EQ(base_info.size(), 1); + ASSERT_EQ(modified_info.size(), 1); + + // check that the chunk sizes are within the expected range + AssertContentDefinedChunkSizes(base->column(0), base_info.front(), param.is_nullable, + kMinChunkSize, kMaxChunkSize, + /*expect_dictionary_page=*/enable_dictionary); + AssertContentDefinedChunkSizes(modified->column(0), modified_info.front(), + param.is_nullable, kMinChunkSize, kMaxChunkSize, + /*expect_dictionary_page=*/enable_dictionary); + + // check that there is a single "diff" between the two page length sequences + // and that the diff removes edit_length number of values, there should be no + // other differences because we deal with a single row group (in case of multiple + // row groups the first page of each subsequent row group would be different due + // to shifting caused by the fixed sized row group length) + AssertPageLengthDifferences(base_info.front(), modified_info.front(), + /*exact_number_of_equal_diffs=*/0, + /*exact_number_of_larger_diffs=*/0, + /*exact_number_of_smaller_diffs=*/1, part2_->column(0)); + } +} + +TEST_P(TestCDCSingleRowGroup, DeleteTwice) { + const auto& param = GetParam(); + + ASSERT_OK_AND_ASSIGN(auto base, + ConcatAndCombine({part1_, part2_, part3_, part4_, part5_})); + ASSERT_OK_AND_ASSIGN(auto modified, ConcatAndCombine({part1_, part3_, part5_})); + ASSERT_FALSE(base->Equals(*modified)); + + for (bool enable_dictionary : {false, true}) { + ASSERT_OK_AND_ASSIGN( + auto base_parquet, + WriteTableToBuffer(base, kMinChunkSize, kMaxChunkSize, kRowGroupLength, + enable_dictionary, param.data_page_version)); + ASSERT_OK_AND_ASSIGN( + auto modified_parquet, + WriteTableToBuffer(modified, kMinChunkSize, kMaxChunkSize, kRowGroupLength, + enable_dictionary, param.data_page_version)); + + auto base_info = GetColumnParquetInfo(base_parquet, /*column_index=*/0); + auto modified_info = GetColumnParquetInfo(modified_parquet, /*column_index=*/0); + + // assert that there is only one row group + ASSERT_EQ(base_info.size(), 1); + ASSERT_EQ(modified_info.size(), 1); + + // check that the chunk sizes are within the expected range + AssertContentDefinedChunkSizes(base->column(0), base_info.front(), param.is_nullable, + kMinChunkSize, kMaxChunkSize, + /*expect_dictionary_page=*/enable_dictionary); + AssertContentDefinedChunkSizes(modified->column(0), modified_info.front(), + param.is_nullable, kMinChunkSize, kMaxChunkSize, + /*expect_dictionary_page=*/enable_dictionary); + + // check that there are exactly two "diffs" between the two page length sequences + // and those diffs remove edit_length number of values (part2 and part4 have the + // same number of values), there should be no other differences because we have + // a single row group + AssertPageLengthDifferences(base_info.front(), modified_info.front(), + /*exact_number_of_equal_diffs=*/0, + /*exact_number_of_larger_diffs=*/0, + /*exact_number_of_smaller_diffs=*/2, part2_->column(0)); + } +} + +TEST_P(TestCDCSingleRowGroup, UpdateOnce) { + const auto& param = GetParam(); + + ASSERT_OK_AND_ASSIGN(auto base, ConcatAndCombine({part1_, part2_, part3_})); + ASSERT_OK_AND_ASSIGN(auto modified, ConcatAndCombine({part1_, part4_, part3_})); + ASSERT_FALSE(base->Equals(*modified)); + + for (bool enable_dictionary : {false, true}) { + ASSERT_OK_AND_ASSIGN( + auto base_parquet, + WriteTableToBuffer(base, kMinChunkSize, kMaxChunkSize, kRowGroupLength, + enable_dictionary, param.data_page_version)); + ASSERT_OK_AND_ASSIGN( + auto modified_parquet, + WriteTableToBuffer(modified, kMinChunkSize, kMaxChunkSize, kRowGroupLength, + enable_dictionary, param.data_page_version)); + + auto base_info = GetColumnParquetInfo(base_parquet, /*column_index=*/0); + auto modified_info = GetColumnParquetInfo(modified_parquet, /*column_index=*/0); + + // assert that there is only one row group + ASSERT_EQ(base_info.size(), 1); + ASSERT_EQ(modified_info.size(), 1); + + // check that the chunk sizes are within the expected range + AssertContentDefinedChunkSizes(base->column(0), base_info.front(), param.is_nullable, + kMinChunkSize, kMaxChunkSize, + /*expect_dictionary_page=*/enable_dictionary); + AssertContentDefinedChunkSizes(modified->column(0), modified_info.front(), + param.is_nullable, kMinChunkSize, kMaxChunkSize, + /*expect_dictionary_page=*/enable_dictionary); + + // check that there is a single "diff" between the two page length sequences + // which doesn't change the length of the array, only the values are updated + // there should be no other differences because we deal with a single row group + AssertPageLengthDifferences(base_info.front(), modified_info.front(), + /*max_number_of_equal_diffs=*/1); + } +} + +TEST_P(TestCDCSingleRowGroup, UpdateTwice) { + const auto& param = GetParam(); + + ASSERT_OK_AND_ASSIGN(auto base, + ConcatAndCombine({part1_, part2_, part3_, part4_, part5_})); + ASSERT_OK_AND_ASSIGN(auto modified, + ConcatAndCombine({part1_, part6_, part3_, part7_, part5_})); + ASSERT_FALSE(base->Equals(*modified)); + + for (bool enable_dictionary : {false, true}) { + ASSERT_OK_AND_ASSIGN( + auto base_parquet, + WriteTableToBuffer(base, kMinChunkSize, kMaxChunkSize, kRowGroupLength, + enable_dictionary, param.data_page_version)); + ASSERT_OK_AND_ASSIGN( + auto modified_parquet, + WriteTableToBuffer(modified, kMinChunkSize, kMaxChunkSize, kRowGroupLength, + enable_dictionary, param.data_page_version)); + + auto base_info = GetColumnParquetInfo(base_parquet, /*column_index=*/0); + auto modified_info = GetColumnParquetInfo(modified_parquet, /*column_index=*/0); + + // assert that there is only one row group + ASSERT_EQ(base_info.size(), 1); + ASSERT_EQ(modified_info.size(), 1); + + // check that the chunk sizes are within the expected range + AssertContentDefinedChunkSizes(base->column(0), base_info.front(), param.is_nullable, + kMinChunkSize, kMaxChunkSize, + /*expect_dictionary_page=*/enable_dictionary); + AssertContentDefinedChunkSizes(modified->column(0), modified_info.front(), + param.is_nullable, kMinChunkSize, kMaxChunkSize, + /*expect_dictionary_page=*/enable_dictionary); + + // check that there are exactly two "diffs" between the two page length sequences + // which don't change the length of the array, only the values are updated + AssertPageLengthDifferences(base_info.front(), modified_info.front(), + /*max_number_of_equal_diffs=*/2); + } +} + +TEST_P(TestCDCSingleRowGroup, InsertOnce) { + const auto& param = GetParam(); + + ASSERT_OK_AND_ASSIGN(auto base, ConcatAndCombine({part1_, part3_})); + ASSERT_OK_AND_ASSIGN(auto modified, ConcatAndCombine({part1_, part2_, part3_})); + ASSERT_FALSE(base->Equals(*modified)); + + for (bool enable_dictionary : {false, true}) { + ASSERT_OK_AND_ASSIGN( + auto base_parquet, + WriteTableToBuffer(base, kMinChunkSize, kMaxChunkSize, kRowGroupLength, + enable_dictionary, param.data_page_version)); + ASSERT_OK_AND_ASSIGN( + auto modified_parquet, + WriteTableToBuffer(modified, kMinChunkSize, kMaxChunkSize, kRowGroupLength, + enable_dictionary, param.data_page_version)); + + auto base_info = GetColumnParquetInfo(base_parquet, /*column_index=*/0); + auto modified_info = GetColumnParquetInfo(modified_parquet, /*column_index=*/0); + + // assert that there is only one row group + ASSERT_EQ(base_info.size(), 1); + ASSERT_EQ(modified_info.size(), 1); + + // check that the chunk sizes are within the expected range + AssertContentDefinedChunkSizes(base->column(0), base_info.front(), param.is_nullable, + kMinChunkSize, kMaxChunkSize, + /*expect_dictionary_page=*/enable_dictionary); + AssertContentDefinedChunkSizes(modified->column(0), modified_info.front(), + param.is_nullable, kMinChunkSize, kMaxChunkSize, + /*expect_dictionary_page=*/enable_dictionary); + + // check that there is a single "diff" between the two page length sequences + // adding edit_length number of values, there should be no other differences + // because we deal with a single row group and made a single modification + AssertPageLengthDifferences(base_info.front(), modified_info.front(), + /*exact_number_of_equal_diffs=*/0, + /*exact_number_of_larger_diffs=*/1, + /*exact_number_of_smaller_diffs=*/0, part2_->column(0)); + } +} + +TEST_P(TestCDCSingleRowGroup, InsertTwice) { + const auto& param = GetParam(); + + ASSERT_OK_AND_ASSIGN(auto base, ConcatAndCombine({part1_, part3_, part5_})); + ASSERT_OK_AND_ASSIGN(auto modified, + ConcatAndCombine({part1_, part2_, part3_, part4_, part5_})); + ASSERT_FALSE(base->Equals(*modified)); + + for (bool enable_dictionary : {false, true}) { + ASSERT_OK_AND_ASSIGN( + auto base_parquet, + WriteTableToBuffer(base, kMinChunkSize, kMaxChunkSize, kRowGroupLength, + enable_dictionary, param.data_page_version)); + ASSERT_OK_AND_ASSIGN( + auto modified_parquet, + WriteTableToBuffer(modified, kMinChunkSize, kMaxChunkSize, kRowGroupLength, + enable_dictionary, param.data_page_version)); + + auto base_info = GetColumnParquetInfo(base_parquet, /*column_index=*/0); + auto modified_info = GetColumnParquetInfo(modified_parquet, /*column_index=*/0); + + // assert that there is only one row group + ASSERT_EQ(base_info.size(), 1); + ASSERT_EQ(modified_info.size(), 1); + + // check that the chunk sizes are within the expected range + AssertContentDefinedChunkSizes(base->column(0), base_info.front(), param.is_nullable, + kMinChunkSize, kMaxChunkSize, + /*expect_dictionary_page=*/enable_dictionary); + AssertContentDefinedChunkSizes(modified->column(0), modified_info.front(), + param.is_nullable, kMinChunkSize, kMaxChunkSize, + /*expect_dictionary_page=*/enable_dictionary); + + // check that there are exactly two "diffs" between the two page length sequences + // which add edit_length number of values, there should be no other differences + AssertPageLengthDifferences(base_info.front(), modified_info.front(), + /*exact_number_of_equal_diffs=*/0, + /*exact_number_of_larger_diffs=*/2, + /*exact_number_of_smaller_diffs=*/0, part2_->column(0)); + } +} + +TEST_P(TestCDCSingleRowGroup, Prepend) { + const auto& param = GetParam(); + + ASSERT_OK_AND_ASSIGN(auto base, ConcatAndCombine({part1_, part2_, part3_})); + ASSERT_OK_AND_ASSIGN(auto modified, ConcatAndCombine({part4_, part1_, part2_, part3_})); + ASSERT_FALSE(base->Equals(*modified)); + + for (bool enable_dictionary : {false, true}) { + ASSERT_OK_AND_ASSIGN( + auto base_parquet, + WriteTableToBuffer(base, kMinChunkSize, kMaxChunkSize, kRowGroupLength, + enable_dictionary, param.data_page_version)); + ASSERT_OK_AND_ASSIGN( + auto modified_parquet, + WriteTableToBuffer(modified, kMinChunkSize, kMaxChunkSize, kRowGroupLength, + enable_dictionary, param.data_page_version)); + + auto base_info = GetColumnParquetInfo(base_parquet, /*column_index=*/0); + auto modified_info = GetColumnParquetInfo(modified_parquet, /*column_index=*/0); + + // assert that there is only one row group + ASSERT_EQ(base_info.size(), 1); + ASSERT_EQ(modified_info.size(), 1); + + // check that the chunk sizes are within the expected range + AssertContentDefinedChunkSizes(base->column(0), base_info.front(), param.is_nullable, + kMinChunkSize, kMaxChunkSize, + /*expect_dictionary_page=*/enable_dictionary); + AssertContentDefinedChunkSizes(modified->column(0), modified_info.front(), + param.is_nullable, kMinChunkSize, kMaxChunkSize, + /*expect_dictionary_page=*/enable_dictionary); + + auto original_page_lengths = base_info.front().page_lengths; + auto modified_page_lengths = modified_info.front().page_lengths; + + // we expect to have the same number or more pages at the beginning of the + // modified file without increasing the size of any subsequent page + ASSERT_LE(original_page_lengths.size(), modified_page_lengths.size()); + AssertPageLengthDifferences(base_info.front(), modified_info.front(), + /*exact_number_of_equal_diffs=*/0, + /*exact_number_of_larger_diffs=*/1, + /*exact_number_of_smaller_diffs=*/0, part4_->column(0)); + } +} + +TEST_P(TestCDCSingleRowGroup, Append) { + const auto& param = GetParam(); + + ASSERT_OK_AND_ASSIGN(auto base, ConcatAndCombine({part1_, part2_, part3_})); + ASSERT_OK_AND_ASSIGN(auto modified, ConcatAndCombine({part1_, part2_, part3_, part4_})); + ASSERT_FALSE(base->Equals(*modified)); + + for (bool enable_dictionary : {false, true}) { + ASSERT_OK_AND_ASSIGN( + auto base_parquet, + WriteTableToBuffer(base, kMinChunkSize, kMaxChunkSize, kRowGroupLength, + enable_dictionary, param.data_page_version)); + ASSERT_OK_AND_ASSIGN( + auto modified_parquet, + WriteTableToBuffer(modified, kMinChunkSize, kMaxChunkSize, kRowGroupLength, + enable_dictionary, param.data_page_version)); + + auto base_info = GetColumnParquetInfo(base_parquet, /*column_index=*/0); + auto modified_info = GetColumnParquetInfo(modified_parquet, /*column_index=*/0); + + // assert that there is only one row group + ASSERT_EQ(base_info.size(), 1); + ASSERT_EQ(modified_info.size(), 1); + + // check that the chunk sizes are within the expected range + AssertContentDefinedChunkSizes(base->column(0), base_info.front(), param.is_nullable, + kMinChunkSize, kMaxChunkSize, + /*expect_dictionary_page=*/enable_dictionary); + AssertContentDefinedChunkSizes(modified->column(0), modified_info.front(), + param.is_nullable, kMinChunkSize, kMaxChunkSize, + /*expect_dictionary_page=*/enable_dictionary); + + auto original_page_lengths = base_info.front().page_lengths; + auto modified_page_lengths = modified_info.front().page_lengths; + + // there are either additional pages and/or the last page is larger in the modified + // than in the original file + ASSERT_LE(original_page_lengths.size(), modified_page_lengths.size()); + // all pages must be identical except for the last one which can be larger + for (size_t i = 0; i < original_page_lengths.size() - 1; i++) { + ASSERT_EQ(original_page_lengths[i], modified_page_lengths[i]); + } + auto last_index = original_page_lengths.size() - 1; + ASSERT_GE(modified_page_lengths[last_index], original_page_lengths[last_index]); + } +} + +TEST_P(TestCDCSingleRowGroup, EmptyTable) { + const auto& param = GetParam(); + + auto schema = ::arrow::schema({::arrow::field("f0", param.dtype, param.is_nullable)}); + ASSERT_OK_AND_ASSIGN(auto empty_table, GenerateTable(schema, 0, /*seed=*/0)); + ASSERT_EQ(empty_table->num_rows(), 0); + + for (bool enable_dictionary : {false, true}) { + ASSERT_OK_AND_ASSIGN( + auto parquet, + WriteTableToBuffer(empty_table, kMinChunkSize, kMaxChunkSize, kRowGroupLength, + enable_dictionary, param.data_page_version)); + + auto info = GetColumnParquetInfo(parquet, /*column_index=*/0); + + // There is a single row group + ASSERT_EQ(info.size(), 1); + + // An empty table should result in no data pages + ASSERT_TRUE(info.front().page_lengths.empty()); + ASSERT_TRUE(info.front().page_sizes.empty()); + } +} + +TEST_P(TestCDCSingleRowGroup, ArrayOffsets) { + // check that the array offsets are respected in the chunker + const auto& param = GetParam(); + ASSERT_OK_AND_ASSIGN(auto table, ConcatAndCombine({part1_, part2_, part3_})); + + for (auto offset : {0, 512, 1024}) { + auto sliced_table = table->Slice(offset); + + // assert that the first column has a non-zero offset + auto column = sliced_table->column(0); + auto first_chunk = column->chunk(0); + ASSERT_EQ(first_chunk->offset(), offset); + + // write out the sliced table, read it back and compare + ASSERT_OK_AND_ASSIGN( + auto sliced_parquet, + WriteTableToBuffer(sliced_table, kMinChunkSize, kMaxChunkSize, kRowGroupLength, + true, param.data_page_version)); + + auto sliced_info = GetColumnParquetInfo(sliced_parquet, /*column_index=*/0); + ASSERT_EQ(sliced_info.size(), 1); + } +} + +#if defined(ADDRESS_SANITIZER) || defined(ARROW_VALGRIND) +// Instantiate the test suite with a reduced set of types to avoid slow tests +INSTANTIATE_TEST_SUITE_P( + Types, TestCDCSingleRowGroup, + testing::Values( + CaseConfig{::arrow::boolean(), false}, CaseConfig{::arrow::int64(), true}, + // Binary-like + CaseConfig{::arrow::utf8(), false}, + CaseConfig{::arrow::fixed_size_binary(16), true}, + // Nested types + CaseConfig{::arrow::list(::arrow::int32()), false}, + CaseConfig{::arrow::list(::arrow::utf8()), true}, + CaseConfig{::arrow::struct_({::arrow::field("f0", ::arrow::float64())}), true})); +#else +INSTANTIATE_TEST_SUITE_P( + Types, TestCDCSingleRowGroup, + testing::Values( + // Boolean + CaseConfig{::arrow::boolean(), false}, + // Numeric + CaseConfig{::arrow::uint8(), false}, CaseConfig{::arrow::uint16(), false}, + CaseConfig{::arrow::uint32(), false}, CaseConfig{::arrow::uint64(), true}, + CaseConfig{::arrow::int8(), false}, CaseConfig{::arrow::int16(), false}, + CaseConfig{::arrow::int32(), false}, CaseConfig{::arrow::int64(), true}, + CaseConfig{::arrow::float16(), false}, CaseConfig{::arrow::float32(), false}, + CaseConfig{::arrow::float64(), true}, + CaseConfig{::arrow::decimal128(18, 6), false}, + CaseConfig{::arrow::decimal256(40, 6), false}, + // Binary-like + CaseConfig{::arrow::utf8(), false}, CaseConfig{::arrow::binary(), true}, + CaseConfig{::arrow::fixed_size_binary(16), true}, + // Temporal + CaseConfig{::arrow::date32(), false}, + CaseConfig{::arrow::time32(::arrow::TimeUnit::MILLI), true}, + CaseConfig{::arrow::time64(::arrow::TimeUnit::NANO), false}, + CaseConfig{::arrow::timestamp(::arrow::TimeUnit::NANO), true}, + CaseConfig{::arrow::duration(::arrow::TimeUnit::NANO), false}, + // Nested types + CaseConfig{::arrow::list(::arrow::int16()), false}, + CaseConfig{::arrow::list(::arrow::int32()), true}, + CaseConfig{::arrow::list(::arrow::utf8()), true}, + CaseConfig{::arrow::struct_({::arrow::field("f0", ::arrow::int32())}), false}, + CaseConfig{::arrow::struct_({::arrow::field("f0", ::arrow::float64())}), true}, + CaseConfig{ + ::arrow::list(::arrow::struct_({::arrow::field("f0", ::arrow::int32())})), + false}, + // Extension type + CaseConfig{::arrow::extension::json(), true}, + // Use ParquetDataPageVersion::V2 + CaseConfig{::arrow::large_binary(), false, ParquetDataPageVersion::V2}, + CaseConfig{::arrow::list(::arrow::utf8()), true, ParquetDataPageVersion::V2})); +#endif + +class TestCDCMultipleRowGroups : public ::testing::Test { + protected: + static auto constexpr kPartLength = 128 * 1024; + static auto constexpr kEditLength = 128; + static auto constexpr kRowGroupLength = 64 * 1024; + static auto constexpr kEnableDictionary = false; + static auto constexpr kMinChunkSize = 4 * 1024; + static auto constexpr kMaxChunkSize = 16 * 1024; + + // Column random table parts for testing + + std::shared_ptr
part1_, part2_, part3_; + std::shared_ptr
edit1_, edit2_, edit3_; + + void SetUp() override { + auto schema = ::arrow::schema({ + ::arrow::field("int32", ::arrow::int32(), true), + ::arrow::field("float64", ::arrow::float64(), true), + ::arrow::field("bool", ::arrow::boolean(), false), + }); + + ASSERT_OK_AND_ASSIGN(part1_, GenerateTable(schema, kPartLength, /*seed=*/0)); + ASSERT_OK_AND_ASSIGN(part2_, GenerateTable(schema, kPartLength, /*seed=*/2)); + ASSERT_OK_AND_ASSIGN(part3_, GenerateTable(schema, kPartLength, /*seed=*/4)); + + ASSERT_OK_AND_ASSIGN(edit1_, GenerateTable(schema, kEditLength, /*seed=*/1)); + ASSERT_OK_AND_ASSIGN(edit2_, GenerateTable(schema, kEditLength, /*seed=*/3)); + ASSERT_OK_AND_ASSIGN(edit3_, GenerateTable(schema, kEditLength, /*seed=*/5)); + } +}; + +TEST_F(TestCDCMultipleRowGroups, InsertOnce) { + ASSERT_OK_AND_ASSIGN(auto base, ConcatAndCombine({part1_, edit1_, part2_, part3_})); + ASSERT_OK_AND_ASSIGN(auto modified, + ConcatAndCombine({part1_, edit1_, edit2_, part2_, part3_})); + ASSERT_FALSE(base->Equals(*modified)); + ASSERT_EQ(modified->num_rows(), base->num_rows() + edit2_->num_rows()); + + ASSERT_OK_AND_ASSIGN( + auto base_parquet, + WriteTableToBuffer(base, kMinChunkSize, kMaxChunkSize, kRowGroupLength, + kEnableDictionary, ParquetDataPageVersion::V1)); + ASSERT_OK_AND_ASSIGN( + auto modified_parquet, + WriteTableToBuffer(modified, kMinChunkSize, kMaxChunkSize, kRowGroupLength, + kEnableDictionary, ParquetDataPageVersion::V1)); + + for (int col = 0; col < base->num_columns(); col++) { + auto base_info = GetColumnParquetInfo(base_parquet, /*column_index=*/col); + auto modified_info = GetColumnParquetInfo(modified_parquet, /*column_index=*/col); + + // assert that there are 7 row groups + ASSERT_EQ(base_info.size(), 7); + ASSERT_EQ(modified_info.size(), 7); + + // the first two row groups should be identical, each part contains two row groups and + // the first part is not modified + ASSERT_EQ(base_info.at(0).page_lengths, modified_info.at(0).page_lengths); + ASSERT_EQ(base_info.at(1).page_lengths, modified_info.at(1).page_lengths); + // then there is an insertion which causes a larger "diff" somewhere in the row group + // and a smaller "diff" at the end of the row group because the row group length is + // fixed; this rule applies to the subsequent row groups as well because the values + // are shifted by the insertion + auto edit_array = edit2_->column(col); + for (size_t i = 2; i < modified_info.size() - 1; i++) { + AssertPageLengthDifferences(base_info.at(i), modified_info.at(i), + /*exact_number_of_equal_diffs=*/0, + /*exact_number_of_larger_diffs=*/1, + /*exact_number_of_smaller_diffs=*/1, edit_array); + } + // the last row group will simply be larger because of the insertion + AssertPageLengthDifferences(base_info.back(), modified_info.back(), + /*exact_number_of_equal_diffs=*/0, + /*exact_number_of_larger_diffs=*/1, + /*exact_number_of_smaller_diffs=*/0, edit_array); + } +} + +TEST_F(TestCDCMultipleRowGroups, DeleteOnce) { + ASSERT_OK_AND_ASSIGN(auto base, + ConcatAndCombine({part1_, edit1_, part2_, part3_, edit2_})); + ASSERT_OK_AND_ASSIGN(auto modified, ConcatAndCombine({part1_, part2_, part3_, edit2_})); + ASSERT_FALSE(base->Equals(*modified)); + ASSERT_EQ(modified->num_rows(), base->num_rows() - edit1_->num_rows()); + + ASSERT_OK_AND_ASSIGN( + auto base_parquet, + WriteTableToBuffer(base, kMinChunkSize, kMaxChunkSize, kRowGroupLength, + kEnableDictionary, ParquetDataPageVersion::V1)); + ASSERT_OK_AND_ASSIGN( + auto modified_parquet, + WriteTableToBuffer(modified, kMinChunkSize, kMaxChunkSize, kRowGroupLength, + kEnableDictionary, ParquetDataPageVersion::V1)); + + for (int col = 0; col < base->num_columns(); col++) { + auto base_info = GetColumnParquetInfo(base_parquet, /*column_index=*/col); + auto modified_info = GetColumnParquetInfo(modified_parquet, /*column_index=*/col); + + // assert that there are 7 row groups + ASSERT_EQ(base_info.size(), 7); + ASSERT_EQ(modified_info.size(), 7); + + // the first two row groups should be identical, each part contains two row groups and + // the first part is not modified + ASSERT_EQ(base_info.at(0).page_lengths, modified_info.at(0).page_lengths); + ASSERT_EQ(base_info.at(1).page_lengths, modified_info.at(1).page_lengths); + // because of the deletion values are shifted in the row group, we expect a smaller + // "diff" at the beginning of the row group and a larger "diff" at the end of the + // row group + auto edit_array = edit2_->column(col); + for (size_t i = 2; i < modified_info.size() - 1; i++) { + AssertPageLengthDifferences(base_info.at(i), modified_info.at(i), + /*exact_number_of_equal_diffs=*/0, + /*exact_number_of_larger_diffs=*/1, + /*exact_number_of_smaller_diffs=*/1, edit_array); + } + // the last row group will simply be smaller because of the deletion + AssertPageLengthDifferences(base_info.back(), modified_info.back(), + /*exact_number_of_equal_diffs=*/0, + /*exact_number_of_larger_diffs=*/0, + /*exact_number_of_smaller_diffs=*/1, edit_array); + } +} + +TEST_F(TestCDCMultipleRowGroups, UpdateOnce) { + ASSERT_OK_AND_ASSIGN(auto base, + ConcatAndCombine({part1_, edit1_, part2_, part3_, edit2_})); + ASSERT_OK_AND_ASSIGN(auto modified, + ConcatAndCombine({part1_, edit3_, part2_, part3_, edit2_})); + ASSERT_FALSE(base->Equals(*modified)); + + ASSERT_OK_AND_ASSIGN( + auto base_parquet, + WriteTableToBuffer(base, kMinChunkSize, kMaxChunkSize, kRowGroupLength, + kEnableDictionary, ParquetDataPageVersion::V1)); + ASSERT_OK_AND_ASSIGN( + auto modified_parquet, + WriteTableToBuffer(modified, kMinChunkSize, kMaxChunkSize, kRowGroupLength, + kEnableDictionary, ParquetDataPageVersion::V1)); + for (int col = 0; col < base->num_columns(); col++) { + auto base_info = GetColumnParquetInfo(base_parquet, /*column_index=*/col); + auto modified_info = GetColumnParquetInfo(modified_parquet, /*column_index=*/col); + + // assert that there are 7 row groups + ASSERT_EQ(base_info.size(), 7); + ASSERT_EQ(modified_info.size(), 7); + + // the first two row groups should be identical, each part contains two row groups and + // the first part is not modified + ASSERT_EQ(base_info.at(0).page_lengths, modified_info.at(0).page_lengths); + ASSERT_EQ(base_info.at(1).page_lengths, modified_info.at(1).page_lengths); + // then there is an update (without insertion or deletion so no shifting occurs) which + // causes a "diff" with both sides having the same number of values but different ones + AssertPageLengthDifferences(base_info.at(2), modified_info.at(2), + /*max_number_of_equal_diffs=*/1); + for (size_t i = 2; i < modified_info.size(); i++) { + // the rest of the row groups should be identical + ASSERT_EQ(base_info.at(i).page_lengths, modified_info.at(i).page_lengths); + } + } +} + +TEST_F(TestCDCMultipleRowGroups, Append) { + ASSERT_OK_AND_ASSIGN(auto base, ConcatAndCombine({part1_, edit1_, part2_, part3_})); + ASSERT_OK_AND_ASSIGN(auto modified, + ConcatAndCombine({part1_, edit1_, part2_, part3_, edit2_})); + ASSERT_FALSE(base->Equals(*modified)); + ASSERT_EQ(modified->num_rows(), base->num_rows() + edit2_->num_rows()); + + ASSERT_OK_AND_ASSIGN( + auto base_parquet, + WriteTableToBuffer(base, kMinChunkSize, kMaxChunkSize, kRowGroupLength, + kEnableDictionary, ParquetDataPageVersion::V1)); + ASSERT_OK_AND_ASSIGN( + auto modified_parquet, + WriteTableToBuffer(modified, kMinChunkSize, kMaxChunkSize, kRowGroupLength, + kEnableDictionary, ParquetDataPageVersion::V1)); + + for (int col = 0; col < base->num_columns(); col++) { + auto base_info = GetColumnParquetInfo(base_parquet, /*column_index=*/col); + auto modified_info = GetColumnParquetInfo(modified_parquet, /*column_index=*/col); + + // assert that there are 7 row groups + ASSERT_EQ(base_info.size(), 7); + ASSERT_EQ(modified_info.size(), 7); + + for (size_t i = 0; i < modified_info.size() - 1; i++) { + ASSERT_EQ(base_info.at(i).page_lengths, modified_info.at(i).page_lengths); + } + // only the last row group should have more or equal number of pages + auto original_page_lengths = base_info.back().page_lengths; + auto modified_page_lengths = modified_info.back().page_lengths; + + // the last row group should be larger or equal in size + ASSERT_GE(original_page_lengths.size(), modified_page_lengths.size()); + // all pages must be identical except for the last one which can be larger + for (size_t i = 0; i < original_page_lengths.size() - 1; i++) { + ASSERT_EQ(original_page_lengths[i], modified_page_lengths[i]); + } + ASSERT_GT(modified_page_lengths.back(), original_page_lengths.back()); + } +} + +} // namespace parquet::internal diff --git a/cpp/src/parquet/properties_test.cc b/cpp/src/parquet/properties_test.cc --- a/cpp/src/parquet/properties_test.cc +++ b/cpp/src/parquet/properties_test.cc @@ -111,6 +111,26 @@ TEST(TestWriterProperties, SetCodecOptions) { ->window_bits); } +TEST(TestWriterProperties, ContentDefinedChunkingSettings) { + WriterProperties::Builder builder; + std::shared_ptr props = builder.build(); + + ASSERT_FALSE(props->content_defined_chunking_enabled()); + auto cdc_options = props->content_defined_chunking_options(); + ASSERT_EQ(cdc_options.min_chunk_size, 256 * 1024); + ASSERT_EQ(cdc_options.max_chunk_size, 1024 * 1024); + ASSERT_EQ(cdc_options.norm_level, 0); + + builder.enable_content_defined_chunking(); + builder.content_defined_chunking_options(CdcOptions{512 * 1024, 2048 * 1024, 1}); + props = builder.build(); + ASSERT_TRUE(props->content_defined_chunking_enabled()); + cdc_options = props->content_defined_chunking_options(); + ASSERT_EQ(cdc_options.min_chunk_size, 512 * 1024); + ASSERT_EQ(cdc_options.max_chunk_size, 2048 * 1024); + ASSERT_EQ(cdc_options.norm_level, 1); +} + TEST(TestReaderProperties, GetStreamInsufficientData) { // ARROW-6058 std::string data = "shorter than expected"; diff --git a/python/pyarrow/tests/parquet/test_parquet_writer.py b/python/pyarrow/tests/parquet/test_parquet_writer.py --- a/python/pyarrow/tests/parquet/test_parquet_writer.py +++ b/python/pyarrow/tests/parquet/test_parquet_writer.py @@ -361,3 +361,81 @@ def test_parquet_writer_append_key_value_metadata(tempdir): assert metadata[b'key1'] == b'1' assert metadata[b'key2'] == b'2' assert metadata[b'key3'] == b'3' + + +def test_parquet_content_defined_chunking(tempdir): + table = pa.table({'a': range(100_000)}) + + # use PLAIN encoding because we compare the overall size of the row groups + # which would vary depending on the encoding making the assertions wrong + pq.write_table(table, tempdir / 'unchunked.parquet', + use_dictionary=False, + column_encoding="PLAIN") + pq.write_table(table, tempdir / 'chunked-default.parquet', + use_dictionary=False, + column_encoding="PLAIN", + use_content_defined_chunking=True) + pq.write_table(table, tempdir / 'chunked-custom.parquet', + use_dictionary=False, + column_encoding="PLAIN", + use_content_defined_chunking={"min_chunk_size": 32_768, + "max_chunk_size": 65_536}) + + # the data must be the same + unchunked = pq.read_table(tempdir / 'unchunked.parquet') + chunked_default = pq.read_table(tempdir / 'chunked-default.parquet') + chunked_custom = pq.read_table(tempdir / 'chunked-custom.parquet') + assert unchunked.equals(chunked_default) + assert unchunked.equals(chunked_custom) + + # number of row groups and their sizes are not affected by content defined chunking + unchunked_metadata = pq.read_metadata(tempdir / 'unchunked.parquet') + chunked_default_metadata = pq.read_metadata(tempdir / 'chunked-default.parquet') + chunked_custom_metadata = pq.read_metadata(tempdir / 'chunked-custom.parquet') + + assert unchunked_metadata.num_row_groups == chunked_default_metadata.num_row_groups + assert unchunked_metadata.num_row_groups == chunked_custom_metadata.num_row_groups + + for i in range(unchunked_metadata.num_row_groups): + rg_unchunked = unchunked_metadata.row_group(i) + rg_chunked_default = chunked_default_metadata.row_group(i) + rg_chunked_custom = chunked_custom_metadata.row_group(i) + assert rg_unchunked.num_rows == rg_chunked_default.num_rows + assert rg_unchunked.num_rows == rg_chunked_custom.num_rows + # since PageReader is not exposed we cannot inspect the page sizes + # so just check that the total byte size is different + assert rg_unchunked.total_byte_size < rg_chunked_default.total_byte_size + assert rg_unchunked.total_byte_size < rg_chunked_custom.total_byte_size + + +def test_parquet_content_defined_chunking_parameters(tempdir): + table = pa.table({'a': range(100)}) + path = tempdir / 'chunked-invalid.parquet' + + # it raises OSError, not ideal but this is how parquet exceptions are handled + # currently + # the exact validation wording is not part of the proposal; assert only the + # error type for an invalid min/max ordering and for bad option dicts. + with pytest.raises(Exception): + cdc_options = {"min_chunk_size": 65_536, "max_chunk_size": 32_768} + pq.write_table(table, path, use_content_defined_chunking=cdc_options) + + invalid_option_cases = [ + {"min_chunk_size": 64 * 1024, "unknown_option": True}, + {"min_chunk_size": 64 * 1024}, + {"max_chunk_size": 64 * 1024}, + ] + for cdc_options in invalid_option_cases: + with pytest.raises(ValueError): + pq.write_table(table, path, use_content_defined_chunking=cdc_options) + + # using the default parametrization + pq.write_table(table, path, use_content_defined_chunking=True) + + # using min_chunk_size and max_chunk_size + cdc_options = {"min_chunk_size": 32_768, "max_chunk_size": 65_536} + pq.write_table(table, path, use_content_defined_chunking=cdc_options) + + # using min_chunk_size, max_chunk_size and norm_level + cdc_options = {"min_chunk_size": 32_768, "max_chunk_size": 65_536, "norm_level": 1} + pq.write_table(table, path, use_content_defined_chunking=cdc_options)