feat: Refresh method support for table

Author: shuxu.li

src/iceberg/catalog.h

@@ -38,6 +38,8 @@ namespace iceberg {
 /// specified by the Iceberg Rest Catalog API.
 class ICEBERG_EXPORT Catalog {
  public:
+  class TableBuilder;
+
   virtual ~Catalog() = default;
 
   /// \brief Return the name for this catalog
@@ -182,8 +184,8 @@ class ICEBERG_EXPORT Catalog {
   /// \param identifier a table identifier
   /// \param schema a schema
   /// \return the builder to create a table or start a create/replace transaction
-  virtual std::unique_ptr<class TableBuilder> BuildTable(
-      const TableIdentifier& identifier, const Schema& schema) const = 0;
+  virtual std::unique_ptr<TableBuilder> BuildTable(const TableIdentifier& identifier,
+                                                   const Schema& schema) const = 0;
 
   /// \brief A builder used to create valid tables or start create/replace transactions
   class TableBuilder {

src/iceberg/catalog/in_memory_catalog.cc

@@ -441,7 +441,7 @@ Result<std::shared_ptr<Table>> InMemoryCatalog::RegisterTable(
   return LoadTable(identifier);
 }
 
-std::unique_ptr<TableBuilder> InMemoryCatalog::BuildTable(
+std::unique_ptr<Catalog::TableBuilder> InMemoryCatalog::BuildTable(
     const TableIdentifier& identifier, const Schema& schema) const {
   throw IcebergError("not implemented");
 }

src/iceberg/catalog/in_memory_catalog.h

@@ -91,8 +91,8 @@ class ICEBERG_EXPORT InMemoryCatalog
       const TableIdentifier& identifier,
       const std::string& metadata_file_location) override;
 
-  std::unique_ptr<iceberg::TableBuilder> BuildTable(const TableIdentifier& identifier,
-                                                    const Schema& schema) const override;
+  std::unique_ptr<TableBuilder> BuildTable(const TableIdentifier& identifier,
+                                           const Schema& schema) const override;
 
  private:
   std::string catalog_name_;

test/in_memory_catalog_test.cc

@@ -17,13 +17,16 @@
  * under the License.
  */
 
+#include "iceberg/catalog/in_memory_catalog.h"
+
 #include <filesystem>
 
 #include <arrow/filesystem/localfs.h>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
 #include "iceberg/arrow/arrow_fs_file_io_internal.h"
+#include "iceberg/schema.h"
 #include "iceberg/table.h"
 #include "iceberg/table_metadata.h"
 #include "matchers.h"
@@ -115,42 +118,53 @@ TEST_F(InMemoryCatalogTest, RegisterTable) {
 }
 
 TEST_F(InMemoryCatalogTest, RefreshTable) {
-  TableIdentifier tableIdent{.ns = {}, .name = "t1"};
-  std::shared_ptr<MockInMemoryCatalog> mock_catalog =
-      std::make_shared<MockInMemoryCatalog>(
-          "mock_catalog", file_io_, "/tmp/warehouse/",
-          std::unordered_map<std::string, std::string>());
-  auto table_location = GenerateTestTableLocation(tableIdent.name);
-  auto buildTable = [this, &tableIdent, &mock_catalog, &table_location](
-                        int64_t snapshot_id, int64_t version) -> std::unique_ptr<Table> {
-    std::unique_ptr<TableMetadata> metadata;
-    ReadTableMetadata("TableMetadataV2Valid.json", &metadata);
-    metadata->current_snapshot_id = snapshot_id;
-    return std::make_unique<Table>(
-        tableIdent, std::move(metadata),
-        std::format("{}v{}.metadata.json", table_location, version), file_io_,
-        std::static_pointer_cast<Catalog>(mock_catalog));
-  };
-
-  auto table_v0 = buildTable(3051729675574597004, 0);
-  auto table_v1 = buildTable(3055729675574597004, 1);
-  EXPECT_CALL(*mock_catalog, LoadTable(::testing::_))
-      .WillOnce(::testing::Return(
-          ::testing::ByMove(Result<std::unique_ptr<Table>>(std::move(table_v0)))))
-      .WillOnce(::testing::Return(
-          ::testing::ByMove(Result<std::unique_ptr<Table>>(std::move(table_v1)))));
+  TableIdentifier table_ident{.ns = {}, .name = "t1"};
+  auto schema = std::make_shared<Schema>(
+      std::vector<SchemaField>{SchemaField::MakeRequired(1, "x", int64())},
+      /*schema_id=*/1);
 
-  auto metadata_location = std::format("{}v{}.metadata.json", table_location, 0);
-  auto table = mock_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, 3051729675574597004);
+  std::shared_ptr<FileIO> io;
 
-  // refresh table to new snapshot
-  auto status = table.value()->Refresh();
-  EXPECT_THAT(status, IsOk());
-  ASSERT_TRUE(table.value()->current_snapshot().has_value());
-  ASSERT_EQ(table.value()->current_snapshot().value()->snapshot_id, 3055729675574597004);
+  auto catalog = std::make_shared<MockCatalog>();
+  // Mock 1st call to LoadTable
+  EXPECT_CALL(*catalog, LoadTable(::testing::_))
+      .WillOnce(::testing::Return(
+          std::make_unique<Table>(table_ident,
+                                  std::make_shared<TableMetadata>(TableMetadata{
+                                      .schemas = {schema},
+                                      .current_schema_id = 1,
+                                      .current_snapshot_id = 1,
+                                      .snapshots = {std::make_shared<Snapshot>(Snapshot{
+                                          .snapshot_id = 1,
+                                          .sequence_number = 1,
+                                      })}}),
+                                  "s3://location/1.json", io, catalog)));
+  auto load_table_result = catalog->LoadTable(table_ident);
+  ASSERT_THAT(load_table_result, IsOk());
+  auto loaded_table = std::move(load_table_result.value());
+  ASSERT_EQ(loaded_table->current_snapshot().value()->snapshot_id, 1);
+
+  // Mock 2nd call to LoadTable
+  EXPECT_CALL(*catalog, LoadTable(::testing::_))
+      .WillOnce(::testing::Return(
+          std::make_unique<Table>(table_ident,
+                                  std::make_shared<TableMetadata>(TableMetadata{
+                                      .schemas = {schema},
+                                      .current_schema_id = 1,
+                                      .current_snapshot_id = 2,
+                                      .snapshots = {std::make_shared<Snapshot>(Snapshot{
+                                                        .snapshot_id = 1,
+                                                        .sequence_number = 1,
+                                                    }),
+                                                    std::make_shared<Snapshot>(Snapshot{
+                                                        .snapshot_id = 2,
+                                                        .sequence_number = 2,
+                                                    })}}),
+                                  "s3://location/2.json", io, catalog)));
+  auto refreshed_result = loaded_table->Refresh();
+  ASSERT_THAT(refreshed_result, IsOk());
+  // check table is refreshed
+  ASSERT_EQ(loaded_table->current_snapshot().value()->snapshot_id, 2);
 }
 
 TEST_F(InMemoryCatalogTest, DropTable) {

test/mock_catalog.h

@@ -19,18 +19,67 @@
 
 #pragma once
 
-#include "iceberg/catalog/in_memory_catalog.h"
+#include "iceberg/catalog.h"
 
 namespace iceberg {
 
-class MockInMemoryCatalog : public InMemoryCatalog {
+class MockCatalog : public Catalog {
  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) {}
+  MockCatalog() = default;
+  ~MockCatalog() override = default;
 
-  MOCK_METHOD(Result<std::unique_ptr<Table>>, LoadTable, (const TableIdentifier&),
+  MOCK_METHOD(std::string_view, name, (), (const, override));
+
+  MOCK_METHOD(Status, CreateNamespace,
+              (const Namespace&, (const std::unordered_map<std::string, std::string>&)),
+              (override));
+
+  MOCK_METHOD((Result<std::vector<Namespace>>), ListNamespaces, (const Namespace&),
+              (const, override));
+
+  MOCK_METHOD((Result<std::unordered_map<std::string, std::string>>),
+              GetNamespaceProperties, (const Namespace&), (const, override));
+
+  MOCK_METHOD(Status, UpdateNamespaceProperties,
+              (const Namespace&, (const std::unordered_map<std::string, std::string>&),
+               (const std::unordered_set<std::string>&)),
               (override));
+
+  MOCK_METHOD(Status, DropNamespace, (const Namespace&), (override));
+
+  MOCK_METHOD(Result<bool>, NamespaceExists, (const Namespace&), (const, override));
+
+  MOCK_METHOD((Result<std::vector<TableIdentifier>>), ListTables, (const Namespace&),
+              (const, override));
+
+  MOCK_METHOD((Result<std::unique_ptr<Table>>), CreateTable,
+              (const TableIdentifier&, const Schema&, const PartitionSpec&,
+               const std::string&, (const std::unordered_map<std::string, std::string>&)),
+              (override));
+
+  MOCK_METHOD((Result<std::unique_ptr<Table>>), UpdateTable,
+              (const TableIdentifier&,
+               (const std::vector<std::unique_ptr<UpdateRequirement>>&),
+               (const std::vector<std::unique_ptr<MetadataUpdate>>&)),
+              (override));
+
+  MOCK_METHOD((Result<std::shared_ptr<Transaction>>), StageCreateTable,
+              (const TableIdentifier&, const Schema&, const PartitionSpec&,
+               const std::string&, (const std::unordered_map<std::string, std::string>&)),
+              (override));
+
+  MOCK_METHOD(Result<bool>, TableExists, (const TableIdentifier&), (const, override));
+
+  MOCK_METHOD(Status, DropTable, (const TableIdentifier&, bool), (override));
+
+  MOCK_METHOD((Result<std::unique_ptr<Table>>), LoadTable, (const TableIdentifier&),
+              (override));
+
+  MOCK_METHOD((Result<std::shared_ptr<Table>>), RegisterTable,
+              (const TableIdentifier&, const std::string&), (override));
+
+  MOCK_METHOD((std::unique_ptr<Catalog::TableBuilder>), BuildTable,
+              (const TableIdentifier&, const Schema&), (const, override));
 };
+
 }  // namespace iceberg