merge skip limit

src/include/binder/query/return_with_clause/bound_projection_body.h

@@ -22,9 +22,6 @@ class BoundProjectionBody {
 
     inline bool getIsDistinct() const { return isDistinct; }
 
-    inline void setProjectionExpressions(expression_vector expressions) {
-        projectionExpressions = std::move(expressions);
-    }
     inline expression_vector getProjectionExpressions() const { return projectionExpressions; }
 
     inline void setGroupByExpressions(expression_vector expressions) {

src/include/optimizer/factorization_rewriter.h

@@ -19,7 +19,6 @@ class FactorizationRewriter : public LogicalOperatorVisitor {
     void visitAccumulate(planner::LogicalOperator* op) override;
     void visitAggregate(planner::LogicalOperator* op) override;
     void visitOrderBy(planner::LogicalOperator* op) override;
-    void visitSkip(planner::LogicalOperator* op) override;
     void visitLimit(planner::LogicalOperator* op) override;
     void visitDistinct(planner::LogicalOperator* op) override;
     void visitUnwind(planner::LogicalOperator* op) override;

src/include/optimizer/logical_operator_visitor.h

@@ -87,12 +87,6 @@ class LogicalOperatorVisitor {
         return op;
     }
 
-    virtual void visitSkip(planner::LogicalOperator* op) {}
-    virtual std::shared_ptr<planner::LogicalOperator> visitSkipReplace(
-        std::shared_ptr<planner::LogicalOperator> op) {
-        return op;
-    }
-
     virtual void visitLimit(planner::LogicalOperator* op) {}
     virtual std::shared_ptr<planner::LogicalOperator> visitLimitReplace(
         std::shared_ptr<planner::LogicalOperator> op) {

src/include/planner/logical_plan/logical_limit.h

@@ -1,39 +1,41 @@
 #pragma once
 
 #include "logical_operator.h"
-#include "planner/logical_plan/factorization/flatten_resolver.h"
 
 namespace kuzu {
 namespace planner {
 
 class LogicalLimit : public LogicalOperator {
 public:
-    LogicalLimit(uint64_t limitNumber, std::shared_ptr<LogicalOperator> child)
-        : LogicalOperator{LogicalOperatorType::LIMIT, std::move(child)}, limitNumber{limitNumber} {}
+    LogicalLimit(uint64_t skipNum, uint64_t limitNum, std::shared_ptr<LogicalOperator> child)
+        : LogicalOperator{LogicalOperatorType::LIMIT, std::move(child)}, skipNum{skipNum},
+          limitNum{limitNum} {}
 
     f_group_pos_set getGroupsPosToFlatten();
 
-    inline void computeFactorizedSchema() override { copyChildSchema(0); }
-    inline void computeFlatSchema() override { copyChildSchema(0); }
+    inline void computeFactorizedSchema() final { copyChildSchema(0); }
+    inline void computeFlatSchema() final { copyChildSchema(0); }
 
-    inline std::string getExpressionsForPrinting() const override {
-        return std::to_string(limitNumber);
-    }
+    std::string getExpressionsForPrinting() const final;
 
-    inline uint64_t getLimitNumber() const { return limitNumber; }
+    inline bool hasSkipNum() const { return skipNum != UINT64_MAX; }
+    inline uint64_t getSkipNum() const { return skipNum; }
+    inline bool hasLimitNum() const { return limitNum != UINT64_MAX; }
+    inline uint64_t getLimitNum() const { return limitNum; }
 
     f_group_pos getGroupPosToSelect() const;
 
     inline std::unordered_set<f_group_pos> getGroupsPosToLimit() const {
         return schema->getGroupsPosInScope();
     }
 
-    inline std::unique_ptr<LogicalOperator> copy() override {
-        return make_unique<LogicalLimit>(limitNumber, children[0]->copy());
+    inline std::unique_ptr<LogicalOperator> copy() final {
+        return make_unique<LogicalLimit>(skipNum, limitNum, children[0]->copy());
     }
 
 private:
-    uint64_t limitNumber;
+    uint64_t skipNum;
+    uint64_t limitNum;
 };
 
 } // namespace planner

src/include/planner/logical_plan/logical_operator.h

@@ -48,7 +48,6 @@ enum class LogicalOperatorType : uint8_t {
     SEMI_MASKER,
     SET_NODE_PROPERTY,
     SET_REL_PROPERTY,
-    SKIP,
     STANDALONE_CALL,
     UNION_ALL,
     UNWIND,

src/include/planner/query_planner.h

@@ -166,8 +166,7 @@ class QueryPlanner {
     void appendOrderBy(const binder::expression_vector& expressions,
         const std::vector<bool>& isAscOrders, LogicalPlan& plan);
     void appendMultiplicityReducer(LogicalPlan& plan);
-    void appendLimit(uint64_t limitNumber, LogicalPlan& plan);
-    void appendSkip(uint64_t skipNumber, LogicalPlan& plan);
+    void appendLimit(uint64_t skipNum, uint64_t limitNum, LogicalPlan& plan);
 
     // Append scan operators
     void appendExpressionsScan(const expression_vector& expressions, LogicalPlan& plan);

src/include/processor/plan_mapper.h

@@ -58,7 +58,6 @@ class PlanMapper {
     std::unique_ptr<PhysicalOperator> mapMultiplicityReducer(
         planner::LogicalOperator* logicalOperator);
     std::unique_ptr<PhysicalOperator> mapNodeLabelFilter(planner::LogicalOperator* logicalOperator);
-    std::unique_ptr<PhysicalOperator> mapSkip(planner::LogicalOperator* logicalOperator);
     std::unique_ptr<PhysicalOperator> mapLimit(planner::LogicalOperator* logicalOperator);
     std::unique_ptr<PhysicalOperator> mapMerge(planner::LogicalOperator* logicalOperator);
     std::unique_ptr<PhysicalOperator> mapAggregate(planner::LogicalOperator* logicalOperator);

src/optimizer/factorization_rewriter.cpp

@@ -14,7 +14,6 @@
 #include "planner/logical_plan/logical_limit.h"
 #include "planner/logical_plan/logical_order_by.h"
 #include "planner/logical_plan/logical_projection.h"
-#include "planner/logical_plan/logical_skip.h"
 #include "planner/logical_plan/logical_union.h"
 #include "planner/logical_plan/logical_unwind.h"
 #include "planner/logical_plan/persistent/logical_create.h"
@@ -103,12 +102,6 @@ void FactorizationRewriter::visitOrderBy(planner::LogicalOperator* op) {
     orderBy->setChild(0, appendFlattens(orderBy->getChild(0), groupsPosToFlatten));
 }
 
-void FactorizationRewriter::visitSkip(planner::LogicalOperator* op) {
-    auto skip = (LogicalSkip*)op;
-    auto groupsPosToFlatten = skip->getGroupsPosToFlatten();
-    skip->setChild(0, appendFlattens(skip->getChild(0), groupsPosToFlatten));
-}
-
 void FactorizationRewriter::visitLimit(planner::LogicalOperator* op) {
     auto limit = (LogicalLimit*)op;
     auto groupsPosToFlatten = limit->getGroupsPosToFlatten();

src/optimizer/logical_operator_visitor.cpp

@@ -43,9 +43,6 @@ void LogicalOperatorVisitor::visitOperatorSwitch(planner::LogicalOperator* op) {
     case LogicalOperatorType::ORDER_BY: {
         visitOrderBy(op);
     } break;
-    case LogicalOperatorType::SKIP: {
-        visitSkip(op);
-    } break;
     case LogicalOperatorType::LIMIT: {
         visitLimit(op);
     } break;
@@ -132,9 +129,6 @@ std::shared_ptr<planner::LogicalOperator> LogicalOperatorVisitor::visitOperatorR
     case LogicalOperatorType::ORDER_BY: {
         return visitOrderByReplace(op);
     }
-    case LogicalOperatorType::SKIP: {
-        return visitSkipReplace(op);
-    }
     case LogicalOperatorType::LIMIT: {
         return visitLimitReplace(op);
     }

src/planner/operator/CMakeLists.txt

@@ -25,7 +25,6 @@ add_library(kuzu_planner_operator
         logical_plan.cpp
         logical_plan_util.cpp
         logical_projection.cpp
-        logical_skip.cpp
         logical_union.cpp
         logical_unwind.cpp
         schema.cpp)

src/planner/operator/logical_limit.cpp

@@ -1,8 +1,21 @@
 #include "planner/logical_plan/logical_limit.h"
 
+#include "planner/logical_plan/factorization/flatten_resolver.h"
+
 namespace kuzu {
 namespace planner {
 
+std::string LogicalLimit::getExpressionsForPrinting() const {
+    std::string result;
+    if (hasSkipNum()) {
+        result += "SKIP " + std::to_string(skipNum) + " ";
+    }
+    if (hasLimitNum()) {
+        result += "LIMIT " + std::to_string(limitNum);
+    }
+    return result;
+}
+
 f_group_pos_set LogicalLimit::getGroupsPosToFlatten() {
     auto childSchema = children[0]->getSchema();
     return factorization::FlattenAllButOne::getGroupsPosToFlatten(

src/planner/operator/logical_operator.cpp

@@ -135,9 +135,6 @@ std::string LogicalOperatorUtils::logicalOperatorTypeToString(LogicalOperatorTyp
     case LogicalOperatorType::SET_REL_PROPERTY: {
         return "SET_REL_PROPERTY";
     }
-    case LogicalOperatorType::SKIP: {
-        return "SKIP";
-    }
     case LogicalOperatorType::STANDALONE_CALL: {
         return "STANDALONE_CALL";
     }

src/planner/plan/CMakeLists.txt

@@ -19,7 +19,6 @@ add_library(kuzu_planner_plan_operator
         append_projection.cpp
         append_scan_node.cpp
         append_set.cpp
-        append_skip.cpp
         append_unwind.cpp
         plan_join_order.cpp
         plan_projection.cpp

src/planner/plan/append_limit.cpp

@@ -4,12 +4,12 @@
 namespace kuzu {
 namespace planner {
 
-void QueryPlanner::appendLimit(uint64_t limitNumber, LogicalPlan& plan) {
-    auto limit = make_shared<LogicalLimit>(limitNumber, plan.getLastOperator());
+void QueryPlanner::appendLimit(uint64_t skipNum, uint64_t limitNum, LogicalPlan& plan) {
+    auto limit = make_shared<LogicalLimit>(skipNum, limitNum, plan.getLastOperator());
     appendFlattens(limit->getGroupsPosToFlatten(), plan);
     limit->setChild(0, plan.getLastOperator());
     limit->computeFactorizedSchema();
-    plan.setCardinality(limitNumber);
+    plan.setCardinality(limitNum);
     plan.setLastOperator(std::move(limit));
 }
 

src/planner/plan/plan_projection.cpp

@@ -36,12 +36,7 @@ void QueryPlanner::planProjectionBody(
     }
     if (projectionBody.hasSkipOrLimit()) {
         appendMultiplicityReducer(plan);
-        if (projectionBody.hasSkip()) {
-            appendSkip(projectionBody.getSkipNumber(), plan);
-        }
-        if (projectionBody.hasLimit()) {
-            appendLimit(projectionBody.getLimitNumber(), plan);
-        }
+        appendLimit(projectionBody.getSkipNumber(), projectionBody.getLimitNumber(), plan);
     }
 }
 

src/processor/map/CMakeLists.txt

@@ -37,7 +37,6 @@ add_library(kuzu_processor_mapper
         map_scan_node_property.cpp
         map_semi_masker.cpp
         map_set.cpp
-        map_skip.cpp
         map_union.cpp
         map_unwind.cpp
         plan_mapper.cpp)

src/processor/map/map_limit.cpp

@@ -1,5 +1,6 @@
 #include "planner/logical_plan/logical_limit.h"
 #include "processor/operator/limit.h"
+#include "processor/operator/skip.h"
 #include "processor/plan_mapper.h"
 
 using namespace kuzu::planner;
@@ -8,13 +9,23 @@ namespace kuzu {
 namespace processor {
 
 std::unique_ptr<PhysicalOperator> PlanMapper::mapLimit(LogicalOperator* logicalOperator) {
-    auto& logicalLimit = (const LogicalLimit&)*logicalOperator;
+    auto logicalLimit = (LogicalLimit*)logicalOperator;
     auto prevOperator = mapOperator(logicalOperator->getChild(0).get());
-    auto dataChunkToSelectPos = logicalLimit.getGroupPosToSelect();
-    return make_unique<Limit>(logicalLimit.getLimitNumber(),
-        std::make_shared<std::atomic_uint64_t>(0), dataChunkToSelectPos,
-        logicalLimit.getGroupsPosToLimit(), std::move(prevOperator), getOperatorID(),
-        logicalLimit.getExpressionsForPrinting());
+    auto dataChunkToSelectPos = logicalLimit->getGroupPosToSelect();
+    auto groupsPotToLimit = logicalLimit->getGroupsPosToLimit();
+    auto paramStr = logicalLimit->getExpressionsForPrinting();
+    std::unique_ptr<PhysicalOperator> lastOperator = std::move(prevOperator);
+    if (logicalLimit->hasSkipNum()) {
+        lastOperator = make_unique<Skip>(logicalLimit->getSkipNum(),
+            std::make_shared<std::atomic_uint64_t>(0), dataChunkToSelectPos, groupsPotToLimit,
+            std::move(lastOperator), getOperatorID(), paramStr);
+    }
+    if (logicalLimit->hasLimitNum()) {
+        lastOperator = make_unique<Limit>(logicalLimit->getLimitNum(),
+            std::make_shared<std::atomic_uint64_t>(0), dataChunkToSelectPos, groupsPotToLimit,
+            std::move(lastOperator), getOperatorID(), paramStr);
+    }
+    return lastOperator;
 }
 
 } // namespace processor

src/processor/map/plan_mapper.cpp

@@ -83,9 +83,6 @@ std::unique_ptr<PhysicalOperator> PlanMapper::mapOperator(LogicalOperator* logic
     case LogicalOperatorType::NODE_LABEL_FILTER: {
         physicalOperator = mapNodeLabelFilter(logicalOperator);
     } break;
-    case LogicalOperatorType::SKIP: {
-        physicalOperator = mapSkip(logicalOperator);
-    } break;
     case LogicalOperatorType::LIMIT: {
         physicalOperator = mapLimit(logicalOperator);
     } break;