lbug 0.12.3-dev.2 → 0.12.3-dev.20

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,13 +13,7 @@ using storage_version_t = uint64_t;
 
 struct StorageVersionInfo {
     static std::unordered_map<std::string, storage_version_t> getStorageVersionInfo() {
-        return {{"0.11.1", 39}, {"0.11.0", 39}, {"0.10.0", 38}, {"0.9.0", 37}, {"0.8.0", 36},
-            {"0.7.1.1", 35}, {"0.7.0", 34}, {"0.6.0.6", 33}, {"0.6.0.5", 32}, {"0.6.0.2", 31},
-            {"0.6.0.1", 31}, {"0.6.0", 28}, {"0.5.0", 28}, {"0.4.2", 27}, {"0.4.1", 27},
-            {"0.4.0", 27}, {"0.3.2", 26}, {"0.3.1", 26}, {"0.3.0", 26}, {"0.2.1", 25},
-            {"0.2.0", 25}, {"0.1.0", 24}, {"0.0.12.3", 24}, {"0.0.12.2", 24}, {"0.0.12.1", 24},
-            {"0.0.12", 23}, {"0.0.11", 23}, {"0.0.10", 23}, {"0.0.9", 23}, {"0.0.8", 17},
-            {"0.0.7", 15}, {"0.0.6", 9}, {"0.0.5", 8}, {"0.0.4", 7}, {"0.0.3", 1}};
+        return {{"0.12.0", 40}, {"0.12.2", 40}};
     }
 
     static LBUG_API storage_version_t getStorageVersion();

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/main/query_result/materialized_query_result.cpp

@@ -79,8 +79,8 @@ std::string MaterializedQueryResult::toString() const {
     result += "\n";
     auto tuple_ = FlatTuple(this->columnTypes);
     auto iterator_ = FactorizedTableIterator(*table);
-    while (iterator->hasNext()) {
-        iterator->getNext(tuple_);
+    while (iterator_.hasNext()) {
+        iterator_.getNext(tuple_);
         result += tuple_.toString();
     }
     return result;

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

package/lbug-source/src/optimizer/count_rel_table_optimizer.cpp

@@ -0,0 +1,217 @@
+#include "optimizer/count_rel_table_optimizer.h"
+
+#include "binder/expression/aggregate_function_expression.h"
+#include "binder/expression/node_expression.h"
+#include "catalog/catalog_entry/node_table_id_pair.h"
+#include "function/aggregate/count_star.h"
+#include "main/client_context.h"
+#include "planner/operator/extend/logical_extend.h"
+#include "planner/operator/logical_aggregate.h"
+#include "planner/operator/logical_projection.h"
+#include "planner/operator/scan/logical_count_rel_table.h"
+#include "planner/operator/scan/logical_scan_node_table.h"
+
+using namespace lbug::common;
+using namespace lbug::planner;
+using namespace lbug::binder;
+using namespace lbug::catalog;
+
+namespace lbug {
+namespace optimizer {
+
+void CountRelTableOptimizer::rewrite(LogicalPlan* plan) {
+    visitOperator(plan->getLastOperator());
+}
+
+std::shared_ptr<LogicalOperator> CountRelTableOptimizer::visitOperator(
+    const std::shared_ptr<LogicalOperator>& op) {
+    // bottom-up traversal
+    for (auto i = 0u; i < op->getNumChildren(); ++i) {
+        op->setChild(i, visitOperator(op->getChild(i)));
+    }
+    auto result = visitOperatorReplaceSwitch(op);
+    result->computeFlatSchema();
+    return result;
+}
+
+bool CountRelTableOptimizer::isSimpleCountStar(LogicalOperator* op) const {
+    if (op->getOperatorType() != LogicalOperatorType::AGGREGATE) {
+        return false;
+    }
+    auto& aggregate = op->constCast<LogicalAggregate>();
+
+    // Must have no keys (i.e., a simple aggregate without GROUP BY)
+    if (aggregate.hasKeys()) {
+        return false;
+    }
+
+    // Must have exactly one aggregate expression
+    auto aggregates = aggregate.getAggregates();
+    if (aggregates.size() != 1) {
+        return false;
+    }
+
+    // Must be COUNT_STAR
+    auto& aggExpr = aggregates[0];
+    if (aggExpr->expressionType != ExpressionType::AGGREGATE_FUNCTION) {
+        return false;
+    }
+    auto& aggFuncExpr = aggExpr->constCast<AggregateFunctionExpression>();
+    if (aggFuncExpr.getFunction().name != function::CountStarFunction::name) {
+        return false;
+    }
+
+    // COUNT_STAR should not be DISTINCT (conceptually it doesn't make sense)
+    if (aggFuncExpr.isDistinct()) {
+        return false;
+    }
+
+    return true;
+}
+
+bool CountRelTableOptimizer::canOptimize(LogicalOperator* aggregate) const {
+    // Pattern we're looking for:
+    // AGGREGATE (COUNT_STAR, no keys)
+    //   -> PROJECTION (empty expressions or pass-through)
+    //      -> EXTEND (single rel table, no properties scanned)
+    //         -> SCAN_NODE_TABLE (no properties scanned)
+    //
+    // Note: The projection between aggregate and extend might be empty or
+    // just projecting the count expression.
+
+    auto* current = aggregate->getChild(0).get();
+
+    // Skip any projections (they should be empty or just for count)
+    while (current->getOperatorType() == LogicalOperatorType::PROJECTION) {
+        auto& proj = current->constCast<LogicalProjection>();
+        // Empty projection is okay, it's just a passthrough
+        if (!proj.getExpressionsToProject().empty()) {
+            // If projection has expressions, they should all be aggregate expressions
+            // (which means they're just passing through the count)
+            for (auto& expr : proj.getExpressionsToProject()) {
+                if (expr->expressionType != ExpressionType::AGGREGATE_FUNCTION) {
+                    return false;
+                }
+            }
+        }
+        current = current->getChild(0).get();
+    }
+
+    // Now we should have EXTEND
+    if (current->getOperatorType() != LogicalOperatorType::EXTEND) {
+        return false;
+    }
+    auto& extend = current->constCast<LogicalExtend>();
+
+    // Don't optimize for undirected edges (BOTH direction) - the query pattern
+    // (a)-[e]-(b) generates a plan that scans both directions, and optimizing
+    // this would require special handling to avoid double counting.
+    if (extend.getDirection() == ExtendDirection::BOTH) {
+        return false;
+    }
+
+    // The rel should be a single table (not multi-labeled)
+    auto rel = extend.getRel();
+    if (rel->isMultiLabeled()) {
+        return false;
+    }
+
+    // Check if we're scanning any properties (we can only optimize when no properties needed)
+    if (!extend.getProperties().empty()) {
+        return false;
+    }
+
+    // The child of extend should be SCAN_NODE_TABLE
+    auto* extendChild = current->getChild(0).get();
+    if (extendChild->getOperatorType() != LogicalOperatorType::SCAN_NODE_TABLE) {
+        return false;
+    }
+    auto& scanNode = extendChild->constCast<LogicalScanNodeTable>();
+
+    // Check if node scan has any properties (we can only optimize when no properties needed)
+    if (!scanNode.getProperties().empty()) {
+        return false;
+    }
+
+    return true;
+}
+
+std::shared_ptr<LogicalOperator> CountRelTableOptimizer::visitAggregateReplace(
+    std::shared_ptr<LogicalOperator> op) {
+    if (!isSimpleCountStar(op.get())) {
+        return op;
+    }
+
+    if (!canOptimize(op.get())) {
+        return op;
+    }
+
+    // Find the EXTEND operator
+    auto* current = op->getChild(0).get();
+    while (current->getOperatorType() == LogicalOperatorType::PROJECTION) {
+        current = current->getChild(0).get();
+    }
+
+    KU_ASSERT(current->getOperatorType() == LogicalOperatorType::EXTEND);
+    auto& extend = current->constCast<LogicalExtend>();
+    auto rel = extend.getRel();
+    auto boundNode = extend.getBoundNode();
+    auto nbrNode = extend.getNbrNode();
+
+    // Get the rel group entry
+    KU_ASSERT(rel->getNumEntries() == 1);
+    auto* relGroupEntry = rel->getEntry(0)->ptrCast<RelGroupCatalogEntry>();
+
+    // Determine the source and destination node table IDs based on extend direction.
+    // If extendFromSource is true, then boundNode is the source and nbrNode is the destination.
+    // If extendFromSource is false, then boundNode is the destination and nbrNode is the source.
+    auto boundNodeTableIDs = boundNode->getTableIDsSet();
+    auto nbrNodeTableIDs = nbrNode->getTableIDsSet();
+
+    // Get only the rel table IDs that match the specific node table ID pairs in the query.
+    // A rel table connects a specific (srcTableID, dstTableID) pair.
+    std::vector<table_id_t> relTableIDs;
+    for (auto& info : relGroupEntry->getRelEntryInfos()) {
+        table_id_t srcTableID = info.nodePair.srcTableID;
+        table_id_t dstTableID = info.nodePair.dstTableID;
+
+        bool matches = false;
+        if (extend.extendFromSourceNode()) {
+            // boundNode is src, nbrNode is dst
+            matches =
+                boundNodeTableIDs.contains(srcTableID) && nbrNodeTableIDs.contains(dstTableID);
+        } else {
+            // boundNode is dst, nbrNode is src
+            matches =
+                boundNodeTableIDs.contains(dstTableID) && nbrNodeTableIDs.contains(srcTableID);
+        }
+
+        if (matches) {
+            relTableIDs.push_back(info.oid);
+        }
+    }
+
+    // If no matching rel tables, don't optimize (shouldn't happen for valid queries)
+    if (relTableIDs.empty()) {
+        return op;
+    }
+
+    // Get the count expression from the original aggregate
+    auto& aggregate = op->constCast<LogicalAggregate>();
+    auto countExpr = aggregate.getAggregates()[0];
+
+    // Get the bound node table IDs as a vector
+    std::vector<table_id_t> boundNodeTableIDsVec(boundNodeTableIDs.begin(),
+        boundNodeTableIDs.end());
+
+    // Create the new COUNT_REL_TABLE operator with all necessary information for scanning
+    auto countRelTable =
+        std::make_shared<LogicalCountRelTable>(relGroupEntry, std::move(relTableIDs),
+            std::move(boundNodeTableIDsVec), boundNode, extend.getDirection(), countExpr);
+    countRelTable->computeFlatSchema();
+
+    return countRelTable;
+}
+
+} // namespace optimizer
+} // namespace lbug

package/lbug-source/src/optimizer/logical_operator_visitor.cpp

@@ -19,6 +19,9 @@ void LogicalOperatorVisitor::visitOperatorSwitch(LogicalOperator* op) {
     case LogicalOperatorType::COPY_TO: {
         visitCopyTo(op);
     } break;
+    case LogicalOperatorType::COUNT_REL_TABLE: {
+        visitCountRelTable(op);
+    } break;
     case LogicalOperatorType::DELETE: {
         visitDelete(op);
     } break;
@@ -108,6 +111,9 @@ std::shared_ptr<LogicalOperator> LogicalOperatorVisitor::visitOperatorReplaceSwi
     case LogicalOperatorType::COPY_TO: {
         return visitCopyToReplace(op);
     }
+    case LogicalOperatorType::COUNT_REL_TABLE: {
+        return visitCountRelTableReplace(op);
+    }
     case LogicalOperatorType::DELETE: {
         return visitDeleteReplace(op);
     }

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

@@ -5,6 +5,7 @@
 #include "optimizer/agg_key_dependency_optimizer.h"
 #include "optimizer/cardinality_updater.h"
 #include "optimizer/correlated_subquery_unnest_solver.h"
+#include "optimizer/count_rel_table_optimizer.h"
 #include "optimizer/factorization_rewriter.h"
 #include "optimizer/filter_push_down_optimizer.h"
 #include "optimizer/limit_push_down_optimizer.h"
@@ -32,6 +33,11 @@ void Optimizer::optimize(planner::LogicalPlan* plan, main::ClientContext* contex
         auto removeUnnecessaryJoinOptimizer = RemoveUnnecessaryJoinOptimizer();
         removeUnnecessaryJoinOptimizer.rewrite(plan);
 
+        // CountRelTableOptimizer should be applied early before other optimizations
+        // that might change the plan structure.
+        auto countRelTableOptimizer = CountRelTableOptimizer(context);
+        countRelTableOptimizer.rewrite(plan);
+
         auto filterPushDownOptimizer = FilterPushDownOptimizer(context);
         filterPushDownOptimizer.rewrite(plan);
 

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

@@ -81,7 +81,12 @@ std::unique_ptr<Statement> Transformer::transformCreateNodeTable(
     } else {
         createTableInfo.propertyDefinitions =
             transformPropertyDefinitions(*ctx.kU_PropertyDefinitions());
-        createTableInfo.extraInfo = std::make_unique<ExtraCreateNodeTableInfo>(getPKName(ctx));
+        options_t options;
+        if (ctx.kU_Options()) {
+            options = transformOptions(*ctx.kU_Options());
+        }
+        createTableInfo.extraInfo =
+            std::make_unique<ExtraCreateNodeTableInfo>(getPKName(ctx), std::move(options));
         return std::make_unique<CreateTable>(std::move(createTableInfo));
     }
 }

package/lbug-source/src/planner/operator/logical_operator.cpp

@@ -22,6 +22,8 @@ std::string LogicalOperatorUtils::logicalOperatorTypeToString(LogicalOperatorTyp
         return "COPY_FROM";
     case LogicalOperatorType::COPY_TO:
         return "COPY_TO";
+    case LogicalOperatorType::COUNT_REL_TABLE:
+        return "COUNT_REL_TABLE";
     case LogicalOperatorType::CREATE_MACRO:
         return "CREATE_MACRO";
     case LogicalOperatorType::CREATE_SEQUENCE: