lbug 0.12.3-dev.16 → 0.12.3-dev.18

package/lbug-source/CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.15)
 
-project(Lbug VERSION 0.12.3.16 LANGUAGES CXX C)
+project(Lbug VERSION 0.12.3.18 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/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

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

@@ -34,10 +34,10 @@ 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 = "")
         : TableCatalogEntry{type_, std::move(tableName)}, srcMultiplicity{srcMultiplicity},
           dstMultiplicity{dstMultiplicity}, storageDirection{storageDirection},
-          relTableInfos{std::move(relTableInfos)} {
+          relTableInfos{std::move(relTableInfos)}, storage{std::move(storage)} {
         propertyCollection =
             PropertyDefinitionCollection{1}; // Skip NBR_NODE_ID column as the first one.
     }
@@ -53,6 +53,7 @@ public:
     }
 
     common::ExtendDirection getStorageDirection() const { return storageDirection; }
+    const std::string& getStorage() const { return storage; }
 
     common::idx_t getNumRelTables() const { return relTableInfos.size(); }
     const std::vector<RelTableCatalogInfo>& getRelEntryInfos() const { return relTableInfos; }
@@ -97,6 +98,7 @@ private:
     // TODO(Guodong): Avoid using extend direction for storage direction
     common::ExtendDirection storageDirection = common::ExtendDirection::BOTH;
     std::vector<RelTableCatalogInfo> relTableInfos;
+    std::string storage;
 };
 
 } // namespace catalog

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/parser/ddl/create_table_info.h

