lbug 0.12.3-dev.3 → 0.12.3-dev.30

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/function/table/show_connection.cpp

@@ -71,7 +71,12 @@ static std::unique_ptr<TableFuncBindData> bindFunc(const ClientContext* context,
         if (entry->getType() != catalog::CatalogEntryType::REL_GROUP_ENTRY) {
             throw BinderException{"Show connection can only be called on a rel table!"};
         }
-        for (auto& info : entry->ptrCast<RelGroupCatalogEntry>()->getRelEntryInfos()) {
+        for (auto& info : entry->ptrCast<RelGroupCatalogEntry>()
+                              ->getRelEntryInfos()) { // Skip foreign-backed rel tables (they have
+                                                      // FOREIGN_TABLE_ID)
+            if (info.nodePair.srcTableID == common::FOREIGN_TABLE_ID) {
+                continue;
+            }
             auto srcEntry = catalog->getTableCatalogEntry(transaction, info.nodePair.srcTableID)
                                 ->ptrCast<NodeTableCatalogEntry>();
             auto dstEntry = catalog->getTableCatalogEntry(transaction, info.nodePair.dstTableID)

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

@@ -1,5 +1,6 @@
 #include "binder/binder.h"
 #include "catalog/catalog.h"
+#include "catalog/catalog_entry/rel_group_catalog_entry.h"
 #include "catalog/catalog_entry/table_catalog_entry.h"
 #include "function/table/bind_data.h"
 #include "function/table/simple_table_function.h"
@@ -72,9 +73,16 @@ static std::unique_ptr<TableFuncBindData> bindFunc(const main::ClientContext* co
         auto catalog = Catalog::Get(*context);
         for (auto& entry :
             catalog->getTableEntries(transaction, context->useInternalCatalogEntry())) {
+            std::string dbName = LOCAL_DB_NAME;
+            // For foreign-backed rel tables, use the foreign database name
+            if (entry->getType() == CatalogEntryType::REL_GROUP_ENTRY) {
+                auto relEntry = entry->constPtrCast<RelGroupCatalogEntry>();
+                if (!relEntry->getForeignDatabaseName().empty()) {
+                    dbName = relEntry->getForeignDatabaseName();
+                }
+            }
             tableInfos.emplace_back(entry->getName(), entry->getTableID(),
-                TableTypeUtils::toString(entry->getTableType()), LOCAL_DB_NAME,
-                entry->getComment());
+                TableTypeUtils::toString(entry->getTableType()), dbName, entry->getComment());
         }
     }
 

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

@@ -100,8 +100,17 @@ std::unique_ptr<PhysicalOperator> TableFunction::getPhysicalPlan(PlanMapper* pla
     auto initInput =
         TableFuncInitSharedStateInput(info.bindData.get(), planMapper->executionContext);
     auto sharedState = info.function.initSharedStateFunc(initInput);
-    auto printInfo = std::make_unique<TableFunctionCallPrintInfo>(call.getTableFunc().name,
-        call.getBindData()->columns);
+    // Filter columns for print info based on column skips
+    binder::expression_vector printExprs;
+    auto columnSkips = call.getBindData()->getColumnSkips();
+    for (auto i = 0u; i < call.getBindData()->columns.size(); ++i) {
+        if (columnSkips.empty() || !columnSkips[i]) {
+            printExprs.push_back(call.getBindData()->columns[i]);
+        }
+    }
+    auto desc = call.getBindData()->getDescription();
+    auto printInfo = std::make_unique<TableFunctionCallPrintInfo>(
+        desc.empty() ? call.getTableFunc().name : desc, printExprs);
     return std::make_unique<TableFunctionCall>(std::move(info), sharedState,
         planMapper->getOperatorID(), std::move(printInfo));
 }

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

@@ -1,10 +1,14 @@
 #pragma once
 
+#include <optional>
+
 #include "catalog/catalog_entry/catalog_entry_type.h"
 #include "catalog/catalog_entry/node_table_id_pair.h"
 #include "common/enums/conflict_action.h"
 #include "common/enums/extend_direction.h"
 #include "common/enums/rel_multiplicity.h"
+#include "function/table/bind_data.h"
+#include "function/table/table_function.h"
 #include "property_definition.h"
 
 namespace lbug {
@@ -71,14 +75,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 +95,30 @@ struct BoundExtraCreateRelTableGroupInfo final : BoundExtraCreateTableInfo {
     common::RelMultiplicity dstMultiplicity;
     common::ExtendDirection storageDirection;
     std::vector<catalog::NodeTableIDPair> nodePairs;
+    std::string storage;
+    std::optional<function::TableFunction> scanFunction;
+    std::optional<std::shared_ptr<function::TableFuncBindData>> scanBindData;
+    std::string foreignDatabaseName;
 
     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 = "",
+        std::optional<function::TableFunction> scanFunction = std::nullopt,
+        std::optional<std::shared_ptr<function::TableFuncBindData>> scanBindData = std::nullopt,
+        std::string foreignDatabaseName = "")
         : BoundExtraCreateTableInfo{std::move(definitions)}, srcMultiplicity{srcMultiplicity},
           dstMultiplicity{dstMultiplicity}, storageDirection{storageDirection},
-          nodePairs{std::move(nodePairs)} {}
+          nodePairs{std::move(nodePairs)}, storage{std::move(storage)},
+          scanFunction{std::move(scanFunction)}, scanBindData{std::move(scanBindData)},
+          foreignDatabaseName{std::move(foreignDatabaseName)} {}
 
     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}, scanFunction{other.scanFunction},
+          scanBindData{other.scanBindData}, foreignDatabaseName{other.foreignDatabaseName} {}
 
     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

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

@@ -1,9 +1,13 @@
 #pragma once
 
+#include <optional>
+
 #include "catalog/catalog_entry/table_catalog_entry.h"
 #include "common/enums/extend_direction.h"
 #include "common/enums/rel_direction.h"
 #include "common/enums/rel_multiplicity.h"
+#include "function/table/bind_data.h"
+#include "function/table/table_function.h"
 #include "node_table_id_pair.h"
 
 namespace lbug {
@@ -34,10 +38,15 @@ public:
     RelGroupCatalogEntry() = default;
     RelGroupCatalogEntry(std::string tableName, common::RelMultiplicity srcMultiplicity,
         common::RelMultiplicity dstMultiplicity, common::ExtendDirection storageDirection,
-        std::vector<RelTableCatalogInfo> relTableInfos)
+        std::vector<RelTableCatalogInfo> relTableInfos, std::string storage = "",
+        std::optional<function::TableFunction> scanFunction = std::nullopt,
+        std::optional<std::shared_ptr<function::TableFuncBindData>> scanBindData = std::nullopt,
+        std::string foreignDatabaseName = "")
         : TableCatalogEntry{type_, std::move(tableName)}, srcMultiplicity{srcMultiplicity},
           dstMultiplicity{dstMultiplicity}, storageDirection{storageDirection},
-          relTableInfos{std::move(relTableInfos)} {
+          relTableInfos{std::move(relTableInfos)}, storage{std::move(storage)},
+          scanFunction{std::move(scanFunction)}, scanBindData{std::move(scanBindData)},
+          foreignDatabaseName{std::move(foreignDatabaseName)} {
         propertyCollection =
             PropertyDefinitionCollection{1}; // Skip NBR_NODE_ID column as the first one.
     }
@@ -53,6 +62,12 @@ public:
     }
 
     common::ExtendDirection getStorageDirection() const { return storageDirection; }
+    const std::string& getStorage() const { return storage; }
+    const std::optional<function::TableFunction>& getScanFunction() const { return scanFunction; }
+    const std::optional<std::shared_ptr<function::TableFuncBindData>>& getScanBindData() const {
+        return scanBindData;
+    }
+    const std::string& getForeignDatabaseName() const { return foreignDatabaseName; }
 
     common::idx_t getNumRelTables() const { return relTableInfos.size(); }
     const std::vector<RelTableCatalogInfo>& getRelEntryInfos() const { return relTableInfos; }
@@ -97,6 +112,10 @@ private:
     // TODO(Guodong): Avoid using extend direction for storage direction
     common::ExtendDirection storageDirection = common::ExtendDirection::BOTH;
     std::vector<RelTableCatalogInfo> relTableInfos;
+    std::string storage;
+    std::optional<function::TableFunction> scanFunction;
+    std::optional<std::shared_ptr<function::TableFuncBindData>> scanBindData;
+    std::string foreignDatabaseName; // Database name for foreign-backed rel tables
 };
 
 } // namespace catalog

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

