feat: implement validation for table update requirements

Implement Validate() methods for remaining table requirement classes:
- AssertDoesNotExist: validates table doesn't exist
- AssertRefSnapshotID: validates snapshot references (branches/tags)
- AssertLastAssignedFieldId: validates last assigned field ID
- AssertLastAssignedPartitionId: validates last assigned partition ID
- AssertDefaultSpecID: validates default partition spec ID
- AssertDefaultSortOrderID: validates default sort order ID

All implementations follow the pattern established in AssertCurrentSchemaID
and provide descriptive error messages for validation failures.

Author: shangxinli

src/iceberg/table_requirement.cc

@@ -19,13 +19,20 @@
 
 #include "iceberg/table_requirement.h"
 
+#include "iceberg/snapshot.h"
 #include "iceberg/table_metadata.h"
 #include "iceberg/util/string_util.h"
 
 namespace iceberg::table {
 
 Status AssertDoesNotExist::Validate(const TableMetadata* base) const {
-  return NotImplemented("AssertDoesNotExist::Validate not implemented");
+  // Validate that the table does not exist
+
+  if (base != nullptr) {
+    return CommitFailed("Requirement failed: table already exists");
+  }
+
+  return {};
 }
 
 Status AssertUUID::Validate(const TableMetadata* base) const {
@@ -45,12 +52,54 @@ Status AssertUUID::Validate(const TableMetadata* base) const {
 }
 
 Status AssertRefSnapshotID::Validate(const TableMetadata* base) const {
-  return NotImplemented("AssertTableRefSnapshotID::Validate not implemented");
+  // Validate that a reference (branch or tag) points to the expected snapshot ID
+
+  if (base == nullptr) {
+    return CommitFailed("Requirement failed: current table metadata is missing");
+  }
+
+  auto it = base->refs.find(ref_name_);
+
+  // If snapshot_id is nullopt, the reference should not exist
+  if (!snapshot_id_.has_value()) {
+    if (it != base->refs.end()) {
+      return CommitFailed(
+          "Requirement failed: reference '{}' should not exist but found snapshot ID {}",
+          ref_name_, it->second->snapshot_id);
+    }
+    return {};
+  }
+
+  // snapshot_id has a value, so the reference should exist and match
+  if (it == base->refs.end()) {
+    return CommitFailed(
+        "Requirement failed: reference '{}' is missing in table metadata", ref_name_);
+  }
+
+  if (it->second->snapshot_id != snapshot_id_.value()) {
+    return CommitFailed(
+        "Requirement failed: reference '{}' snapshot ID does not match (expected={}, "
+        "actual={})",
+        ref_name_, snapshot_id_.value(), it->second->snapshot_id);
+  }
+
+  return {};
 }
 
 Status AssertLastAssignedFieldId::Validate(const TableMetadata* base) const {
-  return NotImplemented(
-      "AssertCurrentTableLastAssignedFieldId::Validate not implemented");
+  // Validate that the last assigned field ID matches the expected value
+
+  if (base == nullptr) {
+    return CommitFailed("Requirement failed: current table metadata is missing");
+  }
+
+  if (base->last_column_id != last_assigned_field_id_) {
+    return CommitFailed(
+        "Requirement failed: last assigned field ID does not match (expected={}, actual={})",
+        last_assigned_field_id_, base->last_column_id);
+  }
+
+  return {};
 }
 
 Status AssertCurrentSchemaID::Validate(const TableMetadata* base) const {
@@ -75,16 +124,52 @@ Status AssertCurrentSchemaID::Validate(const TableMetadata* base) const {
 }
 
 Status AssertLastAssignedPartitionId::Validate(const TableMetadata* base) const {
-  return NotImplemented(
-      "AssertCurrentTableLastAssignedPartitionId::Validate not implemented");
+  // Validate that the last assigned partition ID matches the expected value
+
+  if (base == nullptr) {
+    return CommitFailed("Requirement failed: current table metadata is missing");
+  }
+
+  if (base->last_partition_id != last_assigned_partition_id_) {
+    return CommitFailed(
+        "Requirement failed: last assigned partition ID does not match (expected={}, "
+        "actual={})",
+        last_assigned_partition_id_, base->last_partition_id);
+  }
+
+  return {};
 }
 
 Status AssertDefaultSpecID::Validate(const TableMetadata* base) const {
-  return NotImplemented("AssertDefaultTableSpecID::Validate not implemented");
+  // Validate that the default partition spec ID matches the expected value
+
+  if (base == nullptr) {
+    return CommitFailed("Requirement failed: current table metadata is missing");
+  }
+
+  if (base->default_spec_id != spec_id_) {
+    return CommitFailed(
+        "Requirement failed: default spec ID does not match (expected={}, actual={})",
+        spec_id_, base->default_spec_id);
+  }
+
+  return {};
 }
 
 Status AssertDefaultSortOrderID::Validate(const TableMetadata* base) const {
-  return NotImplemented("AssertDefaultTableSortOrderID::Validate not implemented");
+  // Validate that the default sort order ID matches the expected value
+
+  if (base == nullptr) {
+    return CommitFailed("Requirement failed: current table metadata is missing");
+  }
+
+  if (base->default_sort_order_id != sort_order_id_) {
+    return CommitFailed(
+        "Requirement failed: default sort order ID does not match (expected={}, actual={})",
+        sort_order_id_, base->default_sort_order_id);
+  }
+
+  return {};
 }
 
 }  // namespace iceberg::table