@@ -36,8 +36,10 @@ struct CreateTableInfo {
 
 struct ExtraCreateNodeTableInfo final : ExtraCreateTableInfo {
     std::string pKName;
+    options_t options;
 
-    explicit ExtraCreateNodeTableInfo(std::string pKName) : pKName{std::move(pKName)} {}
+    explicit ExtraCreateNodeTableInfo(std::string pKName, options_t options = {})
+        : pKName{std::move(pKName)}, options{std::move(options)} {}
 };
 
 struct ExtraCreateRelTableGroupInfo final : ExtraCreateTableInfo {

package/lbug-source/src/include/processor/operator/scan/scan_node_table.h

@@ -24,7 +24,7 @@ public:
     void initialize(const transaction::Transaction* transaction, storage::NodeTable* table,
         ScanNodeTableProgressSharedState& progressSharedState);
 
-    void nextMorsel(storage::NodeTableScanState& scanState,
+    void nextMorsel(storage::TableScanState& scanState,
         ScanNodeTableProgressSharedState& progressSharedState);
 
     common::SemiMask* getSemiMask() const { return semiMask.get(); }
@@ -116,7 +116,7 @@ private:
 
 private:
     common::idx_t currentTableIdx;
-    std::unique_ptr<storage::NodeTableScanState> scanState;
+    std::unique_ptr<storage::TableScanState> scanState;
     std::vector<ScanNodeTableInfo> tableInfos;
     std::vector<std::shared_ptr<ScanNodeTableSharedState>> sharedStates;
     std::shared_ptr<ScanNodeTableProgressSharedState> progressSharedState;

package/lbug-source/src/include/storage/storage_manager.h

@@ -97,6 +97,7 @@ private:
     bool enableCompression;
     bool inMemory;
     std::vector<IndexType> registeredIndexTypes;
+    std::unordered_map<common::table_id_t, std::string> tableNameCache;
 };
 
 } // namespace storage

package/lbug-source/src/include/storage/table/node_table.h

@@ -107,7 +107,7 @@ private:
 
 class StorageManager;
 
-class LBUG_API NodeTable final : public Table {
+class LBUG_API NodeTable : public Table {
 public:
     NodeTable(const StorageManager* storageManager,
         const catalog::NodeTableCatalogEntry* nodeTableEntry, MemoryManager* mm);
@@ -119,6 +119,11 @@ public:
     void initScanState(transaction::Transaction* transaction, TableScanState& scanState,
         common::table_id_t tableID, common::offset_t startOffset) const;
 
+    // Virtual method for operator-level scan coordination initialization
+    // Called once per scan operation (not per scan state)
+    virtual void initializeScanCoordination(
+        [[maybe_unused]] const transaction::Transaction* transaction) {}
+
     bool scanInternal(transaction::Transaction* transaction, TableScanState& scanState) override;
     template<bool lock = true>
     bool lookup(const transaction::Transaction* transaction, const TableScanState& scanState) const;

package/lbug-source/src/include/storage/table/parquet_node_table.h

@@ -0,0 +1,103 @@
+#pragma once
+
+#include <mutex>
+#include <vector>
+
+#include "catalog/catalog_entry/node_table_catalog_entry.h"
+#include "common/exception/runtime.h"
+#include "common/types/internal_id_util.h"
+#include "common/types/value/value.h"
+#include "processor/operator/persistent/reader/parquet/parquet_reader.h"
+#include "storage/table/node_table.h"
+
+namespace lbug {
+namespace storage {
+
+struct ParquetNodeTableScanState final : NodeTableScanState {
+    std::unique_ptr<processor::ParquetReader> parquetReader;
+    std::unique_ptr<processor::ParquetReaderScanState> parquetScanState;
+    bool initialized = false;
+    bool scanCompleted = false; // Track if this scan state has finished reading
+    bool dataRead = false;
+    std::vector<std::vector<std::unique_ptr<common::Value>>> allData;
+    size_t totalRows = 0;
+    size_t nextRowToDistribute = 0;
+    uint64_t lastQueryId = 0; // Track the last query ID to detect new queries
+
+    ParquetNodeTableScanState([[maybe_unused]] MemoryManager& mm, common::ValueVector* nodeIDVector,
+        std::vector<common::ValueVector*> outputVectors,
+        std::shared_ptr<common::DataChunkState> outChunkState)
+        : NodeTableScanState{nodeIDVector, std::move(outputVectors), std::move(outChunkState)} {
+        parquetScanState = std::make_unique<processor::ParquetReaderScanState>();
+    }
+};
+
+// Shared state to coordinate row group assignment across parallel scan states
+struct ParquetNodeTableSharedState {
+    std::mutex mtx;
+    common::node_group_idx_t currentRowGroupIdx = 0;
+    common::node_group_idx_t numRowGroups = 0;
+
+    void reset(common::node_group_idx_t totalRowGroups) {
+        std::lock_guard<std::mutex> lock(mtx);
+        currentRowGroupIdx = 0;
+        numRowGroups = totalRowGroups;
+    }
+
+    bool getNextRowGroup(common::node_group_idx_t& assignedRowGroupIdx) {
+        std::lock_guard<std::mutex> lock(mtx);
+        if (currentRowGroupIdx < numRowGroups) {
+            assignedRowGroupIdx = currentRowGroupIdx++;
+            return true;
+        }
+        return false;
+    }
+};
+
+class ParquetNodeTable final : public NodeTable {
+public:
+    ParquetNodeTable(const StorageManager* storageManager,
+        const catalog::NodeTableCatalogEntry* nodeTableEntry, MemoryManager* memoryManager);
+
+    void initScanState(transaction::Transaction* transaction, TableScanState& scanState,
+        bool resetCachedBoundNodeSelVec = true) const override;
+
+    // Override to reset shared state for row group coordination at the start of each scan operation
+    void initializeScanCoordination(const transaction::Transaction* transaction) override;
+
+    bool scanInternal(transaction::Transaction* transaction, TableScanState& scanState) override;
+
+    // For parquet-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 parquet-backed node table");
+    }
+    void update([[maybe_unused]] transaction::Transaction* transaction,
+        [[maybe_unused]] TableUpdateState& updateState) override {
+        throw common::RuntimeException("Cannot update parquet-backed node table");
+    }
+    bool delete_([[maybe_unused]] transaction::Transaction* transaction,
+        [[maybe_unused]] TableDeleteState& deleteState) override {
+        throw common::RuntimeException("Cannot delete from parquet-backed node table");
+        return false;
+    }
+
+    common::row_idx_t getNumTotalRows(const transaction::Transaction* transaction) override;
+
+    const std::string& getParquetFilePath() const { return parquetFilePath; }
+
+    // Note: Cannot override getNumCommittedNodeGroups since it's not virtual in base class
+    // Will need a different approach
+
+private:
+    std::string parquetFilePath;
+    const catalog::NodeTableCatalogEntry* nodeTableCatalogEntry;
+    mutable std::unique_ptr<ParquetNodeTableSharedState> sharedState;
+
+    void initializeParquetReader(transaction::Transaction* transaction) const;
+    void initParquetScanForRowGroup(transaction::Transaction* transaction,
+        ParquetNodeTableScanState& scanState) const;
+};
+
+} // namespace storage
+} // namespace lbug

package/lbug-source/src/include/storage/table/parquet_rel_table.h

@@ -0,0 +1,91 @@
+#pragma once
+
+#include "catalog/catalog_entry/rel_group_catalog_entry.h"
+#include "common/exception/runtime.h"
+#include "common/types/internal_id_util.h"
+#include "processor/operator/persistent/reader/parquet/parquet_reader.h"
+#include "storage/table/rel_table.h"
+#include "transaction/transaction.h"
+
+namespace lbug {
+namespace storage {
+
+struct ParquetRelTableScanState final : RelTableScanState {
+    std::unique_ptr<processor::ParquetReaderScanState> parquetScanState;
+    // For CSR format: store matching rows for current bound node
+    size_t nextRowToProcess = 0;
+
+    // Row group range for morsel-driven parallelism
+    uint64_t startRowGroup = 0;
+    uint64_t endRowGroup = 0;
+    uint64_t currentRowGroup = 0;
+
+    // Per-scan-state readers for thread safety
+    std::unique_ptr<processor::ParquetReader> indicesReader;
+    std::unique_ptr<processor::ParquetReader> indptrReader;
+
+    ParquetRelTableScanState(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)} {
+        parquetScanState = std::make_unique<processor::ParquetReaderScanState>();
+    }
+
+    void setToTable(const transaction::Transaction* transaction, Table* table_,
+        std::vector<common::column_id_t> columnIDs_,
+        std::vector<ColumnPredicateSet> columnPredicateSets_,
+        common::RelDataDirection direction_) override;
+};
+
+class ParquetRelTable final : public RelTable {
+public:
+    ParquetRelTable(catalog::RelGroupCatalogEntry* relGroupEntry, common::table_id_t fromTableID,
+        common::table_id_t toTableID, const StorageManager* storageManager,
+        MemoryManager* memoryManager);
+
+    void initScanState(transaction::Transaction* transaction, TableScanState& scanState,
+        bool resetCachedBoundNodeSelVec = true) const override;
+
+    bool scanInternal(transaction::Transaction* transaction, TableScanState& scanState) override;
+
+    // For parquet-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 parquet-backed rel table");
+    }
+    void update([[maybe_unused]] transaction::Transaction* transaction,
+        [[maybe_unused]] TableUpdateState& updateState) override {
+        throw common::RuntimeException("Cannot update parquet-backed rel table");
+    }
+    bool delete_([[maybe_unused]] transaction::Transaction* transaction,
+        [[maybe_unused]] TableDeleteState& deleteState) override {
+        throw common::RuntimeException("Cannot delete from parquet-backed rel table");
+        return false;
+    }
+
+    common::row_idx_t getNumTotalRows(const transaction::Transaction* transaction) override;
+
+private:
+    catalog::RelGroupCatalogEntry* relGroupEntry; // Store reference to table schema
+    std::string indicesFilePath;
+    std::string indptrFilePath;
+    mutable std::unique_ptr<processor::ParquetReader> indicesReader;
+    mutable std::unique_ptr<processor::ParquetReader> indptrReader;
+    mutable std::mutex parquetReaderMutex;
+    mutable std::mutex indptrDataMutex;
+    mutable std::vector<common::offset_t> indptrData; // Cached indptr data for CSR format
+
+    void initializeParquetReaders(transaction::Transaction* transaction) const;
+    void initializeIndptrReader(transaction::Transaction* transaction) const;
+    void loadIndptrData(transaction::Transaction* transaction) const;
+    bool scanInternalByRowGroups(transaction::Transaction* transaction,
+        ParquetRelTableScanState& parquetRelScanState);
+    bool scanRowGroupForBoundNodes(transaction::Transaction* transaction,
+        ParquetRelTableScanState& parquetRelScanState,
+        const std::vector<uint64_t>& rowGroupsToProcess,
+        const std::unordered_set<common::offset_t>& boundNodeOffsets);
+    common::offset_t findSourceNodeForRow(common::offset_t globalRowIdx) const;
+};
+
+} // namespace storage
+} // namespace lbug

