database.h

Go to the documentation of this file.

#pragma once
 
#include <memory>
#include <mutex>
#include <vector>
 
#include "api.h"
#include "case_insensitive_map.h"
#include "kuzu_fwd.h"
#include "db_config.h"
 
namespace kuzu {
namespace common {
class FileSystem;
enum class LogicalTypeID : uint8_t;
} // namespace common
 
namespace catalog {
class CatalogEntry;
} // namespace catalog
 
namespace function {
struct Function;
} // namespace function
 
namespace extension {
struct ExtensionUtils;
struct ExtensionOptions;
} // namespace extension
 
namespace storage {
class StorageExtension;
} // namespace storage
 
namespace main {
struct ExtensionOption;
class DatabaseManager;
class ClientContext;
 
struct KUZU_API SystemConfig {
    explicit SystemConfig(uint64_t bufferPoolSize = -1u, uint64_t maxNumThreads = 0,
        bool enableCompression = true, bool readOnly = false, uint64_t maxDBSize = -1u,
        bool autoCheckpoint = true, uint64_t checkpointThreshold = 16777216 /* 16MB */);
 
    uint64_t bufferPoolSize;
    uint64_t maxNumThreads;
    bool enableCompression;
    bool readOnly;
    uint64_t maxDBSize;
    bool autoCheckpoint;
    uint64_t checkpointThreshold;
};
 
class Database {
    friend class EmbeddedShell;
    friend class ClientContext;
    friend class Connection;
    friend class StorageDriver;
    friend class testing::BaseGraphTest;
    friend class testing::PrivateGraphTest;
    friend class transaction::TransactionContext;
    friend struct extension::ExtensionUtils;
 
public:
    KUZU_API explicit Database(std::string_view databasePath,
        SystemConfig systemConfig = SystemConfig());
    KUZU_API ~Database();
 
    // TODO(Ziyi): Instead of exposing a dedicated API for adding a new function, we should consider
    // add function through the extension module.
    void addTableFunction(std::string name,
        std::vector<std::unique_ptr<function::Function>> functionSet);
 
    KUZU_API void registerFileSystem(std::unique_ptr<common::FileSystem> fs);
 
    KUZU_API void registerStorageExtension(std::string name,
        std::unique_ptr<storage::StorageExtension> storageExtension);
 
    KUZU_API void addExtensionOption(std::string name, common::LogicalTypeID type,
        common::Value defaultValue);
 
    KUZU_API catalog::Catalog* getCatalog() { return catalog.get(); }
 
    ExtensionOption* getExtensionOption(std::string name) const;
 
    const DBConfig& getConfig() const { return dbConfig; }
 
    common::case_insensitive_map_t<std::unique_ptr<storage::StorageExtension>>&
    getStorageExtensions();
 
    uint64_t getNextQueryID();
 
private:
    struct QueryIDGenerator {
        uint64_t queryID = 0;
        std::mutex queryIDLock;
    };
 
    void openLockFile();
    void initAndLockDBDir();
 
private:
    std::string databasePath;
    DBConfig dbConfig;
    std::unique_ptr<common::VirtualFileSystem> vfs;
    std::unique_ptr<storage::BufferManager> bufferManager;
    std::unique_ptr<storage::MemoryManager> memoryManager;
    std::unique_ptr<processor::QueryProcessor> queryProcessor;
    std::unique_ptr<catalog::Catalog> catalog;
    std::unique_ptr<storage::StorageManager> storageManager;
    std::unique_ptr<transaction::TransactionManager> transactionManager;
    std::unique_ptr<common::FileInfo> lockFile;
    std::unique_ptr<extension::ExtensionOptions> extensionOptions;
    std::unique_ptr<DatabaseManager> databaseManager;
    common::case_insensitive_map_t<std::unique_ptr<storage::StorageExtension>> storageExtensions;
    QueryIDGenerator queryIDGenerator;
};
 
} // namespace main
} // namespace kuzu