fix build error

Author: gty404

src/iceberg/CMakeLists.txt

@@ -47,7 +47,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/table_metadata.cc

@@ -32,7 +32,6 @@
 #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"
 
@@ -198,4 +197,185 @@ 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) {
+  return *this;
+}
+
+TableMetadataBuilder& TableMetadataBuilder::SetPreviousMetadataLocation(
+    std::string_view previous_metadata_location) {
+  return *this;
+}
+
+TableMetadataBuilder& TableMetadataBuilder::AssignUUID() { return *this; }
+
+TableMetadataBuilder& TableMetadataBuilder::AssignUUID(std::string_view uuid) {
+  return *this;
+}
+
+TableMetadataBuilder& TableMetadataBuilder::UpgradeFormatVersion(
+    int8_t new_format_version) {
+  return *this;
+}
+
+TableMetadataBuilder& TableMetadataBuilder::SetCurrentSchema(
+    std::shared_ptr<Schema> schema, int32_t new_last_column_id) {
+  return *this;
+}
+
+TableMetadataBuilder& TableMetadataBuilder::SetCurrentSchema(int32_t schema_id) {
+  return *this;
+}
+
+TableMetadataBuilder& TableMetadataBuilder::AddSchema(std::shared_ptr<Schema> schema) {
+  return *this;
+}
+
+TableMetadataBuilder& TableMetadataBuilder::SetDefaultPartitionSpec(
+    std::shared_ptr<PartitionSpec> spec) {
+  return *this;
+}
+
+TableMetadataBuilder& TableMetadataBuilder::SetDefaultPartitionSpec(int32_t spec_id) {
+  return *this;
+}
+
+TableMetadataBuilder& TableMetadataBuilder::AddPartitionSpec(
+    std::shared_ptr<PartitionSpec> spec) {
+  return *this;
+}
+
+TableMetadataBuilder& TableMetadataBuilder::RemovePartitionSpecs(
+    const std::vector<int32_t>& spec_ids) {
+  return *this;
+}
+
+TableMetadataBuilder& TableMetadataBuilder::RemoveSchemas(
+    const std::vector<int32_t>& schema_ids) {
+  return *this;
+}
+
+TableMetadataBuilder& TableMetadataBuilder::SetDefaultSortOrder(
+    std::shared_ptr<SortOrder> order) {
+  return *this;
+}
+
+TableMetadataBuilder& TableMetadataBuilder::SetDefaultSortOrder(int32_t order_id) {
+  return *this;
+}
+
+TableMetadataBuilder& TableMetadataBuilder::AddSortOrder(
+    std::shared_ptr<SortOrder> order) {
+  return *this;
+}
+
+TableMetadataBuilder& TableMetadataBuilder::AddSnapshot(
+    std::shared_ptr<Snapshot> snapshot) {
+  return *this;
+}
+
+TableMetadataBuilder& TableMetadataBuilder::SetBranchSnapshot(int64_t snapshot_id,
+                                                              const std::string& branch) {
+  return *this;
+}
+
+TableMetadataBuilder& TableMetadataBuilder::SetRef(const std::string& name,
+                                                   std::shared_ptr<SnapshotRef> ref) {
+  return *this;
+}
+
+TableMetadataBuilder& TableMetadataBuilder::RemoveRef(const std::string& name) {
+  return *this;
+}
+
+TableMetadataBuilder& TableMetadataBuilder::RemoveSnapshots(
+    const std::vector<std::shared_ptr<Snapshot>>& snapshots_to_remove) {
+  return *this;
+}
+
+TableMetadataBuilder& TableMetadataBuilder::RemoveSnapshots(
+    const std::vector<int64_t>& snapshot_ids) {
+  return *this;
+}
+
+TableMetadataBuilder& TableMetadataBuilder::suppressHistoricalSnapshots() {
+  return *this;
+}
+
+TableMetadataBuilder& TableMetadataBuilder::SetStatistics(
+    const std::shared_ptr<StatisticsFile>& statistics_file) {
+  return *this;
+}
+
+TableMetadataBuilder& TableMetadataBuilder::RemoveStatistics(int64_t snapshot_id) {
+  return *this;
+}
+
+TableMetadataBuilder& TableMetadataBuilder::SetPartitionStatistics(
+    const std::shared_ptr<PartitionStatisticsFile>& partition_statistics_file) {
+  return *this;
+}
+
+TableMetadataBuilder& TableMetadataBuilder::RemovePartitionStatistics(
+    int64_t snapshot_id) {
+  return *this;
+}
+
+TableMetadataBuilder& TableMetadataBuilder::SetProperties(
+    const std::unordered_map<std::string, std::string>& updated) {
+  return *this;
+}
+
+TableMetadataBuilder& TableMetadataBuilder::RemoveProperties(
+    const std::vector<std::string>& removed) {
+  return *this;
+}
+
+TableMetadataBuilder& TableMetadataBuilder::SetLocation(std::string_view location) {
+  return *this;
+}
+
+TableMetadataBuilder& TableMetadataBuilder::AddEncryptionKey(
+    std::shared_ptr<EncryptedKey> key) {
+  return *this;
+}
+
+TableMetadataBuilder& TableMetadataBuilder::RemoveEncryptionKey(std::string_view key_id) {
+  return *this;
+}
+
+TableMetadataBuilder& TableMetadataBuilder::DiscardChanges() { return *this; }
+
+Result<std::unique_ptr<TableMetadata>> TableMetadataBuilder::Build() {
+  return NotImplemented("TableMetadataBuilder::Build not implemented");
+}
+
 }  // namespace iceberg

