2020#include " iceberg/row/struct_like.h"
2121
2222#include < array>
23+ #include < memory>
24+ #include < optional>
2325#include < utility>
26+ #include < vector>
2427
2528#include < arrow/c/bridge.h>
2629#include < arrow/json/from_string.h>
@@ -71,6 +74,7 @@ namespace {
7174class SingleFieldStructLike : public StructLike {
7275 public:
7376 explicit SingleFieldStructLike (Scalar value) : value_(std::move(value)) {}
77+ explicit SingleFieldStructLike (Result<Scalar> value) : value_(std::move(value)) {}
7478
7579 Result<Scalar> GetField (size_t pos) const override {
7680 if (pos != 0 ) {
@@ -82,9 +86,35 @@ class SingleFieldStructLike : public StructLike {
8286 size_t num_fields () const override { return 1 ; }
8387
8488 private:
85- Scalar value_;
89+ Result< Scalar> value_;
8690};
8791
92+ std::shared_ptr<StructLike> WrapSingleFieldRow (Result<Scalar> field, size_t depth) {
93+ std::shared_ptr<StructLike> row =
94+ std::make_shared<SingleFieldStructLike>(std::move (field));
95+ for (size_t i = 1 ; i < depth; ++i) {
96+ row = std::make_shared<SingleFieldStructLike>(Scalar{row});
97+ }
98+ return row;
99+ }
100+
101+ std::unique_ptr<Schema> MakeNestedSchema (
102+ size_t depth, std::optional<size_t > optional_parent = std::nullopt ,
103+ bool optional_leaf = false ) {
104+ auto field =
105+ optional_leaf
106+ ? SchemaField::MakeOptional (static_cast <int32_t >(depth), " value" , int32 ())
107+ : SchemaField::MakeRequired (static_cast <int32_t >(depth), " value" , int32 ());
108+ for (size_t level = depth - 1 ; level > 0 ; --level) {
109+ auto nested = struct_ ({field});
110+ field =
111+ optional_parent == level - 1
112+ ? SchemaField::MakeOptional (static_cast <int32_t >(level), " nested" , nested)
113+ : SchemaField::MakeRequired (static_cast <int32_t >(level), " nested" , nested);
114+ }
115+ return std::make_unique<Schema>(std::vector<SchemaField>{std::move (field)});
116+ }
117+
88118} // namespace
89119
90120TEST (ManifestFileStructLike, BasicFields) {
@@ -152,7 +182,7 @@ TEST(StructLikeAccessorTest, GetLiteralUuid) {
152182 std::string_view uuid_data (reinterpret_cast <const char *>(bytes.data ()), bytes.size ());
153183 SingleFieldStructLike row (Scalar{uuid_data});
154184 std::array<size_t , 1 > path = {0 };
155- StructLikeAccessor accessor (iceberg::uuid (), path);
185+ StructLikeAccessor accessor (iceberg::uuid (), path, { false } );
156186
157187 ICEBERG_UNWRAP_OR_FAIL (auto literal, accessor.GetLiteral (row));
158188 EXPECT_EQ (literal.type ()->type_id (), TypeId::kUuid );
@@ -163,13 +193,138 @@ TEST(StructLikeAccessorTest, GetLiteralUuid) {
163193TEST (StructLikeAccessorTest, GetLiteralUuidRejectsWrongLength) {
164194 SingleFieldStructLike row (Scalar{std::string_view (" not-a-uuid" )});
165195 std::array<size_t , 1 > path = {0 };
166- StructLikeAccessor accessor (iceberg::uuid (), path);
196+ StructLikeAccessor accessor (iceberg::uuid (), path, { false } );
167197
168198 auto result = accessor.GetLiteral (row);
169199 EXPECT_THAT (result, IsError (ErrorKind::kInvalidArgument ));
170200 EXPECT_THAT (result, HasErrorMessage (" UUID byte array must be exactly 16 bytes" ));
171201}
172202
203+ TEST (StructLikeAccessorTest, RequiredAndOptionalLeaf) {
204+ SingleFieldStructLike row (Scalar{std::monostate{}});
205+ for (bool optional : {false , true }) {
206+ auto schema = MakeNestedSchema (1 , std::nullopt , optional);
207+ ICEBERG_UNWRAP_OR_FAIL (auto accessor, schema->GetAccessorById (1 ));
208+ if (optional) {
209+ EXPECT_SCALAR_NULL (accessor->Get (row));
210+ ICEBERG_UNWRAP_OR_FAIL (auto literal, accessor->GetLiteral (row));
211+ EXPECT_TRUE (literal.IsNull ());
212+ } else {
213+ EXPECT_THAT (accessor->Get (row), IsError (ErrorKind::kInvalidArgument ));
214+ EXPECT_THAT (accessor->GetLiteral (row), IsError (ErrorKind::kInvalidArgument ));
215+ }
216+ }
217+ }
218+
219+ class NestedStructLikeAccessorTest : public ::testing::TestWithParam<size_t > {};
220+
221+ TEST_P (NestedStructLikeAccessorTest, NullParents) {
222+ const std::vector<size_t > path (GetParam (), 0 );
223+ StructLikeAccessor accessor (int32 (), path, std::vector<bool >(path.size (), true ));
224+ for (const Scalar null :
225+ {Scalar{std::monostate{}}, Scalar{std::shared_ptr<StructLike>{}}}) {
226+ for (size_t parent = 0 ; parent + 1 < path.size (); ++parent) {
227+ SCOPED_TRACE (parent);
228+ auto row = WrapSingleFieldRow (null, parent + 1 );
229+ ICEBERG_UNWRAP_OR_FAIL (auto scalar, accessor.Get (*row));
230+ EXPECT_TRUE (std::holds_alternative<std::monostate>(scalar));
231+ ICEBERG_UNWRAP_OR_FAIL (auto literal, accessor.GetLiteral (*row));
232+ EXPECT_TRUE (literal.IsNull ());
233+ EXPECT_EQ (literal.type ()->type_id (), TypeId::kInt );
234+ }
235+ }
236+ }
237+
238+ TEST_P (NestedStructLikeAccessorTest, SchemaRequiredAndOptionalParents) {
239+ const auto depth = GetParam ();
240+ auto required_schema = MakeNestedSchema (depth);
241+ ICEBERG_UNWRAP_OR_FAIL (auto required_accessor,
242+ required_schema->GetAccessorById (static_cast <int32_t >(depth)));
243+ EXPECT_EQ (required_accessor->position_path (), std::vector<size_t >(depth, 0 ));
244+
245+ for (const Scalar null :
246+ {Scalar{std::monostate{}}, Scalar{std::shared_ptr<StructLike>{}}}) {
247+ for (size_t parent = 0 ; parent + 1 < depth; ++parent) {
248+ SCOPED_TRACE (parent);
249+ auto row = WrapSingleFieldRow (null, parent + 1 );
250+ auto schema = MakeNestedSchema (depth, parent);
251+ ICEBERG_UNWRAP_OR_FAIL (auto accessor,
252+ schema->GetAccessorById (static_cast <int32_t >(depth)));
253+ EXPECT_SCALAR_NULL (accessor->Get (*row));
254+ ICEBERG_UNWRAP_OR_FAIL (auto literal, accessor->GetLiteral (*row));
255+ EXPECT_TRUE (literal.IsNull ());
256+ EXPECT_EQ (literal.type ()->type_id (), TypeId::kInt );
257+
258+ EXPECT_THAT (required_accessor->Get (*row), IsError (ErrorKind::kInvalidArgument ));
259+ EXPECT_THAT (required_accessor->GetLiteral (*row),
260+ IsError (ErrorKind::kInvalidArgument ));
261+ }
262+ }
263+ }
264+
265+ TEST_P (NestedStructLikeAccessorTest, ValueAndNullLeaf) {
266+ const std::vector<size_t > path (GetParam (), 0 );
267+ StructLikeAccessor accessor (int32 (), path, std::vector<bool >(path.size (), true ));
268+ auto row = WrapSingleFieldRow (Scalar{int32_t {42 }}, path.size ());
269+ ICEBERG_UNWRAP_OR_FAIL (auto value, accessor.GetLiteral (*row));
270+ EXPECT_EQ (value, Literal::Int (42 ));
271+
272+ auto null_row = WrapSingleFieldRow (Scalar{std::monostate{}}, path.size ());
273+ ICEBERG_UNWRAP_OR_FAIL (auto null, accessor.GetLiteral (*null_row));
274+ EXPECT_TRUE (null.IsNull ());
275+ EXPECT_EQ (null.type ()->type_id (), TypeId::kInt );
276+ }
277+
278+ TEST_P (NestedStructLikeAccessorTest, RequiredAndOptionalLeaf) {
279+ const auto depth = GetParam ();
280+ auto row = WrapSingleFieldRow (Scalar{std::monostate{}}, depth);
281+ for (bool optional : {false , true }) {
282+ auto schema = MakeNestedSchema (depth, std::nullopt , optional);
283+ ICEBERG_UNWRAP_OR_FAIL (auto accessor,
284+ schema->GetAccessorById (static_cast <int32_t >(depth)));
285+ if (optional) {
286+ EXPECT_SCALAR_NULL (accessor->Get (*row));
287+ ICEBERG_UNWRAP_OR_FAIL (auto literal, accessor->GetLiteral (*row));
288+ EXPECT_TRUE (literal.IsNull ());
289+ } else {
290+ EXPECT_THAT (accessor->Get (*row), IsError (ErrorKind::kInvalidArgument ));
291+ EXPECT_THAT (accessor->GetLiteral (*row), IsError (ErrorKind::kInvalidArgument ));
292+ }
293+ }
294+
295+ auto schema = MakeNestedSchema (depth, 0 );
296+ ICEBERG_UNWRAP_OR_FAIL (auto accessor,
297+ schema->GetAccessorById (static_cast <int32_t >(depth)));
298+ EXPECT_THAT (accessor->Get (*row), IsError (ErrorKind::kInvalidArgument ));
299+ auto absent_parent = WrapSingleFieldRow (Scalar{std::monostate{}}, 1 );
300+ EXPECT_SCALAR_NULL (accessor->Get (*absent_parent));
301+ }
302+
303+ TEST_P (NestedStructLikeAccessorTest, RejectsNonStructParents) {
304+ const std::vector<size_t > path (GetParam (), 0 );
305+ StructLikeAccessor accessor (int32 (), path, std::vector<bool >(path.size (), true ));
306+ for (size_t parent = 0 ; parent + 1 < path.size (); ++parent) {
307+ SCOPED_TRACE (parent);
308+ auto row = WrapSingleFieldRow (Scalar{int32_t {42 }}, parent + 1 );
309+ EXPECT_THAT (accessor.Get (*row), IsError (ErrorKind::kInvalidSchema ));
310+ }
311+ }
312+
313+ TEST_P (NestedStructLikeAccessorTest, PreservesFieldErrors) {
314+ const std::vector<size_t > path (GetParam (), 0 );
315+ StructLikeAccessor accessor (int32 (), path, std::vector<bool >(path.size (), true ));
316+ for (size_t level = 0 ; level < path.size (); ++level) {
317+ SCOPED_TRACE (level);
318+ auto row = WrapSingleFieldRow (IOError (" Cannot read field" ), level + 1 );
319+ auto result = accessor.GetLiteral (*row);
320+ EXPECT_THAT (result, IsError (ErrorKind::kIOError ));
321+ EXPECT_THAT (result, HasErrorMessage (" Cannot read field" ));
322+ }
323+ }
324+
325+ INSTANTIATE_TEST_SUITE_P (NestedPaths, NestedStructLikeAccessorTest,
326+ ::testing::Values (size_t {2 }, size_t {3 }, size_t {4 }));
327+
173328TEST (ManifestFileStructLike, OptionalFields) {
174329 ManifestFile manifest_file{.manifest_path = " /path/to/manifest2.avro" ,
175330 .manifest_length = 54321 ,
0 commit comments