@@ -2,6 +2,7 @@
 
 #include <vector>
 
+#include "binder/bound_scan_source.h"
 #include "binder/ddl/bound_alter_info.h"
 #include "binder/ddl/bound_create_table_info.h"
 #include "catalog/catalog_entry/catalog_entry.h"
@@ -43,6 +44,12 @@ public:
 
     virtual function::TableFunction getScanFunction() { KU_UNREACHABLE; }
 
+    virtual std::unique_ptr<binder::BoundTableScanInfo> getBoundScanInfo(
+        [[maybe_unused]] main::ClientContext* context,
+        [[maybe_unused]] const std::string& nodeUniqueName = "") {
+        return nullptr;
+    }
+
     common::column_id_t getMaxColumnID() const;
     void vacuumColumnIDs(common::column_id_t nextColumnID);
     std::vector<binder::PropertyDefinition> getProperties() const {

package/lbug-source/src/include/common/constants.h

@@ -83,6 +83,7 @@ struct StorageConstants {
 
 struct TableOptionConstants {
     static constexpr char REL_STORAGE_DIRECTION_OPTION[] = "STORAGE_DIRECTION";
+    static constexpr char REL_STORAGE_OPTION[] = "STORAGE";
 };
 
 // Hash Index Configurations

package/lbug-source/src/include/common/string_format.h

@@ -14,8 +14,8 @@ namespace common {
 #if USE_STD_FORMAT
 
 template<typename... Args>
-inline std::string stringFormat(std::format_string<Args...> format, Args&&... args) {
-    return std::format(format, std::forward<Args>(args)...);
+inline std::string stringFormat(std::string_view format, Args&&... args) {
+    return std::vformat(format, std::make_format_args(args...));
 }
 
 #else

package/lbug-source/src/include/common/types/types.h

@@ -75,6 +75,7 @@ using table_id_set_t = std::unordered_set<table_id_t>;
 template<typename T>
 using table_id_map_t = std::unordered_map<table_id_t, T>;
 constexpr table_id_t INVALID_TABLE_ID = INVALID_OID;
+constexpr table_id_t FOREIGN_TABLE_ID = INVALID_OID - 1;
 // offset type alias
 using offset_t = uint64_t;
 constexpr offset_t INVALID_OFFSET = UINT64_MAX;

package/lbug-source/src/include/function/table/bind_data.h

@@ -25,7 +25,8 @@ struct LBUG_API TableFuncBindData {
     TableFuncBindData(const TableFuncBindData& other)
         : columns{other.columns}, numRows{other.numRows},
           optionalParams{other.optionalParams == nullptr ? nullptr : other.optionalParams->copy()},
-          columnSkips{other.columnSkips}, columnPredicates{copyVector(other.columnPredicates)} {}
+          columnSkips{other.columnSkips}, columnPredicates{copyVector(other.columnPredicates)},
+          limitNum{other.limitNum}, orderBy{other.orderBy} {}
     TableFuncBindData& operator=(const TableFuncBindData& other) = delete;
     virtual ~TableFuncBindData() = default;
 
@@ -46,10 +47,18 @@ struct LBUG_API TableFuncBindData {
         return columnPredicates;
     }
 
+    void setLimitNum(common::row_idx_t limit) { limitNum = limit; }
+    common::row_idx_t getLimitNum() const { return limitNum; }
+
+    void setOrderBy(std::string orderBy) { this->orderBy = orderBy; }
+    std::string getOrderBy() const { return orderBy; }
+
     virtual bool getIgnoreErrorsOption() const;
 
     virtual std::unique_ptr<TableFuncBindData> copy() const;
 
+    virtual std::string getDescription() const { return ""; }
+
     template<class TARGET>
     const TARGET* constPtrCast() const {
         return common::ku_dynamic_cast<const TARGET*>(this);
@@ -63,6 +72,8 @@ struct LBUG_API TableFuncBindData {
 protected:
     std::vector<bool> columnSkips;
     std::vector<storage::ColumnPredicateSet> columnPredicates;
+    common::row_idx_t limitNum = common::INVALID_ROW_IDX;
+    std::string orderBy;
 };
 
 } // namespace function

package/lbug-source/src/include/function/table/simple_table_function.h

@@ -134,6 +134,12 @@ struct FileInfoFunction final {
     static function_set getFunctionSet();
 };
 
+struct DiskSizeInfoFunction final {
+    static constexpr const char* name = "DISK_SIZE_INFO";
+
+    static function_set getFunctionSet();
+};
+
 struct ShowAttachedDatabasesFunction final {
     static constexpr const char* name = "SHOW_ATTACHED_DATABASES";
 

package/lbug-source/src/include/function/table/table_function.h

@@ -133,6 +133,7 @@ using table_func_init_local_t =
 using table_func_init_output_t =
     std::function<std::unique_ptr<TableFuncOutput>(const TableFuncInitOutputInput&)>;
 using table_func_can_parallel_t = std::function<bool()>;
+using table_func_supports_push_down_t = std::function<bool()>;
 using table_func_progress_t = std::function<double(TableFuncSharedState* sharedState)>;
 using table_func_finalize_t =
     std::function<void(const processor::ExecutionContext*, TableFuncSharedState*)>;
@@ -153,6 +154,7 @@ struct LBUG_API TableFunction final : Function {
     table_func_init_local_t initLocalStateFunc = nullptr;
     table_func_init_output_t initOutputFunc = nullptr;
     table_func_can_parallel_t canParallelFunc = [] { return true; };
+    table_func_supports_push_down_t supportsPushDownFunc = [] { return false; };
     table_func_progress_t progressFunc = [](TableFuncSharedState*) { return 0.0; };
     table_func_finalize_t finalizeFunc = [](auto, auto) {};
     table_func_rewrite_t rewriteFunc = nullptr;