lbug 0.12.3-dev.9 → 0.13.1-dev.1

package/lbug-source/src/include/optimizer/count_rel_table_optimizer.h

@@ -0,0 +1,49 @@
+#pragma once
+
+#include "logical_operator_visitor.h"
+#include "planner/operator/logical_plan.h"
+
+namespace lbug {
+namespace main {
+class ClientContext;
+}
+
+namespace optimizer {
+
+/**
+ * This optimizer detects patterns where we're counting all rows from a single rel table
+ * without any filters, and replaces the scan + aggregate with a direct count from table metadata.
+ *
+ * Pattern detected:
+ *   AGGREGATE (COUNT_STAR only, no keys) →
+ *   PROJECTION (empty or pass-through) →
+ *   EXTEND (single rel table) →
+ *   SCAN_NODE_TABLE
+ *
+ * This pattern is replaced with:
+ *   COUNT_REL_TABLE (new operator that directly reads the count from table metadata)
+ */
+class CountRelTableOptimizer : public LogicalOperatorVisitor {
+public:
+    explicit CountRelTableOptimizer(main::ClientContext* context) : context{context} {}
+
+    void rewrite(planner::LogicalPlan* plan);
+
+private:
+    std::shared_ptr<planner::LogicalOperator> visitOperator(
+        const std::shared_ptr<planner::LogicalOperator>& op);
+
+    std::shared_ptr<planner::LogicalOperator> visitAggregateReplace(
+        std::shared_ptr<planner::LogicalOperator> op) override;
+
+    // Check if the aggregate is a simple COUNT(*) with no keys
+    bool isSimpleCountStar(planner::LogicalOperator* op) const;
+
+    // Check if the plan below aggregate matches the pattern for optimization
+    bool canOptimize(planner::LogicalOperator* aggregate) const;
+
+    main::ClientContext* context;
+};
+
+} // namespace optimizer
+} // namespace lbug

package/lbug-source/src/include/optimizer/logical_operator_visitor.h

@@ -39,6 +39,12 @@ protected:
         return op;
     }
 
+    virtual void visitCountRelTable(planner::LogicalOperator* /*op*/) {}
+    virtual std::shared_ptr<planner::LogicalOperator> visitCountRelTableReplace(
+        std::shared_ptr<planner::LogicalOperator> op) {
+        return op;
+    }
+
     virtual void visitDelete(planner::LogicalOperator* /*op*/) {}
     virtual std::shared_ptr<planner::LogicalOperator> visitDeleteReplace(
         std::shared_ptr<planner::LogicalOperator> op) {

package/lbug-source/src/include/optimizer/order_by_push_down_optimizer.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "planner/operator/logical_plan.h"
+
+namespace lbug {
+namespace optimizer {
+
+class OrderByPushDownOptimizer {
+public:
+    void rewrite(planner::LogicalPlan* plan);
+
+private:
+    std::shared_ptr<planner::LogicalOperator> visitOperator(
+        std::shared_ptr<planner::LogicalOperator> op, std::string currentOrderBy = "");
+
+    static std::string buildOrderByString(const binder::expression_vector& expressions,
+        const std::vector<bool>& isAscOrders);
+};
+
+} // namespace optimizer
+} // namespace lbug

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/planner/operator/logical_operator.h

@@ -17,6 +17,7 @@ enum class LogicalOperatorType : uint8_t {
     ATTACH_DATABASE,
     COPY_FROM,
     COPY_TO,
+    COUNT_REL_TABLE,
     CREATE_MACRO,
     CREATE_SEQUENCE,
     CREATE_TABLE,

package/lbug-source/src/include/planner/operator/logical_table_function_call.h

@@ -27,11 +27,18 @@ public:
     void setColumnPredicates(std::vector<storage::ColumnPredicateSet> predicates) {
         bindData->setColumnPredicates(std::move(predicates));
     }
+    void setLimitNum(common::row_idx_t limit) { bindData->setLimitNum(limit); }
+    void setOrderBy(std::string orderBy) { bindData->setOrderBy(orderBy); }
 
     void computeFlatSchema() override;
     void computeFactorizedSchema() override;
 
-    std::string getExpressionsForPrinting() const override { return tableFunc.name; }
+    std::string getExpressionsForPrinting() const override {
+        auto desc = bindData->getDescription();
+        return desc.empty() ? tableFunc.name : desc;
+    }
+
+    std::unique_ptr<OPPrintInfo> getPrintInfo() const override;
 
     std::unique_ptr<LogicalOperator> copy() override {
         return std::make_unique<LogicalTableFunctionCall>(tableFunc, bindData->copy());
@@ -42,5 +49,11 @@ private:
     std::unique_ptr<function::TableFuncBindData> bindData;
 };
 
+struct LogicalTableFunctionCallPrintInfo final : OPPrintInfo {
+    std::string desc;
+    explicit LogicalTableFunctionCallPrintInfo(std::string desc) : desc{std::move(desc)} {}
+    std::string toString() const override { return desc; }
+};
+
 } // namespace planner
 } // namespace lbug

