lbug 0.12.3-dev.13 → 0.12.3-dev.15

package/lbug-source/.github/workflows/ci-workflow.yml

@@ -1152,6 +1152,9 @@ jobs:
     name: minimal test
     runs-on: ubuntu-latest
     needs: [ sanity-checks ]
+    env:
+      GEN: Ninja
+      USE_STD_FORMAT: 1
     steps:
       - uses: actions/checkout@v4
 
@@ -1159,12 +1162,14 @@ jobs:
         uses: hendrikmuhs/ccache-action@v1.2
         with:
           key: minimal-test-${{ runner.os }}
+          max-size: 2G
+          restore-keys: minimal-test-
 
       - name: Build
-        run: make GEN=Ninja release USE_STD_FORMAT=1
+        run: make relwithdebinfo
 
       - name: Generate datasets
-        run: bash scripts/generate_binary_demo.sh
+        run: bash scripts/generate_binary_demo.sh --lbug-shell-mode relwithdebinfo
 
       - name: Install uv
         run: pip3 install uv
@@ -1210,6 +1215,8 @@ jobs:
         uses: hendrikmuhs/ccache-action@v1.2
         with:
           key: minimal-extension-test-${{ runner.os }}
+          max-size: 2G
+          restore-keys: minimal-extension-test-
 
       - name: Update PostgreSQL host
         working-directory: extension/postgres/test/test_files

package/lbug-source/CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.15)
 
-project(Lbug VERSION 0.12.3.13 LANGUAGES CXX C)
+project(Lbug VERSION 0.12.3.15 LANGUAGES CXX C)
 
 option(SINGLE_THREADED "Single-threaded mode" FALSE)
 if(SINGLE_THREADED)
@@ -14,15 +14,26 @@ endif()
 
 set(CMAKE_CXX_STANDARD 20)
 set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
-set(CMAKE_CXX_VISIBILITY_PRESET hidden)
-set(CMAKE_C_VISIBILITY_PRESET hidden)
 set(CMAKE_EXPORT_COMPILE_COMMANDS TRUE)
 set(CMAKE_FIND_PACKAGE_RESOLVE_SYMLINKS TRUE)
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
-set(CMAKE_VISIBILITY_INLINES_HIDDEN ON)
 # On Linux, symbols in executables are not accessible by loaded shared libraries (e.g. via dlopen(3)). However, we need to export public symbols in executables so that extensions can access public symbols. This enables that behaviour.
 set(CMAKE_ENABLE_EXPORTS TRUE)
 
+# When building tests, we need all symbols visible so tests can link to the shared library
+# instead of static linking (which bloats binary sizes significantly)
+option(BUILD_TESTS "Build C++ tests." FALSE)
+option(BUILD_EXTENSION_TESTS "Build C++ extension tests." FALSE)
+if(BUILD_TESTS OR BUILD_EXTENSION_TESTS)
+    set(CMAKE_CXX_VISIBILITY_PRESET default)
+    set(CMAKE_C_VISIBILITY_PRESET default)
+    set(CMAKE_VISIBILITY_INLINES_HIDDEN OFF)
+else()
+    set(CMAKE_CXX_VISIBILITY_PRESET hidden)
+    set(CMAKE_C_VISIBILITY_PRESET hidden)
+    set(CMAKE_VISIBILITY_INLINES_HIDDEN ON)
+endif()
+
 option(ENABLE_WERROR "Treat all warnings as errors" FALSE)
 if(ENABLE_WERROR)
     if (CMAKE_VERSION VERSION_GREATER "3.24.0" OR CMAKE_VERSION VERSION_EQUAL "3.24.0")
@@ -302,8 +313,6 @@ option(BUILD_NODEJS "Build NodeJS API." FALSE)
 option(BUILD_PYTHON "Build Python API." FALSE)
 option(BUILD_SHELL "Build Interactive Shell" TRUE)
 option(BUILD_SINGLE_FILE_HEADER "Build single file header. Requires Python >= 3.9." TRUE)
