database.h

Go to the documentation of this file.

#pragma once
 
#include <memory>
#include <mutex>
#include <vector>
 
#if defined(__APPLE__)
#include <pthread/qos.h>
#endif
 
#include "api.h"
#include "database_lifecycle_manager.h"
#include "lbug_fwd.h"
#include "db_config.h"
 
namespace lbug {
namespace common {
class FileSystem;
} // namespace common
 
namespace extension {
class ExtensionManager;
class TransformerExtension;
class BinderExtension;
class PlannerExtension;
class MapperExtension;
} // namespace extension
 
namespace storage {
class StorageExtension;
} // namespace storage
 
namespace main {
class DatabaseManager;
struct LBUG_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 */,
        bool forceCheckpointOnClose = true, bool throwOnWalReplayFailure = true,
        bool enableChecksums = true
#if defined(__APPLE__)
        ,
        uint32_t threadQos = QOS_CLASS_DEFAULT
#endif
    );
 
    uint64_t bufferPoolSize;
    uint64_t maxNumThreads;
    bool enableCompression;
    bool readOnly;
    uint64_t maxDBSize;
    bool autoCheckpoint;
    uint64_t checkpointThreshold;
    bool forceCheckpointOnClose;
    bool throwOnWalReplayFailure;
    bool enableChecksums;
#if defined(__APPLE__)
    uint32_t threadQos;
#endif
};

class Database {
    friend class EmbeddedShell;
    friend class ClientContext;
    friend class Connection;
    friend class testing::BaseGraphTest;
 
public:
    LBUG_API explicit Database(std::string_view databasePath,
        SystemConfig systemConfig = SystemConfig());
    LBUG_API ~Database();
 
    LBUG_API void registerFileSystem(std::unique_ptr<common::FileSystem> fs);
 
    LBUG_API void registerStorageExtension(std::string name,
        std::unique_ptr<storage::StorageExtension> storageExtension);
 
    LBUG_API void addExtensionOption(std::string name, common::LogicalTypeID type,
        common::Value defaultValue, bool isConfidential = false);
 
    LBUG_API void addTransformerExtension(
        std::unique_ptr<extension::TransformerExtension> transformerExtension);
 
    std::vector<extension::TransformerExtension*> getTransformerExtensions();
 
    LBUG_API void addBinderExtension(
        std::unique_ptr<extension::BinderExtension> transformerExtension);
 
    std::vector<extension::BinderExtension*> getBinderExtensions();
 
    LBUG_API void addPlannerExtension(
        std::unique_ptr<extension::PlannerExtension> plannerExtension);
 
    std::vector<extension::PlannerExtension*> getPlannerExtensions();
 
    LBUG_API void addMapperExtension(std::unique_ptr<extension::MapperExtension> mapperExtension);
 
    std::vector<extension::MapperExtension*> getMapperExtensions();
 
    catalog::Catalog* getCatalog() { return catalog.get(); }
 
    const DBConfig& getConfig() const { return dbConfig; }
 
    std::vector<storage::StorageExtension*> getStorageExtensions();
 
    uint64_t getNextQueryID();
 
    storage::StorageManager* getStorageManager() { return storageManager.get(); }
 
    transaction::TransactionManager* getTransactionManager() { return transactionManager.get(); }
 
    DatabaseManager* getDatabaseManager() { return databaseManager.get(); }
 
    storage::MemoryManager* getMemoryManager() { return memoryManager.get(); }
 
    processor::QueryProcessor* getQueryProcessor() { return queryProcessor.get(); }
 
    extension::ExtensionManager* getExtensionManager() { return extensionManager.get(); }
 
    common::VirtualFileSystem* getVFS() { return vfs.get(); }
 
private:
    using construct_bm_func_t =
        std::function<std::unique_ptr<storage::BufferManager>(const Database&)>;
 
    struct QueryIDGenerator {
        uint64_t queryID = 0;
        std::mutex queryIDLock;
    };
 
    static std::unique_ptr<storage::BufferManager> initBufferManager(const Database& db);
    void initMembers(std::string_view dbPath, construct_bm_func_t initBmFunc);
 
    // factory method only to be used for tests
    Database(std::string_view databasePath, SystemConfig systemConfig,
        construct_bm_func_t constructBMFunc);
 
    void validatePathInReadOnly() const;
 
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<DatabaseManager> databaseManager;
    std::unique_ptr<extension::ExtensionManager> extensionManager;
    QueryIDGenerator queryIDGenerator;
    std::shared_ptr<common::DatabaseLifeCycleManager> dbLifeCycleManager;
    std::vector<std::unique_ptr<extension::TransformerExtension>> transformerExtensions;
    std::vector<std::unique_ptr<extension::BinderExtension>> binderExtensions;
    std::vector<std::unique_ptr<extension::PlannerExtension>> plannerExtensions;
    std::vector<std::unique_ptr<extension::MapperExtension>> mapperExtensions;
};
 
} // namespace main
} // namespace lbug