catalog.h

Go to the documentation of this file.

#pragma once
 
#include "function_catalog_entry.h"
#include "catalog_set.h"
#include "cast.h"
#include "function.h"
 
namespace kuzu::main {
struct DBConfig;
} // namespace kuzu::main
 
namespace kuzu {
namespace main {
class AttachedKuzuDatabase;
} // namespace main
 
namespace binder {
struct BoundAlterInfo;
struct BoundCreateTableInfo;
struct BoundCreateSequenceInfo;
} // namespace binder
 
namespace common {
class VirtualFileSystem;
} // namespace common
 
namespace function {
struct ScalarMacroFunction;
} // namespace function
 
namespace storage {
class WAL;
} // namespace storage
 
namespace transaction {
class Transaction;
} // namespace transaction
 
namespace catalog {
class TableCatalogEntry;
class NodeTableCatalogEntry;
class RelTableCatalogEntry;
class RelGroupCatalogEntry;
class RDFGraphCatalogEntry;
class FunctionCatalogEntry;
class SequenceCatalogEntry;
 
class KUZU_API Catalog {
    friend class main::AttachedKuzuDatabase;
 
public:
    // This is extended by DuckCatalog and PostgresCatalog.
    Catalog();
    Catalog(const std::string& directory, common::VirtualFileSystem* vfs);
    virtual ~Catalog() = default;
 
    // ----------------------------- Table Schemas ----------------------------
    bool containsTable(transaction::Transaction* transaction, const std::string& tableName) const;
 
    common::table_id_t getTableID(transaction::Transaction* transaction,
        const std::string& tableName) const;
    std::vector<common::table_id_t> getNodeTableIDs(transaction::Transaction* transaction) const;
    std::vector<common::table_id_t> getRelTableIDs(transaction::Transaction* transaction) const;
 
    // TODO: Should remove this.
    std::string getTableName(transaction::Transaction* transaction,
        common::table_id_t tableID) const;
    TableCatalogEntry* getTableCatalogEntry(transaction::Transaction* transaction,
        const std::string& tableName) const;
    TableCatalogEntry* getTableCatalogEntry(transaction::Transaction* transaction,
        common::table_id_t tableID) const;
    std::vector<NodeTableCatalogEntry*> getNodeTableEntries(
        transaction::Transaction* transaction) const;
    std::vector<RelTableCatalogEntry*> getRelTableEntries(
        transaction::Transaction* transaction) const;
    std::vector<RelGroupCatalogEntry*> getRelTableGroupEntries(
        transaction::Transaction* transaction) const;
    std::vector<RDFGraphCatalogEntry*> getRdfGraphEntries(
        transaction::Transaction* transaction) const;
    std::vector<TableCatalogEntry*> getTableEntries(transaction::Transaction* transaction) const;
    std::vector<TableCatalogEntry*> getTableEntries(transaction::Transaction* transaction,
        const common::table_id_vector_t& tableIDs) const;
    bool tableInRDFGraph(transaction::Transaction* transaction, common::table_id_t tableID) const;
    bool tableInRelGroup(transaction::Transaction* transaction, common::table_id_t tableID) const;
    common::table_id_set_t getFwdRelTableIDs(transaction::Transaction* transaction,
        common::table_id_t nodeTableID) const;
    common::table_id_set_t getBwdRelTableIDs(transaction::Transaction* transaction,
        common::table_id_t nodeTableID) const;
 
    common::table_id_t createTableSchema(transaction::Transaction* transaction,
        const binder::BoundCreateTableInfo& info);
    void dropTableEntry(transaction::Transaction* transaction, std::string name);
    void dropTableEntry(transaction::Transaction* transaction, common::table_id_t tableID);
    void alterTableEntry(transaction::Transaction* transaction, const binder::BoundAlterInfo& info);
 
    // ----------------------------- Sequences ----------------------------
    bool containsSequence(transaction::Transaction* transaction,
        const std::string& sequenceName) const;
 
    common::sequence_id_t getSequenceID(transaction::Transaction* transaction,
        const std::string& sequenceName) const;
    SequenceCatalogEntry* getSequenceCatalogEntry(transaction::Transaction* transaction,
        common::sequence_id_t sequenceID) const;
    std::vector<SequenceCatalogEntry*> getSequenceEntries(
        transaction::Transaction* transaction) const;
 
    common::sequence_id_t createSequence(transaction::Transaction* transaction,
        const binder::BoundCreateSequenceInfo& info);
    void dropSequence(transaction::Transaction* transaction, std::string name);
    void dropSequence(transaction::Transaction* transaction, common::sequence_id_t sequenceID);
 
