lbug 0.12.3-dev.29 → 0.12.3-dev.30

package/lbug-source/CMakeLists.txt

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

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

@@ -896,7 +896,7 @@ oC_PropertyExpression
     : oC_Atom SP? oC_PropertyLookup ;
 
 oC_PropertyKeyName
-    : oC_SchemaName ;
+    : oC_SymbolicName ;
 
 oC_IntegerLiteral
     : DecimalInteger ;
@@ -956,7 +956,7 @@ RegularDecimalReal
     : ( Digit )* '.' ( Digit )+ ;
 
 oC_SchemaName
-    : oC_SymbolicName ;
+    : oC_SymbolicName ( '.' oC_SymbolicName )? ;
 
 oC_SymbolicName
     : UnescapedSymbolicName

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

@@ -1 +1 @@
-d606604ea3991978c8b514d4ac36b8f6
+3f763bc647d64c15286c2616518546df

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

@@ -649,7 +649,7 @@ oC_PropertyExpression
     : oC_Atom SP? oC_PropertyLookup ;
 
 oC_PropertyKeyName
-    : oC_SchemaName ;
+    : oC_SymbolicName ;
 
 oC_IntegerLiteral
     : DecimalInteger ;
@@ -709,7 +709,7 @@ RegularDecimalReal
     : ( Digit )* '.' ( Digit )+ ;
 
 oC_SchemaName
-    : oC_SymbolicName ;
+    : oC_SymbolicName ( '.' oC_SymbolicName )? ;
 
 oC_SymbolicName
     : UnescapedSymbolicName

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

@@ -1,3 +1,5 @@
+#include <optional>
+
 #include "binder/binder.h"
 #include "binder/ddl/bound_alter.h"
 #include "binder/ddl/bound_create_sequence.h"
@@ -16,7 +18,9 @@
 #include "common/types/types.h"
 #include "function/cast/functions/cast_from_string_functions.h"
 #include "function/sequence/sequence_functions.h"
+#include "function/table/table_function.h"
 #include "main/client_context.h"
+#include "main/database_manager.h"
 #include "parser/ddl/alter.h"
 #include "parser/ddl/create_sequence.h"
 #include "parser/ddl/create_table.h"
