Remove update planner

src/include/planner/query_planner.h

@@ -6,23 +6,29 @@
 #include "join_order_enumerator.h"
 #include "planner/join_order/cardinality_estimator.h"
 #include "projection_planner.h"
-#include "update_planner.h"
 
 namespace kuzu {
+namespace binder {
+class BoundCreateNode;
+class BoundCreateRel;
+class BoundSetNodeProperty;
+class BoundSetRelProperty;
+class BoundDeleteNode;
+} // namespace binder
+
 namespace planner {
 
 class QueryPlanner {
     friend class JoinOrderEnumerator;
     friend class ProjectionPlanner;
-    friend class UpdatePlanner;
 
 public:
     explicit QueryPlanner(const catalog::Catalog& catalog,
         const storage::NodesStatisticsAndDeletedIDs& nodesStatistics,
         const storage::RelsStatistics& relsStatistics)
         : catalog{catalog}, cardinalityEstimator{std::make_unique<CardinalityEstimator>(
                                 nodesStatistics, relsStatistics)},
-          joinOrderEnumerator{catalog, this}, projectionPlanner{this}, updatePlanner{this} {}
+          joinOrderEnumerator{catalog, this}, projectionPlanner{this} {}
 
     std::vector<std::unique_ptr<LogicalPlan>> getAllPlans(const BoundStatement& boundStatement);
 
@@ -33,21 +39,31 @@ class QueryPlanner {
 private:
     std::unique_ptr<LogicalPlan> getBestPlan(std::vector<std::unique_ptr<LogicalPlan>> plans);
 
+    // Plan query
     std::vector<std::unique_ptr<LogicalPlan>> planSingleQuery(
         const NormalizedSingleQuery& singleQuery);
     std::vector<std::unique_ptr<LogicalPlan>> planQueryPart(
         const NormalizedQueryPart& queryPart, std::vector<std::unique_ptr<LogicalPlan>> prevPlans);
 
-    // Reading clause planning
-    void planReadingClause(BoundReadingClause* boundReadingClause,
-        std::vector<std::unique_ptr<LogicalPlan>>& prevPlans);
+    // Plan reading
+    void planReadingClause(
+        BoundReadingClause* readingClause, std::vector<std::unique_ptr<LogicalPlan>>& prevPlans);
     void planMatchClause(
-        BoundReadingClause* boundReadingClause, std::vector<std::unique_ptr<LogicalPlan>>& plans);
+        BoundReadingClause* readingClause, std::vector<std::unique_ptr<LogicalPlan>>& plans);
     void planUnwindClause(
-        BoundReadingClause* boundReadingClause, std::vector<std::unique_ptr<LogicalPlan>>& plans);
+        BoundReadingClause* readingClause, std::vector<std::unique_ptr<LogicalPlan>>& plans);
     void planInQueryCall(
-        BoundReadingClause* boundReadingClause, std::vector<std::unique_ptr<LogicalPlan>>& plans);
+        BoundReadingClause* readingClause, std::vector<std::unique_ptr<LogicalPlan>>& plans);
+
+    // Plan updating
+    void planUpdatingClause(binder::BoundUpdatingClause& updatingClause,
+        std::vector<std::unique_ptr<LogicalPlan>>& plans);
+    void planUpdatingClause(binder::BoundUpdatingClause& updatingClause, LogicalPlan& plan);
+    void planCreateClause(binder::BoundUpdatingClause& updatingClause, LogicalPlan& plan);
+    void planSetClause(binder::BoundUpdatingClause& updatingClause, LogicalPlan& plan);
+    void planDeleteClause(binder::BoundUpdatingClause& updatingClause, LogicalPlan& plan);
 
+    // Plan subquery
     void planOptionalMatch(const QueryGraphCollection& queryGraphCollection,
         const expression_vector& predicates, LogicalPlan& leftPlan);
     void planRegularMatch(const QueryGraphCollection& queryGraphCollection,
@@ -80,6 +96,24 @@ class QueryPlanner {
     void appendScanNodePropIfNecessary(const expression_vector& propertyExpressions,
         std::shared_ptr<NodeExpression> node, LogicalPlan& plan);
 
+    // Append updating operators
+    void appendCreateNode(const std::vector<std::unique_ptr<binder::BoundCreateNode>>& createNodes,
+        LogicalPlan& plan);
+    void appendCreateRel(
+        const std::vector<std::unique_ptr<binder::BoundCreateRel>>& createRels, LogicalPlan& plan);
+
+    void appendSetNodeProperty(
+        const std::vector<std::unique_ptr<binder::BoundSetNodeProperty>>& setNodeProperties,
+        LogicalPlan& plan);
+    void appendSetRelProperty(
+        const std::vector<std::unique_ptr<binder::BoundSetRelProperty>>& setRelProperties,
+        LogicalPlan& plan);
+
+    void appendDeleteNode(const std::vector<std::unique_ptr<binder::BoundDeleteNode>>& deleteNodes,
+        LogicalPlan& plan);
+    void appendDeleteRel(
+        const std::vector<std::shared_ptr<binder::RelExpression>>& deleteRels, LogicalPlan& plan);
+
     std::unique_ptr<LogicalPlan> createUnionPlan(
         std::vector<std::unique_ptr<LogicalPlan>>& childrenPlans, bool isUnionAll);
 
@@ -97,7 +131,6 @@ class QueryPlanner {
     expression_vector propertiesToScan;
     JoinOrderEnumerator joinOrderEnumerator;
     ProjectionPlanner projectionPlanner;
-    UpdatePlanner updatePlanner;
 };
 
 } // namespace planner

src/planner/CMakeLists.txt

@@ -1,6 +1,6 @@
 add_subdirectory(join_order)
 add_subdirectory(operator)
-add_subdirectory(plan_operator)
+add_subdirectory(plan)
 
 add_library(kuzu_planner
         OBJECT
@@ -9,8 +9,7 @@ add_library(kuzu_planner
         planner.cpp
         projection_planner.cpp
         query_planner.cpp
-        subplans_table.cpp
-        update_planner.cpp)
+        subplans_table.cpp)
 
 set(ALL_OBJECT_FILES
         ${ALL_OBJECT_FILES} $<TARGET_OBJECTS:kuzu_planner>

src/planner/plan_operator/CMakeLists.txt → src/planner/plan/CMakeLists.txt

@@ -1,6 +1,10 @@
 add_library(kuzu_planner_plan_operator
         OBJECT
-        append_accumulate.cpp)
+        append_accumulate.cpp
+        append_create.cpp
+        append_delete.cpp
+        append_set.cpp
+        plan_update.cpp)
 
 set(ALL_OBJECT_FILES
         ${ALL_OBJECT_FILES} $<TARGET_OBJECTS:kuzu_planner_plan_operator>

src/planner/plan/append_create.cpp

@@ -0,0 +1,50 @@
+#include "binder/query/updating_clause/bound_create_clause.h"
+#include "binder/query/updating_clause/bound_set_clause.h"
+#include "planner/logical_plan/logical_operator/logical_create.h"
+#include "planner/query_planner.h"
+
+using namespace kuzu::binder;
+
+namespace kuzu {
+namespace planner {
+
+void QueryPlanner::appendCreateNode(
+    const std::vector<std::unique_ptr<binder::BoundCreateNode>>& createNodes, LogicalPlan& plan) {
+    std::vector<std::shared_ptr<NodeExpression>> nodes;
+    expression_vector primaryKeys;
+    std::vector<std::unique_ptr<BoundSetNodeProperty>> setNodeProperties;
+    for (auto& createNode : createNodes) {
+        auto node = createNode->getNode();
+        nodes.push_back(node);
+        primaryKeys.push_back(createNode->getPrimaryKeyExpression());
+        for (auto& setItem : createNode->getSetItems()) {
+            setNodeProperties.push_back(std::make_unique<BoundSetNodeProperty>(node, setItem));
+        }
+    }
+    auto createNode = std::make_shared<LogicalCreateNode>(
+        std::move(nodes), std::move(primaryKeys), plan.getLastOperator());
+    appendFlattens(createNode->getGroupsPosToFlatten(), plan);
+    createNode->setChild(0, plan.getLastOperator());
+    createNode->computeFactorizedSchema();
+    plan.setLastOperator(createNode);
+    appendSetNodeProperty(setNodeProperties, plan);
+}
+
+void QueryPlanner::appendCreateRel(
+    const std::vector<std::unique_ptr<binder::BoundCreateRel>>& createRels, LogicalPlan& plan) {
+    std::vector<std::shared_ptr<RelExpression>> rels;
+    std::vector<std::vector<expression_pair>> setItemsPerRel;
+    for (auto& createRel : createRels) {
+        rels.push_back(createRel->getRel());
+        setItemsPerRel.push_back(createRel->getSetItems());
+    }
+    auto createRel = std::make_shared<LogicalCreateRel>(
+        std::move(rels), std::move(setItemsPerRel), plan.getLastOperator());
+    appendFlattens(createRel->getGroupsPosToFlatten(), plan);
+    createRel->setChild(0, plan.getLastOperator());
+    createRel->computeFactorizedSchema();
+    plan.setLastOperator(createRel);
+}
+
+} // namespace planner
+} // namespace kuzu

src/planner/plan/append_delete.cpp

@@ -0,0 +1,34 @@
+#include "binder/query/updating_clause/bound_delete_clause.h"
+#include "planner/logical_plan/logical_operator/logical_delete.h"
+#include "planner/query_planner.h"
+
+namespace kuzu {
+namespace planner {
+
+void QueryPlanner::appendDeleteNode(
+    const std::vector<std::unique_ptr<binder::BoundDeleteNode>>& deleteNodes, LogicalPlan& plan) {
+    std::vector<std::shared_ptr<NodeExpression>> nodes;
+    expression_vector primaryKeys;
+    for (auto& deleteNode : deleteNodes) {
+        nodes.push_back(deleteNode->getNode());
+        primaryKeys.push_back(deleteNode->getPrimaryKeyExpression());
+    }
+    auto deleteNode = std::make_shared<LogicalDeleteNode>(
+        std::move(nodes), std::move(primaryKeys), plan.getLastOperator());
+    deleteNode->computeFactorizedSchema();
+    plan.setLastOperator(std::move(deleteNode));
+}
+
+void QueryPlanner::appendDeleteRel(
+    const std::vector<std::shared_ptr<binder::RelExpression>>& deleteRels, LogicalPlan& plan) {
+    auto deleteRel = std::make_shared<LogicalDeleteRel>(deleteRels, plan.getLastOperator());
+    for (auto i = 0u; i < deleteRel->getNumRels(); ++i) {
+        appendFlattens(deleteRel->getGroupsPosToFlatten(i), plan);
+        deleteRel->setChild(0, plan.getLastOperator());
+    }
+    deleteRel->computeFactorizedSchema();
+    plan.setLastOperator(std::move(deleteRel));
+}
+
+} // namespace planner
+} // namespace kuzu

src/planner/plan/append_set.cpp

@@ -0,0 +1,59 @@
+#include "binder/query/updating_clause/bound_set_clause.h"
+#include "planner/logical_plan/logical_operator/logical_set.h"
+#include "planner/query_planner.h"
+
+namespace kuzu {
+namespace planner {
+
+void QueryPlanner::appendSetNodeProperty(
+    const std::vector<std::unique_ptr<binder::BoundSetNodeProperty>>& setNodeProperties,
+    LogicalPlan& plan) {
+    std::vector<std::shared_ptr<NodeExpression>> nodes;
+    std::vector<expression_pair> setItems;
+    for (auto& setNodeProperty : setNodeProperties) {
+        nodes.push_back(setNodeProperty->getNode());
+        setItems.push_back(setNodeProperty->getSetItem());
+    }
+    for (auto i = 0u; i < setItems.size(); ++i) {
+        auto lhsNodeID = nodes[i]->getInternalIDProperty();
+        auto rhs = setItems[i].second;
+        // flatten rhs
+        auto rhsDependentGroupsPos = plan.getSchema()->getDependentGroupsPos(rhs);
+        auto rhsGroupsPosToFlatten = factorization::FlattenAllButOne::getGroupsPosToFlatten(
+            rhsDependentGroupsPos, plan.getSchema());
+        appendFlattens(rhsGroupsPosToFlatten, plan);
+        // flatten lhs if needed
+        auto lhsGroupPos = plan.getSchema()->getGroupPos(*lhsNodeID);
+        auto rhsLeadingGroupPos =
+            SchemaUtils::getLeadingGroupPos(rhsDependentGroupsPos, *plan.getSchema());
+        if (lhsGroupPos != rhsLeadingGroupPos) {
+            appendFlattenIfNecessary(lhsGroupPos, plan);
+        }
+    }
+    auto setNodeProperty = std::make_shared<LogicalSetNodeProperty>(
+        std::move(nodes), std::move(setItems), plan.getLastOperator());
+    setNodeProperty->computeFactorizedSchema();
+    plan.setLastOperator(setNodeProperty);
+}
+
+void QueryPlanner::appendSetRelProperty(
+    const std::vector<std::unique_ptr<binder::BoundSetRelProperty>>& setRelProperties,
+    LogicalPlan& plan) {
+    std::vector<std::shared_ptr<RelExpression>> rels;
+    std::vector<expression_pair> setItems;
+    for (auto& setRelProperty : setRelProperties) {
+        rels.push_back(setRelProperty->getRel());
+        setItems.push_back(setRelProperty->getSetItem());
+    }
+    auto setRelProperty = std::make_shared<LogicalSetRelProperty>(
+        std::move(rels), std::move(setItems), plan.getLastOperator());
+    for (auto i = 0u; i < setRelProperty->getNumRels(); ++i) {
+        appendFlattens(setRelProperty->getGroupsPosToFlatten(i), plan);
+        setRelProperty->setChild(0, plan.getLastOperator());
+    }
+    setRelProperty->computeFactorizedSchema();
+    plan.setLastOperator(setRelProperty);
+}
+
+} // namespace planner
+} // namespace kuzu