fix: allow SnapshotUtil::IsAncestorOf to handle an empty current snapshot

metadata.Snapshot() raised "No current snapshot" when the ancestor check
had nothing to compare against, which surfaced as a cherry-pick failure
when picking onto a branch with no history yet. Java's equivalent
(SnapshotUtil.ancestorsOf(null, ...)) treats this as an empty ancestor
list instead of an error, so nothing can be an ancestor of it; mirror
that here.

Author: shangxinli

src/iceberg/test/cherry_pick_operation_test.cc

@@ -114,6 +114,19 @@ class CherryPickOperationTest : public UpdateTestBase {
     return snap.value()->snapshot_id;
   }
 
+  // Commit an append onto the given branch and return its snapshot ID. Main's
+  // current snapshot is unchanged.
+  int64_t CommitAppendToBranch(const std::string& branch,
+                               const std::shared_ptr<DataFile>& file) {
+    auto fa = table_->NewFastAppend();
+    EXPECT_TRUE(fa.has_value());
+    fa.value()->ToBranch(branch);
+    fa.value()->AppendFile(file);
+    EXPECT_THAT(fa.value()->Commit(), IsOk());
+    EXPECT_THAT(table_->Refresh(), IsOk());
+    return table_->metadata()->snapshots.back()->snapshot_id;
+  }
+
   // Commit a staged append and return the staged snapshot's ID. The table's
   // current snapshot is unchanged.
   int64_t StageAppend(const std::shared_ptr<DataFile>& file,
@@ -280,6 +293,26 @@ TEST_F(CherryPickOperationTest, CherryPickAppend) {
                                               replacement_a_->file_path));
 }
 
+// A snapshot picked from another branch of an otherwise empty table can be
+// applied to main even though main has no current snapshot yet. The pick's
+// parent (on the source branch) keeps it from qualifying as a fast-forward, so
+// it must go through the ordinary ancestor checks with no current snapshot to
+// compare against.
+TEST_F(CherryPickOperationTest, CherryPickAppendOntoEmptyMain) {
+  CommitAppendToBranch("b1", file_a_);
+  int64_t staged_id = CommitAppendToBranch("b1", file_b_);
+
+  EXPECT_THAT(Cherrypick(staged_id), IsOk());
+
+  ICEBERG_UNWRAP_OR_FAIL(auto snapshot, table_->current_snapshot());
+  EXPECT_NE(snapshot->snapshot_id, staged_id);
+  EXPECT_EQ(snapshot->summary.at(SnapshotSummaryFields::kSourceSnapshotId),
+            std::to_string(staged_id));
+
+  ICEBERG_UNWRAP_OR_FAIL(auto live, LiveDataFilePaths());
+  EXPECT_THAT(live, ::testing::UnorderedElementsAre(file_b_->file_path));
+}
+
 // When the picked snapshot's parent is the current snapshot, the pick moves the
 // current snapshot instead of creating one.
 TEST_F(CherryPickOperationTest, FastForwardSetsCurrentSnapshot) {

src/iceberg/test/snapshot_util_test.cc

@@ -222,6 +222,19 @@ TEST_F(SnapshotUtilTest, IsAncestorOf) {
   EXPECT_FALSE(result5);
 }
 
+// No current snapshot means an empty ancestor history, so nothing can be an
+// ancestor of it; this must return false rather than raising "No current
+// snapshot", matching Java's SnapshotUtil.ancestorsOf(null, ...).
+TEST_F(SnapshotUtilTest, IsAncestorOfNoCurrentSnapshot) {
+  TableMetadata metadata;
+  metadata.current_snapshot_id = kInvalidSnapshotId;
+  metadata.snapshots = {CreateSnapshot(base_snapshot_id_, std::nullopt, 1, base_timestamp_)};
+
+  ICEBERG_UNWRAP_OR_FAIL(auto result,
+                         SnapshotUtil::IsAncestorOf(metadata, base_snapshot_id_));
+  EXPECT_FALSE(result);
+}
+
 TEST_F(SnapshotUtilTest, CurrentAncestors) {
   ICEBERG_UNWRAP_OR_FAIL(auto ancestors, SnapshotUtil::CurrentAncestors(*table_));
   auto ids = ExtractSnapshotIds(ancestors);

src/iceberg/util/snapshot_util.cc

@@ -66,9 +66,13 @@ Result<bool> SnapshotUtil::IsAncestorOf(const Table& table,
 
 Result<bool> SnapshotUtil::IsAncestorOf(const TableMetadata& metadata,
                                         int64_t ancestor_snapshot_id) {
-  ICEBERG_ASSIGN_OR_RAISE(auto current, metadata.Snapshot());
-  ICEBERG_CHECK(current != nullptr, "Current snapshot is null");
-  return IsAncestorOf(metadata, current->snapshot_id, ancestor_snapshot_id);
+  // No current snapshot means an empty ancestor history, so nothing can be an
+  // ancestor of it; matches Java's SnapshotUtil.ancestorsOf(null, ...), which
+  // returns an empty iterable instead of raising.
+  if (metadata.current_snapshot_id == kInvalidSnapshotId) {
+    return false;
+  }
+  return IsAncestorOf(metadata, metadata.current_snapshot_id, ancestor_snapshot_id);
 }
 
 bool SnapshotUtil::CanFastForward(const TableMetadata& metadata,