@@ -137,7 +141,8 @@ BoundCreateTableInfo Binder::bindCreateTableInfo(const CreateTableInfo* info) {
 }
 
 void Binder::validateNodeTableType(const TableCatalogEntry* entry) {
-    if (entry->getType() != CatalogEntryType::NODE_TABLE_ENTRY) {
+    if (entry->getType() != CatalogEntryType::NODE_TABLE_ENTRY &&
+        entry->getType() != CatalogEntryType::FOREIGN_TABLE_ENTRY) {
         throw BinderException(stringFormat("{} is not of type NODE.", entry->getName()));
     }
 }
@@ -203,15 +208,81 @@ BoundCreateTableInfo Binder::bindCreateRelTableGroupInfo(const CreateTableInfo*
     auto boundOptions = bindParsingOptions(extraInfo.options);
     auto storageDirection = getStorageDirection(boundOptions);
     auto storage = getStorage(boundOptions);
+    std::optional<function::TableFunction> scanFunction = std::nullopt;
+    std::optional<std::unique_ptr<function::TableFuncBindData>> scanBindData = std::nullopt;
+    if (!storage.empty()) {
+        auto dotPos = storage.find('.');
+        if (dotPos != std::string::npos) {
+            // schema.table format, check if it's a foreign table
+            std::string dbName = storage.substr(0, dotPos);
+            std::string tableName = storage.substr(dotPos + 1);
+            auto transaction = transaction::Transaction::Get(*clientContext);
+            if (!dbName.empty()) {
+                auto attachedDB =
+                    main::DatabaseManager::Get(*clientContext)->getAttachedDatabase(dbName);
+                if (attachedDB && attachedDB->getCatalog()->containsTable(transaction, tableName,
+                                      clientContext->useInternalCatalogEntry())) {
+                    auto tableEntry = attachedDB->getCatalog()->getTableCatalogEntry(transaction,
+                        tableName, clientContext->useInternalCatalogEntry());
+                    if (tableEntry->getType() == CatalogEntryType::FOREIGN_TABLE_ENTRY) {
+                        scanFunction = tableEntry->getScanFunction();
+                        auto boundScanInfo =
+                            tableEntry->getBoundScanInfo(clientContext, "" /* nodeUniqueName */);
+                        scanBindData = std::move(boundScanInfo->bindData);
+                    }
+                }
+            }
+        }
+    }
     // Bind from to pairs
     node_table_id_pair_set_t nodePairsSet;
     std::vector<NodeTableIDPair> nodePairs;
+    std::string foreignDatabaseName;
+    std::string foreignDatabaseType;
     for (auto& [srcTableName, dstTableName] : extraInfo.srcDstTablePairs) {
         auto srcEntry = bindNodeTableEntry(srcTableName);
         validateNodeTableType(srcEntry);
         auto dstEntry = bindNodeTableEntry(dstTableName);
         validateNodeTableType(dstEntry);
-        NodeTableIDPair pair{srcEntry->getTableID(), dstEntry->getTableID()};
+
+        // For foreign-backed rel tables, validate that FROM and TO are from same database
+        if (scanFunction.has_value()) {
+            // Both must be foreign tables
+            if (srcEntry->getType() != CatalogEntryType::FOREIGN_TABLE_ENTRY ||
+                dstEntry->getType() != CatalogEntryType::FOREIGN_TABLE_ENTRY) {
+                throw BinderException("Foreign-backed rel tables require both FROM and TO tables "
+                                      "to be foreign tables.");
+            }
+            // Extract database names from qualified table names
+            auto srcDotPos = srcTableName.find('.');
+            auto dstDotPos = dstTableName.find('.');
+            if (srcDotPos == std::string::npos || dstDotPos == std::string::npos) {
+                throw BinderException(
+                    "Foreign-backed rel tables require qualified table names (database.table).");
+            }
+            auto srcDbName = srcTableName.substr(0, srcDotPos);
+            auto dstDbName = dstTableName.substr(0, dstDotPos);
+            if (srcDbName != dstDbName) {
+                throw BinderException(
+                    stringFormat("Cannot create rel table with FROM and TO tables from different "
+                                 "databases. FROM is from '{}', TO is from '{}'.",
+                        srcDbName, dstDbName));
+            }
+            // Get database type for display
+            auto attachedDB =
+                main::DatabaseManager::Get(*clientContext)->getAttachedDatabase(srcDbName);
+            if (attachedDB) {
+                foreignDatabaseName = stringFormat("{}({})", srcDbName, attachedDB->getDBType());
+            }
+        }
+
+        // For foreign-backed rel tables, use FOREIGN_TABLE_ID since we don't reference local node
+        // tables
+        auto srcTableID =
+            scanFunction.has_value() ? common::FOREIGN_TABLE_ID : srcEntry->getTableID();
+        auto dstTableID =
+            scanFunction.has_value() ? common::FOREIGN_TABLE_ID : dstEntry->getTableID();
+        NodeTableIDPair pair{srcTableID, dstTableID};
         if (nodePairsSet.contains(pair)) {
             throw BinderException(
                 stringFormat("Found duplicate FROM-TO {}-{} pairs.", srcTableName, dstTableName));
@@ -221,7 +292,8 @@ BoundCreateTableInfo Binder::bindCreateRelTableGroupInfo(const CreateTableInfo*
     }
     auto boundExtraInfo = std::make_unique<BoundExtraCreateRelTableGroupInfo>(
         std::move(propertyDefinitions), srcMultiplicity, dstMultiplicity, storageDirection,
-        std::move(nodePairs), std::move(storage));
+        std::move(nodePairs), std::move(storage), std::move(scanFunction), std::move(scanBindData),
+        std::move(foreignDatabaseName));
     return BoundCreateTableInfo(CatalogEntryType::REL_GROUP_ENTRY, info->tableName,
         info->onConflict, std::move(boundExtraInfo), clientContext->useInternalCatalogEntry());
 }

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

@@ -192,7 +192,8 @@ CatalogEntry* Catalog::createRelGroupEntry(Transaction* transaction,
     }
     auto relGroupEntry = std::make_unique<RelGroupCatalogEntry>(info.tableName,
         extraInfo->srcMultiplicity, extraInfo->dstMultiplicity, extraInfo->storageDirection,
-        std::move(relTableInfos), extraInfo->storage);
+        std::move(relTableInfos), extraInfo->storage, extraInfo->scanFunction,
+        std::move(extraInfo->scanBindData), extraInfo->foreignDatabaseName);
     for (auto& definition : extraInfo->propertyDefinitions) {
         relGroupEntry->addProperty(definition);
     }

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

@@ -74,7 +74,10 @@ const RelTableCatalogInfo* RelGroupCatalogEntry::getRelEntryInfo(table_id_t srcT
 std::unordered_set<table_id_t> RelGroupCatalogEntry::getSrcNodeTableIDSet() const {
     std::unordered_set<table_id_t> result;
     for (auto& info : relTableInfos) {
-        result.insert(info.nodePair.srcTableID);
+        // Skip FOREIGN_TABLE_ID for foreign-backed rel tables
+        if (info.nodePair.srcTableID != FOREIGN_TABLE_ID) {
+            result.insert(info.nodePair.srcTableID);
+        }
     }
     return result;
 }
@@ -82,7 +85,10 @@ std::unordered_set<table_id_t> RelGroupCatalogEntry::getSrcNodeTableIDSet() cons
 std::unordered_set<table_id_t> RelGroupCatalogEntry::getDstNodeTableIDSet() const {
     std::unordered_set<table_id_t> result;
     for (auto& info : relTableInfos) {
-        result.insert(info.nodePair.dstTableID);
+        // Skip FOREIGN_TABLE_ID for foreign-backed rel tables
+        if (info.nodePair.dstTableID != FOREIGN_TABLE_ID) {
+            result.insert(info.nodePair.dstTableID);
+        }
     }
     return result;
 }
@@ -97,6 +103,11 @@ void RelGroupCatalogEntry::serialize(Serializer& serializer) const {
     serializer.serializeValue(storageDirection);
     serializer.writeDebuggingInfo("storage");
     serializer.serializeValue(storage);
+    serializer.writeDebuggingInfo("scanFunction");
+    serializer.serializeValue(scanFunction.has_value());
+    if (scanFunction.has_value()) {
+        // TODO: serialize TableFunction
+    }
     serializer.writeDebuggingInfo("relTableInfos");
     serializer.serializeVector(relTableInfos);
 }
@@ -117,6 +128,13 @@ std::unique_ptr<RelGroupCatalogEntry> RelGroupCatalogEntry::deserialize(
     deserializer.deserializeValue(storageDirection);
     deserializer.validateDebuggingInfo(debuggingInfo, "storage");
     deserializer.deserializeValue(storage);
+    deserializer.validateDebuggingInfo(debuggingInfo, "scanFunction");
+    bool hasScanFunction;
+    deserializer.deserializeValue(hasScanFunction);
+    std::optional<function::TableFunction> scanFunction = std::nullopt;
+    if (hasScanFunction) {
+        // TODO: deserialize TableFunction
+    }
     deserializer.validateDebuggingInfo(debuggingInfo, "relTableInfos");
     deserializer.deserializeVector(relTableInfos);
     auto relGroupEntry = std::make_unique<RelGroupCatalogEntry>();
@@ -124,14 +142,24 @@ std::unique_ptr<RelGroupCatalogEntry> RelGroupCatalogEntry::deserialize(
     relGroupEntry->dstMultiplicity = dstMultiplicity;
     relGroupEntry->storageDirection = storageDirection;
     relGroupEntry->storage = storage;
+    relGroupEntry->scanFunction = scanFunction;
     relGroupEntry->relTableInfos = relTableInfos;
     return relGroupEntry;
 }
 
 static std::string getFromToStr(const NodeTableIDPair& pair, const Catalog* catalog,
-    const transaction::Transaction* transaction) {
-    auto srcTableName = catalog->getTableCatalogEntry(transaction, pair.srcTableID)->getName();
-    auto dstTableName = catalog->getTableCatalogEntry(transaction, pair.dstTableID)->getName();
+    const transaction::Transaction* transaction, const std::string& storage) {
+    std::string srcTableName, dstTableName;
+    // For foreign-backed rel tables, node table IDs are FOREIGN_TABLE_ID
+    if (pair.srcTableID == common::FOREIGN_TABLE_ID && !storage.empty()) {
+        auto dotPos = storage.find('.');
+        srcTableName =
+            dotPos != std::string::npos ? storage.substr(0, dotPos) + ".nodes" : "foreign_table";
+        dstTableName = srcTableName;
+    } else {
+        srcTableName = catalog->getTableCatalogEntry(transaction, pair.srcTableID)->getName();
+        dstTableName = catalog->getTableCatalogEntry(transaction, pair.dstTableID)->getName();
+    }
     return stringFormat("FROM `{}` TO `{}`", srcTableName, dstTableName);
 }
 
@@ -142,9 +170,10 @@ std::string RelGroupCatalogEntry::toCypher(const ToCypherInfo& info) const {
     std::stringstream ss;
     ss << stringFormat("CREATE REL TABLE `{}` (", getName());
     KU_ASSERT(!relTableInfos.empty());
-    ss << getFromToStr(relTableInfos[0].nodePair, catalog, transaction);
+    ss << getFromToStr(relTableInfos[0].nodePair, catalog, transaction, storage);
     for (auto i = 1u; i < relTableInfos.size(); ++i) {
-        ss << stringFormat(", {}", getFromToStr(relTableInfos[i].nodePair, catalog, transaction));
+        ss << stringFormat(", {}",
+            getFromToStr(relTableInfos[i].nodePair, catalog, transaction, storage));
     }
     ss << ", " << propertyCollection.toCypher() << RelMultiplicityUtils::toString(srcMultiplicity)
        << "_" << RelMultiplicityUtils::toString(dstMultiplicity) << ");";
@@ -174,6 +203,9 @@ std::unique_ptr<TableCatalogEntry> RelGroupCatalogEntry::copy() const {
     other->dstMultiplicity = dstMultiplicity;
     other->storageDirection = storageDirection;
     other->storage = storage;
+    other->scanFunction = scanFunction;
+    other->scanBindData = std::nullopt; // TODO: implement copy for bindData if needed
+    other->foreignDatabaseName = foreignDatabaseName;
     other->relTableInfos = relTableInfos;
     other->copyFrom(*this);
     return other;

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/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 {
@@ -92,20 +96,29 @@ struct BoundExtraCreateRelTableGroupInfo final : BoundExtraCreateTableInfo {
     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,
-        std::string storage = "")
+        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)}, storage{std::move(storage)} {}
+          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},
-          storage{other.storage} {}
+          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/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::string storage = "")
+        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)}, storage{std::move(storage)} {
+          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.
     }
