feat: add metadata updates and requirements interface

src/iceberg/CMakeLists.txt

@@ -52,7 +52,10 @@ set(ICEBERG_SOURCES
     table.cc
     table_metadata.cc
     table_properties.cc
+    table_requirement.cc
+    table_requirements.cc
     table_scan.cc
+    table_update.cc
     transform.cc
     transform_function.cc
     type.cc

src/iceberg/catalog.h

@@ -123,8 +123,8 @@ class ICEBERG_EXPORT Catalog {
   /// \return a Table instance or ErrorKind::kAlreadyExists if the table already exists
   virtual Result<std::unique_ptr<Table>> UpdateTable(
       const TableIdentifier& identifier,
-      const std::vector<std::unique_ptr<UpdateRequirement>>& requirements,
-      const std::vector<std::unique_ptr<MetadataUpdate>>& updates) = 0;
+      const std::vector<std::unique_ptr<TableRequirement>>& requirements,
+      const std::vector<std::unique_ptr<TableUpdate>>& updates) = 0;
 
   /// \brief Start a transaction to create a table
   ///

src/iceberg/catalog/memory/in_memory_catalog.cc

@@ -392,8 +392,8 @@ Result<std::unique_ptr<Table>> InMemoryCatalog::CreateTable(
 
 Result<std::unique_ptr<Table>> InMemoryCatalog::UpdateTable(
     const TableIdentifier& identifier,
-    const std::vector<std::unique_ptr<UpdateRequirement>>& requirements,
-    const std::vector<std::unique_ptr<MetadataUpdate>>& updates) {
+    const std::vector<std::unique_ptr<TableRequirement>>& requirements,
+    const std::vector<std::unique_ptr<TableUpdate>>& updates) {
   return NotImplemented("update table");
 }
 

src/iceberg/catalog/memory/in_memory_catalog.h

@@ -77,8 +77,8 @@ class ICEBERG_EXPORT InMemoryCatalog
 
   Result<std::unique_ptr<Table>> UpdateTable(
       const TableIdentifier& identifier,
-      const std::vector<std::unique_ptr<UpdateRequirement>>& requirements,
-      const std::vector<std::unique_ptr<MetadataUpdate>>& updates) override;
+      const std::vector<std::unique_ptr<TableRequirement>>& requirements,
+      const std::vector<std::unique_ptr<TableUpdate>>& updates) override;
 
   Result<std::shared_ptr<Transaction>> StageCreateTable(
       const TableIdentifier& identifier, const Schema& schema, const PartitionSpec& spec,

src/iceberg/meson.build

@@ -74,7 +74,10 @@ iceberg_sources = files(
     'table.cc',
     'table_metadata.cc',
     'table_properties.cc',
+    'table_requirement.cc',
+    'table_requirements.cc',
     'table_scan.cc',
+    'table_update.cc',
     'transform.cc',
     'transform_function.cc',
     'type.cc',
@@ -169,7 +172,10 @@ install_headers(
         'table.h',
         'table_identifier.h',
         'table_metadata.h',
+        'table_requirement.h',
+        'table_requirements.h',
         'table_scan.h',
+        'table_update.h',
         'transaction.h',
         'transform_function.h',
         'transform.h',

src/iceberg/result.h

@@ -30,6 +30,7 @@ namespace iceberg {
 /// \brief Error types for iceberg.
 enum class ErrorKind {
   kAlreadyExists,
+  kCommitFailed,
   kCommitStateUnknown,
   kDecompressError,
   kInvalid,  // For general invalid errors
@@ -78,6 +79,7 @@ using Status = Result<void>;
   }
 
 DEFINE_ERROR_FUNCTION(AlreadyExists)
+DEFINE_ERROR_FUNCTION(CommitFailed)
 DEFINE_ERROR_FUNCTION(CommitStateUnknown)
 DEFINE_ERROR_FUNCTION(DecompressError)
 DEFINE_ERROR_FUNCTION(Invalid)

src/iceberg/table_metadata.cc

@@ -19,18 +19,21 @@
 
 #include "iceberg/table_metadata.h"
 
+#include <algorithm>
 #include <format>
 #include <string>
 
 #include <nlohmann/json.hpp>
 
+#include "iceberg/exception.h"
 #include "iceberg/file_io.h"
 #include "iceberg/json_internal.h"
 #include "iceberg/partition_spec.h"
 #include "iceberg/result.h"
 #include "iceberg/schema.h"
 #include "iceberg/snapshot.h"
 #include "iceberg/sort_order.h"
+#include "iceberg/table_update.h"
 #include "iceberg/util/gzip_internal.h"
 #include "iceberg/util/macros.h"
 
@@ -196,4 +199,190 @@ Status TableMetadataUtil::Write(FileIO& io, const std::string& location,
   return io.WriteFile(location, json_string);
 }
 
+// TableMetadataBuilder implementation
+
+struct TableMetadataBuilder::Impl {};
+
+TableMetadataBuilder::TableMetadataBuilder(int8_t format_version)
+    : impl_(std::make_unique<Impl>()) {}
+
+TableMetadataBuilder::TableMetadataBuilder(const TableMetadata* base)
+    : impl_(std::make_unique<Impl>()) {}
+
+TableMetadataBuilder::~TableMetadataBuilder() = default;
+
+TableMetadataBuilder::TableMetadataBuilder(TableMetadataBuilder&&) noexcept = default;
+
+TableMetadataBuilder& TableMetadataBuilder::operator=(TableMetadataBuilder&&) noexcept =
+    default;
+
+std::unique_ptr<TableMetadataBuilder> TableMetadataBuilder::BuildFromEmpty(
+    int8_t format_version) {
+  return std::unique_ptr<TableMetadataBuilder>(
+      new TableMetadataBuilder(format_version));  // NOLINT
+}
+
+std::unique_ptr<TableMetadataBuilder> TableMetadataBuilder::BuildFrom(
+    const TableMetadata* base) {
+  return std::unique_ptr<TableMetadataBuilder>(new TableMetadataBuilder(base));  // NOLINT
+}
+
+TableMetadataBuilder& TableMetadataBuilder::SetMetadataLocation(
+    std::string_view metadata_location) {
+  throw IcebergError(std::format("{} not implemented", __FUNCTION__));
+}
+
+TableMetadataBuilder& TableMetadataBuilder::SetPreviousMetadataLocation(
+    std::string_view previous_metadata_location) {
+  throw IcebergError(std::format("{} not implemented", __FUNCTION__));
+}
+
+TableMetadataBuilder& TableMetadataBuilder::AssignUUID() {
+  throw IcebergError(std::format("{} not implemented", __FUNCTION__));
+}
+
+TableMetadataBuilder& TableMetadataBuilder::AssignUUID(std::string_view uuid) {
+  throw IcebergError(std::format("{} not implemented", __FUNCTION__));
+  ;
+}
+
+TableMetadataBuilder& TableMetadataBuilder::UpgradeFormatVersion(
+    int8_t new_format_version) {
+  throw IcebergError(std::format("{} not implemented", __FUNCTION__));
+}
+
+TableMetadataBuilder& TableMetadataBuilder::SetCurrentSchema(
+    std::shared_ptr<Schema> schema, int32_t new_last_column_id) {
+  throw IcebergError(std::format("{} not implemented", __FUNCTION__));
+}
+
+TableMetadataBuilder& TableMetadataBuilder::SetCurrentSchema(int32_t schema_id) {
+  throw IcebergError(std::format("{} not implemented", __FUNCTION__));
+}
+
+TableMetadataBuilder& TableMetadataBuilder::AddSchema(std::shared_ptr<Schema> schema) {
+  throw IcebergError(std::format("{} not implemented", __FUNCTION__));
+}
+
+TableMetadataBuilder& TableMetadataBuilder::SetDefaultPartitionSpec(
+    std::shared_ptr<PartitionSpec> spec) {
+  throw IcebergError(std::format("{} not implemented", __FUNCTION__));
+}
+
+TableMetadataBuilder& TableMetadataBuilder::SetDefaultPartitionSpec(int32_t spec_id) {
+  throw IcebergError(std::format("{} not implemented", __FUNCTION__));
+}
+
+TableMetadataBuilder& TableMetadataBuilder::AddPartitionSpec(
+    std::shared_ptr<PartitionSpec> spec) {
+  throw IcebergError(std::format("{} not implemented", __FUNCTION__));
+}
+
+TableMetadataBuilder& TableMetadataBuilder::RemovePartitionSpecs(
+    const std::vector<int32_t>& spec_ids) {
+  throw IcebergError(std::format("{} not implemented", __FUNCTION__));
+}
+
+TableMetadataBuilder& TableMetadataBuilder::RemoveSchemas(
+    const std::vector<int32_t>& schema_ids) {
+  throw IcebergError(std::format("{} not implemented", __FUNCTION__));
+}
+
+TableMetadataBuilder& TableMetadataBuilder::SetDefaultSortOrder(
+    std::shared_ptr<SortOrder> order) {
+  throw IcebergError(std::format("{} not implemented", __FUNCTION__));
+}
+
+TableMetadataBuilder& TableMetadataBuilder::SetDefaultSortOrder(int32_t order_id) {
+  throw IcebergError(std::format("{} not implemented", __FUNCTION__));
+}
+
+TableMetadataBuilder& TableMetadataBuilder::AddSortOrder(
+    std::shared_ptr<SortOrder> order) {
+  throw IcebergError(std::format("{} not implemented", __FUNCTION__));
+}
+
+TableMetadataBuilder& TableMetadataBuilder::AddSnapshot(
+    std::shared_ptr<Snapshot> snapshot) {
+  throw IcebergError(std::format("{} not implemented", __FUNCTION__));
+}
+
+TableMetadataBuilder& TableMetadataBuilder::SetBranchSnapshot(int64_t snapshot_id,
+                                                              const std::string& branch) {
+  throw IcebergError(std::format("{} not implemented", __FUNCTION__));
+}
+
+TableMetadataBuilder& TableMetadataBuilder::SetRef(const std::string& name,
+                                                   std::shared_ptr<SnapshotRef> ref) {
+  throw IcebergError(std::format("{} not implemented", __FUNCTION__));
+}
+
+TableMetadataBuilder& TableMetadataBuilder::RemoveRef(const std::string& name) {
+  throw IcebergError(std::format("{} not implemented", __FUNCTION__));
+}
+
+TableMetadataBuilder& TableMetadataBuilder::RemoveSnapshots(
+    const std::vector<std::shared_ptr<Snapshot>>& snapshots_to_remove) {
+  throw IcebergError(std::format("{} not implemented", __FUNCTION__));
+}
+
+TableMetadataBuilder& TableMetadataBuilder::RemoveSnapshots(
+    const std::vector<int64_t>& snapshot_ids) {
+  throw IcebergError(std::format("{} not implemented", __FUNCTION__));
+}
+
+TableMetadataBuilder& TableMetadataBuilder::suppressHistoricalSnapshots() {
+  throw IcebergError(std::format("{} not implemented", __FUNCTION__));
+}
+
+TableMetadataBuilder& TableMetadataBuilder::SetStatistics(
+    const std::shared_ptr<StatisticsFile>& statistics_file) {
+  throw IcebergError(std::format("{} not implemented", __FUNCTION__));
+}
+
+TableMetadataBuilder& TableMetadataBuilder::RemoveStatistics(int64_t snapshot_id) {
+  throw IcebergError(std::format("{} not implemented", __FUNCTION__));
+}
+
+TableMetadataBuilder& TableMetadataBuilder::SetPartitionStatistics(
+    const std::shared_ptr<PartitionStatisticsFile>& partition_statistics_file) {
+  throw IcebergError(std::format("{} not implemented", __FUNCTION__));
+}
+
+TableMetadataBuilder& TableMetadataBuilder::RemovePartitionStatistics(
+    int64_t snapshot_id) {
+  throw IcebergError(std::format("{} not implemented", __FUNCTION__));
+}
+
+TableMetadataBuilder& TableMetadataBuilder::SetProperties(
+    const std::unordered_map<std::string, std::string>& updated) {
+  throw IcebergError(std::format("{} not implemented", __FUNCTION__));
+}
+
+TableMetadataBuilder& TableMetadataBuilder::RemoveProperties(
+    const std::vector<std::string>& removed) {
+  throw IcebergError(std::format("{} not implemented", __FUNCTION__));
+}
+
+TableMetadataBuilder& TableMetadataBuilder::SetLocation(std::string_view location) {
+  throw IcebergError(std::format("{} not implemented", __FUNCTION__));
+}
+
+TableMetadataBuilder& TableMetadataBuilder::AddEncryptionKey(
+    std::shared_ptr<EncryptedKey> key) {
+  throw IcebergError(std::format("{} not implemented", __FUNCTION__));
+}
+
+TableMetadataBuilder& TableMetadataBuilder::RemoveEncryptionKey(std::string_view key_id) {
+  throw IcebergError(std::format("{} not implemented", __FUNCTION__));
+}
+
+TableMetadataBuilder& TableMetadataBuilder::DiscardChanges() {
+  throw IcebergError(std::format("{} not implemented", __FUNCTION__));
+}
+
+Result<std::unique_ptr<TableMetadata>> TableMetadataBuilder::Build() {
+  return NotImplemented("TableMetadataBuilder::Build not implemented");
+}
+
 }  // namespace iceberg