    static std::string genSerialName(const std::string& tableName, const std::string& propertyName);
 
    // ----------------------------- Types ----------------------------
    void createType(transaction::Transaction* transaction, std::string name,
        common::LogicalType type);
    common::LogicalType getType(transaction::Transaction*, std::string name);
    bool containsType(transaction::Transaction* transaction, const std::string& typeName);
 
    // ----------------------------- Functions ----------------------------
    void addFunction(transaction::Transaction* transaction, CatalogEntryType entryType,
        std::string name, function::function_set functionSet);
    void dropFunction(transaction::Transaction* transaction, const std::string& name);
    void addBuiltInFunction(CatalogEntryType entryType, std::string name,
        function::function_set functionSet);
    CatalogSet* getFunctions(transaction::Transaction* transaction) const;
    CatalogEntry* getFunctionEntry(transaction::Transaction* transaction, const std::string& name);
    std::vector<FunctionCatalogEntry*> getFunctionEntries(
        transaction::Transaction* transaction) const;
 
    bool containsMacro(transaction::Transaction* transaction, const std::string& macroName) const;
    void addScalarMacroFunction(transaction::Transaction* transaction, std::string name,
        std::unique_ptr<function::ScalarMacroFunction> macro);
    function::ScalarMacroFunction* getScalarMacroFunction(transaction::Transaction* transaction,
        const std::string& name) const;
    std::vector<std::string> getMacroNames(transaction::Transaction* transaction) const;
 
    void checkpoint(const std::string& databasePath, common::VirtualFileSystem* fs) const;
 
    template<class TARGET>
    TARGET* ptrCast() {
        return common::ku_dynamic_cast<Catalog*, TARGET*>(this);
    }
 
private:
    // The clientContext needs to be used when reading from a remote filesystem which
    // requires some user-specific configs (e.g. s3 username, password).
    void readFromFile(const std::string& directory, common::VirtualFileSystem* fs,
        common::FileVersionType versionType, main::ClientContext* context = nullptr);
    void saveToFile(const std::string& directory, common::VirtualFileSystem* fs,
        common::FileVersionType versionType) const;
 
private:
    // ----------------------------- Functions ----------------------------
    void registerBuiltInFunctions();
 
    // ----------------------------- Table entries ----------------------------
 
    void iterateCatalogEntries(transaction::Transaction* transaction,
        std::function<void(CatalogEntry*)> func) const {
        for (auto& [_, entry] : tables->getEntries(transaction)) {
            func(entry);
        }
    }
    template<typename T>
    std::vector<T*> getTableCatalogEntries(transaction::Transaction* transaction,
        CatalogEntryType catalogType) const {
        std::vector<T*> result;
        iterateCatalogEntries(transaction, [&](CatalogEntry* entry) {
            if (entry->getType() == catalogType) {
                result.push_back(common::ku_dynamic_cast<CatalogEntry*, T*>(entry));
            }
        });
        return result;
    }
 
    std::vector<common::table_id_t> getTableIDs(transaction::Transaction* transaction,
        CatalogEntryType catalogType) const;
 
    void alterRdfChildTableEntries(transaction::Transaction* transaction, CatalogEntry* entry,
        const binder::BoundAlterInfo& info) const;
    std::unique_ptr<CatalogEntry> createNodeTableEntry(transaction::Transaction* transaction,
        common::table_id_t tableID, const binder::BoundCreateTableInfo& info) const;
    std::unique_ptr<CatalogEntry> createRelTableEntry(transaction::Transaction* transaction,
        common::table_id_t tableID, const binder::BoundCreateTableInfo& info) const;
    std::unique_ptr<CatalogEntry> createRelTableGroupEntry(transaction::Transaction* transaction,
        common::table_id_t tableID, const binder::BoundCreateTableInfo& info);
    std::unique_ptr<CatalogEntry> createRdfGraphEntry(transaction::Transaction* transaction,
        common::table_id_t tableID, const binder::BoundCreateTableInfo& info);
 
    // ----------------------------- Sequence entries ----------------------------
    void iterateSequenceCatalogEntries(transaction::Transaction* transaction,
        std::function<void(CatalogEntry*)> func) const {
        for (auto& [_, entry] : sequences->getEntries(transaction)) {
            func(entry);
        }
    }
 
protected:
    std::unique_ptr<CatalogSet> tables;
 
private:
    std::unique_ptr<CatalogSet> sequences;
    std::unique_ptr<CatalogSet> functions;
    std::unique_ptr<CatalogSet> types;
};
 
} // namespace catalog
} // namespace kuzu