lbug 0.12.3-dev.3 → 0.12.3-dev.30

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>

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/limit_push_down_optimizer.cpp

@@ -6,6 +6,7 @@
 #include "planner/operator/logical_distinct.h"
 #include "planner/operator/logical_hash_join.h"
 #include "planner/operator/logical_limit.h"
+#include "planner/operator/logical_table_function_call.h"
 
 using namespace lbug::binder;
 using namespace lbug::common;
@@ -34,10 +35,21 @@ void LimitPushDownOptimizer::visitOperator(planner::LogicalOperator* op) {
     case LogicalOperatorType::MULTIPLICITY_REDUCER:
     case LogicalOperatorType::EXPLAIN:
     case LogicalOperatorType::ACCUMULATE:
+    case LogicalOperatorType::FILTER:
     case LogicalOperatorType::PROJECTION: {
         visitOperator(op->getChild(0).get());
         return;
     }
+    case LogicalOperatorType::TABLE_FUNCTION_CALL: {
+        if (limitNumber == INVALID_LIMIT && skipNumber == 0) {
+            return;
+        }
+        auto& tableFuncCall = op->cast<LogicalTableFunctionCall>();
+        if (tableFuncCall.getTableFunc().supportsPushDownFunc()) {
+            tableFuncCall.setLimitNum(skipNumber + limitNumber);
+        }
+        return;
+    }
     case LogicalOperatorType::DISTINCT: {
         if (limitNumber == INVALID_LIMIT && skipNumber == 0) {
             return;

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,9 +5,11 @@
 #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"
+#include "optimizer/order_by_push_down_optimizer.h"
 #include "optimizer/projection_push_down_optimizer.h"
 #include "optimizer/remove_factorization_rewriter.h"
 #include "optimizer/remove_unnecessary_join_optimizer.h"
@@ -32,6 +34,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);
 
@@ -39,6 +46,9 @@ void Optimizer::optimize(planner::LogicalPlan* plan, main::ClientContext* contex
             ProjectionPushDownOptimizer(context->getClientConfig()->recursivePatternSemantic);
         projectionPushDownOptimizer.rewrite(plan);
 
+        auto orderByPushDownOptimizer = OrderByPushDownOptimizer();
+        orderByPushDownOptimizer.rewrite(plan);
+
         auto limitPushDownOptimizer = LimitPushDownOptimizer();
         limitPushDownOptimizer.rewrite(plan);
 

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

@@ -0,0 +1,123 @@
+#include "optimizer/order_by_push_down_optimizer.h"
+
+#include "binder/expression/expression.h"
+#include "binder/expression/expression_util.h"
+#include "binder/expression/property_expression.h"
+#include "binder/expression/variable_expression.h"
+#include "common/exception/runtime.h"
+#include "planner/operator/logical_order_by.h"
+#include "planner/operator/logical_table_function_call.h"
+
+using namespace lbug::binder;
+using namespace lbug::common;
+using namespace lbug::planner;
+
+namespace lbug {
+namespace optimizer {
+
+// This ensures that ORDER BY can be pushed down only through operators that support it.
+// It should not be pushed down for things like RECURSIVE_EXTEND etc.
+bool isPushDownSupported(LogicalOperator* op) {
+    switch (op->getOperatorType()) {
+    case LogicalOperatorType::TABLE_FUNCTION_CALL: {
+        return op->cast<LogicalTableFunctionCall>().getTableFunc().supportsPushDownFunc();
+    }
+    case LogicalOperatorType::MULTIPLICITY_REDUCER:
+    case LogicalOperatorType::EXPLAIN:
+    case LogicalOperatorType::ACCUMULATE:
+    case LogicalOperatorType::FILTER:
+    case LogicalOperatorType::PROJECTION:
+    case LogicalOperatorType::LIMIT: {
+        if (op->getNumChildren() == 0) {
+            return false;
+        }
+        return isPushDownSupported(op->getChild(0).get());
+    }
+    default:
+        return false;
+    }
+}
+
+void OrderByPushDownOptimizer::rewrite(LogicalPlan* plan) {
+    plan->setLastOperator(visitOperator(plan->getLastOperator()));
+}
+
+std::shared_ptr<LogicalOperator> OrderByPushDownOptimizer::visitOperator(
+    std::shared_ptr<LogicalOperator> op, std::string currentOrderBy) {
+    switch (op->getOperatorType()) {
+    case LogicalOperatorType::ORDER_BY: {
+        auto& orderBy = op->constCast<LogicalOrderBy>();
+        std::string newOrderBy = currentOrderBy;
+        if (!currentOrderBy.empty()) {
+            newOrderBy += ", ";
+        }
+        newOrderBy +=
+            buildOrderByString(orderBy.getExpressionsToOrderBy(), orderBy.getIsAscOrders());
+        auto newChild = visitOperator(orderBy.getChild(0), newOrderBy);
+        if (isPushDownSupported(newChild.get())) {
+            return newChild;
+        }
+        return std::make_shared<LogicalOrderBy>(orderBy.getExpressionsToOrderBy(),
+            orderBy.getIsAscOrders(), newChild);
+    }
+    case LogicalOperatorType::MULTIPLICITY_REDUCER:
+    case LogicalOperatorType::EXPLAIN:
+    case LogicalOperatorType::ACCUMULATE:
+    case LogicalOperatorType::FILTER:
+    case LogicalOperatorType::PROJECTION:
+    case LogicalOperatorType::LIMIT: {
+        for (auto i = 0u; i < op->getNumChildren(); ++i) {
+            op->setChild(i, visitOperator(op->getChild(i), currentOrderBy));
+        }
+        return op;
+    }
+    case LogicalOperatorType::TABLE_FUNCTION_CALL: {
+        if (!currentOrderBy.empty()) {
+            auto& tableFunc = op->cast<LogicalTableFunctionCall>();
+            if (tableFunc.getTableFunc().supportsPushDownFunc()) {
+                tableFunc.setOrderBy(currentOrderBy);
+            }
+        }
+        return op;
+    }
+    default:
+        return op;
+    }
+}
+
+std::string OrderByPushDownOptimizer::buildOrderByString(
+    const binder::expression_vector& expressions, const std::vector<bool>& isAscOrders) {
+    if (expressions.empty()) {
+        return "";
+    }
+    std::string result = " ORDER BY ";
+    bool first = true;
+    for (size_t i = 0; i < expressions.size(); ++i) {
+        auto& expr = expressions[i];
+        std::string colName;
+        if (expr->expressionType == common::ExpressionType::VARIABLE) {
+            auto& var = expr->constCast<binder::VariableExpression>();
+            colName = var.getVariableName();
+        } else if (expr->expressionType == common::ExpressionType::PROPERTY) {
+            auto& prop = expr->constCast<binder::PropertyExpression>();
+            colName = prop.getPropertyName();
+        } else {
+            // Skip expressions that cannot be pushed down
+            continue;
+        }
+        if (!first) {
+            result += ", ";
+        }
+        result += colName;
+        result += isAscOrders[i] ? " ASC" : " DESC";
+        first = false;
+    }
+    if (first) {
+        // No expressions could be pushed down
+        return "";
+    }
+    return result;
+}
+
+} // namespace optimizer
+} // namespace lbug

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

@@ -261,7 +261,11 @@ void ProjectionPushDownOptimizer::visitTableFunctionCall(LogicalOperator* op) {
     auto& tableFunctionCall = op->cast<LogicalTableFunctionCall>();
     std::vector<bool> columnSkips;
     for (auto& column : tableFunctionCall.getBindData()->columns) {
-        columnSkips.push_back(!variablesInUse.contains(column));
+        // Check both variablesInUse and propertiesInUse since foreign table columns
+        // may be referenced as properties in the query (e.g., a.id) but represented
+        // as variables in the table function bind data
+        columnSkips.push_back(
+            !variablesInUse.contains(column) && !propertiesInUse.contains(column));
     }
     tableFunctionCall.setColumnSkips(std::move(columnSkips));
 }

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/parser/transform/transform_expression.cpp

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

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

@@ -202,7 +202,12 @@ std::vector<std::string> Transformer::transformNodeLabels(CypherParser::OC_NodeL
 }
 
 std::string Transformer::transformLabelName(CypherParser::OC_LabelNameContext& ctx) {
-    return transformSchemaName(*ctx.oC_SchemaName());
+    auto schemaNames = ctx.oC_SchemaName();
+    if (schemaNames.size() == 1) {
+        return transformSchemaName(*schemaNames[0]);
+    }
+    // Qualified name: db.table
+    return transformSchemaName(*schemaNames[0]) + "." + transformSchemaName(*schemaNames[1]);
 }
 
 std::string Transformer::transformRelTypeName(CypherParser::OC_RelTypeNameContext& ctx) {

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

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

package/lbug-source/src/planner/join_order/cardinality_estimator.cpp

@@ -1,6 +1,7 @@
 #include "planner/join_order/cardinality_estimator.h"
 
 #include "binder/expression/property_expression.h"
+#include "catalog/catalog_entry/table_catalog_entry.h"
 #include "main/client_context.h"
 #include "planner/join_order/join_order_util.h"
 #include "planner/operator/logical_aggregate.h"
@@ -39,7 +40,12 @@ void CardinalityEstimator::init(const NodeExpression& node) {
     cardinality_t numNodes = 0u;
     auto storageManager = storage::StorageManager::Get(*context);
     auto transaction = transaction::Transaction::Get(*context);
-    for (auto tableID : node.getTableIDs()) {
+    for (auto entry : node.getEntries()) {
+        // Skip foreign tables - they don't have storage in the local database
+        if (entry->getType() == catalog::CatalogEntryType::FOREIGN_TABLE_ENTRY) {
+            continue;
+        }
+        auto tableID = entry->getTableID();
         auto stats =
             storageManager->getTable(tableID)->cast<storage::NodeTable>().getStats(transaction);
         numNodes += stats.getTableCard();
@@ -195,7 +201,10 @@ uint64_t CardinalityEstimator::getNumNodes(const Transaction*,
     const std::vector<table_id_t>& tableIDs) const {
     cardinality_t numNodes = 0u;
     for (auto& tableID : tableIDs) {
-        KU_ASSERT(nodeTableStats.contains(tableID));
+        // Skip foreign tables - they won't be in nodeTableStats
+        if (!nodeTableStats.contains(tableID)) {
+            continue;
+        }
         numNodes += nodeTableStats.at(tableID).getTableCard();
     }
     return atLeastOne(numNodes);

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/logical_table_function_call.cpp

@@ -19,5 +19,9 @@ void LogicalTableFunctionCall::computeFactorizedSchema() {
     }
 }
 
+std::unique_ptr<OPPrintInfo> LogicalTableFunctionCall::getPrintInfo() const {
+    return std::make_unique<LogicalTableFunctionCallPrintInfo>(getExpressionsForPrinting());
+}
+
 } // namespace planner
 } // namespace lbug

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)

package/lbug-source/src/planner/operator/scan/logical_count_rel_table.cpp

@@ -0,0 +1,24 @@
+#include "planner/operator/scan/logical_count_rel_table.h"
+
+namespace lbug {
+namespace planner {
+
+void LogicalCountRelTable::computeFactorizedSchema() {
+    createEmptySchema();
+    // Only output the count expression in a single-state group.
+    // This operator is a source - it has no child in the logical plan.
+    // The bound node is used internally for scanning but not exposed.
+    auto groupPos = schema->createGroup();
+    schema->insertToGroupAndScope(countExpr, groupPos);
+    schema->setGroupAsSingleState(groupPos);
+}
+
+void LogicalCountRelTable::computeFlatSchema() {
+    createEmptySchema();
+    // For flat schema, create a single group with the count expression.
+    auto groupPos = schema->createGroup();
+    schema->insertToGroupAndScope(countExpr, groupPos);
+}
+
+} // namespace planner
+} // namespace lbug

package/lbug-source/src/planner/plan/plan_join_order.cpp

@@ -1,8 +1,11 @@
 #include <cmath>
 
+#include "binder/bound_scan_source.h"
 #include "binder/expression_visitor.h"
+#include "catalog/catalog_entry/catalog_entry_type.h"
 #include "common/enums/join_type.h"
 #include "common/enums/rel_direction.h"
+#include "common/enums/table_type.h"
 #include "common/utils.h"
 #include "planner/join_order/cost_model.h"
 #include "planner/join_order/join_plan_solver.h"
@@ -246,7 +249,19 @@ void Planner::planNodeScan(uint32_t nodePos) {
     newSubgraph.addQueryNode(nodePos);
     auto plan = LogicalPlan();
     auto properties = getProperties(*node);
-    appendScanNodeTable(node->getInternalID(), node->getTableIDs(), properties, plan);
+    if (node->getEntries().size() == 1 &&
+        node->getEntries()[0]->getType() == catalog::CatalogEntryType::FOREIGN_TABLE_ENTRY) {
+        auto boundScanInfo =
+            node->getEntries()[0]->getBoundScanInfo(clientContext, node->getUniqueName());
+        if (boundScanInfo != nullptr) {
+            // Use table function call for foreign tables
+            appendTableFunctionCall(*boundScanInfo, plan);
+        } else {
+            appendScanNodeTable(node->getInternalID(), node->getTableIDs(), properties, plan);
+        }
+    } else {
+        appendScanNodeTable(node->getInternalID(), node->getTableIDs(), properties, plan);
+    }
     auto predicates = getNewlyMatchedExprs(context.getEmptySubqueryGraph(), newSubgraph,
         context.getWhereExpressions());
     appendFilters(predicates, plan);

package/lbug-source/src/processor/map/CMakeLists.txt

@@ -7,6 +7,7 @@ add_library(lbug_processor_mapper
         map_acc_hash_join.cpp
         map_accumulate.cpp
         map_aggregate.cpp
+        map_count_rel_table.cpp
         map_standalone_call.cpp
         map_table_function_call.cpp
         map_copy_to.cpp