-option(BUILD_TESTS "Build C++ tests." FALSE)
-option(BUILD_EXTENSION_TESTS "Build C++ extension tests." FALSE)
 option(BUILD_LBUG "Build Lbug." TRUE)
 option(ENABLE_BACKTRACES "Enable backtrace printing for exceptions and segfaults" FALSE)
 option(USE_STD_FORMAT "Use std::format instead of a custom formatter." FALSE)

package/lbug-source/Makefile

@@ -294,9 +294,8 @@ extension-release:
 		-DBUILD_LBUG=FALSE \
 	)
 
-# pytest expects a `Release` build path.
 shell-test:
-	$(call run-cmake-release, \
+	$(call run-cmake-relwithdebinfo, \
 		-DBUILD_SHELL=TRUE \
 	)
 	$(MAKE) -C tools/shell/test test

package/lbug-source/benchmark/serializer.py

@@ -95,17 +95,28 @@ if __name__ == '__main__':
     parser.add_argument("--single-thread",
                         help="If true, copy single threaded, which makes the results more reproducible",
                         action="store_true")
+    parser.add_argument("--lbug-shell-mode",
+                        help="debug, release or relwithdebinfo",
+                        default="release")
+    default_mode = "release"
     if sys.platform == "win32":
         default_lbug_exec_path = os.path.join(
-            base_dir, '..', 'build', 'release', 'tools', 'shell', 'lbug_shell')
+            base_dir, '..', 'build', default_mode, 'tools', 'shell', 'lbug_shell')
     else:
         default_lbug_exec_path = os.path.join(
-            base_dir, '..', 'build', 'release', 'tools', 'shell', 'lbug')
+            base_dir, '..', 'build', default_mode, 'tools', 'shell', 'lbug')
     parser.add_argument("--lbug-shell",
                         help="Path of the lbug shell executable. Defaults to the path as built in the default release build directory",
                         default=default_lbug_exec_path)
     args = parser.parse_args()
 
+    if args.lbug_shell == default_lbug_exec_path:
+        mode = args.lbug_shell_mode
+        if sys.platform == "win32":
+            args.lbug_shell = os.path.join(base_dir, '..', 'build', mode, 'tools', 'shell', 'lbug_shell')
+        else:
+            args.lbug_shell = os.path.join(base_dir, '..', 'build', mode, 'tools', 'shell', 'lbug')
+
     try:
         serialize(args.lbug_shell, args.dataset_name, args.dataset_path, args.serialized_graph_path,
                   args.benchmark_copy_log_dir, args.single_thread)

package/lbug-source/extension/httpfs/test/test_files/http.test

@@ -148,6 +148,7 @@ tinysnb1|LBUG
 ---- ok
 
 -CASE AttachNotExistPath
+-SKIP
 -LOAD_DYNAMIC_EXTENSION httpfs
 -STATEMENT attach 'http://localhost/dataset/databases/tinysnb1' as test (dbtype lbug)
 ---- error

package/lbug-source/scripts/generate_binary_demo.sh

@@ -2,4 +2,4 @@
 
 CD=`dirname "$0"`
 DATASET_DIR=$CD/../dataset
-python3 $CD/../benchmark/serializer.py DemoDB $DATASET_DIR/demo-db/parquet $DATASET_DIR/binary-demo --single-thread
+python3 $CD/../benchmark/serializer.py DemoDB $DATASET_DIR/demo-db/parquet $DATASET_DIR/binary-demo --single-thread $*

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

package/lbug-source/src/planner/operator/scan/CMakeLists.txt

@@ -1,5 +1,6 @@
 add_library(lbug_planner_scan
         OBJECT
+        logical_count_rel_table.cpp
         logical_expressions_scan.cpp
         logical_index_look_up.cpp
         logical_scan_node_table.cpp)