lbug 0.12.3-dev.15 → 0.12.3-dev.17

package/lbug-source/CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.15)
 
-project(Lbug VERSION 0.12.3.15 LANGUAGES CXX C)
+project(Lbug VERSION 0.12.3.17 LANGUAGES CXX C)
 
 option(SINGLE_THREADED "Single-threaded mode" FALSE)
 if(SINGLE_THREADED)

package/lbug-source/dataset/demo-db/graph-std/schema.cypher

@@ -0,0 +1,4 @@
+CREATE NODE TABLE city(id INT32, name STRING, population INT64, PRIMARY KEY(id)) WITH (storage = 'dataset/demo-db/graph-std/demo');
+CREATE NODE TABLE user(id INT32, name STRING, age INT64, PRIMARY KEY(id)) WITH (storage = 'dataset/demo-db/graph-std/demo');
+CREATE REL TABLE follows(FROM user TO user, since INT32) WITH (storage = 'dataset/demo-db/graph-std/demo');
+CREATE REL TABLE livesin(FROM user TO city) WITH (storage = 'dataset/demo-db/graph-std/demo');

package/lbug-source/scripts/antlr4/Cypher.g4

@@ -342,7 +342,7 @@ kU_IfNotExists
     : IF SP NOT SP EXISTS ;
 
 kU_CreateNodeTable
-    : CREATE SP NODE SP TABLE SP (kU_IfNotExists SP)? oC_SchemaName ( SP? '(' SP? kU_PropertyDefinitions SP? ( ',' SP? kU_CreateNodeConstraint )? SP? ')' | SP AS SP oC_Query ) ;
+    : CREATE SP NODE SP TABLE SP (kU_IfNotExists SP)? oC_SchemaName ( SP? '(' SP? kU_PropertyDefinitions SP? ( ',' SP? kU_CreateNodeConstraint )? SP? ')' | SP AS SP oC_Query ) ( SP WITH SP? '(' SP? kU_Options SP? ')')? ;
 
 kU_CreateRelTable
     : CREATE SP REL SP TABLE ( SP GROUP )? ( SP kU_IfNotExists )? SP oC_SchemaName

package/lbug-source/scripts/antlr4/hash.md5

@@ -1 +1 @@
-8334a684be17e562250acf07ae2bbca0
+52606d4848c2f224b8e480fec2923081

package/lbug-source/src/antlr4/Cypher.g4

@@ -95,7 +95,7 @@ kU_IfNotExists
     : IF SP NOT SP EXISTS ;
 
 kU_CreateNodeTable
-    : CREATE SP NODE SP TABLE SP (kU_IfNotExists SP)? oC_SchemaName ( SP? '(' SP? kU_PropertyDefinitions SP? ( ',' SP? kU_CreateNodeConstraint )? SP? ')' | SP AS SP oC_Query ) ;
+    : CREATE SP NODE SP TABLE SP (kU_IfNotExists SP)? oC_SchemaName ( SP? '(' SP? kU_PropertyDefinitions SP? ( ',' SP? kU_CreateNodeConstraint )? SP? ')' | SP AS SP oC_Query ) ( SP WITH SP? '(' SP? kU_Options SP? ')')? ;
 
 kU_CreateRelTable
     : CREATE SP REL SP TABLE ( SP GROUP )? ( SP kU_IfNotExists )? SP oC_SchemaName

package/lbug-source/src/binder/bind/bind_ddl.cpp

@@ -136,16 +136,6 @@ BoundCreateTableInfo Binder::bindCreateTableInfo(const CreateTableInfo* info) {
     }
 }
 
