diff --git a/extension/duckdb_scanner/src/include/duckdb_catalog.h b/extension/duckdb_scanner/src/include/duckdb_catalog.h index 2ecb068003..e9e57b637c 100644 --- a/extension/duckdb_scanner/src/include/duckdb_catalog.h +++ b/extension/duckdb_scanner/src/include/duckdb_catalog.h @@ -27,7 +27,7 @@ struct BoundExtraCreateDuckDBTableInfo : public binder::BoundExtraCreateTableInf class DuckDBCatalogContent : public catalog::CatalogContent { public: - DuckDBCatalogContent() : catalog::CatalogContent{nullptr /* vfs */} {} + DuckDBCatalogContent() : catalog::CatalogContent{} {} virtual void init(const std::string& dbPath, const std::string& catalogName, main::ClientContext* context); diff --git a/src/catalog/catalog.cpp b/src/catalog/catalog.cpp index 4b39975d4f..52e73a9d95 100644 --- a/src/catalog/catalog.cpp +++ b/src/catalog/catalog.cpp @@ -20,8 +20,8 @@ using namespace kuzu::transaction; namespace kuzu { namespace catalog { -Catalog::Catalog(VirtualFileSystem* vfs) : isUpdated{false}, wal{nullptr} { - readOnlyVersion = std::make_unique(vfs); +Catalog::Catalog() : isUpdated{false}, wal{nullptr} { + readOnlyVersion = std::make_unique(); } Catalog::Catalog(WAL* wal, VirtualFileSystem* vfs) : isUpdated{false}, wal{wal} { @@ -103,11 +103,11 @@ std::vector Catalog::getTableSchemas(Transaction* tx, return result; } -void Catalog::prepareCommitOrRollback(TransactionAction action) { +void Catalog::prepareCommitOrRollback(TransactionAction action, VirtualFileSystem* fs) { if (hasUpdates()) { wal->logCatalogRecord(); if (action == TransactionAction::COMMIT) { - readWriteVersion->saveToFile(wal->getDirectory(), FileVersionType::WAL_VERSION); + readWriteVersion->saveToFile(wal->getDirectory(), FileVersionType::WAL_VERSION, fs); } } } diff --git a/src/catalog/catalog_content.cpp b/src/catalog/catalog_content.cpp index 9b11b84ce3..ecd2a302ec 100644 --- a/src/catalog/catalog_content.cpp +++ b/src/catalog/catalog_content.cpp @@ -29,14 +29,14 @@ using namespace kuzu::storage; namespace kuzu { namespace catalog { -CatalogContent::CatalogContent(VirtualFileSystem* vfs) : nextTableID{0}, vfs{vfs} { +CatalogContent::CatalogContent() : nextTableID{0} { tables = std::make_unique(); functions = std::make_unique(); registerBuiltInFunctions(); } -CatalogContent::CatalogContent(const std::string& directory, VirtualFileSystem* vfs) : vfs{vfs} { - readFromFile(directory, FileVersionType::ORIGINAL); +CatalogContent::CatalogContent(const std::string& directory, VirtualFileSystem* fs) { + readFromFile(directory, FileVersionType::ORIGINAL, fs); registerBuiltInFunctions(); } @@ -239,10 +239,11 @@ static void writeMagicBytes(Serializer& serializer) { } } -void CatalogContent::saveToFile(const std::string& directory, FileVersionType dbFileType) { - auto catalogPath = StorageUtils::getCatalogFilePath(vfs, directory, dbFileType); +void CatalogContent::saveToFile(const std::string& directory, FileVersionType dbFileType, + VirtualFileSystem* fs) { + auto catalogPath = StorageUtils::getCatalogFilePath(fs, directory, dbFileType); Serializer serializer( - std::make_unique(vfs->openFile(catalogPath, O_WRONLY | O_CREAT))); + std::make_unique(fs->openFile(catalogPath, O_WRONLY | O_CREAT))); writeMagicBytes(serializer); serializer.serializeValue(StorageVersionInfo::getStorageVersion()); tables->serialize(serializer); @@ -250,10 +251,11 @@ void CatalogContent::saveToFile(const std::string& directory, FileVersionType db functions->serialize(serializer); } -void CatalogContent::readFromFile(const std::string& directory, FileVersionType dbFileType) { - auto catalogPath = StorageUtils::getCatalogFilePath(vfs, directory, dbFileType); +void CatalogContent::readFromFile(const std::string& directory, FileVersionType dbFileType, + VirtualFileSystem* fs) { + auto catalogPath = StorageUtils::getCatalogFilePath(fs, directory, dbFileType); Deserializer deserializer( - std::make_unique(vfs->openFile(catalogPath, O_RDONLY))); + std::make_unique(fs->openFile(catalogPath, O_RDONLY))); validateMagicBytes(deserializer); storage_version_t savedStorageVersion; deserializer.deserializeValue(savedStorageVersion); @@ -278,8 +280,7 @@ function::ScalarMacroFunction* CatalogContent::getScalarMacroFunction( } std::unique_ptr CatalogContent::copy() const { - std::unordered_map> macrosToCopy; - return std::make_unique(tables->copy(), nextTableID, functions->copy(), vfs); + return std::make_unique(tables->copy(), nextTableID, functions->copy()); } void CatalogContent::registerBuiltInFunctions() { diff --git a/src/include/catalog/catalog.h b/src/include/catalog/catalog.h index fb6c15ad42..eea9a8cad1 100644 --- a/src/include/catalog/catalog.h +++ b/src/include/catalog/catalog.h @@ -21,7 +21,7 @@ class RDFGraphCatalogEntry; class Catalog { public: - explicit Catalog(common::VirtualFileSystem* vfs); + Catalog(); Catalog(storage::WAL* wal, common::VirtualFileSystem* vfs); @@ -73,7 +73,8 @@ class Catalog { std::vector getMacroNames(transaction::Transaction* tx) const; // ----------------------------- Tx ---------------------------- - void prepareCommitOrRollback(transaction::TransactionAction action); + void prepareCommitOrRollback(transaction::TransactionAction action, + common::VirtualFileSystem* fs); void checkpointInMemory(); void initCatalogContentForWriteTrxIfNecessary() { @@ -83,9 +84,9 @@ class Catalog { } static void saveInitialCatalogToFile(const std::string& directory, - common::VirtualFileSystem* vfs) { - std::make_unique(vfs)->getReadOnlyVersion()->saveToFile(directory, - common::FileVersionType::ORIGINAL); + common::VirtualFileSystem* fs) { + auto catalog = Catalog(); + catalog.getReadOnlyVersion()->saveToFile(directory, common::FileVersionType::ORIGINAL, fs); } private: diff --git a/src/include/catalog/catalog_content.h b/src/include/catalog/catalog_content.h index 965c4cc63b..34504150eb 100644 --- a/src/include/catalog/catalog_content.h +++ b/src/include/catalog/catalog_content.h @@ -23,22 +23,23 @@ class CatalogContent { friend class Catalog; public: - KUZU_API explicit CatalogContent(common::VirtualFileSystem* vfs); + KUZU_API CatalogContent(); virtual ~CatalogContent() = default; CatalogContent(const std::string& directory, common::VirtualFileSystem* vfs); CatalogContent(std::unique_ptr tables, common::table_id_t nextTableID, - std::unique_ptr functions, common::VirtualFileSystem* vfs) - : tables{std::move(tables)}, nextTableID{nextTableID}, vfs{vfs}, - functions{std::move(functions)} {} + std::unique_ptr functions) + : tables{std::move(tables)}, nextTableID{nextTableID}, functions{std::move(functions)} {} common::table_id_t getTableID(const std::string& tableName) const; CatalogEntry* getTableCatalogEntry(common::table_id_t tableID) const; - void saveToFile(const std::string& directory, common::FileVersionType dbFileType); - void readFromFile(const std::string& directory, common::FileVersionType dbFileType); + void saveToFile(const std::string& directory, common::FileVersionType dbFileType, + common::VirtualFileSystem* fs); + void readFromFile(const std::string& directory, common::FileVersionType dbFileType, + common::VirtualFileSystem* fs); std::unique_ptr copy() const; @@ -97,7 +98,6 @@ class CatalogContent { private: common::table_id_t nextTableID; - common::VirtualFileSystem* vfs; std::unique_ptr functions; }; diff --git a/src/include/storage/stats/node_table_statistics.h b/src/include/storage/stats/node_table_statistics.h index a50fa3d3fa..8a6726b1c8 100644 --- a/src/include/storage/stats/node_table_statistics.h +++ b/src/include/storage/stats/node_table_statistics.h @@ -28,9 +28,7 @@ class NodeTableStatsAndDeletedIDs : public TableStatistics { propertyStatistics); NodeTableStatsAndDeletedIDs(const NodeTableStatsAndDeletedIDs& other); - inline common::offset_t getMaxNodeOffset() { - return getMaxNodeOffsetFromNumTuples(getNumTuples()); - } + common::offset_t getMaxNodeOffset() { return getMaxNodeOffsetFromNumTuples(getNumTuples()); } common::offset_t addNode(); @@ -43,21 +41,21 @@ class NodeTableStatsAndDeletedIDs : public TableStatistics { std::vector getDeletedNodeOffsets() const; - static inline uint64_t getNumTuplesFromMaxNodeOffset(common::offset_t maxNodeOffset) { + static uint64_t getNumTuplesFromMaxNodeOffset(common::offset_t maxNodeOffset) { return (maxNodeOffset == UINT64_MAX) ? 0ull : maxNodeOffset + 1ull; } - static inline uint64_t getMaxNodeOffsetFromNumTuples(uint64_t numTuples) { + static uint64_t getMaxNodeOffsetFromNumTuples(uint64_t numTuples) { return numTuples == 0 ? UINT64_MAX : numTuples - 1; } - inline void addMetadataDAHInfoForColumn(std::unique_ptr metadataDAHInfo) { + void addMetadataDAHInfoForColumn(std::unique_ptr metadataDAHInfo) { metadataDAHInfos.push_back(std::move(metadataDAHInfo)); } - inline void removeMetadataDAHInfoForColumn(common::column_id_t columnID) { + void removeMetadataDAHInfoForColumn(common::column_id_t columnID) { KU_ASSERT(columnID < metadataDAHInfos.size()); metadataDAHInfos.erase(metadataDAHInfos.begin() + columnID); } - inline MetadataDAHInfo* getMetadataDAHInfo(common::column_id_t columnID) { + MetadataDAHInfo* getMetadataDAHInfo(common::column_id_t columnID) { KU_ASSERT(columnID < metadataDAHInfos.size()); return metadataDAHInfos[columnID].get(); } diff --git a/src/include/storage/stats/nodes_store_statistics.h b/src/include/storage/stats/nodes_store_statistics.h index 5e0cf9cd1f..057c13c753 100644 --- a/src/include/storage/stats/nodes_store_statistics.h +++ b/src/include/storage/stats/nodes_store_statistics.h @@ -14,26 +14,27 @@ class NodesStoreStatsAndDeletedIDs : public TablesStatistics { public: // Should only be used by saveInitialNodesStatisticsAndDeletedIDsToFile to start a database // from an empty directory. - explicit NodesStoreStatsAndDeletedIDs(common::VirtualFileSystem* vfs) - : TablesStatistics{nullptr /* metadataFH */, nullptr /* bufferManager */, nullptr /* wal */, - vfs} {}; + NodesStoreStatsAndDeletedIDs() + : TablesStatistics{nullptr /* metadataFH */, nullptr /* bufferManager */, + nullptr /* wal */} {}; // Should be used when an already loaded database is started from a directory. NodesStoreStatsAndDeletedIDs(BMFileHandle* metadataFH, BufferManager* bufferManager, WAL* wal, - common::VirtualFileSystem* vfs, + common::VirtualFileSystem* fs, common::FileVersionType dbFileType = common::FileVersionType::ORIGINAL) - : TablesStatistics{metadataFH, bufferManager, wal, vfs} { - readFromFile(dbFileType); + : TablesStatistics{metadataFH, bufferManager, wal} { + readFromFile(dbFileType, fs); } - inline NodeTableStatsAndDeletedIDs* getNodeStatisticsAndDeletedIDs( + NodeTableStatsAndDeletedIDs* getNodeStatisticsAndDeletedIDs( transaction::Transaction* transaction, common::table_id_t tableID) const { return getNodeTableStats(transaction->getType(), tableID); } - static inline void saveInitialNodesStatisticsAndDeletedIDsToFile(common::VirtualFileSystem* vfs, + static void saveInitialNodesStatisticsAndDeletedIDsToFile(common::VirtualFileSystem* fs, const std::string& directory) { - std::make_unique(vfs)->saveToFile(directory, - common::FileVersionType::ORIGINAL, transaction::TransactionType::READ_ONLY); + auto stats = NodesStoreStatsAndDeletedIDs(); + stats.saveToFile(directory, common::FileVersionType::ORIGINAL, + transaction::TransactionType::READ_ONLY, fs); } void updateNumTuplesByValue(common::table_id_t tableID, int64_t value) override; @@ -41,14 +42,9 @@ class NodesStoreStatsAndDeletedIDs : public TablesStatistics { common::offset_t getMaxNodeOffset(transaction::Transaction* transaction, common::table_id_t tableID); - // This function is only used for testing purpose. - inline uint32_t getNumNodeStatisticsAndDeleteIDsPerTable() const { - return readOnlyVersion->tableStatisticPerTable.size(); - } - // This function assumes that there is a single write transaction. That is why for now we // keep the interface simple and no transaction is passed. - inline common::offset_t addNode(common::table_id_t tableID) { + common::offset_t addNode(common::table_id_t tableID) { lock_t lck{mtx}; initTableStatisticsForWriteTrxNoLock(); KU_ASSERT(readWriteVersion && readWriteVersion->tableStatisticPerTable.contains(tableID)); @@ -57,7 +53,7 @@ class NodesStoreStatsAndDeletedIDs : public TablesStatistics { } // Refer to the comments for addNode. - inline void deleteNode(common::table_id_t tableID, common::offset_t nodeOffset) { + void deleteNode(common::table_id_t tableID, common::offset_t nodeOffset) { lock_t lck{mtx}; initTableStatisticsForWriteTrxNoLock(); KU_ASSERT(readWriteVersion && readWriteVersion->tableStatisticPerTable.contains(tableID)); @@ -76,26 +72,20 @@ class NodesStoreStatsAndDeletedIDs : public TablesStatistics { common::table_id_t tableID, common::column_id_t columnID); protected: - inline std::unique_ptr constructTableStatistic( + std::unique_ptr constructTableStatistic( catalog::TableCatalogEntry* tableEntry) override { return std::make_unique(metadataFH, *tableEntry, bufferManager, wal); } - inline std::unique_ptr constructTableStatistic( - TableStatistics* tableStatistics) override { - return std::make_unique( - *(NodeTableStatsAndDeletedIDs*)tableStatistics); - } - - inline std::string getTableStatisticsFilePath(const std::string& directory, - common::FileVersionType dbFileType) override { - return StorageUtils::getNodesStatisticsAndDeletedIDsFilePath(vfs, directory, dbFileType); + std::string getTableStatisticsFilePath(const std::string& directory, + common::FileVersionType dbFileType, common::VirtualFileSystem* fs) override { + return StorageUtils::getNodesStatisticsAndDeletedIDsFilePath(fs, directory, dbFileType); } private: - inline NodeTableStatsAndDeletedIDs* getNodeTableStats( - transaction::TransactionType transactionType, common::table_id_t tableID) const { + NodeTableStatsAndDeletedIDs* getNodeTableStats(transaction::TransactionType transactionType, + common::table_id_t tableID) const { return transactionType == transaction::TransactionType::READ_ONLY ? dynamic_cast( readOnlyVersion->tableStatisticPerTable.at(tableID).get()) : diff --git a/src/include/storage/stats/rel_table_statistics.h b/src/include/storage/stats/rel_table_statistics.h index 561b37b35f..98d3830ef3 100644 --- a/src/include/storage/stats/rel_table_statistics.h +++ b/src/include/storage/stats/rel_table_statistics.h @@ -25,29 +25,29 @@ class RelTableStats : public TableStatistics { RelTableStats(const RelTableStats& other); - inline common::offset_t getNextRelOffset() const { return nextRelOffset; } - inline void incrementNextRelOffset(uint64_t numTuples) { nextRelOffset += numTuples; } + common::offset_t getNextRelOffset() const { return nextRelOffset; } + void incrementNextRelOffset(uint64_t numTuples) { nextRelOffset += numTuples; } - inline void addMetadataDAHInfoForColumn(std::unique_ptr metadataDAHInfo, + void addMetadataDAHInfoForColumn(std::unique_ptr metadataDAHInfo, common::RelDataDirection direction) { auto& metadataDAHInfos = getDirectedMetadataDAHInfosRef(direction); metadataDAHInfos.push_back(std::move(metadataDAHInfo)); } - inline void removeMetadataDAHInfoForColumn(common::column_id_t columnID, + void removeMetadataDAHInfoForColumn(common::column_id_t columnID, common::RelDataDirection direction) { auto& metadataDAHInfos = getDirectedMetadataDAHInfosRef(direction); KU_ASSERT(columnID < metadataDAHInfos.size()); metadataDAHInfos.erase(metadataDAHInfos.begin() + columnID); } - inline MetadataDAHInfo* getCSROffsetMetadataDAHInfo(common::RelDataDirection direction) { + MetadataDAHInfo* getCSROffsetMetadataDAHInfo(common::RelDataDirection direction) { return direction == common::RelDataDirection::FWD ? fwdCSROffsetMetadataDAHInfo.get() : bwdCSROffsetMetadataDAHInfo.get(); } - inline MetadataDAHInfo* getCSRLengthMetadataDAHInfo(common::RelDataDirection direction) { + MetadataDAHInfo* getCSRLengthMetadataDAHInfo(common::RelDataDirection direction) { return direction == common::RelDataDirection::FWD ? fwdCSRLengthMetadataDAHInfo.get() : bwdCSRLengthMetadataDAHInfo.get(); } - inline MetadataDAHInfo* getColumnMetadataDAHInfo(common::column_id_t columnID, + MetadataDAHInfo* getColumnMetadataDAHInfo(common::column_id_t columnID, common::RelDataDirection direction) { auto& metadataDAHInfos = getDirectedMetadataDAHInfosRef(direction); KU_ASSERT(columnID < metadataDAHInfos.size()); @@ -58,12 +58,10 @@ class RelTableStats : public TableStatistics { static std::unique_ptr deserialize(uint64_t numRels, common::table_id_t tableID, common::Deserializer& deserializer); - inline std::unique_ptr copy() final { - return std::make_unique(*this); - } + std::unique_ptr copy() final { return std::make_unique(*this); } private: - inline std::vector>& getDirectedMetadataDAHInfosRef( + std::vector>& getDirectedMetadataDAHInfosRef( common::RelDataDirection direction) { return direction == common::RelDataDirection::FWD ? fwdMetadataDAHInfos : bwdMetadataDAHInfos; diff --git a/src/include/storage/stats/rels_store_statistics.h b/src/include/storage/stats/rels_store_statistics.h index 2012b9c2a5..0894093a47 100644 --- a/src/include/storage/stats/rels_store_statistics.h +++ b/src/include/storage/stats/rels_store_statistics.h @@ -12,20 +12,21 @@ class RelsStoreStats : public TablesStatistics { public: // Should only be used by saveInitialRelsStatisticsToFile to start a database from an empty // directory. - explicit RelsStoreStats(common::VirtualFileSystem* vfs) - : TablesStatistics{nullptr /* metadataFH */, nullptr /* bufferManager */, nullptr /* wal */, - vfs} {}; + RelsStoreStats() + : TablesStatistics{nullptr /* metadataFH */, nullptr /* bufferManager */, + nullptr /* wal */} {}; // Should be used when an already loaded database is started from a directory. RelsStoreStats(BMFileHandle* metadataFH, BufferManager* bufferManager, WAL* wal, common::VirtualFileSystem* vfs); - static inline void saveInitialRelsStatisticsToFile(common::VirtualFileSystem* vfs, + static void saveInitialRelsStatisticsToFile(common::VirtualFileSystem* fs, const std::string& directory) { - std::make_unique(vfs)->saveToFile(directory, - common::FileVersionType::ORIGINAL, transaction::TransactionType::READ_ONLY); + auto stats = RelsStoreStats(); + stats.saveToFile(directory, common::FileVersionType::ORIGINAL, + transaction::TransactionType::READ_ONLY, fs); } - inline RelTableStats* getRelStatistics(common::table_id_t tableID, + RelTableStats* getRelStatistics(common::table_id_t tableID, transaction::Transaction* transaction) const { auto& tableStatisticPerTable = transaction->getType() == transaction::TransactionType::READ_ONLY ? @@ -51,22 +52,17 @@ class RelsStoreStats : public TablesStatistics { common::RelDataDirection direction); protected: - inline std::unique_ptr constructTableStatistic( + std::unique_ptr constructTableStatistic( catalog::TableCatalogEntry* tableEntry) override { return std::make_unique(metadataFH, *tableEntry, bufferManager, wal); } - inline std::unique_ptr constructTableStatistic( - TableStatistics* tableStatistics) override { - return std::make_unique(*(RelTableStats*)tableStatistics); + std::string getTableStatisticsFilePath(const std::string& directory, + common::FileVersionType dbFileType, common::VirtualFileSystem* fs) override { + return StorageUtils::getRelsStatisticsFilePath(fs, directory, dbFileType); } - inline std::string getTableStatisticsFilePath(const std::string& directory, - common::FileVersionType dbFileType) override { - return StorageUtils::getRelsStatisticsFilePath(vfs, directory, dbFileType); - } - - inline void increaseNextRelOffset(common::table_id_t relTableID, uint64_t numTuples) { + void increaseNextRelOffset(common::table_id_t relTableID, uint64_t numTuples) { ((RelTableStats*)readWriteVersion->tableStatisticPerTable.at(relTableID).get()) ->incrementNextRelOffset(numTuples); } diff --git a/src/include/storage/stats/table_statistics_collection.h b/src/include/storage/stats/table_statistics_collection.h index 49b8cf09d3..7bb3f92f45 100644 --- a/src/include/storage/stats/table_statistics_collection.h +++ b/src/include/storage/stats/table_statistics_collection.h @@ -21,47 +21,45 @@ struct TablesStatisticsContent { class WAL; class TablesStatistics { public: - TablesStatistics(BMFileHandle* metadataFH, BufferManager* bufferManager, WAL* wal, - common::VirtualFileSystem* vfs); + TablesStatistics(BMFileHandle* metadataFH, BufferManager* bufferManager, WAL* wal); virtual ~TablesStatistics() = default; // Return the num of tuples before update. virtual void updateNumTuplesByValue(common::table_id_t tableID, int64_t value) = 0; - inline void writeTablesStatisticsFileForWALRecord(const std::string& directory) { + void writeTablesStatisticsFileForWALRecord(const std::string& directory, + common::VirtualFileSystem* fs) { saveToFile(directory, common::FileVersionType::WAL_VERSION, - transaction::TransactionType::WRITE); + transaction::TransactionType::WRITE, fs); } - inline bool hasUpdates() const { return isUpdated; } + bool hasUpdates() const { return isUpdated; } - inline void checkpointInMemoryIfNecessary() { + void checkpointInMemoryIfNecessary() { std::unique_lock lck{mtx}; KU_ASSERT(readWriteVersion); readOnlyVersion = std::move(readWriteVersion); resetToNotUpdated(); } - inline void rollbackInMemoryIfNecessary() { + void rollbackInMemoryIfNecessary() { std::unique_lock lck{mtx}; readWriteVersion.reset(); resetToNotUpdated(); } - inline TablesStatisticsContent* getReadOnlyVersion() const { return readOnlyVersion.get(); } - - inline void addTableStatistic(catalog::TableCatalogEntry* tableEntry) { + void addTableStatistic(catalog::TableCatalogEntry* tableEntry) { setToUpdated(); initTableStatisticsForWriteTrx(); readWriteVersion->tableStatisticPerTable[tableEntry->getTableID()] = constructTableStatistic(tableEntry); } - inline void removeTableStatistic(common::table_id_t tableID) { + void removeTableStatistic(common::table_id_t tableID) { setToUpdated(); readOnlyVersion->tableStatisticPerTable.erase(tableID); } - inline uint64_t getNumTuplesForTable(transaction::Transaction* transaction, + uint64_t getNumTuplesForTable(transaction::Transaction* transaction, common::table_id_t tableID) { if (transaction->isWriteTransaction()) { initTableStatisticsForWriteTrx(); @@ -87,32 +85,28 @@ class TablesStatistics { virtual std::unique_ptr constructTableStatistic( catalog::TableCatalogEntry* tableEntry) = 0; - virtual std::unique_ptr constructTableStatistic( - TableStatistics* tableStatistics) = 0; - virtual std::string getTableStatisticsFilePath(const std::string& directory, - common::FileVersionType dbFileType) = 0; + common::FileVersionType dbFileType, common::VirtualFileSystem* fs) = 0; const TablesStatisticsContent* getVersion(transaction::TransactionType type) const { return type == transaction::TransactionType::READ_ONLY ? readOnlyVersion.get() : readWriteVersion.get(); } - void readFromFile(); - void readFromFile(common::FileVersionType dbFileType); + void readFromFile(common::VirtualFileSystem* fs); + void readFromFile(common::FileVersionType dbFileType, common::VirtualFileSystem* fs); void saveToFile(const std::string& directory, common::FileVersionType dbFileType, - transaction::TransactionType transactionType); + transaction::TransactionType transactionType, common::VirtualFileSystem* fs); void initTableStatisticsForWriteTrxNoLock(); - inline void setToUpdated() { isUpdated = true; } - inline void resetToNotUpdated() { isUpdated = false; } + void setToUpdated() { isUpdated = true; } + void resetToNotUpdated() { isUpdated = false; } protected: BMFileHandle* metadataFH; BufferManager* bufferManager; - common::VirtualFileSystem* vfs; WAL* wal; bool isUpdated; std::unique_ptr readOnlyVersion; diff --git a/src/include/storage/storage_manager.h b/src/include/storage/storage_manager.h index dc3888cdbf..d5a8e3a858 100644 --- a/src/include/storage/storage_manager.h +++ b/src/include/storage/storage_manager.h @@ -19,7 +19,7 @@ class StorageManager { transaction::Transaction* transaction); void dropTable(common::table_id_t tableID); - void prepareCommit(transaction::Transaction* transaction); + void prepareCommit(transaction::Transaction* transaction, common::VirtualFileSystem* fs); void prepareRollback(transaction::Transaction* transaction); void checkpointInMemory(); void rollbackInMemory(); diff --git a/src/main/database.cpp b/src/main/database.cpp index 77720645d2..7871707a52 100644 --- a/src/main/database.cpp +++ b/src/main/database.cpp @@ -207,8 +207,8 @@ void Database::commit(Transaction* transaction, bool skipCheckpointForTestingRec return; } KU_ASSERT(transaction->isWriteTransaction()); - catalog->prepareCommitOrRollback(TransactionAction::COMMIT); - storageManager->prepareCommit(transaction); + catalog->prepareCommitOrRollback(TransactionAction::COMMIT, vfs.get()); + storageManager->prepareCommit(transaction, vfs.get()); // Note: It is enough to stop and wait transactions to leave the system instead of // for example checking on the query processor's task scheduler. This is because the // first and last steps that a connection performs when executing a query is to @@ -237,7 +237,7 @@ void Database::rollback(transaction::Transaction* transaction, return; } KU_ASSERT(transaction->isWriteTransaction()); - catalog->prepareCommitOrRollback(TransactionAction::ROLLBACK); + catalog->prepareCommitOrRollback(TransactionAction::ROLLBACK, vfs.get()); storageManager->prepareRollback(transaction); if (skipCheckpointForTestingRecovery) { wal->flushAllPages(); diff --git a/src/storage/stats/rels_store_statistics.cpp b/src/storage/stats/rels_store_statistics.cpp index 03e4e4ffcf..b960595004 100644 --- a/src/storage/stats/rels_store_statistics.cpp +++ b/src/storage/stats/rels_store_statistics.cpp @@ -11,9 +11,9 @@ namespace kuzu { namespace storage { RelsStoreStats::RelsStoreStats(BMFileHandle* metadataFH, BufferManager* bufferManager, WAL* wal, - VirtualFileSystem* vfs) - : TablesStatistics{metadataFH, bufferManager, wal, vfs} { - readFromFile(); + VirtualFileSystem* fs) + : TablesStatistics{metadataFH, bufferManager, wal} { + readFromFile(fs); } void RelsStoreStats::updateNumTuplesByValue(table_id_t relTableID, int64_t value) { diff --git a/src/storage/stats/table_statistics_collection.cpp b/src/storage/stats/table_statistics_collection.cpp index 03430abe49..2ae00f39fa 100644 --- a/src/storage/stats/table_statistics_collection.cpp +++ b/src/storage/stats/table_statistics_collection.cpp @@ -14,28 +14,27 @@ using namespace kuzu::common; namespace kuzu { namespace storage { -TablesStatistics::TablesStatistics(BMFileHandle* metadataFH, BufferManager* bufferManager, WAL* wal, - common::VirtualFileSystem* vfs) - : metadataFH{metadataFH}, bufferManager{bufferManager}, vfs{vfs}, wal{wal}, isUpdated{false} { +TablesStatistics::TablesStatistics(BMFileHandle* metadataFH, BufferManager* bufferManager, WAL* wal) + : metadataFH{metadataFH}, bufferManager{bufferManager}, wal{wal}, isUpdated{false} { readOnlyVersion = std::make_unique(); } -void TablesStatistics::readFromFile() { - readFromFile(FileVersionType::ORIGINAL); +void TablesStatistics::readFromFile(VirtualFileSystem* fs) { + readFromFile(FileVersionType::ORIGINAL, fs); } -void TablesStatistics::readFromFile(FileVersionType fileVersionType) { - auto filePath = getTableStatisticsFilePath(wal->getDirectory(), fileVersionType); +void TablesStatistics::readFromFile(FileVersionType fileVersionType, VirtualFileSystem* fs) { + auto filePath = getTableStatisticsFilePath(wal->getDirectory(), fileVersionType, fs); auto deser = - Deserializer(std::make_unique(vfs->openFile(filePath, O_RDONLY))); + Deserializer(std::make_unique(fs->openFile(filePath, O_RDONLY))); deser.deserializeUnorderedMap(readOnlyVersion->tableStatisticPerTable); } void TablesStatistics::saveToFile(const std::string& directory, FileVersionType fileVersionType, - transaction::TransactionType transactionType) { - auto filePath = getTableStatisticsFilePath(directory, fileVersionType); + transaction::TransactionType transactionType, VirtualFileSystem* fs) { + auto filePath = getTableStatisticsFilePath(directory, fileVersionType, fs); auto ser = Serializer( - std::make_unique(vfs->openFile(filePath, O_WRONLY | O_CREAT))); + std::make_unique(fs->openFile(filePath, O_WRONLY | O_CREAT))); auto& tablesStatisticsContent = (transactionType == transaction::TransactionType::READ_ONLY || readWriteVersion == nullptr) ? readOnlyVersion : diff --git a/src/storage/storage_manager.cpp b/src/storage/storage_manager.cpp index 8828f7c0af..b6494bb86c 100644 --- a/src/storage/storage_manager.cpp +++ b/src/storage/storage_manager.cpp @@ -169,7 +169,7 @@ void StorageManager::dropTable(table_id_t tableID) { tables.erase(tableID); } -void StorageManager::prepareCommit(Transaction* transaction) { +void StorageManager::prepareCommit(Transaction* transaction, common::VirtualFileSystem* fs) { transaction->getLocalStorage()->prepareCommit(); // Tables which are created but not inserted into may have pending writes // which need to be flushed (specifically, the metadata disk array header) @@ -181,11 +181,12 @@ void StorageManager::prepareCommit(Transaction* transaction) { } if (nodesStatisticsAndDeletedIDs->hasUpdates()) { wal->logTableStatisticsRecord(TableType::NODE); - nodesStatisticsAndDeletedIDs->writeTablesStatisticsFileForWALRecord(wal->getDirectory()); + nodesStatisticsAndDeletedIDs->writeTablesStatisticsFileForWALRecord(wal->getDirectory(), + fs); } if (relsStatistics->hasUpdates()) { wal->logTableStatisticsRecord(TableType::REL); - relsStatistics->writeTablesStatisticsFileForWALRecord(wal->getDirectory()); + relsStatistics->writeTablesStatisticsFileForWALRecord(wal->getDirectory(), fs); } } diff --git a/src/storage/wal_replayer.cpp b/src/storage/wal_replayer.cpp index 9ff90da56a..dd0ea630ae 100644 --- a/src/storage/wal_replayer.cpp +++ b/src/storage/wal_replayer.cpp @@ -398,8 +398,9 @@ std::unique_ptr WALReplayer::getCatalogForRecovery(FileVersionType file // When we are recovering our database, the catalog field of walReplayer has not been // initialized and recovered yet. We need to create a new catalog to get node/rel tableEntries // for recovering. - auto catalogForRecovery = std::make_unique(vfs); - catalogForRecovery->getReadOnlyVersion()->readFromFile(wal->getDirectory(), fileVersionType); + auto catalogForRecovery = std::make_unique(); + catalogForRecovery->getReadOnlyVersion()->readFromFile(wal->getDirectory(), fileVersionType, + vfs); return catalogForRecovery; }