zhjwpku commented on code in PR #80: URL: https://github.com/apache/iceberg-cpp/pull/80#discussion_r2048825824
########## src/iceberg/catalog/memory_catalog.cc: ########## @@ -0,0 +1,248 @@ +/* + * 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/catalog/memory_catalog.h" + +#include <algorithm> +#include <iterator> // IWYU pragma: keep + +#include "iceberg/exception.h" +#include "iceberg/table.h" + +namespace iceberg { + +MemoryCatalog::MemoryCatalog(std::shared_ptr<FileIO> file_io, + std::optional<std::string> warehouse_location) + : file_io_(std::move(file_io)), + warehouse_location_(std::move(warehouse_location)), + root_container_(std::make_unique<NamespaceContainer>()) {} + +void MemoryCatalog::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_; } + +Result<std::vector<TableIdentifier>> MemoryCatalog::ListTables( + const Namespace& ns) const { + std::unique_lock lock(mutex_); + const auto& table_names = root_container_->ListTables(ns); + std::vector<TableIdentifier> table_idents; + table_idents.reserve(table_names.size()); + std::ranges::transform( + table_names, std::back_inserter(table_idents), + [&ns](auto const& table_name) { return TableIdentifier(ns, table_name); }); + return table_idents; +} + +Result<std::unique_ptr<Table>> MemoryCatalog::CreateTable( + const TableIdentifier& identifier, const Schema& schema, const PartitionSpec& spec, + const std::string& location, + const std::unordered_map<std::string, std::string>& properties) { + throw IcebergError("not implemented"); Review Comment: maybe return NotImplementedError after #75 merged. ########## src/iceberg/catalog/memory_catalog.h: ########## @@ -0,0 +1,228 @@ +/* + * 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 <mutex> +#include <optional> +#include <unordered_map> + +#include "iceberg/catalog.h" + +namespace iceberg { + +class NamespaceContainer; + +class ICEBERG_EXPORT MemoryCatalog : public Catalog { + public: + MemoryCatalog(std::shared_ptr<FileIO> file_io, + std::optional<std::string> warehouse_location); + + void Initialize( + const std::string& name, + const std::unordered_map<std::string, std::string>& properties) override; + + std::string_view name() const override; + + Result<std::vector<TableIdentifier>> ListTables(const Namespace& ns) const override; + + Result<std::unique_ptr<Table>> CreateTable( + const TableIdentifier& identifier, const Schema& schema, const PartitionSpec& spec, + const std::string& location, + const std::unordered_map<std::string, std::string>& properties) override; + + 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; + + Result<std::shared_ptr<Transaction>> StageCreateTable( + const TableIdentifier& identifier, const Schema& schema, const PartitionSpec& spec, + const std::string& location, + const std::unordered_map<std::string, std::string>& properties) override; + + bool TableExists(const TableIdentifier& identifier) const override; + + bool DropTable(const TableIdentifier& identifier, bool purge) override; + + Result<std::shared_ptr<Table>> LoadTable( + const TableIdentifier& identifier) const override; + + Result<std::shared_ptr<Table>> RegisterTable( + const TableIdentifier& identifier, + const std::string& metadata_file_location) override; + + std::unique_ptr<iceberg::TableBuilder> BuildTable(const TableIdentifier& identifier, + const Schema& schema) const override; + + private: + std::string catalog_name_; + std::unordered_map<std::string, std::string> properties_; + std::shared_ptr<FileIO> file_io_; + std::optional<std::string> warehouse_location_; + std::unique_ptr<NamespaceContainer> root_container_; + mutable std::recursive_mutex mutex_; +}; + +/** + * @brief A hierarchical container that manages namespaces and table metadata in-memory. + * + * Each NamespaceContainer 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 { + public: + /** + * @brief Checks whether the given namespace exists. + * @param namespace_ident The namespace to check. + * @return True if the namespace exists; false otherwise. + */ + bool NamespaceExists(const Namespace& namespace_ident) const; + + /** + * @brief Lists immediate child namespaces under the given parent namespace. + * @param parent_namespace_ident The optional parent namespace. If not provided, + * the children of the root are returned. + * @return A vector of child namespace names. + */ + std::vector<std::string> ListChildrenNamespaces( + const std::optional<Namespace>& parent_namespace_ident = std::nullopt) const; + + /** + * @brief Creates a new namespace with the specified properties. + * @param namespace_ident The namespace to create. + * @param properties A map of key-value pairs to associate with the namespace. + * @return True if the namespace was successfully created; false if it already exists. + */ + bool CreateNamespace(const Namespace& namespace_ident, + const std::unordered_map<std::string, std::string>& properties); + + /** + * @brief Deletes an existing namespace. + * @param namespace_ident The namespace to delete. + * @return True if the namespace was successfully deleted; false if it does not exist. + */ + bool DeleteNamespace(const Namespace& namespace_ident); + + /** + * @brief Retrieves the properties of the specified namespace. + * @param namespace_ident The namespace whose properties to retrieve. + * @return An optional containing the properties map if the namespace exists; + * std::nullopt otherwise. + */ + std::optional<std::unordered_map<std::string, std::string>> GetProperties( + const Namespace& namespace_ident) const; + + /** + * @brief Replaces all properties of the given namespace. + * @param namespace_ident The namespace whose properties will be replaced. + * @param properties The new properties map. + * @return True if the namespace exists and properties were replaced; false otherwise. + */ + bool ReplaceProperties(const Namespace& namespace_ident, + const std::unordered_map<std::string, std::string>& properties); + + /** + * @brief Lists all table names under the specified namespace. + * @param namespace_ident The namespace from which to list tables. + * @return A vector of table names. + */ + std::vector<std::string> ListTables(const Namespace& namespace_ident) const; + + /** + * @brief Registers a table in the given namespace with a metadata location. + * @param table_ident The fully qualified identifier of the table. + * @param metadata_location The path to the table's metadata. + * @return True if the table was registered successfully; false otherwise. + */ + bool RegisterTable(TableIdentifier const& table_ident, + const std::string& metadata_location); + + /** + * @brief Unregisters a table from the specified namespace. + * @param table_ident The identifier of the table to unregister. + * @return True if the table existed and was removed; false otherwise. + */ + bool UnregisterTable(TableIdentifier const& table_ident); + + /** + * @brief Checks if a table exists in the specified namespace. + * @param table_ident The identifier of the table to check. + * @return True if the table exists; false otherwise. + */ + bool TableExists(TableIdentifier const& table_ident) const; + + /** + * @brief Gets the metadata location for the specified table. + * @param table_ident The identifier of the table. + * @return An optional string containing the metadata location if the table exists; + * std::nullopt otherwise. + */ + std::optional<std::string> GetTableMetadataLocation( + TableIdentifier const& table_ident) const; + + private: + /** + * @brief Helper function to retrieve the container node for a given namespace. + * @param root The root of the tree to search. + * @param namespace_ident The namespace path to traverse. + * @return A pointer to the corresponding NamespaceContainer if it exists; nullptr + * otherwise. + */ + static NamespaceContainer* GetNamespaceContainer(NamespaceContainer* root, + const Namespace& namespace_ident); + + /** + * @brief Const version of GetNamespaceContainer. + */ + static const NamespaceContainer* GetNamespaceContainer( + const NamespaceContainer* root, const Namespace& namespace_ident); + + /** + * @brief Templated implementation for retrieving a NamespaceContainer node. + * @tparam ContainerPtr Pointer type to NamespaceContainer (const or non-const). + * @param root The root node. + * @param namespace_ident The namespace path. + * @return A pointer to the container node if found; nullptr otherwise. + */ + template <typename ContainerPtr> Review Comment: Why not just NamespaceContainer here? ########## src/iceberg/catalog/memory_catalog.h: ########## @@ -0,0 +1,228 @@ +/* + * 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 <mutex> +#include <optional> +#include <unordered_map> + +#include "iceberg/catalog.h" + +namespace iceberg { + +class NamespaceContainer; + +class ICEBERG_EXPORT MemoryCatalog : public Catalog { + public: + MemoryCatalog(std::shared_ptr<FileIO> file_io, + std::optional<std::string> warehouse_location); + + void Initialize( + const std::string& name, + const std::unordered_map<std::string, std::string>& properties) override; + + std::string_view name() const override; + + Result<std::vector<TableIdentifier>> ListTables(const Namespace& ns) const override; + + Result<std::unique_ptr<Table>> CreateTable( + const TableIdentifier& identifier, const Schema& schema, const PartitionSpec& spec, + const std::string& location, + const std::unordered_map<std::string, std::string>& properties) override; + + 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; + + Result<std::shared_ptr<Transaction>> StageCreateTable( + const TableIdentifier& identifier, const Schema& schema, const PartitionSpec& spec, + const std::string& location, + const std::unordered_map<std::string, std::string>& properties) override; + + bool TableExists(const TableIdentifier& identifier) const override; + + bool DropTable(const TableIdentifier& identifier, bool purge) override; + + Result<std::shared_ptr<Table>> LoadTable( + const TableIdentifier& identifier) const override; + + Result<std::shared_ptr<Table>> RegisterTable( + const TableIdentifier& identifier, + const std::string& metadata_file_location) override; + + std::unique_ptr<iceberg::TableBuilder> BuildTable(const TableIdentifier& identifier, + const Schema& schema) const override; + + private: + std::string catalog_name_; + std::unordered_map<std::string, std::string> properties_; + std::shared_ptr<FileIO> file_io_; + std::optional<std::string> warehouse_location_; + std::unique_ptr<NamespaceContainer> root_container_; + mutable std::recursive_mutex mutex_; +}; + +/** + * @brief A hierarchical container that manages namespaces and table metadata in-memory. Review Comment: We seem to use `\` other than `@`. -- This is an automated message from the Apache Git Service. To respond to the message, please log on to GitHub and use the URL above to go to the specific comment. To unsubscribe, e-mail: issues-unsubscr...@iceberg.apache.org For queries about this service, please contact Infrastructure at: us...@infra.apache.org --------------------------------------------------------------------- To unsubscribe, e-mail: issues-unsubscr...@iceberg.apache.org For additional commands, e-mail: issues-h...@iceberg.apache.org