src/iceberg/table_requirement.cc

@@ -0,0 +1,58 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include "iceberg/table_requirement.h"
+
+#include "iceberg/table_metadata.h"
+
+namespace iceberg {
+
+Status AssertTableDoesNotExist::Validate(const TableMetadata* base) const {
+  return NotImplemented("AssertTableDoesNotExist::Validate not implemented");
+}
+
+Status AssertTableUUID::Validate(const TableMetadata* base) const {
+  return NotImplemented("AssertTableUUID::Validate not implemented");
+}
+
+Status AssertRefSnapshotID::Validate(const TableMetadata* base) const {
+  return NotImplemented("AssertRefSnapshotID::Validate not implemented");
+}
+
+Status AssertLastAssignedFieldId::Validate(const TableMetadata* base) const {
+  return NotImplemented("AssertLastAssignedFieldId::Validate not implemented");
+}
+
+Status AssertCurrentSchemaID::Validate(const TableMetadata* base) const {
+  return NotImplemented("AssertCurrentSchemaID::Validate not implemented");
+}
+
+Status AssertLastAssignedPartitionId::Validate(const TableMetadata* base) const {
+  return NotImplemented("AssertLastAssignedPartitionId::Validate not implemented");
+}
+
+Status AssertDefaultSpecID::Validate(const TableMetadata* base) const {
+  return NotImplemented("AssertDefaultSpecID::Validate not implemented");
+}
+
+Status AssertDefaultSortOrderID::Validate(const TableMetadata* base) const {
+  return NotImplemented("AssertDefaultSortOrderID::Validate not implemented");
+}
+
+}  // namespace iceberg

src/iceberg/table_requirement.h

@@ -19,14 +19,13 @@
 
 #pragma once
 
-/// \file iceberg/update_requirement.h
+/// \file iceberg/table_requirement.h
 /// Update requirements for Iceberg table operations.
 ///
-/// Update requirements are conditions that must be satisfied before
+/// Table requirements are conditions that must be satisfied before
 /// applying metadata updates to a table. They are used for optimistic
 /// concurrency control in table operations.
 
-#include <memory>
 #include <optional>
 #include <string>
 

src/iceberg/table_requirements.cc

@@ -0,0 +1,53 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include "iceberg/table_requirements.h"
+
+#include "iceberg/table_metadata.h"
+#include "iceberg/table_update.h"
+
+namespace iceberg {
+
+void MetadataUpdateContext::AddRequirement(
+    std::unique_ptr<TableRequirement> requirement) {
+  requirements_.push_back(std::move(requirement));
+}
+
+Result<std::vector<std::unique_ptr<TableRequirement>>> MetadataUpdateContext::Build() {
+  return std::move(requirements_);
+}
+
+Result<std::vector<std::unique_ptr<TableRequirement>>> TableRequirements::ForCreateTable(
+    const std::vector<std::unique_ptr<TableUpdate>>& table_updates) {
+  return NotImplemented("TableRequirements::ForCreateTable not implemented");
+}
+
+Result<std::vector<std::unique_ptr<TableRequirement>>> TableRequirements::ForReplaceTable(
+    const TableMetadata& base,
+    const std::vector<std::unique_ptr<TableUpdate>>& table_updates) {
+  return NotImplemented("TableRequirements::ForReplaceTable not implemented");
+}
+
+Result<std::vector<std::unique_ptr<TableRequirement>>> TableRequirements::ForUpdateTable(
+    const TableMetadata& base,
+    const std::vector<std::unique_ptr<TableUpdate>>& table_updates) {
+  return NotImplemented("TableRequirements::ForUpdateTable not implemented");
+}
+
+}  // namespace iceberg

src/iceberg/table_requirements.h

@@ -87,7 +87,7 @@ class ICEBERG_EXPORT TableRequirements {
   ///
   /// \param table_updates The list of metadata updates for table creation
   /// \return A list of update requirements to validate before creation
-  static std::vector<std::unique_ptr<TableRequirement>> ForCreateTable(
+  static Result<std::vector<std::unique_ptr<TableRequirement>>> ForCreateTable(
       const std::vector<std::unique_ptr<TableUpdate>>& table_updates);
 
   /// \brief Generate requirements for replacing an existing table
@@ -98,7 +98,7 @@ class ICEBERG_EXPORT TableRequirements {
   /// \param base The base table metadata
   /// \param table_updates The list of metadata updates for replacement
   /// \return A list of update requirements to validate before replacement
-  static std::vector<std::unique_ptr<TableRequirement>> ForReplaceTable(
+  static Result<std::vector<std::unique_ptr<TableRequirement>>> ForReplaceTable(
       const TableMetadata& base,
       const std::vector<std::unique_ptr<TableUpdate>>& table_updates);
 
@@ -110,7 +110,7 @@ class ICEBERG_EXPORT TableRequirements {
   /// \param base The base table metadata
   /// \param table_updates The list of metadata updates
   /// \return A list of update requirements to validate before update
-  static std::vector<std::unique_ptr<TableRequirement>> ForUpdateTable(
+  static Result<std::vector<std::unique_ptr<TableRequirement>>> ForUpdateTable(
       const TableMetadata& base,
       const std::vector<std::unique_ptr<TableUpdate>>& table_updates);
 };