-BoundCreateTableInfo Binder::bindCreateNodeTableInfo(const CreateTableInfo* info) {
-    auto propertyDefinitions = bindPropertyDefinitions(info->propertyDefinitions, info->tableName);
-    auto& extraInfo = info->extraInfo->constCast<ExtraCreateNodeTableInfo>();
-    validatePrimaryKey(extraInfo.pKName, propertyDefinitions);
-    auto boundExtraInfo = std::make_unique<BoundExtraCreateNodeTableInfo>(extraInfo.pKName,
-        std::move(propertyDefinitions));
-    return BoundCreateTableInfo(CatalogEntryType::NODE_TABLE_ENTRY, info->tableName,
-        info->onConflict, std::move(boundExtraInfo), clientContext->useInternalCatalogEntry());
-}
-
 void Binder::validateNodeTableType(const TableCatalogEntry* entry) {
     if (entry->getType() != CatalogEntryType::NODE_TABLE_ENTRY) {
         throw BinderException(stringFormat("{} is not of type NODE.", entry->getName()));
@@ -168,6 +158,13 @@ void Binder::validateColumnExistence(const TableCatalogEntry* entry,
     }
 }
 
+static std::string getStorage(const case_insensitive_map_t<Value>& options) {
+    if (options.contains(TableOptionConstants::REL_STORAGE_OPTION)) {
+        return options.at(TableOptionConstants::REL_STORAGE_OPTION).toString();
+    }
+    return "";
+}
+
 static ExtendDirection getStorageDirection(const case_insensitive_map_t<Value>& options) {
     if (options.contains(TableOptionConstants::REL_STORAGE_DIRECTION_OPTION)) {
         return ExtendDirectionUtil::fromString(
@@ -176,6 +173,18 @@ static ExtendDirection getStorageDirection(const case_insensitive_map_t<Value>&
     return DEFAULT_EXTEND_DIRECTION;
 }
 
+BoundCreateTableInfo Binder::bindCreateNodeTableInfo(const CreateTableInfo* info) {
+    auto propertyDefinitions = bindPropertyDefinitions(info->propertyDefinitions, info->tableName);
+    auto& extraInfo = info->extraInfo->constCast<ExtraCreateNodeTableInfo>();
+    validatePrimaryKey(extraInfo.pKName, propertyDefinitions);
+    auto boundOptions = bindParsingOptions(extraInfo.options);
+    auto storage = getStorage(boundOptions);
+    auto boundExtraInfo = std::make_unique<BoundExtraCreateNodeTableInfo>(extraInfo.pKName,
+        std::move(propertyDefinitions), std::move(storage));
+    return BoundCreateTableInfo(CatalogEntryType::NODE_TABLE_ENTRY, info->tableName,
+        info->onConflict, std::move(boundExtraInfo), clientContext->useInternalCatalogEntry());
+}
+
 std::vector<PropertyDefinition> Binder::bindRelPropertyDefinitions(const CreateTableInfo& info) {
     std::vector<PropertyDefinition> propertyDefinitions;
     propertyDefinitions.emplace_back(
@@ -193,6 +202,7 @@ BoundCreateTableInfo Binder::bindCreateRelTableGroupInfo(const CreateTableInfo*
     auto dstMultiplicity = RelMultiplicityUtils::getBwd(extraInfo.relMultiplicity);
     auto boundOptions = bindParsingOptions(extraInfo.options);
     auto storageDirection = getStorageDirection(boundOptions);
+    auto storage = getStorage(boundOptions);
     // Bind from to pairs
     node_table_id_pair_set_t nodePairsSet;
     std::vector<NodeTableIDPair> nodePairs;
@@ -209,9 +219,9 @@ BoundCreateTableInfo Binder::bindCreateRelTableGroupInfo(const CreateTableInfo*
         nodePairsSet.insert(pair);
         nodePairs.emplace_back(pair);
     }
-    auto boundExtraInfo =
-        std::make_unique<BoundExtraCreateRelTableGroupInfo>(std::move(propertyDefinitions),
-            srcMultiplicity, dstMultiplicity, storageDirection, std::move(nodePairs));
+    auto boundExtraInfo = std::make_unique<BoundExtraCreateRelTableGroupInfo>(
+        std::move(propertyDefinitions), srcMultiplicity, dstMultiplicity, storageDirection,
+        std::move(nodePairs), std::move(storage));
     return BoundCreateTableInfo(CatalogEntryType::REL_GROUP_ENTRY, info->tableName,
         info->onConflict, std::move(boundExtraInfo), clientContext->useInternalCatalogEntry());
 }

package/lbug-source/src/catalog/catalog.cpp

@@ -190,9 +190,9 @@ CatalogEntry* Catalog::createRelGroupEntry(Transaction* transaction,
     for (auto& nodePair : extraInfo->nodePairs) {
         relTableInfos.emplace_back(nodePair, tables->getNextOID());
     }
-    auto relGroupEntry =
-        std::make_unique<RelGroupCatalogEntry>(info.tableName, extraInfo->srcMultiplicity,
-            extraInfo->dstMultiplicity, extraInfo->storageDirection, std::move(relTableInfos));
+    auto relGroupEntry = std::make_unique<RelGroupCatalogEntry>(info.tableName,
+        extraInfo->srcMultiplicity, extraInfo->dstMultiplicity, extraInfo->storageDirection,
+        std::move(relTableInfos), extraInfo->storage);
     for (auto& definition : extraInfo->propertyDefinitions) {
         relGroupEntry->addProperty(definition);
     }
@@ -541,7 +541,8 @@ CatalogEntry* Catalog::createTableEntry(Transaction* transaction,
 CatalogEntry* Catalog::createNodeTableEntry(Transaction* transaction,
     const BoundCreateTableInfo& info) {
     const auto extraInfo = info.extraInfo->constPtrCast<BoundExtraCreateNodeTableInfo>();
-    auto entry = std::make_unique<NodeTableCatalogEntry>(info.tableName, extraInfo->primaryKeyName);
+    auto entry = std::make_unique<NodeTableCatalogEntry>(info.tableName, extraInfo->primaryKeyName,
+        extraInfo->storage);
     for (auto& definition : extraInfo->propertyDefinitions) {
         entry->addProperty(definition);
     }

package/lbug-source/src/catalog/catalog_entry/node_table_catalog_entry.cpp

@@ -21,16 +21,22 @@ void NodeTableCatalogEntry::serialize(common::Serializer& serializer) const {
     TableCatalogEntry::serialize(serializer);
     serializer.writeDebuggingInfo("primaryKeyName");
     serializer.write(primaryKeyName);
+    serializer.writeDebuggingInfo("storage");
+    serializer.write(storage);
 }
 
 std::unique_ptr<NodeTableCatalogEntry> NodeTableCatalogEntry::deserialize(
     common::Deserializer& deserializer) {
     std::string debuggingInfo;
     std::string primaryKeyName;
+    std::string storage;
     deserializer.validateDebuggingInfo(debuggingInfo, "primaryKeyName");
     deserializer.deserializeValue(primaryKeyName);
+    deserializer.validateDebuggingInfo(debuggingInfo, "storage");
+    deserializer.deserializeValue(storage);
     auto nodeTableEntry = std::make_unique<NodeTableCatalogEntry>();
     nodeTableEntry->primaryKeyName = primaryKeyName;
+    nodeTableEntry->storage = storage;
     return nodeTableEntry;
 }
 
@@ -42,6 +48,7 @@ std::string NodeTableCatalogEntry::toCypher(const ToCypherInfo& /*info*/) const
 std::unique_ptr<TableCatalogEntry> NodeTableCatalogEntry::copy() const {
     auto other = std::make_unique<NodeTableCatalogEntry>();
     other->primaryKeyName = primaryKeyName;
+    other->storage = storage;
     other->copyFrom(*this);
     return other;
 }
@@ -49,7 +56,7 @@ std::unique_ptr<TableCatalogEntry> NodeTableCatalogEntry::copy() const {
 std::unique_ptr<BoundExtraCreateCatalogEntryInfo> NodeTableCatalogEntry::getBoundExtraCreateInfo(
     transaction::Transaction*) const {
     return std::make_unique<BoundExtraCreateNodeTableInfo>(primaryKeyName,
-        copyVector(getProperties()));
+        copyVector(getProperties()), storage);
 }
 
 } // namespace catalog

package/lbug-source/src/catalog/catalog_entry/rel_group_catalog_entry.cpp

@@ -95,6 +95,8 @@ void RelGroupCatalogEntry::serialize(Serializer& serializer) const {
     serializer.serializeValue(dstMultiplicity);
     serializer.writeDebuggingInfo("storageDirection");
     serializer.serializeValue(storageDirection);
+    serializer.writeDebuggingInfo("storage");
+    serializer.serializeValue(storage);
     serializer.writeDebuggingInfo("relTableInfos");
     serializer.serializeVector(relTableInfos);
 }
@@ -105,6 +107,7 @@ std::unique_ptr<RelGroupCatalogEntry> RelGroupCatalogEntry::deserialize(
     auto srcMultiplicity = RelMultiplicity::MANY;
     auto dstMultiplicity = RelMultiplicity::MANY;
     auto storageDirection = ExtendDirection::BOTH;
+    std::string storage;
     std::vector<RelTableCatalogInfo> relTableInfos;
     deserializer.validateDebuggingInfo(debuggingInfo, "srcMultiplicity");
     deserializer.deserializeValue(srcMultiplicity);
@@ -112,12 +115,15 @@ std::unique_ptr<RelGroupCatalogEntry> RelGroupCatalogEntry::deserialize(
     deserializer.deserializeValue(dstMultiplicity);
     deserializer.validateDebuggingInfo(debuggingInfo, "storageDirection");
     deserializer.deserializeValue(storageDirection);
+    deserializer.validateDebuggingInfo(debuggingInfo, "storage");
+    deserializer.deserializeValue(storage);
     deserializer.validateDebuggingInfo(debuggingInfo, "relTableInfos");
     deserializer.deserializeVector(relTableInfos);
     auto relGroupEntry = std::make_unique<RelGroupCatalogEntry>();
     relGroupEntry->srcMultiplicity = srcMultiplicity;
     relGroupEntry->dstMultiplicity = dstMultiplicity;
     relGroupEntry->storageDirection = storageDirection;
+    relGroupEntry->storage = storage;
     relGroupEntry->relTableInfos = relTableInfos;
     return relGroupEntry;
 }
@@ -167,6 +173,7 @@ std::unique_ptr<TableCatalogEntry> RelGroupCatalogEntry::copy() const {
     other->srcMultiplicity = srcMultiplicity;
     other->dstMultiplicity = dstMultiplicity;
     other->storageDirection = storageDirection;
+    other->storage = storage;
     other->relTableInfos = relTableInfos;
     other->copyFrom(*this);
     return other;

package/lbug-source/src/function/function_collection.cpp

@@ -228,7 +228,8 @@ FunctionCollection* FunctionCollection::getFunctions() {
         TABLE_FUNCTION(StatsInfoFunction), TABLE_FUNCTION(StorageInfoFunction),
         TABLE_FUNCTION(ShowAttachedDatabasesFunction), TABLE_FUNCTION(ShowSequencesFunction),
         TABLE_FUNCTION(ShowFunctionsFunction), TABLE_FUNCTION(BMInfoFunction),
-        TABLE_FUNCTION(FileInfoFunction), TABLE_FUNCTION(ShowLoadedExtensionsFunction),
+        TABLE_FUNCTION(FileInfoFunction), TABLE_FUNCTION(DiskSizeInfoFunction),
+        TABLE_FUNCTION(ShowLoadedExtensionsFunction),
         TABLE_FUNCTION(ShowOfficialExtensionsFunction), TABLE_FUNCTION(ShowIndexesFunction),
         TABLE_FUNCTION(ShowProjectedGraphsFunction), TABLE_FUNCTION(ProjectedGraphInfoFunction),
         TABLE_FUNCTION(ShowMacrosFunction),

package/lbug-source/src/function/table/CMakeLists.txt

@@ -8,6 +8,7 @@ add_library(lbug_table_function
         clear_warnings.cpp
         current_setting.cpp
         db_version.cpp
+        disk_size_info.cpp
         drop_project_graph.cpp
         file_info.cpp
         free_space_info.cpp

package/lbug-source/src/function/table/disk_size_info.cpp

@@ -0,0 +1,322 @@
+#include "binder/binder.h"
+#include "catalog/catalog.h"
+#include "catalog/catalog_entry/node_table_catalog_entry.h"
+#include "catalog/catalog_entry/rel_group_catalog_entry.h"
+#include "common/exception/binder.h"
+#include "function/table/bind_data.h"
+#include "function/table/simple_table_function.h"
+#include "main/client_context.h"
+#include "storage/database_header.h"
+#include "storage/index/hash_index.h"
+#include "storage/page_manager.h"
+#include "storage/storage_manager.h"
+#include "storage/table/list_chunk_data.h"
+#include "storage/table/node_table.h"
+#include "storage/table/rel_table.h"
+#include "storage/table/string_chunk_data.h"
+#include "storage/table/struct_chunk_data.h"
+#include "transaction/transaction.h"
+
+using namespace lbug::common;
+using namespace lbug::catalog;
+using namespace lbug::storage;
+using namespace lbug::main;
+
+namespace lbug {
+namespace function {
+
+struct DiskSizeInfoBindData final : TableFuncBindData {
+    const ClientContext* ctx;
+    DiskSizeInfoBindData(binder::expression_vector columns, row_idx_t numRows,
+        const ClientContext* ctx)
+        : TableFuncBindData{std::move(columns), numRows}, ctx{ctx} {}
+
+    std::unique_ptr<TableFuncBindData> copy() const override {
+        return std::make_unique<DiskSizeInfoBindData>(columns, numRows, ctx);
+    }
+};
+
+static uint64_t countChunkDataPages(const ColumnChunkData& chunkData) {
+    uint64_t pages = 0;
+    auto metadata = chunkData.getResidencyState() == ResidencyState::ON_DISK ?
+                        chunkData.getMetadata() :
+                        chunkData.getMetadataToFlush();
+    pages += metadata.getNumPages();
+
+    if (chunkData.hasNullData()) {
+        pages += countChunkDataPages(*chunkData.getNullData());
+    }
+
+    auto physicalType = chunkData.getDataType().getPhysicalType();
+    switch (physicalType) {
+    case PhysicalTypeID::STRUCT: {
+        auto& structChunk = chunkData.cast<StructChunkData>();
+        for (auto i = 0u; i < structChunk.getNumChildren(); i++) {
+            pages += countChunkDataPages(structChunk.getChild(i));
+        }
+    } break;
+    case PhysicalTypeID::STRING: {
+        auto& stringChunk = chunkData.cast<StringChunkData>();
+        pages += countChunkDataPages(*stringChunk.getIndexColumnChunk());
+        auto& dictionaryChunk = stringChunk.getDictionaryChunk();
+        pages += countChunkDataPages(*dictionaryChunk.getStringDataChunk());
+        pages += countChunkDataPages(*dictionaryChunk.getOffsetChunk());
+    } break;
+    case PhysicalTypeID::ARRAY:
+    case PhysicalTypeID::LIST: {
+        auto& listChunk = chunkData.cast<ListChunkData>();
+        pages += countChunkDataPages(*listChunk.getOffsetColumnChunk());
+        pages += countChunkDataPages(*listChunk.getSizeColumnChunk());
+        pages += countChunkDataPages(*listChunk.getDataColumnChunk());
+    } break;
+    default:
+        break;
+    }
+    return pages;
+}
+
+static uint64_t countChunkedGroupPages(ChunkedNodeGroup* chunkedGroup) {
+    uint64_t pages = 0;
+    auto numColumns = chunkedGroup->getNumColumns();
+    for (auto i = 0u; i < numColumns; i++) {
+        for (auto* segment : chunkedGroup->getColumnChunk(i).getSegments()) {
+            pages += countChunkDataPages(*segment);
+        }
+    }
+    if (chunkedGroup->getFormat() == NodeGroupDataFormat::CSR) {
+        auto& chunkedCSRGroup = chunkedGroup->cast<ChunkedCSRNodeGroup>();
+        for (auto* segment : chunkedCSRGroup.getCSRHeader().offset->getSegments()) {
+            pages += countChunkDataPages(*segment);
+        }
+        for (auto* segment : chunkedCSRGroup.getCSRHeader().length->getSegments()) {
+            pages += countChunkDataPages(*segment);
+        }
+    }
+    return pages;
+}
+
+static uint64_t countNodeGroupPages(NodeGroup* nodeGroup) {
+    uint64_t pages = 0;
+    auto numChunks = nodeGroup->getNumChunkedGroups();
+    for (auto chunkIdx = 0ul; chunkIdx < numChunks; chunkIdx++) {
+        pages += countChunkedGroupPages(nodeGroup->getChunkedNodeGroup(chunkIdx));
+    }
+    if (nodeGroup->getFormat() == NodeGroupDataFormat::CSR) {
+        auto& csrNodeGroup = nodeGroup->cast<CSRNodeGroup>();
+        auto persistentChunk = csrNodeGroup.getPersistentChunkedGroup();
+        if (persistentChunk) {
+            pages += countChunkedGroupPages(persistentChunk);
+        }
+    }
+    return pages;
+}
+
+struct DiskSizeEntry {
+    std::string category;
+    std::string name;
+    uint64_t numPages;
+    uint64_t sizeBytes;
+};
+
+// Estimate the number of pages used by a hash index based on the number of entries
+// Hash index structure:
+// - INDEX_HEADER_PAGES pages for HashIndexHeaderOnDisk (2 pages for 256 sub-indexes)
+// - DiskArrayCollection header pages (1+ pages)
+// - For each of 256 sub-indexes: pSlots and oSlots disk arrays
+// - Each slot is SLOT_CAPACITY_BYTES (256 bytes), so 16 slots per page
+// - Number of primary slots = 2^currentLevel + nextSplitSlotId
+// - Overflow slots depend on collisions
+static uint64_t estimateHashIndexPages(const PrimaryKeyIndex* pkIndex) {
+    if (!pkIndex) {
+        return 0;
+    }
+
+    uint64_t totalPages = 0;
+
+    // Index header pages (storing HashIndexHeaderOnDisk for all 256 sub-indexes)
+    totalPages += INDEX_HEADER_PAGES; // 2 pages
+
+    // DiskArrayCollection header pages (at least 1)
+    // Each header page stores headers for up to ~170 disk arrays
+    // With 256 sub-indexes * 2 arrays (pSlots + oSlots) = 512 arrays
+    totalPages += 4; // Approximate: ~3-4 header pages for DiskArrayCollection
+
+    // For each sub-index, estimate primary and overflow slot pages
+    // We can access the headers through the pkIndex to get actual sizes
+    // But since the headers are private, we estimate based on numEntries
+
+    // Get total entries from all sub-indexes
+    // Each entry requires a slot, and slots have capacity of ~3-20 entries depending on key type
+    // With linear hashing, we expect ~70-80% fill rate
+
+    // Rough estimation: For N entries with 8-byte keys:
+    // - Slot capacity is approximately 3 entries per slot (256-byte slot / 80 bytes per entry)
+    // - Number of slots ≈ N / (3 * 0.7) ≈ N / 2
+    // - Pages for slots = slots / 16 (16 slots per page)
+    // - Plus PIP pages for addressing
+
+    // Since we can't easily access internal headers, we return the header overhead
+    // and let the unaccounted calculation handle the rest
+    return totalPages;
+}
+
+static std::vector<DiskSizeEntry> collectDiskSizeInfo(const ClientContext* context) {
+    std::vector<DiskSizeEntry> entries;
+    auto storageManager = StorageManager::Get(*context);
+    auto catalog = Catalog::Get(*context);
+    auto dataFH = storageManager->getDataFH();
+
+    // Handle in-memory databases
+    if (storageManager->isInMemory()) {
+        entries.push_back({"info", "in_memory_database", 0, 0});
+        return entries;
+    }
+
+    auto pageManager = dataFH->getPageManager();
+
+    // 1. Database header (always 1 page at index 0)
+    entries.push_back({"header", "database_header", 1, LBUG_PAGE_SIZE});
+
+    // 2. Get catalog and metadata page ranges from database header
+    auto databaseHeader = DatabaseHeader::readDatabaseHeader(*dataFH->getFileInfo());
+    if (databaseHeader.has_value()) {
+        entries.push_back({"catalog", "catalog", databaseHeader->catalogPageRange.numPages,
+            databaseHeader->catalogPageRange.numPages * LBUG_PAGE_SIZE});
+
+        entries.push_back({"metadata", "metadata", databaseHeader->metadataPageRange.numPages,
+            databaseHeader->metadataPageRange.numPages * LBUG_PAGE_SIZE});
+    }
+
+    // 3. Count table data pages
+    auto nodeTableEntries =
+        catalog->getNodeTableEntries(&transaction::DUMMY_CHECKPOINT_TRANSACTION);
+    auto relGroupEntries = catalog->getRelGroupEntries(&transaction::DUMMY_CHECKPOINT_TRANSACTION);
+
+    for (const auto tableEntry : nodeTableEntries) {
+        auto& nodeTable = storageManager->getTable(tableEntry->getTableID())->cast<NodeTable>();
+        uint64_t tablePages = 0;
+        auto numNodeGroups = nodeTable.getNumNodeGroups();
+        for (auto i = 0ul; i < numNodeGroups; i++) {
+            tablePages += countNodeGroupPages(nodeTable.getNodeGroup(i));
+        }
+        entries.push_back(
+            {"node_table", tableEntry->getName(), tablePages, tablePages * LBUG_PAGE_SIZE});
+
+        // Count primary key index header pages (rough estimate for overhead)
+        auto* pkIndex = nodeTable.getPKIndex();
+        uint64_t indexPages = estimateHashIndexPages(pkIndex);
+        if (indexPages > 0) {
+            entries.push_back({"pk_index_overhead", tableEntry->getName() + "_pk", indexPages,
+                indexPages * LBUG_PAGE_SIZE});
+        }
+    }
+
+    for (const auto entry : relGroupEntries) {
+        auto& relGroupEntry = entry->cast<RelGroupCatalogEntry>();
+        for (auto& info : relGroupEntry.getRelEntryInfos()) {
+            auto& relTable = storageManager->getTable(info.oid)->cast<RelTable>();
+            uint64_t tablePages = 0;
+
+            for (auto direction : relTable.getStorageDirections()) {
+                auto* directedRelTableData = relTable.getDirectedTableData(direction);
+                auto numNodeGroups = directedRelTableData->getNumNodeGroups();
+                for (auto i = 0ul; i < numNodeGroups; i++) {
+                    tablePages += countNodeGroupPages(directedRelTableData->getNodeGroup(i));
+                }
+            }
+            auto tableName = relGroupEntry.getName() + ":" +
+                             catalog
+                                 ->getTableCatalogEntry(&transaction::DUMMY_CHECKPOINT_TRANSACTION,
+                                     info.nodePair.srcTableID)
+                                 ->getName() +
+                             "->" +
+                             catalog
+                                 ->getTableCatalogEntry(&transaction::DUMMY_CHECKPOINT_TRANSACTION,
+                                     info.nodePair.dstTableID)
+                                 ->getName();
+            entries.push_back({"rel_table", tableName, tablePages, tablePages * LBUG_PAGE_SIZE});
+        }
+    }
+
+    // 4. Free space (from FSM)
+    auto freeEntries = pageManager->getFreeEntries(0, pageManager->getNumFreeEntries());
+    uint64_t freePages = 0;
+    for (const auto& freeEntry : freeEntries) {
+        freePages += freeEntry.numPages;
+    }
+    entries.push_back({"free_space", "free_pages", freePages, freePages * LBUG_PAGE_SIZE});
+
+    // 5. Calculate unaccounted pages (index slot data)
+    auto totalFilePages = dataFH->getNumPages();
+    uint64_t accountedPages = 1; // header
+    if (databaseHeader.has_value()) {
+        accountedPages +=
+            databaseHeader->catalogPageRange.numPages + databaseHeader->metadataPageRange.numPages;
+    }
+    for (const auto& entry : entries) {
+        if (entry.category == "node_table" || entry.category == "rel_table" ||
+            entry.category == "pk_index_overhead") {
+            accountedPages += entry.numPages;
+        }
+    }
+    accountedPages += freePages;
+
+    if (totalFilePages > accountedPages) {
+        uint64_t unaccountedPages = totalFilePages - accountedPages;
+        entries.push_back({"index_data", "hash_index_slots", unaccountedPages,
+            unaccountedPages * LBUG_PAGE_SIZE});
+    }
+
+    // 6. Total file size (last row)
+    entries.push_back({"total", "file_total", totalFilePages, totalFilePages * LBUG_PAGE_SIZE});
+
+    return entries;
+}
+
+static offset_t internalTableFunc(const TableFuncMorsel& morsel, const TableFuncInput& input,
+    DataChunk& output) {
+    const auto bindData = input.bindData->constPtrCast<DiskSizeInfoBindData>();
+    auto entries = collectDiskSizeInfo(bindData->ctx);
+
+    auto numEntriesToOutput = std::min(static_cast<uint64_t>(entries.size()) - morsel.startOffset,
+        morsel.getMorselSize());
+
+    for (row_idx_t i = 0; i < numEntriesToOutput; ++i) {
+        const auto& entry = entries[morsel.startOffset + i];
+        output.getValueVectorMutable(0).setValue(i, entry.category);
+        output.getValueVectorMutable(1).setValue(i, entry.name);
+        output.getValueVectorMutable(2).setValue<uint64_t>(i, entry.numPages);
+        output.getValueVectorMutable(3).setValue<uint64_t>(i, entry.sizeBytes);
+    }
+    return numEntriesToOutput;
+}
+
+static std::unique_ptr<TableFuncBindData> bindFunc(const ClientContext* context,
+    const TableFuncBindInput* input) {
+    std::vector<std::string> columnNames = {"category", "name", "num_pages", "size_bytes"};
+    std::vector<LogicalType> columnTypes;
+    columnTypes.push_back(LogicalType::STRING());
+    columnTypes.push_back(LogicalType::STRING());
+    columnTypes.push_back(LogicalType::UINT64());
+    columnTypes.push_back(LogicalType::UINT64());
+
+    // Get number of entries to report
+    auto entries = collectDiskSizeInfo(context);
+
+    auto columns = input->binder->createVariables(columnNames, columnTypes);
+    return std::make_unique<DiskSizeInfoBindData>(columns, entries.size(), context);
+}
+
+function_set DiskSizeInfoFunction::getFunctionSet() {
+    function_set functionSet;
+    auto function = std::make_unique<TableFunction>(name, std::vector<LogicalTypeID>{});
+    function->tableFunc = SimpleTableFunc::getTableFunc(internalTableFunc);
+    function->bindFunc = bindFunc;
+    function->initSharedStateFunc = SimpleTableFunc::initSharedState;
+    function->initLocalStateFunc = TableFunction::initEmptyLocalState;
+    functionSet.push_back(std::move(function));
+    return functionSet;
+}
+
+} // namespace function
+} // namespace lbug

package/lbug-source/src/include/binder/ddl/bound_create_table_info.h

@@ -71,14 +71,15 @@ struct LBUG_API BoundExtraCreateTableInfo : BoundExtraCreateCatalogEntryInfo {
 
 struct BoundExtraCreateNodeTableInfo final : BoundExtraCreateTableInfo {
     std::string primaryKeyName;
+    std::string storage;
 
     BoundExtraCreateNodeTableInfo(std::string primaryKeyName,
-        std::vector<PropertyDefinition> definitions)
+        std::vector<PropertyDefinition> definitions, std::string storage = "")
         : BoundExtraCreateTableInfo{std::move(definitions)},
-          primaryKeyName{std::move(primaryKeyName)} {}
+          primaryKeyName{std::move(primaryKeyName)}, storage{std::move(storage)} {}
     BoundExtraCreateNodeTableInfo(const BoundExtraCreateNodeTableInfo& other)
         : BoundExtraCreateTableInfo{copyVector(other.propertyDefinitions)},
-          primaryKeyName{other.primaryKeyName} {}
+          primaryKeyName{other.primaryKeyName}, storage{other.storage} {}
 
     std::unique_ptr<BoundExtraCreateCatalogEntryInfo> copy() const override {
         return std::make_unique<BoundExtraCreateNodeTableInfo>(*this);
@@ -90,18 +91,21 @@ struct BoundExtraCreateRelTableGroupInfo final : BoundExtraCreateTableInfo {
     common::RelMultiplicity dstMultiplicity;
     common::ExtendDirection storageDirection;
     std::vector<catalog::NodeTableIDPair> nodePairs;
+    std::string storage;
 
     explicit BoundExtraCreateRelTableGroupInfo(std::vector<PropertyDefinition> definitions,
         common::RelMultiplicity srcMultiplicity, common::RelMultiplicity dstMultiplicity,
-        common::ExtendDirection storageDirection, std::vector<catalog::NodeTableIDPair> nodePairs)
+        common::ExtendDirection storageDirection, std::vector<catalog::NodeTableIDPair> nodePairs,
+        std::string storage = "")
         : BoundExtraCreateTableInfo{std::move(definitions)}, srcMultiplicity{srcMultiplicity},
           dstMultiplicity{dstMultiplicity}, storageDirection{storageDirection},
-          nodePairs{std::move(nodePairs)} {}
+          nodePairs{std::move(nodePairs)}, storage{std::move(storage)} {}
 
     BoundExtraCreateRelTableGroupInfo(const BoundExtraCreateRelTableGroupInfo& other)
         : BoundExtraCreateTableInfo{copyVector(other.propertyDefinitions)},
           srcMultiplicity{other.srcMultiplicity}, dstMultiplicity{other.dstMultiplicity},
-          storageDirection{other.storageDirection}, nodePairs{other.nodePairs} {}
+          storageDirection{other.storageDirection}, nodePairs{other.nodePairs},
+          storage{other.storage} {}
 
     std::unique_ptr<BoundExtraCreateCatalogEntryInfo> copy() const override {
         return std::make_unique<BoundExtraCreateRelTableGroupInfo>(*this);

package/lbug-source/src/include/catalog/catalog_entry/node_table_catalog_entry.h

@@ -15,9 +15,9 @@ class LBUG_API NodeTableCatalogEntry final : public TableCatalogEntry {
 
 public:
     NodeTableCatalogEntry() = default;
-    NodeTableCatalogEntry(std::string name, std::string primaryKeyName)
-        : TableCatalogEntry{entryType_, std::move(name)},
-          primaryKeyName{std::move(primaryKeyName)} {}
+    NodeTableCatalogEntry(std::string name, std::string primaryKeyName, std::string storage = "")
+        : TableCatalogEntry{entryType_, std::move(name)}, primaryKeyName{std::move(primaryKeyName)},
+          storage{std::move(storage)} {}
 
     bool isParent(common::table_id_t /*tableID*/) override { return false; }
     common::TableType getTableType() const override { return common::TableType::NODE; }
@@ -29,6 +29,7 @@ public:
     const binder::PropertyDefinition& getPrimaryKeyDefinition() const {
         return getProperty(primaryKeyName);
     }
+    const std::string& getStorage() const { return storage; }
 
     void renameProperty(const std::string& propertyName, const std::string& newName) override;
 
@@ -44,6 +45,7 @@ private:
 
 private:
     std::string primaryKeyName;
+    std::string storage;
 };
 
 } // namespace catalog