feat: Refresh method support for table

Author: shuxu.li

src/iceberg/catalog/in_memory_catalog.cc

@@ -109,6 +109,15 @@ class ICEBERG_EXPORT InMemoryNamespace {
   ///         ErrorKind::kNoSuchTable if the table does not exist.
   Status UnregisterTable(const TableIdentifier& table_ident);
 
+  /// \brief Updates the metadata location of an existing table.
+  ///
+  /// \param table_ident The fully qualified identifier of the table.
+  /// \param metadata_location The path to the table's metadata.
+  /// \return Status::OK if the table metadata location is updated;
+  ///         Error otherwise.
+  Status UpdateTableMetaLocation(const TableIdentifier& table_ident,
+                                 const std::string& metadata_location);
+
   /// \brief Checks if a table exists in the specified namespace.
   ///
   /// \param table_ident The identifier of the table to check.
@@ -297,6 +306,17 @@ Status InMemoryNamespace::UnregisterTable(TableIdentifier const& table_ident) {
   return {};
 }
 
+Status InMemoryNamespace::UpdateTableMetaLocation(const TableIdentifier& table_ident,
+                                                  const std::string& metadata_location) {
+  const auto ns = GetNamespace(this, table_ident.ns);
+  ICEBERG_RETURN_UNEXPECTED(ns);
+  if (!ns.value()->table_metadata_locations_.contains(table_ident.name)) {
+    return NotFound("{} does not exist", table_ident.name);
+  }
+  ns.value()->table_metadata_locations_[table_ident.name] = metadata_location;
+  return {};
+}
+
 Result<bool> InMemoryNamespace::TableExists(TableIdentifier const& table_ident) const {
   const auto ns = GetNamespace(this, table_ident.ns);
   ICEBERG_RETURN_UNEXPECTED(ns);
@@ -446,4 +466,10 @@ std::unique_ptr<TableBuilder> InMemoryCatalog::BuildTable(
   throw IcebergError("not implemented");
 }
 
+Status InMemoryCatalog::UpdateTableMetaLocationInternal(
+    const TableIdentifier& identifier, const std::string& metadata_location) {
+  std::unique_lock lock(mutex_);
+  return root_namespace_->UpdateTableMetaLocation(identifier, metadata_location);
+}
+
 }  // namespace iceberg

src/iceberg/catalog/in_memory_catalog.h

@@ -93,6 +93,10 @@ class ICEBERG_EXPORT InMemoryCatalog
   std::unique_ptr<iceberg::TableBuilder> BuildTable(const TableIdentifier& identifier,
                                                     const Schema& schema) const override;
 
+ protected:
+  Status UpdateTableMetaLocationInternal(const TableIdentifier& identifier,
+                                         const std::string& metadata_location);
+
  private:
   std::string catalog_name_;
   std::unordered_map<std::string, std::string> properties_;

src/iceberg/table.cc

@@ -35,14 +35,14 @@ const std::string& Table::uuid() const { return metadata_->table_uuid; }
 
 Status Table::Refresh() {
   if (!catalog_) {
-    return InvalidArgument("Cannot refresh table metadata without a catalog");
+    return InvalidArgument("Refresh is not supported for table without a catalog");
   }
 
-  ICEBERG_ASSIGN_OR_RAISE(auto fresh, catalog_->LoadTable(identifier_));
-  if (metadata_location_ != fresh->metadata_location_) {
-    metadata_ = std::move(fresh->metadata_);
-    metadata_location_ = std::move(fresh->metadata_location_);
-    io_ = std::move(fresh->io_);
+  ICEBERG_ASSIGN_OR_RAISE(auto refreshed_table, catalog_->LoadTable(identifier_));
+  if (metadata_location_ != refreshed_table->metadata_location_) {
+    metadata_ = std::move(refreshed_table->metadata_);
+    metadata_location_ = std::move(refreshed_table->metadata_location_);
+    io_ = std::move(refreshed_table->io_);
 
     schemas_map_.reset();
     partition_spec_map_.reset();

test/in_memory_catalog_test.cc

@@ -17,8 +17,6 @@
  * under the License.
  */
 
-#include "iceberg/catalog/in_memory_catalog.h"
-
 #include <filesystem>
 
 #include <arrow/filesystem/localfs.h>
@@ -29,6 +27,7 @@
 #include "iceberg/table.h"
 #include "iceberg/table_metadata.h"
 #include "matchers.h"
+#include "mock_catalog.h"
 #include "test_common.h"
 
 namespace iceberg {
@@ -39,8 +38,8 @@ class InMemoryCatalogTest : public ::testing::Test {
     file_io_ = std::make_shared<iceberg::arrow::ArrowFileSystemFileIO>(
         std::make_shared<::arrow::fs::LocalFileSystem>());
     std::unordered_map<std::string, std::string> properties = {{"prop1", "val1"}};
-    catalog_ = std::make_shared<InMemoryCatalog>("test_catalog", file_io_,
-                                                 "/tmp/warehouse/", properties);
+    catalog_ = std::make_shared<MockInMemoryCatalog>("test_catalog", file_io_,
+                                                     "/tmp/warehouse/", properties);
   }
 
   void TearDown() override {
@@ -74,7 +73,7 @@ class InMemoryCatalogTest : public ::testing::Test {
   }
 
   std::shared_ptr<FileIO> file_io_;
-  std::shared_ptr<InMemoryCatalog> catalog_;
+  std::shared_ptr<MockInMemoryCatalog> catalog_;
   // Used to store temporary paths created during the test
   std::vector<std::string> created_temp_paths_;
 };
@@ -121,6 +120,7 @@ TEST_F(InMemoryCatalogTest, RefreshTable) {
   std::unique_ptr<TableMetadata> metadata;
   ASSERT_NO_FATAL_FAILURE(ReadTableMetadata("TableMetadataV2Valid.json", &metadata));
 
+  metadata->current_snapshot_id = 3051729675574597004;
   auto table_location = GenerateTestTableLocation(tableIdent.name);
   auto metadata_location = std::format("{}v0.metadata.json", table_location);
   auto status = TableMetadataUtil::Write(*file_io_, metadata_location, *metadata);
@@ -129,9 +129,18 @@ TEST_F(InMemoryCatalogTest, RefreshTable) {
   auto table = catalog_->RegisterTable(tableIdent, metadata_location);
   EXPECT_THAT(table, IsOk());
   ASSERT_TRUE(table.value()->current_snapshot().has_value());
-  ASSERT_EQ(table.value()->current_snapshot().value()->snapshot_id, 3055729675574597004);
+  ASSERT_EQ(table.value()->current_snapshot().value()->snapshot_id, 3051729675574597004);
+
+  // update table version to 3055729675574597004
+  metadata_location = std::format("{}v1.metadata.json", table_location);
+  metadata->current_snapshot_id = 3055729675574597004;
+  status = TableMetadataUtil::Write(*file_io_, metadata_location, *metadata);
+  EXPECT_THAT(status, IsOk());
+
+  // update table metadata location in catalog
+  status = catalog_->UpdateTableMetaLocation(tableIdent, metadata_location);
+  EXPECT_THAT(status, IsOk());
 
-  // Now we don't support commit method in catalog, so here only test refresh with the
   // same version
   status = table.value()->Refresh();
   EXPECT_THAT(status, IsOk());

test/mock_catalog.h

@@ -0,0 +1,40 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include "iceberg/catalog/in_memory_catalog.h"
+
+namespace iceberg {
+
+class ICEBERG_EXPORT MockInMemoryCatalog : public InMemoryCatalog {
+ public:
+  MockInMemoryCatalog(std::string const& name, std::shared_ptr<FileIO> const& file_io,
+                      std::string const& warehouse_location,
+                      std::unordered_map<std::string, std::string> const& properties)
+      : InMemoryCatalog(name, file_io, warehouse_location, properties) {}
+
+  /// \brief Directly sets the metadata location of a table.
+  /// \note This should only be used in unit tests.
+  Status UpdateTableMetaLocation(const TableIdentifier& identifier,
+                                 const std::string& metadata_location) {
+    return UpdateTableMetaLocationInternal(identifier, metadata_location);
+  }
+};
+}  // namespace iceberg