@@ -54,6 +63,11 @@ 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; }
@@ -99,6 +113,9 @@ private:
     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/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/storage/table/foreign_rel_table.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#include "catalog/catalog_entry/rel_group_catalog_entry.h"
+#include "common/exception/runtime.h"
+#include "function/table/table_function.h"
+#include "storage/table/rel_table.h"
+
+namespace lbug {
+namespace storage {
+
+struct ForeignRelTableScanState final : RelTableScanState {
+    std::shared_ptr<function::TableFuncSharedState> sharedState;
+    std::shared_ptr<function::TableFuncLocalState> localState;
+    common::DataChunk dataChunk;
+
+    ForeignRelTableScanState(MemoryManager& mm, common::ValueVector* nodeIDVector,
+        std::vector<common::ValueVector*> outputVectors,
+        std::shared_ptr<common::DataChunkState> outChunkState);
+};
+
+class ForeignRelTable final : public RelTable {
+public:
+    ForeignRelTable(catalog::RelGroupCatalogEntry* relGroupEntry, common::table_id_t fromTableID,
+        common::table_id_t toTableID, const StorageManager* storageManager,
+        MemoryManager* memoryManager, function::TableFunction scanFunction,
+        std::shared_ptr<function::TableFuncBindData> scanBindData);
+
+    void initScanState(transaction::Transaction* transaction, TableScanState& scanState,
+        bool resetCachedBoundNodeSelVec = true) const override;
+
+    bool scanInternal(transaction::Transaction* transaction, TableScanState& scanState) override;
+
+    // For foreign-backed tables, we don't support modifications
+    void insert([[maybe_unused]] transaction::Transaction* transaction,
+        [[maybe_unused]] TableInsertState& insertState) override {
+        throw common::RuntimeException("Cannot insert into foreign-backed rel table");
+    }
+    void update([[maybe_unused]] transaction::Transaction* transaction,
+        [[maybe_unused]] TableUpdateState& updateState) override {
+        throw common::RuntimeException("Cannot update foreign-backed rel table");
+    }
+    bool delete_([[maybe_unused]] transaction::Transaction* transaction,
+        [[maybe_unused]] TableDeleteState& deleteState) override {
+        throw common::RuntimeException("Cannot delete from foreign-backed rel table");
+        return false;
+    }
+
+    common::row_idx_t getNumTotalRows(const transaction::Transaction* transaction) override;
+
+private:
+    function::TableFunction scanFunction;
+    std::shared_ptr<function::TableFuncBindData> scanBindData;
+};
+
+} // namespace storage
+} // namespace lbug

