From 04648e9e039365c8fa9130f7ddf598d178e79112 Mon Sep 17 00:00:00 2001 From: akshatvasu Date: Mon, 9 Nov 2026 07:45:30 -0500 Subject: [PATCH 1/7] support_large_types_arrowToAvro --- src/iceberg/avro/avro_data_util.cc | 40 +++++++++++++++++++++++++++--- 1 file changed, 37 insertions(+), 3 deletions(-) diff --git a/src/iceberg/avro/avro_data_util.cc b/src/iceberg/avro/avro_data_util.cc index 39f2948b9..c3843c2f6 100644 --- a/src/iceberg/avro/avro_data_util.cc +++ b/src/iceberg/avro/avro_data_util.cc @@ -748,7 +748,6 @@ Status ExtractDatumFromArray(const ::arrow::Array& array, int64_t index, return {}; } - // TODO(gangwu): support LARGE_STRING. case ::arrow::Type::STRING: { const auto& string_array = internal::checked_cast(array); @@ -756,7 +755,13 @@ Status ExtractDatumFromArray(const ::arrow::Array& array, int64_t index, return {}; } - // TODO(gangwu): support LARGE_BINARY. + case ::arrow::Type::LARGE_STRING: { + const auto& large_string_array = + internal::checked_cast(array); + datum->value() = large_string_array.GetString(index); + return {}; + } + case ::arrow::Type::BINARY: { const auto& binary_array = internal::checked_cast(array); @@ -767,6 +772,16 @@ Status ExtractDatumFromArray(const ::arrow::Array& array, int64_t index, return {}; } + case ::arrow::Type::LARGE_BINARY: { + const auto& large_binary_array = + internal::checked_cast(array); + std::string_view value = large_binary_array.GetView(index); + datum->value>().assign( + reinterpret_cast(value.data()), + reinterpret_cast(value.data()) + value.size()); + return {}; + } + case ::arrow::Type::FIXED_SIZE_BINARY: { const auto& fixed_array = internal::checked_cast(array); @@ -835,7 +850,6 @@ Status ExtractDatumFromArray(const ::arrow::Array& array, int64_t index, return {}; } - // TODO(gangwu): support LARGE_LIST. case ::arrow::Type::LIST: { const auto& list_array = internal::checked_cast(array); auto& avro_array = datum->value<::avro::GenericArray>(); @@ -855,6 +869,26 @@ Status ExtractDatumFromArray(const ::arrow::Array& array, int64_t index, return {}; } + case ::arrow::Type::LARGE_LIST: { + const auto& large_list_array = + internal::checked_cast(array); + auto& avro_array = datum->value<::avro::GenericArray>(); + auto& elements = avro_array.value(); + + auto start = large_list_array.value_offset(index); + auto end = large_list_array.value_offset(index + 1); + auto length = end - start; + + auto values = large_list_array.values(); + elements.resize(length, ::avro::GenericDatum(avro_array.schema()->leafAt(0))); + + for (int64_t i = 0; i < length; ++i) { + ICEBERG_RETURN_UNEXPECTED( + ExtractDatumFromArray(*values, start + i, &elements[i])); + } + return {}; + } + case ::arrow::Type::MAP: { const auto& map_array = internal::checked_cast(array); auto start = map_array.value_offset(index); From 119346e247db2bae57c6bce67a04068d2e7c9abd Mon Sep 17 00:00:00 2001 From: akshatvasu Date: Mon, 9 Nov 2026 19:02:27 -0500 Subject: [PATCH 2/7] test(avro): add tests for LARGE_STRING, LARGE_BINARY, and LARGE_LIST in ExtractDatumFromArray Add three standalone tests to verify that ExtractDatumFromArray correctly handles Arrow large-offset variants introduced in the previous commit: - LargeString: builds LargeStringArray via LargeStringBuilder, verifies string values reach datum->value() - LargeBinary: builds LargeBinaryArray via LargeBinaryBuilder, verifies bytes reach datum->value>() - LargeListOfIntegers: builds LargeListArray via LargeListBuilder, verifies list elements are correctly extracted into avro::GenericArray Arrays are constructed manually using Arrow builders rather than JSON parsing, since the JSON reader does not produce large-offset arrays. Co-Authored-By: Claude Sonnet 4.6 --- src/iceberg/test/avro_data_test.cc | 121 +++++++++++++++++++++++++++++ 1 file changed, 121 insertions(+) diff --git a/src/iceberg/test/avro_data_test.cc b/src/iceberg/test/avro_data_test.cc index 9ec0221da..a172e16e3 100644 --- a/src/iceberg/test/avro_data_test.cc +++ b/src/iceberg/test/avro_data_test.cc @@ -21,6 +21,8 @@ #include #include +#include +#include #include #include #include @@ -1547,6 +1549,125 @@ TEST(ExtractDatumFromArrayTest, MapStringToInt) { } } +TEST(ExtractDatumFromArrayTest, LargeString) { + Schema iceberg_schema({ + SchemaField::MakeRequired(1, "name", string()), + }); + + ::avro::NodePtr avro_node; + ASSERT_THAT(ToAvroNodeVisitor{}.Visit(iceberg_schema, &avro_node), IsOk()); + + ::arrow::LargeStringBuilder builder; + ASSERT_TRUE(builder.Append("hello").ok()); + ASSERT_TRUE(builder.Append("world").ok()); + ASSERT_TRUE(builder.Append("iceberg").ok()); + std::shared_ptr<::arrow::Array> large_string_array; + ASSERT_TRUE(builder.Finish(&large_string_array).ok()); + + auto struct_array = + ::arrow::StructArray::Make(::arrow::ArrayVector{large_string_array}, + std::vector>{ + ::arrow::field("name", ::arrow::large_utf8())}) + .ValueOrDie(); + + std::vector expected = {"hello", "world", "iceberg"}; + + for (int64_t i = 0; i < static_cast(expected.size()); ++i) { + ::avro::GenericDatum extracted_datum(avro_node); + ASSERT_THAT(ExtractDatumFromArray(*struct_array, i, &extracted_datum), IsOk()); + const auto& record = extracted_datum.value<::avro::GenericRecord>(); + EXPECT_EQ(record.fieldAt(0).value(), expected[i]); + } +} + +TEST(ExtractDatumFromArrayTest, LargeBinary) { + Schema iceberg_schema({ + SchemaField::MakeRequired(1, "data", binary()), + }); + + ::avro::NodePtr avro_node; + ASSERT_THAT(ToAvroNodeVisitor{}.Visit(iceberg_schema, &avro_node), IsOk()); + + ::arrow::LargeBinaryBuilder builder; + ASSERT_TRUE(builder.Append("hello").ok()); + ASSERT_TRUE(builder.Append("world").ok()); + std::shared_ptr<::arrow::Array> large_binary_array; + ASSERT_TRUE(builder.Finish(&large_binary_array).ok()); + + auto struct_array = + ::arrow::StructArray::Make(::arrow::ArrayVector{large_binary_array}, + std::vector>{ + ::arrow::field("data", ::arrow::large_binary())}) + .ValueOrDie(); + + std::vector expected_str = {"hello", "world"}; + + for (int64_t i = 0; i < static_cast(expected_str.size()); ++i) { + ::avro::GenericDatum extracted_datum(avro_node); + ASSERT_THAT(ExtractDatumFromArray(*struct_array, i, &extracted_datum), IsOk()); + const auto& record = extracted_datum.value<::avro::GenericRecord>(); + const auto& bytes = record.fieldAt(0).value>(); + EXPECT_EQ(std::string(bytes.begin(), bytes.end()), expected_str[i]); + } +} + +TEST(ExtractDatumFromArrayTest, LargeListOfIntegers) { + Schema iceberg_schema({ + SchemaField::MakeRequired( + 1, "numbers", + std::make_shared(SchemaField::MakeRequired(2, "element", int32()))), + }); + + ::avro::NodePtr avro_node; + ASSERT_THAT(ToAvroNodeVisitor{}.Visit(iceberg_schema, &avro_node), IsOk()); + + auto int32_builder = std::make_shared<::arrow::Int32Builder>(); + ::arrow::LargeListBuilder list_builder(::arrow::default_memory_pool(), int32_builder); + + ASSERT_TRUE(list_builder.Append().ok()); + ASSERT_TRUE(int32_builder->Append(10).ok()); + ASSERT_TRUE(int32_builder->Append(11).ok()); + ASSERT_TRUE(int32_builder->Append(12).ok()); + + ASSERT_TRUE(list_builder.Append().ok()); + ASSERT_TRUE(int32_builder->Append(20).ok()); + ASSERT_TRUE(int32_builder->Append(21).ok()); + + ASSERT_TRUE(list_builder.Append().ok()); + ASSERT_TRUE(int32_builder->Append(30).ok()); + ASSERT_TRUE(int32_builder->Append(31).ok()); + ASSERT_TRUE(int32_builder->Append(32).ok()); + ASSERT_TRUE(int32_builder->Append(33).ok()); + + std::shared_ptr<::arrow::Array> large_list_array; + ASSERT_TRUE(list_builder.Finish(&large_list_array).ok()); + + auto struct_array = ::arrow::StructArray::Make( + ::arrow::ArrayVector{large_list_array}, + std::vector>{::arrow::field( + "numbers", ::arrow::large_list(::arrow::int32()))}) + .ValueOrDie(); + + std::vector> expected = {{10, 11, 12}, {20, 21}, {30, 31, 32, 33}}; + + auto verify_record = [&](int64_t index, const std::vector& expected_numbers) { + ::avro::GenericDatum extracted_datum(avro_node); + ASSERT_THAT(ExtractDatumFromArray(*struct_array, index, &extracted_datum), IsOk()); + const auto& record = extracted_datum.value<::avro::GenericRecord>(); + const auto& avro_arr = record.fieldAt(0).value<::avro::GenericArray>(); + const auto& elements = avro_arr.value(); + + ASSERT_EQ(elements.size(), expected_numbers.size()); + for (size_t i = 0; i < expected_numbers.size(); ++i) { + EXPECT_EQ(elements[i].value(), expected_numbers[i]); + } + }; + + for (size_t i = 0; i < expected.size(); ++i) { + verify_record(i, expected[i]); + } +} + TEST(ExtractDatumFromArrayTest, ErrorHandling) { Schema iceberg_schema({SchemaField::MakeRequired(1, "a", int32())}); ::avro::NodePtr avro_node; From 104f58d333d071ed46322627221ae83ba5b39ad1 Mon Sep 17 00:00:00 2001 From: akshatvasu Date: Mon, 9 Nov 2026 19:12:54 -0500 Subject: [PATCH 3/7] Revert "test(avro): add tests for LARGE_STRING, LARGE_BINARY, and LARGE_LIST in ExtractDatumFromArray" This reverts commit 119346e247db2bae57c6bce67a04068d2e7c9abd. --- src/iceberg/test/avro_data_test.cc | 121 ----------------------------- 1 file changed, 121 deletions(-) diff --git a/src/iceberg/test/avro_data_test.cc b/src/iceberg/test/avro_data_test.cc index a172e16e3..9ec0221da 100644 --- a/src/iceberg/test/avro_data_test.cc +++ b/src/iceberg/test/avro_data_test.cc @@ -21,8 +21,6 @@ #include #include -#include -#include #include #include #include @@ -1549,125 +1547,6 @@ TEST(ExtractDatumFromArrayTest, MapStringToInt) { } } -TEST(ExtractDatumFromArrayTest, LargeString) { - Schema iceberg_schema({ - SchemaField::MakeRequired(1, "name", string()), - }); - - ::avro::NodePtr avro_node; - ASSERT_THAT(ToAvroNodeVisitor{}.Visit(iceberg_schema, &avro_node), IsOk()); - - ::arrow::LargeStringBuilder builder; - ASSERT_TRUE(builder.Append("hello").ok()); - ASSERT_TRUE(builder.Append("world").ok()); - ASSERT_TRUE(builder.Append("iceberg").ok()); - std::shared_ptr<::arrow::Array> large_string_array; - ASSERT_TRUE(builder.Finish(&large_string_array).ok()); - - auto struct_array = - ::arrow::StructArray::Make(::arrow::ArrayVector{large_string_array}, - std::vector>{ - ::arrow::field("name", ::arrow::large_utf8())}) - .ValueOrDie(); - - std::vector expected = {"hello", "world", "iceberg"}; - - for (int64_t i = 0; i < static_cast(expected.size()); ++i) { - ::avro::GenericDatum extracted_datum(avro_node); - ASSERT_THAT(ExtractDatumFromArray(*struct_array, i, &extracted_datum), IsOk()); - const auto& record = extracted_datum.value<::avro::GenericRecord>(); - EXPECT_EQ(record.fieldAt(0).value(), expected[i]); - } -} - -TEST(ExtractDatumFromArrayTest, LargeBinary) { - Schema iceberg_schema({ - SchemaField::MakeRequired(1, "data", binary()), - }); - - ::avro::NodePtr avro_node; - ASSERT_THAT(ToAvroNodeVisitor{}.Visit(iceberg_schema, &avro_node), IsOk()); - - ::arrow::LargeBinaryBuilder builder; - ASSERT_TRUE(builder.Append("hello").ok()); - ASSERT_TRUE(builder.Append("world").ok()); - std::shared_ptr<::arrow::Array> large_binary_array; - ASSERT_TRUE(builder.Finish(&large_binary_array).ok()); - - auto struct_array = - ::arrow::StructArray::Make(::arrow::ArrayVector{large_binary_array}, - std::vector>{ - ::arrow::field("data", ::arrow::large_binary())}) - .ValueOrDie(); - - std::vector expected_str = {"hello", "world"}; - - for (int64_t i = 0; i < static_cast(expected_str.size()); ++i) { - ::avro::GenericDatum extracted_datum(avro_node); - ASSERT_THAT(ExtractDatumFromArray(*struct_array, i, &extracted_datum), IsOk()); - const auto& record = extracted_datum.value<::avro::GenericRecord>(); - const auto& bytes = record.fieldAt(0).value>(); - EXPECT_EQ(std::string(bytes.begin(), bytes.end()), expected_str[i]); - } -} - -TEST(ExtractDatumFromArrayTest, LargeListOfIntegers) { - Schema iceberg_schema({ - SchemaField::MakeRequired( - 1, "numbers", - std::make_shared(SchemaField::MakeRequired(2, "element", int32()))), - }); - - ::avro::NodePtr avro_node; - ASSERT_THAT(ToAvroNodeVisitor{}.Visit(iceberg_schema, &avro_node), IsOk()); - - auto int32_builder = std::make_shared<::arrow::Int32Builder>(); - ::arrow::LargeListBuilder list_builder(::arrow::default_memory_pool(), int32_builder); - - ASSERT_TRUE(list_builder.Append().ok()); - ASSERT_TRUE(int32_builder->Append(10).ok()); - ASSERT_TRUE(int32_builder->Append(11).ok()); - ASSERT_TRUE(int32_builder->Append(12).ok()); - - ASSERT_TRUE(list_builder.Append().ok()); - ASSERT_TRUE(int32_builder->Append(20).ok()); - ASSERT_TRUE(int32_builder->Append(21).ok()); - - ASSERT_TRUE(list_builder.Append().ok()); - ASSERT_TRUE(int32_builder->Append(30).ok()); - ASSERT_TRUE(int32_builder->Append(31).ok()); - ASSERT_TRUE(int32_builder->Append(32).ok()); - ASSERT_TRUE(int32_builder->Append(33).ok()); - - std::shared_ptr<::arrow::Array> large_list_array; - ASSERT_TRUE(list_builder.Finish(&large_list_array).ok()); - - auto struct_array = ::arrow::StructArray::Make( - ::arrow::ArrayVector{large_list_array}, - std::vector>{::arrow::field( - "numbers", ::arrow::large_list(::arrow::int32()))}) - .ValueOrDie(); - - std::vector> expected = {{10, 11, 12}, {20, 21}, {30, 31, 32, 33}}; - - auto verify_record = [&](int64_t index, const std::vector& expected_numbers) { - ::avro::GenericDatum extracted_datum(avro_node); - ASSERT_THAT(ExtractDatumFromArray(*struct_array, index, &extracted_datum), IsOk()); - const auto& record = extracted_datum.value<::avro::GenericRecord>(); - const auto& avro_arr = record.fieldAt(0).value<::avro::GenericArray>(); - const auto& elements = avro_arr.value(); - - ASSERT_EQ(elements.size(), expected_numbers.size()); - for (size_t i = 0; i < expected_numbers.size(); ++i) { - EXPECT_EQ(elements[i].value(), expected_numbers[i]); - } - }; - - for (size_t i = 0; i < expected.size(); ++i) { - verify_record(i, expected[i]); - } -} - TEST(ExtractDatumFromArrayTest, ErrorHandling) { Schema iceberg_schema({SchemaField::MakeRequired(1, "a", int32())}); ::avro::NodePtr avro_node; From 754fab575e2451d9e2c32619d16b6afabb8fa7c2 Mon Sep 17 00:00:00 2001 From: akshatvasu Date: Tue, 10 Nov 2026 08:27:00 -0500 Subject: [PATCH 4/7] test(avro): add LargeListOfIntegers test for ExtractDatumFromArray --- src/iceberg/test/avro_data_test.cc | 60 ++++++++++++++++++++++++++++++ 1 file changed, 60 insertions(+) diff --git a/src/iceberg/test/avro_data_test.cc b/src/iceberg/test/avro_data_test.cc index 9ec0221da..9bdb486ee 100644 --- a/src/iceberg/test/avro_data_test.cc +++ b/src/iceberg/test/avro_data_test.cc @@ -21,6 +21,7 @@ #include #include +#include #include #include #include @@ -1547,6 +1548,65 @@ TEST(ExtractDatumFromArrayTest, MapStringToInt) { } } +TEST(ExtractDatumFromArrayTest, LargeListOfIntegers) { + Schema iceberg_schema({ + SchemaField::MakeRequired( + 1, "numbers", + std::make_shared(SchemaField::MakeRequired(2, "element", int32()))), + }); + + ::avro::NodePtr avro_node; + ASSERT_THAT(ToAvroNodeVisitor{}.Visit(iceberg_schema, &avro_node), IsOk()); + + // Build a LargeListArray manually — JSON parsing always produces regular ListArray, + // so we use builders to get the large-offset variant. + auto int32_builder = std::make_shared<::arrow::Int32Builder>(); + ::arrow::LargeListBuilder list_builder(::arrow::default_memory_pool(), int32_builder); + + ASSERT_TRUE(list_builder.Append().ok()); + ASSERT_TRUE(int32_builder->Append(10).ok()); + ASSERT_TRUE(int32_builder->Append(11).ok()); + ASSERT_TRUE(int32_builder->Append(12).ok()); + + ASSERT_TRUE(list_builder.Append().ok()); + ASSERT_TRUE(int32_builder->Append(20).ok()); + ASSERT_TRUE(int32_builder->Append(21).ok()); + + ASSERT_TRUE(list_builder.Append().ok()); + ASSERT_TRUE(int32_builder->Append(30).ok()); + ASSERT_TRUE(int32_builder->Append(31).ok()); + ASSERT_TRUE(int32_builder->Append(32).ok()); + ASSERT_TRUE(int32_builder->Append(33).ok()); + + std::shared_ptr<::arrow::Array> large_list_array; + ASSERT_TRUE(list_builder.Finish(&large_list_array).ok()); + + auto arrow_array = ::arrow::StructArray::Make( + ::arrow::ArrayVector{large_list_array}, + std::vector>{::arrow::field( + "numbers", ::arrow::large_list(::arrow::int32()))}) + .ValueOrDie(); + + std::vector> expected = {{10, 11, 12}, {20, 21}, {30, 31, 32, 33}}; + + auto verify_record = [&](int64_t index, const std::vector& expected_numbers) { + ::avro::GenericDatum extracted_datum(avro_node); + ASSERT_THAT(ExtractDatumFromArray(*arrow_array, index, &extracted_datum), IsOk()); + const auto& record = extracted_datum.value<::avro::GenericRecord>(); + const auto& avro_arr = record.fieldAt(0).value<::avro::GenericArray>(); + const auto& elements = avro_arr.value(); + + ASSERT_EQ(elements.size(), expected_numbers.size()); + for (size_t i = 0; i < expected_numbers.size(); ++i) { + EXPECT_EQ(elements[i].value(), expected_numbers[i]); + } + }; + + for (size_t i = 0; i < expected.size(); ++i) { + verify_record(i, expected[i]); + } +} + TEST(ExtractDatumFromArrayTest, ErrorHandling) { Schema iceberg_schema({SchemaField::MakeRequired(1, "a", int32())}); ::avro::NodePtr avro_node; From 0598520f484ca523e7b733dbf7019b7cae628a8b Mon Sep 17 00:00:00 2001 From: akshatvasu Date: Tue, 10 Nov 2026 10:09:46 -0500 Subject: [PATCH 5/7] added_test_for_large_strings --- src/iceberg/test/avro_data_test.cc | 33 ++++++++++++++++++++++++++++++ 1 file changed, 33 insertions(+) diff --git a/src/iceberg/test/avro_data_test.cc b/src/iceberg/test/avro_data_test.cc index 9bdb486ee..d95df9ec1 100644 --- a/src/iceberg/test/avro_data_test.cc +++ b/src/iceberg/test/avro_data_test.cc @@ -22,6 +22,7 @@ #include #include +#include #include #include #include @@ -1607,6 +1608,38 @@ TEST(ExtractDatumFromArrayTest, LargeListOfIntegers) { } } +TEST(ExtractDatumFromArrayTest, LargeString) { + Schema iceberg_schema({ + SchemaField::MakeRequired(1, "name", string()), + }); + + ::avro::NodePtr avro_node; + ASSERT_THAT(ToAvroNodeVisitor{}.Visit(iceberg_schema, &avro_node), IsOk()); + + // Build a LargeStringArray manually + ::arrow::LargeStringBuilder builder; + ASSERT_TRUE(builder.Append("hello").ok()); + ASSERT_TRUE(builder.Append("world").ok()); + ASSERT_TRUE(builder.Append("iceberg").ok()); + std::shared_ptr<::arrow::Array> large_string_array; + ASSERT_TRUE(builder.Finish(&large_string_array).ok()); + + auto arrow_array = + ::arrow::StructArray::Make(::arrow::ArrayVector{large_string_array}, + std::vector>{ + ::arrow::field("name", ::arrow::large_utf8())}) + .ValueOrDie(); + + std::vector expected = {"hello", "world", "iceberg"}; + + for (int64_t i = 0; i < static_cast(expected.size()); ++i) { + ::avro::GenericDatum extracted_datum(avro_node); + ASSERT_THAT(ExtractDatumFromArray(*arrow_array, i, &extracted_datum), IsOk()); + const auto& record = extracted_datum.value<::avro::GenericRecord>(); + EXPECT_EQ(record.fieldAt(0).value(), expected[i]); + } +} + TEST(ExtractDatumFromArrayTest, ErrorHandling) { Schema iceberg_schema({SchemaField::MakeRequired(1, "a", int32())}); ::avro::NodePtr avro_node; From 94e541c3ece01e1bbb049746ff0bf291cdac9f55 Mon Sep 17 00:00:00 2001 From: akshatvasu Date: Tue, 10 Nov 2026 10:30:48 -0500 Subject: [PATCH 6/7] added_tests_largeBinary --- src/iceberg/test/avro_data_test.cc | 34 ++++++++++++++++++++++++++++++ 1 file changed, 34 insertions(+) diff --git a/src/iceberg/test/avro_data_test.cc b/src/iceberg/test/avro_data_test.cc index d95df9ec1..0acf71599 100644 --- a/src/iceberg/test/avro_data_test.cc +++ b/src/iceberg/test/avro_data_test.cc @@ -1640,6 +1640,40 @@ TEST(ExtractDatumFromArrayTest, LargeString) { } } +TEST(ExtractDatumFromArrayTest, LargeBinary) { + Schema iceberg_schema({ + SchemaField::MakeRequired(1, "data", binary()), + }); + + ::avro::NodePtr avro_node; + ASSERT_THAT(ToAvroNodeVisitor{}.Visit(iceberg_schema, &avro_node), IsOk()); + + // Build a LargeBinaryArray manually + ::arrow::LargeBinaryBuilder builder; + ASSERT_TRUE(builder.Append("abc").ok()); + ASSERT_TRUE(builder.Append("bcd").ok()); + ASSERT_TRUE(builder.Append("cde").ok()); + std::shared_ptr<::arrow::Array> large_binary_array; + ASSERT_TRUE(builder.Finish(&large_binary_array).ok()); + + auto arrow_array = + ::arrow::StructArray::Make(::arrow::ArrayVector{large_binary_array}, + std::vector>{ + ::arrow::field("data", ::arrow::large_binary())}) + .ValueOrDie(); + + for (int64_t i = 0; i < 3; ++i) { + ::avro::GenericDatum extracted_datum(avro_node); + ASSERT_THAT(ExtractDatumFromArray(*arrow_array, i, &extracted_datum), IsOk()); + const auto& record = extracted_datum.value<::avro::GenericRecord>(); + const auto& bytes = record.fieldAt(0).value>(); + ASSERT_EQ(bytes.size(), 3); + EXPECT_EQ(bytes[0], static_cast('a' + i)); + EXPECT_EQ(bytes[1], static_cast('b' + i)); + EXPECT_EQ(bytes[2], static_cast('c' + i)); + } +} + TEST(ExtractDatumFromArrayTest, ErrorHandling) { Schema iceberg_schema({SchemaField::MakeRequired(1, "a", int32())}); ::avro::NodePtr avro_node; From 27f3ff5177a8d7f7d2a04f87b91254af1a757947 Mon Sep 17 00:00:00 2001 From: akshatvasu Date: Tue, 10 Nov 2026 11:09:26 -0500 Subject: [PATCH 7/7] fixed_signed_unsigned_int_comparison --- src/iceberg/test/avro_data_test.cc | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/iceberg/test/avro_data_test.cc b/src/iceberg/test/avro_data_test.cc index 0acf71599..78ef2bc6f 100644 --- a/src/iceberg/test/avro_data_test.cc +++ b/src/iceberg/test/avro_data_test.cc @@ -1632,7 +1632,7 @@ TEST(ExtractDatumFromArrayTest, LargeString) { std::vector expected = {"hello", "world", "iceberg"}; - for (int64_t i = 0; i < static_cast(expected.size()); ++i) { + for (int64_t i = 0; std::cmp_less(i, expected.size()); ++i) { ::avro::GenericDatum extracted_datum(avro_node); ASSERT_THAT(ExtractDatumFromArray(*arrow_array, i, &extracted_datum), IsOk()); const auto& record = extracted_datum.value<::avro::GenericRecord>();