package/lbug-source/src/include/planner/operator/scan/logical_count_rel_table.h

@@ -0,0 +1,84 @@
+#pragma once
+
+#include "binder/expression/expression.h"
+#include "binder/expression/node_expression.h"
+#include "catalog/catalog_entry/rel_group_catalog_entry.h"
+#include "common/enums/extend_direction.h"
+#include "planner/operator/logical_operator.h"
+
+namespace lbug {
+namespace planner {
+
+struct LogicalCountRelTablePrintInfo final : OPPrintInfo {
+    std::string relTableName;
+    std::shared_ptr<binder::Expression> countExpr;
+
+    LogicalCountRelTablePrintInfo(std::string relTableName,
+        std::shared_ptr<binder::Expression> countExpr)
+        : relTableName{std::move(relTableName)}, countExpr{std::move(countExpr)} {}
+
+    std::string toString() const override {
+        return "Table: " + relTableName + ", Count: " + countExpr->toString();
+    }
+
+    std::unique_ptr<OPPrintInfo> copy() const override {
+        return std::make_unique<LogicalCountRelTablePrintInfo>(relTableName, countExpr);
+    }
+};
+
+/**
+ * LogicalCountRelTable is an optimized operator that counts the number of rows
+ * in a rel table by scanning through bound nodes and counting edges.
+ *
+ * This operator is created by CountRelTableOptimizer when it detects:
+ *   COUNT(*) over a single rel table with no filters
+ */
+class LogicalCountRelTable final : public LogicalOperator {
+    static constexpr LogicalOperatorType type_ = LogicalOperatorType::COUNT_REL_TABLE;
+
+public:
+    LogicalCountRelTable(catalog::RelGroupCatalogEntry* relGroupEntry,
+        std::vector<common::table_id_t> relTableIDs,
+        std::vector<common::table_id_t> boundNodeTableIDs,
+        std::shared_ptr<binder::NodeExpression> boundNode, common::ExtendDirection direction,
+        std::shared_ptr<binder::Expression> countExpr)
+        : LogicalOperator{type_}, relGroupEntry{relGroupEntry}, relTableIDs{std::move(relTableIDs)},
+          boundNodeTableIDs{std::move(boundNodeTableIDs)}, boundNode{std::move(boundNode)},
+          direction{direction}, countExpr{std::move(countExpr)} {
+        cardinality = 1; // Always returns exactly one row
+    }
+
+    void computeFactorizedSchema() override;
+    void computeFlatSchema() override;
+
+    std::string getExpressionsForPrinting() const override { return countExpr->toString(); }
+
+    catalog::RelGroupCatalogEntry* getRelGroupEntry() const { return relGroupEntry; }
+    const std::vector<common::table_id_t>& getRelTableIDs() const { return relTableIDs; }
+    const std::vector<common::table_id_t>& getBoundNodeTableIDs() const {
+        return boundNodeTableIDs;
+    }
+    std::shared_ptr<binder::NodeExpression> getBoundNode() const { return boundNode; }
+    common::ExtendDirection getDirection() const { return direction; }
+    std::shared_ptr<binder::Expression> getCountExpr() const { return countExpr; }
+
+    std::unique_ptr<OPPrintInfo> getPrintInfo() const override {
+        return std::make_unique<LogicalCountRelTablePrintInfo>(relGroupEntry->getName(), countExpr);
+    }
+
+    std::unique_ptr<LogicalOperator> copy() override {
+        return std::make_unique<LogicalCountRelTable>(relGroupEntry, relTableIDs, boundNodeTableIDs,
+            boundNode, direction, countExpr);
+    }
+
+private:
+    catalog::RelGroupCatalogEntry* relGroupEntry;
+    std::vector<common::table_id_t> relTableIDs;
+    std::vector<common::table_id_t> boundNodeTableIDs;
+    std::shared_ptr<binder::NodeExpression> boundNode;
+    common::ExtendDirection direction;
+    std::shared_ptr<binder::Expression> countExpr;
+};
+
+} // namespace planner
+} // namespace lbug

package/lbug-source/src/include/processor/operator/physical_operator.h