package/lbug-source/src/parser/transform/transform_expression.cpp

@@ -663,7 +663,7 @@ std::unique_ptr<ParsedExpression> Transformer::transformProperty(
 }
 
 std::string Transformer::transformPropertyKeyName(CypherParser::OC_PropertyKeyNameContext& ctx) {
-    return transformSchemaName(*ctx.oC_SchemaName());
+    return transformSymbolicName(*ctx.oC_SymbolicName());
 }
 
 std::unique_ptr<ParsedExpression> Transformer::transformIntegerLiteral(

package/lbug-source/src/parser/transformer.cpp

@@ -88,7 +88,13 @@ std::unique_ptr<ParsedExpression> Transformer::transformWhere(CypherParser::OC_W
 }
 
 std::string Transformer::transformSchemaName(CypherParser::OC_SchemaNameContext& ctx) {
-    return transformSymbolicName(*ctx.oC_SymbolicName());
+    auto symbolicNames = ctx.oC_SymbolicName();
+    if (symbolicNames.size() == 1) {
+        return transformSymbolicName(*symbolicNames[0]);
+    }
+    // Qualified name: db.table
+    return transformSymbolicName(*symbolicNames[0]) + "." +
+           transformSymbolicName(*symbolicNames[1]);
 }
 
 std::string Transformer::transformStringLiteral(antlr4::tree::TerminalNode& stringLiteral) {

package/lbug-source/src/processor/operator/scan/scan_rel_table.cpp

@@ -4,6 +4,7 @@
 #include "processor/execution_context.h"
 #include "storage/buffer_manager/memory_manager.h"
 #include "storage/local_storage/local_rel_table.h"
+#include "storage/table/foreign_rel_table.h"
 #include "storage/table/parquet_rel_table.h"
 
 using namespace lbug::common;
@@ -68,12 +69,17 @@ void ScanRelTable::initLocalStateInternal(ResultSet* resultSet, ExecutionContext
     auto clientContext = context->clientContext;
     auto boundNodeIDVector = resultSet->getValueVector(opInfo.nodeIDPos).get();
     auto nbrNodeIDVector = outVectors[0];
-    // Check if this is a ParquetRelTable and create appropriate scan state
+    // Check if this is a ParquetRelTable or ForeignRelTable and create appropriate scan state
     auto* parquetTable = dynamic_cast<storage::ParquetRelTable*>(tableInfo.table);
+    auto* foreignTable = dynamic_cast<storage::ForeignRelTable*>(tableInfo.table);
     if (parquetTable) {
         scanState =
             std::make_unique<storage::ParquetRelTableScanState>(*MemoryManager::Get(*clientContext),
                 boundNodeIDVector, outVectors, nbrNodeIDVector->state);
+    } else if (foreignTable) {
+        scanState =
+            std::make_unique<storage::ForeignRelTableScanState>(*MemoryManager::Get(*clientContext),
+                boundNodeIDVector, outVectors, nbrNodeIDVector->state);
     } else {
         scanState = std::make_unique<RelTableScanState>(*MemoryManager::Get(*clientContext),
             boundNodeIDVector, outVectors, nbrNodeIDVector->state);

package/lbug-source/src/storage/storage_manager.cpp

@@ -12,6 +12,7 @@
 #include "storage/buffer_manager/buffer_manager.h"
 #include "storage/buffer_manager/memory_manager.h"
 #include "storage/checkpointer.h"
+#include "storage/table/foreign_rel_table.h"
 #include "storage/table/node_table.h"
 #include "storage/table/parquet_node_table.h"
 #include "storage/table/parquet_rel_table.h"
@@ -94,7 +95,12 @@ void StorageManager::createNodeTable(NodeTableCatalogEntry* entry) {
 // rel table. We may have to refactor the existing StorageManager::createTable(TableCatalogEntry*
 // entry).
 void StorageManager::addRelTable(RelGroupCatalogEntry* entry, const RelTableCatalogInfo& info) {
-    if (!entry->getStorage().empty()) {
+    if (entry->getScanFunction().has_value()) {
+        // Create foreign-backed rel table
+        tables[info.oid] = std::make_unique<ForeignRelTable>(entry, info.nodePair.srcTableID,
+            info.nodePair.dstTableID, this, &memoryManager, *entry->getScanFunction(),
+            std::move(entry->getScanBindData().value()));
+    } else if (!entry->getStorage().empty()) {
         // Create parquet-backed rel table
         tables[info.oid] = std::make_unique<ParquetRelTable>(entry, info.nodePair.srcTableID,
             info.nodePair.dstTableID, this, &memoryManager);

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

@@ -13,6 +13,7 @@ add_library(lbug_storage_store
         compression_flush_buffer.cpp
         dictionary_chunk.cpp
         dictionary_column.cpp
+        foreign_rel_table.cpp
         in_mem_chunked_node_group_collection.cpp
         in_memory_exception_chunk.cpp
         lazy_segment_scanner.cpp

package/lbug-source/src/storage/table/foreign_rel_table.cpp

@@ -0,0 +1,63 @@
+#include "storage/table/foreign_rel_table.h"
+
+#include "function/table/table_function.h"
+#include "processor/operator/scan/scan_rel_table.h"
+#include "storage/storage_manager.h"
+#include "transaction/transaction.h"
+
+namespace lbug {
+namespace storage {
+
+ForeignRelTableScanState::ForeignRelTableScanState(MemoryManager& mm,
+    common::ValueVector* nodeIDVector, std::vector<common::ValueVector*> outputVectors,
+    std::shared_ptr<common::DataChunkState> outChunkState)
+    : RelTableScanState{mm, nodeIDVector, std::move(outputVectors), std::move(outChunkState)} {
+    dataChunk.valueVectors.resize(this->outputVectors.size());
+    for (size_t i = 0; i < this->outputVectors.size(); ++i) {
+        dataChunk.valueVectors[i] = std::shared_ptr<common::ValueVector>(this->outputVectors[i],
+            [](common::ValueVector*) {});
+    }
+    dataChunk.state = this->outState;
+}
+
+ForeignRelTable::ForeignRelTable(catalog::RelGroupCatalogEntry* relGroupEntry,
+    common::table_id_t fromTableID, common::table_id_t toTableID,
+    const StorageManager* storageManager, MemoryManager* memoryManager,
+    function::TableFunction scanFunction, std::shared_ptr<function::TableFuncBindData> scanBindData)
+    : RelTable{relGroupEntry, fromTableID, toTableID, storageManager, memoryManager},
+      scanFunction{std::move(scanFunction)}, scanBindData{std::move(scanBindData)} {}
+
+void ForeignRelTable::initScanState([[maybe_unused]] transaction::Transaction* transaction,
+    TableScanState& scanState, [[maybe_unused]] bool resetCachedBoundNodeSelVec) const {
+    // For foreign tables, we don't need node group initialization
+    // RelTable::initScanState(transaction, scanState, resetCachedBoundNodeSelVec);
+    auto& foreignRelScanState = static_cast<ForeignRelTableScanState&>(scanState);
+    function::TableFuncInitSharedStateInput sharedInput{scanBindData.get(), nullptr /* context */};
+    foreignRelScanState.sharedState = scanFunction.initSharedStateFunc(sharedInput);
+    function::TableFuncInitLocalStateInput localInput{*foreignRelScanState.sharedState,
+        *scanBindData, nullptr /* clientContext */};
+    foreignRelScanState.localState = scanFunction.initLocalStateFunc(localInput);
+}
+
+bool ForeignRelTable::scanInternal([[maybe_unused]] transaction::Transaction* transaction,
+    TableScanState& scanState) {
+    auto& foreignRelScanState = static_cast<ForeignRelTableScanState&>(scanState);
+    function::TableFuncInput input{scanBindData.get(), foreignRelScanState.localState.get(),
+        foreignRelScanState.sharedState.get(), nullptr /* clientContext */};
+    common::DataChunk dc;
+    dc.valueVectors = foreignRelScanState.dataChunk.valueVectors;
+    dc.state = foreignRelScanState.dataChunk.state;
+    function::TableFuncOutput output{std::move(dc)};
+    auto numTuples = scanFunction.tableFunc(input, output);
+    return numTuples > 0;
+}
+
+common::row_idx_t ForeignRelTable::getNumTotalRows(
+    [[maybe_unused]] const transaction::Transaction* transaction) {
+    // For foreign tables, we might need to query the foreign table for row count
+    // For now, return 0 or implement proper counting
+    return 0;
+}
+
+} // namespace storage
+} // namespace lbug