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