@@ -22,6 +22,7 @@ enum class PhysicalOperatorType : uint8_t {
     ATTACH_DATABASE,
     BATCH_INSERT,
     COPY_TO,
+    COUNT_REL_TABLE,
     CREATE_MACRO,
     CREATE_SEQUENCE,
     CREATE_TABLE,

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

@@ -0,0 +1,62 @@
+#pragma once
+
+#include "common/enums/rel_direction.h"
+#include "processor/operator/physical_operator.h"
+#include "storage/table/node_table.h"
+#include "storage/table/rel_table.h"
+
+namespace lbug {
+namespace processor {
+
+struct CountRelTablePrintInfo final : OPPrintInfo {
+    std::string relTableName;
+
+    explicit CountRelTablePrintInfo(std::string relTableName)
+        : relTableName{std::move(relTableName)} {}
+
+    std::string toString() const override { return "Table: " + relTableName; }
+
+    std::unique_ptr<OPPrintInfo> copy() const override {
+        return std::make_unique<CountRelTablePrintInfo>(relTableName);
+    }
+};
+
+/**
+ * CountRelTable is a source operator that counts edges in a rel table
+ * by scanning through all bound nodes and counting their edges.
+ * It creates its own internal vectors for node scanning (not exposed in ResultSet).
+ */
+class CountRelTable final : public PhysicalOperator {
+    static constexpr PhysicalOperatorType type_ = PhysicalOperatorType::COUNT_REL_TABLE;
+
+public:
+    CountRelTable(std::vector<storage::NodeTable*> nodeTables,
+        std::vector<storage::RelTable*> relTables, common::RelDataDirection direction,
+        DataPos countOutputPos, physical_op_id id, std::unique_ptr<OPPrintInfo> printInfo)
+        : PhysicalOperator{type_, id, std::move(printInfo)}, nodeTables{std::move(nodeTables)},
+          relTables{std::move(relTables)}, direction{direction}, countOutputPos{countOutputPos} {}
+
+    bool isSource() const override { return true; }
+    bool isParallel() const override { return false; }
+
+    void initLocalStateInternal(ResultSet* resultSet, ExecutionContext* context) override;
+
+    bool getNextTuplesInternal(ExecutionContext* context) override;
+
+    std::unique_ptr<PhysicalOperator> copy() override {
+        return std::make_unique<CountRelTable>(nodeTables, relTables, direction, countOutputPos, id,
+            printInfo->copy());
+    }
+
+private:
+    std::vector<storage::NodeTable*> nodeTables;
+    std::vector<storage::RelTable*> relTables;
+    common::RelDataDirection direction;
+    DataPos countOutputPos;
+    common::ValueVector* countVector;
+    bool hasExecuted;
+    common::row_idx_t totalCount;
+};
+
+} // namespace processor
+} // namespace lbug

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/processor/plan_mapper.h

@@ -90,6 +90,8 @@ public:
     std::unique_ptr<PhysicalOperator> mapCopyRelFrom(
         const planner::LogicalOperator* logicalOperator);
     std::unique_ptr<PhysicalOperator> mapCopyTo(const planner::LogicalOperator* logicalOperator);
+    std::unique_ptr<PhysicalOperator> mapCountRelTable(
+        const planner::LogicalOperator* logicalOperator);
     std::unique_ptr<PhysicalOperator> mapCreateMacro(
         const planner::LogicalOperator* logicalOperator);
     std::unique_ptr<PhysicalOperator> mapCreateSequence(

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/storage_version_info.h

@@ -13,7 +13,7 @@ using storage_version_t = uint64_t;
 
 struct StorageVersionInfo {
     static std::unordered_map<std::string, storage_version_t> getStorageVersionInfo() {
-        return {{"0.12.0", 40}, {"0.12.2", 40}};
+        return {{"0.12.0", 40}, {"0.12.2", 40}, {"0.13.0", 40}};
     }
 
     static LBUG_API storage_version_t getStorageVersion();

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/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,

package/lbug-source/src/optimizer/CMakeLists.txt

@@ -4,6 +4,7 @@ add_library(lbug_optimizer
         agg_key_dependency_optimizer.cpp
         cardinality_updater.cpp
         correlated_subquery_unnest_solver.cpp
+        count_rel_table_optimizer.cpp
         factorization_rewriter.cpp
         filter_push_down_optimizer.cpp
         logical_operator_collector.cpp
@@ -14,7 +15,8 @@ add_library(lbug_optimizer
         remove_factorization_rewriter.cpp
         remove_unnecessary_join_optimizer.cpp
         top_k_optimizer.cpp
-        limit_push_down_optimizer.cpp)
+        limit_push_down_optimizer.cpp
+        order_by_push_down_optimizer.cpp)
 
 set(ALL_OBJECT_FILES
         ${ALL_OBJECT_FILES} $<TARGET_OBJECTS:lbug_optimizer>