package/lbug-source/src/include/storage/table/rel_table.h

@@ -48,7 +48,7 @@ struct RelTableScanState : TableScanState {
         nodeGroupScanState = std::make_unique<CSRNodeGroupScanState>();
     }
 
-    void setToTable(const transaction::Transaction* transaction, Table* table_,
+    virtual void setToTable(const transaction::Transaction* transaction, Table* table_,
         std::vector<common::column_id_t> columnIDs_,
         std::vector<ColumnPredicateSet> columnPredicateSets_,
         common::RelDataDirection direction_) override;
@@ -138,7 +138,7 @@ struct LBUG_API RelTableDeleteState final : TableDeleteState {
           relIDVector{relIDVector}, detachDeleteDirection{detachDeleteDirection} {}
 };
 
-class LBUG_API RelTable final : public Table {
+class LBUG_API RelTable : public Table {
 public:
     using rel_multiplicity_constraint_throw_func_t =
         std::function<void(const std::string&, common::offset_t, common::RelDataDirection)>;

package/lbug-source/src/include/transaction/transaction.h

@@ -130,6 +130,8 @@ public:
         return getMinUncommittedNodeOffset(tableID) + localRowIdx;
     }
 
+    main::ClientContext* getClientContext() const { return clientContext; }
+
     void pushCreateDropCatalogEntry(catalog::CatalogSet& catalogSet,
         catalog::CatalogEntry& catalogEntry, bool isInternal, bool skipLoggingToWAL = false);
     void pushAlterCatalogEntry(catalog::CatalogSet& catalogSet, catalog::CatalogEntry& catalogEntry,