fix: Merge the latest commits from the main branch

Author: gty404

src/iceberg/catalog/memory_catalog.cc

@@ -29,37 +29,37 @@ namespace iceberg {
 
 namespace {
 
-NamespaceContainer* GetNamespaceContainer(NamespaceContainer* root,
-                                          const Namespace& namespace_ident) {
-  return NamespaceContainer::GetNamespaceContainerImpl(root, namespace_ident);
+InMemoryNamespace* GetNamespace(InMemoryNamespace* root,
+                                const Namespace& namespace_ident) {
+  return InMemoryNamespace::GetNamespaceImpl(root, namespace_ident);
 }
 
-const NamespaceContainer* GetNamespaceContainer(const NamespaceContainer* root,
-                                                const Namespace& namespace_ident) {
-  return NamespaceContainer::GetNamespaceContainerImpl(root, namespace_ident);
+const InMemoryNamespace* GetNamespace(const InMemoryNamespace* root,
+                                      const Namespace& namespace_ident) {
+  return InMemoryNamespace::GetNamespaceImpl(root, namespace_ident);
 }
 
 }  // namespace
 
-MemoryCatalog::MemoryCatalog(std::shared_ptr<FileIO> file_io,
-                             std::string warehouse_location)
+InMemoryCatalog::InMemoryCatalog(std::shared_ptr<FileIO> file_io,
+                                 std::string warehouse_location)
     : file_io_(std::move(file_io)),
       warehouse_location_(std::move(warehouse_location)),
-      root_container_(std::make_unique<NamespaceContainer>()) {}
+      root_namespace_(std::make_unique<InMemoryNamespace>()) {}
 
-void MemoryCatalog::Initialize(
+void InMemoryCatalog::Initialize(
     const std::string& name,
     const std::unordered_map<std::string, std::string>& properties) {
   catalog_name_ = name;
   properties_ = properties;
 }
 
-std::string_view MemoryCatalog::name() const { return catalog_name_; }
+std::string_view InMemoryCatalog::name() const { return catalog_name_; }
 
-Result<std::vector<TableIdentifier>> MemoryCatalog::ListTables(
+Result<std::vector<TableIdentifier>> InMemoryCatalog::ListTables(
     const Namespace& ns) const {
   std::unique_lock lock(mutex_);
-  const auto& table_names = root_container_->ListTables(ns);
+  const auto& table_names = root_namespace_->ListTables(ns);
   std::vector<TableIdentifier> table_idents;
   table_idents.reserve(table_names.size());
   std::ranges::transform(
@@ -68,117 +68,116 @@ Result<std::vector<TableIdentifier>> MemoryCatalog::ListTables(
   return table_idents;
 }
 
-Result<std::unique_ptr<Table>> MemoryCatalog::CreateTable(
+Result<std::unique_ptr<Table>> InMemoryCatalog::CreateTable(
     const TableIdentifier& identifier, const Schema& schema, const PartitionSpec& spec,
     const std::string& location,
     const std::unordered_map<std::string, std::string>& properties) {
   return unexpected<Error>(
       {.kind = ErrorKind::kNotImplemented, .message = "CreateTable"});
 }
 
-Result<std::unique_ptr<Table>> MemoryCatalog::UpdateTable(
+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) {
   return unexpected<Error>(
       {.kind = ErrorKind::kNotImplemented, .message = "UpdateTable"});
 }
 
-Result<std::shared_ptr<Transaction>> MemoryCatalog::StageCreateTable(
+Result<std::shared_ptr<Transaction>> InMemoryCatalog::StageCreateTable(
     const TableIdentifier& identifier, const Schema& schema, const PartitionSpec& spec,
     const std::string& location,
     const std::unordered_map<std::string, std::string>& properties) {
   return unexpected<Error>(
       {.kind = ErrorKind::kNotImplemented, .message = "StageCreateTable"});
 }
 
-bool MemoryCatalog::TableExists(const TableIdentifier& identifier) const {
+bool InMemoryCatalog::TableExists(const TableIdentifier& identifier) const {
   std::unique_lock lock(mutex_);
-  return root_container_->TableExists(identifier);
+  return root_namespace_->TableExists(identifier);
 }
 
-bool MemoryCatalog::DropTable(const TableIdentifier& identifier, bool purge) {
+bool InMemoryCatalog::DropTable(const TableIdentifier& identifier, bool purge) {
   std::unique_lock lock(mutex_);
   // TODO(Guotao): Delete all metadata files if purge is true.
-  return root_container_->UnregisterTable(identifier);
+  return root_namespace_->UnregisterTable(identifier);
 }
 
-Result<std::shared_ptr<Table>> MemoryCatalog::LoadTable(
+Result<std::shared_ptr<Table>> InMemoryCatalog::LoadTable(
     const TableIdentifier& identifier) const {
   return unexpected<Error>({.kind = ErrorKind::kNotImplemented, .message = "LoadTable"});
 }
 
-Result<std::shared_ptr<Table>> MemoryCatalog::RegisterTable(
+Result<std::shared_ptr<Table>> InMemoryCatalog::RegisterTable(
     const TableIdentifier& identifier, const std::string& metadata_file_location) {
   std::unique_lock lock(mutex_);
-  if (!root_container_->NamespaceExists(identifier.ns)) {
+  if (!root_namespace_->NamespaceExists(identifier.ns)) {
     return unexpected<Error>({.kind = ErrorKind::kNoSuchNamespace,
                               .message = "table namespace does not exist"});
   }
-  if (!root_container_->RegisterTable(identifier, metadata_file_location)) {
+  if (!root_namespace_->RegisterTable(identifier, metadata_file_location)) {
     return unexpected<Error>(
         {.kind = ErrorKind::kUnknownError, .message = "The registry failed."});
   }
   return LoadTable(identifier);
 }
 
-std::unique_ptr<TableBuilder> MemoryCatalog::BuildTable(const TableIdentifier& identifier,
-                                                        const Schema& schema) const {
+std::unique_ptr<TableBuilder> InMemoryCatalog::BuildTable(
+    const TableIdentifier& identifier, const Schema& schema) const {
   throw IcebergError("not implemented");
 }
 
-bool NamespaceContainer::NamespaceExists(const Namespace& namespace_ident) const {
-  return GetNamespaceContainer(this, namespace_ident) != nullptr;
+bool InMemoryNamespace::NamespaceExists(const Namespace& namespace_ident) const {
+  return GetNamespace(this, namespace_ident) != nullptr;
 }
 
-std::vector<std::string> NamespaceContainer::ListChildrenNamespaces(
+std::vector<std::string> InMemoryNamespace::ListChildrenNamespaces(
     const std::optional<Namespace>& parent_namespace_ident) const {
-  auto container = this;
+  auto ns = this;
   if (parent_namespace_ident.has_value()) {
-    container = GetNamespaceContainer(this, *parent_namespace_ident);
-    if (!container) return {};
+    ns = GetNamespace(this, *parent_namespace_ident);
+    if (!ns) return {};
   }
 
   std::vector<std::string> names;
-  auto const& children = container->children_;
+  auto const& children = ns->children_;
   names.reserve(children.size());
   std::ranges::transform(children, std::back_inserter(names),
                          [](const auto& pair) { return pair.first; });
   return names;
 }
 
-bool NamespaceContainer::CreateNamespace(
+bool InMemoryNamespace::CreateNamespace(
     const Namespace& namespace_ident,
     const std::unordered_map<std::string, std::string>& properties) {
-  auto container = this;
+  auto ns = this;
   bool newly_created = false;
 
   for (const auto& part_level : namespace_ident.levels) {
-    if (auto it = container->children_.find(part_level);
-        it == container->children_.end()) {
-      container = &container->children_[part_level];
+    if (auto it = ns->children_.find(part_level); it == ns->children_.end()) {
+      ns = &ns->children_[part_level];
       newly_created = true;
     } else {
-      container = &it->second;
+      ns = &it->second;
     }
   }
 
   if (!newly_created) {
     return false;
   }
 
-  container->properties_ = properties;
+  ns->properties_ = properties;
   return true;
 }
 
-bool NamespaceContainer::DeleteNamespace(const Namespace& namespace_ident) {
+bool InMemoryNamespace::DeleteNamespace(const Namespace& namespace_ident) {
   if (namespace_ident.levels.empty()) return false;
 
   auto parent_namespace_ident = namespace_ident;
   const auto to_delete = parent_namespace_ident.levels.back();
   parent_namespace_ident.levels.pop_back();
 
-  auto* parent = GetNamespaceContainer(this, parent_namespace_ident);
+  auto* parent = GetNamespace(this, parent_namespace_ident);
   if (!parent) return false;
 
   auto it = parent->children_.find(to_delete);
@@ -193,27 +192,27 @@ bool NamespaceContainer::DeleteNamespace(const Namespace& namespace_ident) {
 }
 
 std::optional<std::unordered_map<std::string, std::string>>
-NamespaceContainer::GetProperties(const Namespace& namespace_ident) const {
-  const auto container = GetNamespaceContainer(this, namespace_ident);
-  if (!container) return std::nullopt;
-  return container->properties_;
+InMemoryNamespace::GetProperties(const Namespace& namespace_ident) const {
+  const auto ns = GetNamespace(this, namespace_ident);
+  if (!ns) return std::nullopt;
+  return ns->properties_;
 }
 
-bool NamespaceContainer::ReplaceProperties(
+bool InMemoryNamespace::ReplaceProperties(
     const Namespace& namespace_ident,
     const std::unordered_map<std::string, std::string>& properties) {
-  const auto container = GetNamespaceContainer(this, namespace_ident);
-  if (!container) return false;
-  container->properties_ = properties;
+  const auto ns = GetNamespace(this, namespace_ident);
+  if (!ns) return false;
+  ns->properties_ = properties;
   return true;
 }
 
-std::vector<std::string> NamespaceContainer::ListTables(
+std::vector<std::string> InMemoryNamespace::ListTables(
     const Namespace& namespace_ident) const {
-  const auto container = GetNamespaceContainer(this, namespace_ident);
-  if (!container) return {};
+  const auto ns = GetNamespace(this, namespace_ident);
+  if (!ns) return {};
 
-  const auto& locations = container->table_metadata_locations_;
+  const auto& locations = ns->table_metadata_locations_;
   std::vector<std::string> table_names;
   table_names.reserve(locations.size());
 
@@ -224,33 +223,33 @@ std::vector<std::string> NamespaceContainer::ListTables(
   return table_names;
 }
 
-bool NamespaceContainer::RegisterTable(TableIdentifier const& table_ident,
-                                       const std::string& metadata_location) {
-  const auto container = GetNamespaceContainer(this, table_ident.ns);
-  if (!container) return false;
-  if (container->table_metadata_locations_.contains(table_ident.name)) return false;
-  container->table_metadata_locations_[table_ident.name] = metadata_location;
+bool InMemoryNamespace::RegisterTable(TableIdentifier const& table_ident,
+                                      const std::string& metadata_location) {
+  const auto ns = GetNamespace(this, table_ident.ns);
+  if (!ns) return false;
+  if (ns->table_metadata_locations_.contains(table_ident.name)) return false;
+  ns->table_metadata_locations_[table_ident.name] = metadata_location;
   return true;
 }
 
-bool NamespaceContainer::UnregisterTable(TableIdentifier const& table_ident) {
-  const auto container = GetNamespaceContainer(this, table_ident.ns);
-  if (!container) return false;
-  return container->table_metadata_locations_.erase(table_ident.name) > 0;
+bool InMemoryNamespace::UnregisterTable(TableIdentifier const& table_ident) {
+  const auto ns = GetNamespace(this, table_ident.ns);
+  if (!ns) return false;
+  return ns->table_metadata_locations_.erase(table_ident.name) > 0;
 }
 
-bool NamespaceContainer::TableExists(TableIdentifier const& table_ident) const {
-  const auto container = GetNamespaceContainer(this, table_ident.ns);
-  if (!container) return false;
-  return container->table_metadata_locations_.contains(table_ident.name);
+bool InMemoryNamespace::TableExists(TableIdentifier const& table_ident) const {
+  const auto ns = GetNamespace(this, table_ident.ns);
+  if (!ns) return false;
+  return ns->table_metadata_locations_.contains(table_ident.name);
 }
 
-std::optional<std::string> NamespaceContainer::GetTableMetadataLocation(
+std::optional<std::string> InMemoryNamespace::GetTableMetadataLocation(
     TableIdentifier const& table_ident) const {
-  const auto container = GetNamespaceContainer(this, table_ident.ns);
-  if (!container) return std::nullopt;
-  const auto it = container->table_metadata_locations_.find(table_ident.name);
-  if (it == container->table_metadata_locations_.end()) return std::nullopt;
+  const auto ns = GetNamespace(this, table_ident.ns);
+  if (!ns) return std::nullopt;
+  const auto it = ns->table_metadata_locations_.find(table_ident.name);
+  if (it == ns->table_metadata_locations_.end()) return std::nullopt;
   return it->second;
 }
 }  // namespace iceberg

src/iceberg/catalog/memory_catalog.h

@@ -27,11 +27,11 @@
 
 namespace iceberg {
 
-class NamespaceContainer;
+class InMemoryNamespace;
 
-class ICEBERG_EXPORT MemoryCatalog : public Catalog {
+class ICEBERG_EXPORT InMemoryCatalog : public Catalog {
  public:
-  MemoryCatalog(std::shared_ptr<FileIO> file_io, std::string warehouse_location);
+  InMemoryCatalog(std::shared_ptr<FileIO> file_io, std::string warehouse_location);
 
   void Initialize(
       const std::string& name,
@@ -75,18 +75,18 @@ class ICEBERG_EXPORT MemoryCatalog : public Catalog {
   std::unordered_map<std::string, std::string> properties_;
   std::shared_ptr<FileIO> file_io_;
   std::string warehouse_location_;
-  std::unique_ptr<NamespaceContainer> root_container_;
+  std::unique_ptr<InMemoryNamespace> root_namespace_;
   mutable std::recursive_mutex mutex_;
 };
 
 /**
- * \brief A hierarchical container that manages namespaces and table metadata in-memory.
+ * \brief A hierarchical namespace that manages namespaces and table metadata in-memory.
  *
- * Each NamespaceContainer represents a namespace level and can contain properties,
+ * Each InMemoryNamespace represents a namespace level and can contain properties,
  * tables, and child namespaces. This structure enables a tree-like representation
  * of nested namespaces.
  */
-class ICEBERG_EXPORT NamespaceContainer {
+class ICEBERG_EXPORT InMemoryNamespace {
  public:
   /**
    * \brief Checks whether the given namespace exists.
@@ -177,9 +177,9 @@ class ICEBERG_EXPORT NamespaceContainer {
   std::optional<std::string> GetTableMetadataLocation(
       TableIdentifier const& table_ident) const;
 
-  template <typename ContainerPtr>
-  static ContainerPtr GetNamespaceContainerImpl(ContainerPtr root,
-                                                const Namespace& namespace_ident) {
+  template <typename NamespacePtr>
+  static NamespacePtr GetNamespaceImpl(NamespacePtr root,
+                                       const Namespace& namespace_ident) {
     auto node = root;
     for (const auto& part_level : namespace_ident.levels) {
       auto it = node->children_.find(part_level);
@@ -192,8 +192,8 @@ class ICEBERG_EXPORT NamespaceContainer {
   }
 
  private:
-  /// Map of child namespace names to their corresponding container instances.
-  std::unordered_map<std::string, NamespaceContainer> children_;
+  /// Map of child namespace names to their corresponding namespace instances.
+  std::unordered_map<std::string, InMemoryNamespace> children_;
 
   /// Key-value property map for this namespace.
   std::unordered_map<std::string, std::string> properties_;