clean

kuzudb · Feb 21, 2023 · 0096f2e · 0096f2e
1 parent 82cf285
commit 0096f2e
Show file tree

Hide file tree

Showing 17 changed files with 35 additions and 38 deletions.
diff --git a/src/include/planner/logical_plan/logical_operator/factorization_resolver.h b/src/include/planner/logical_plan/logical_operator/factorization_resolver.h
@@ -4,16 +4,16 @@
 
 namespace kuzu {
 namespace planner {
+namespace factorization {
 
-struct FlattenAllButOneFactorizationSolver {
-    static std::unordered_set<f_group_pos> getGroupsPosToFlatten(
-        const std::unordered_set<f_group_pos>& groupsPos, Schema* schema);
+struct FlattenAllButOne {
+    static f_group_pos_set getGroupsPosToFlatten(const f_group_pos_set& groupsPos, Schema* schema);
 };
 
-struct FlattenAllFactorizationSolver {
-    static std::unordered_set<f_group_pos> getGroupsPosToFlatten(
-        const std::unordered_set<f_group_pos>& groupsPos, Schema* schema);
+struct FlattenAll {
+    static f_group_pos_set getGroupsPosToFlatten(const f_group_pos_set& groupsPos, Schema* schema);
 };
 
+} // namespace factorization
 } // namespace planner
 } // namespace kuzu
diff --git a/src/include/planner/logical_plan/logical_operator/logical_create.h b/src/include/planner/logical_plan/logical_operator/logical_create.h
@@ -20,7 +20,7 @@ class LogicalCreateNode : public LogicalUpdateNode {
         // Flatten all inputs. E.g. MATCH (a) CREATE (b). We need to create b for each tuple in the
         // match clause. This is to simplify operator implementation.
         auto childSchema = children[0]->getSchema();
-        return FlattenAllFactorizationSolver::getGroupsPosToFlatten(
+        return factorization::FlattenAll::getGroupsPosToFlatten(
             childSchema->getGroupsPosInScope(), childSchema);
     }
 
@@ -47,7 +47,7 @@ class LogicalCreateRel : public LogicalUpdateRel {
 
     inline f_group_pos_set getGroupsPosToFlatten() {
         auto childSchema = children[0]->getSchema();
-        return FlattenAllFactorizationSolver::getGroupsPosToFlatten(
+        return factorization::FlattenAll::getGroupsPosToFlatten(
             childSchema->getGroupsPosInScope(), childSchema);
     }
 

diff --git a/src/include/planner/logical_plan/logical_operator/logical_delete.h b/src/include/planner/logical_plan/logical_operator/logical_delete.h
@@ -39,7 +39,7 @@ class LogicalDeleteRel : public LogicalUpdateRel {
         auto childSchema = children[0]->getSchema();
         result.insert(childSchema->getGroupPos(*rel->getSrcNode()->getInternalIDProperty()));
         result.insert(childSchema->getGroupPos(*rel->getDstNode()->getInternalIDProperty()));
-        return FlattenAllFactorizationSolver::getGroupsPosToFlatten(result, childSchema);
+        return factorization::FlattenAll::getGroupsPosToFlatten(result, childSchema);
     }
 
     inline std::unique_ptr<LogicalOperator> copy() override {

diff --git a/src/optimizer/factorization_rewriter.cpp b/src/optimizer/factorization_rewriter.cpp
@@ -120,7 +120,7 @@ void FactorizationRewriter::visitProjection(planner::LogicalOperator* op) {
     auto projection = (LogicalProjection*)op;
     for (auto& expression : projection->getExpressionsToProject()) {
         auto dependentGroupsPos = op->getChild(0)->getSchema()->getDependentGroupsPos(expression);
-        auto groupsPosToFlatten = FlattenAllButOneFactorizationSolver::getGroupsPosToFlatten(
+        auto groupsPosToFlatten = factorization::FlattenAllButOne::getGroupsPosToFlatten(
             dependentGroupsPos, op->getChild(0)->getSchema());
         projection->setChild(0, appendFlattens(projection->getChild(0), groupsPosToFlatten));
     }
@@ -185,7 +185,7 @@ void FactorizationRewriter::visitSetNodeProperty(planner::LogicalOperator* op) {
         auto rhs = setNodeProperty->getSetItem(i).second;
         // flatten rhs
         auto rhsDependentGroupsPos = op->getChild(0)->getSchema()->getDependentGroupsPos(rhs);
-        auto rhsGroupsPosToFlatten = FlattenAllButOneFactorizationSolver::getGroupsPosToFlatten(
+        auto rhsGroupsPosToFlatten = factorization::FlattenAllButOne::getGroupsPosToFlatten(
             rhsDependentGroupsPos, op->getChild(0)->getSchema());
         setNodeProperty->setChild(
             0, appendFlattens(setNodeProperty->getChild(0), rhsGroupsPosToFlatten));

diff --git a/src/planner/operator/factorization_resolver.cpp b/src/planner/operator/factorization_resolver.cpp
@@ -1,29 +1,28 @@
 #include "planner/logical_plan/logical_operator/factorization_resolver.h"
 
-#include "planner/logical_plan/logical_operator/logical_flatten.h"
-
 namespace kuzu {
 namespace planner {
+namespace factorization {
 
-std::unordered_set<f_group_pos> FlattenAllButOneFactorizationSolver::getGroupsPosToFlatten(
-    const std::unordered_set<f_group_pos>& groupsPos, Schema* schema) {
+f_group_pos_set FlattenAllButOne::getGroupsPosToFlatten(
+    const f_group_pos_set& groupsPos, Schema* schema) {
     std::vector<f_group_pos> unFlatGroupsPos;
     for (auto groupPos : groupsPos) {
         if (!schema->getGroup(groupPos)->isFlat()) {
             unFlatGroupsPos.push_back(groupPos);
         }
     }
-    std::unordered_set<f_group_pos> result;
+    f_group_pos_set result;
     // Keep the first group as unFlat.
     for (auto i = 1u; i < unFlatGroupsPos.size(); ++i) {
         result.insert(unFlatGroupsPos[i]);
     }
     return result;
 }
 
-std::unordered_set<f_group_pos> FlattenAllFactorizationSolver::getGroupsPosToFlatten(
-    const std::unordered_set<f_group_pos>& groupsPos, Schema* schema) {
-    std::unordered_set<f_group_pos> result;
+f_group_pos_set FlattenAll::getGroupsPosToFlatten(
+    const f_group_pos_set& groupsPos, Schema* schema) {
+    f_group_pos_set result;
     for (auto groupPos : groupsPos) {
         if (!schema->getGroup(groupPos)->isFlat()) {
             result.insert(groupPos);
@@ -32,5 +31,6 @@ std::unordered_set<f_group_pos> FlattenAllFactorizationSolver::getGroupsPosToFla
     return result;
 }
 
+} // namespace factorization
 } // namespace planner
 } // namespace kuzu
diff --git a/src/planner/operator/logical_aggregate.cpp b/src/planner/operator/logical_aggregate.cpp
@@ -6,6 +6,8 @@
 namespace kuzu {
 namespace planner {
 
+using namespace factorization;
+
 f_group_pos_set LogicalAggregate::getGroupsPosToFlattenForGroupBy() {
     f_group_pos_set dependentGroupsPos;
     for (auto& expression : expressionsToGroupBy) {
@@ -14,10 +16,9 @@ f_group_pos_set LogicalAggregate::getGroupsPosToFlattenForGroupBy() {
         }
     }
     if (hasDistinctAggregate()) {
-        return FlattenAllFactorizationSolver::getGroupsPosToFlatten(
-            dependentGroupsPos, children[0]->getSchema());
+        return FlattenAll::getGroupsPosToFlatten(dependentGroupsPos, children[0]->getSchema());
     } else {
-        return FlattenAllButOneFactorizationSolver::getGroupsPosToFlatten(
+        return FlattenAllButOne::getGroupsPosToFlatten(
             dependentGroupsPos, children[0]->getSchema());
     }
 }
@@ -30,8 +31,7 @@ f_group_pos_set LogicalAggregate::getGroupsPosToFlattenForAggregate() {
                 dependentGroupsPos.insert(groupPos);
             }
         }
-        return FlattenAllFactorizationSolver::getGroupsPosToFlatten(
-            dependentGroupsPos, children[0]->getSchema());
+        return FlattenAll::getGroupsPosToFlatten(dependentGroupsPos, children[0]->getSchema());
     }
     return f_group_pos_set{};
 }

diff --git a/src/planner/operator/logical_distinct.cpp b/src/planner/operator/logical_distinct.cpp
@@ -13,7 +13,7 @@ f_group_pos_set LogicalDistinct::getGroupsPosToFlatten() {
             dependentGroupsPos.insert(groupPos);
         }
     }
-    return FlattenAllFactorizationSolver::getGroupsPosToFlatten(dependentGroupsPos, childSchema);
+    return factorization::FlattenAll::getGroupsPosToFlatten(dependentGroupsPos, childSchema);
 }
 
 std::string LogicalDistinct::getExpressionsForPrinting() const {

diff --git a/src/planner/operator/logical_filter.cpp b/src/planner/operator/logical_filter.cpp
@@ -8,8 +8,7 @@ namespace planner {
 f_group_pos_set LogicalFilter::getGroupsPosToFlatten() {
     auto childSchema = children[0]->getSchema();
     auto dependentGroupsPos = childSchema->getDependentGroupsPos(expression);
-    return FlattenAllButOneFactorizationSolver::getGroupsPosToFlatten(
-        dependentGroupsPos, childSchema);
+    return factorization::FlattenAllButOne::getGroupsPosToFlatten(dependentGroupsPos, childSchema);
 }
 
 f_group_pos LogicalFilter::getGroupPosToSelect() const {

diff --git a/src/planner/operator/logical_hash_join.cpp b/src/planner/operator/logical_hash_join.cpp
@@ -25,8 +25,7 @@ f_group_pos_set LogicalHashJoin::getGroupsPosToFlattenOnBuildSide() {
     for (auto& joinNodeID : joinNodeIDs) {
         joinNodesGroupPos.insert(buildSchema->getGroupPos(*joinNodeID));
     }
-    return FlattenAllButOneFactorizationSolver::getGroupsPosToFlatten(
-        joinNodesGroupPos, buildSchema);
+    return factorization::FlattenAllButOne::getGroupsPosToFlatten(joinNodesGroupPos, buildSchema);
 }
 
 void LogicalHashJoin::computeSchema() {

diff --git a/src/planner/operator/logical_limit.cpp b/src/planner/operator/logical_limit.cpp
@@ -5,7 +5,7 @@ namespace planner {
 
 f_group_pos_set LogicalLimit::getGroupsPosToFlatten() {
     auto childSchema = children[0]->getSchema();
-    return FlattenAllButOneFactorizationSolver::getGroupsPosToFlatten(
+    return factorization::FlattenAllButOne::getGroupsPosToFlatten(
         childSchema->getGroupsPosInScope(), childSchema);
 }
 

diff --git a/src/planner/operator/logical_order_by.cpp b/src/planner/operator/logical_order_by.cpp
@@ -28,8 +28,7 @@ f_group_pos_set LogicalOrderBy::getGroupsPosToFlatten() {
                 dependentGroupsPos.insert(groupPos);
             }
         }
-        return FlattenAllFactorizationSolver::getGroupsPosToFlatten(
-            dependentGroupsPos, childSchema);
+        return factorization::FlattenAll::getGroupsPosToFlatten(dependentGroupsPos, childSchema);
     }
     return f_group_pos_set{};
 }

diff --git a/src/planner/operator/logical_set.cpp b/src/planner/operator/logical_set.cpp
@@ -15,7 +15,7 @@ f_group_pos_set LogicalSetRelProperty::getGroupsPosToFlatten(uint32_t setItemIdx
     for (auto groupPos : childSchema->getDependentGroupsPos(rhs)) {
         result.insert(groupPos);
     }
-    return FlattenAllFactorizationSolver::getGroupsPosToFlatten(result, childSchema);
+    return factorization::FlattenAll::getGroupsPosToFlatten(result, childSchema);
 }
 
 } // namespace planner

diff --git a/src/planner/operator/logical_skip.cpp b/src/planner/operator/logical_skip.cpp
@@ -5,7 +5,7 @@ namespace planner {
 
 f_group_pos_set LogicalSkip::getGroupsPosToFlatten() {
     auto childSchema = children[0]->getSchema();
-    return FlattenAllButOneFactorizationSolver::getGroupsPosToFlatten(
+    return factorization::FlattenAllButOne::getGroupsPosToFlatten(
         childSchema->getGroupsPosInScope(), childSchema);
 }
 

diff --git a/src/planner/operator/logical_union.cpp b/src/planner/operator/logical_union.cpp
@@ -15,7 +15,7 @@ f_group_pos_set LogicalUnion::getGroupsPosToFlatten(uint32_t childIdx) {
             groupsPos.insert(childSchema->getGroupPos(*expression));
         }
     }
-    return FlattenAllFactorizationSolver::getGroupsPosToFlatten(groupsPos, childSchema);
+    return factorization::FlattenAll::getGroupsPosToFlatten(groupsPos, childSchema);
 }
 
 void LogicalUnion::computeSchema() {

diff --git a/src/planner/operator/logical_unwind.cpp b/src/planner/operator/logical_unwind.cpp
@@ -8,7 +8,7 @@ namespace planner {
 f_group_pos_set LogicalUnwind::getGroupsPosToFlatten() {
     auto childSchema = children[0]->getSchema();
     auto dependentGroupsPos = childSchema->getDependentGroupsPos(expression);
-    return FlattenAllFactorizationSolver::getGroupsPosToFlatten(dependentGroupsPos, childSchema);
+    return factorization::FlattenAll::getGroupsPosToFlatten(dependentGroupsPos, childSchema);
 }
 
 void LogicalUnwind::computeSchema() {

diff --git a/src/planner/projection_planner.cpp b/src/planner/projection_planner.cpp
@@ -93,7 +93,7 @@ void ProjectionPlanner::appendProjection(
     }
     for (auto& expression : expressionsToProject) {
         auto dependentGroupsPos = plan.getSchema()->getDependentGroupsPos(expression);
-        auto groupsPosToFlatten = FlattenAllButOneFactorizationSolver::getGroupsPosToFlatten(
+        auto groupsPosToFlatten = factorization::FlattenAllButOne::getGroupsPosToFlatten(
             dependentGroupsPos, plan.getSchema());
         QueryPlanner::appendFlattens(groupsPosToFlatten, plan);
     }

diff --git a/src/planner/update_planner.cpp b/src/planner/update_planner.cpp
@@ -112,7 +112,7 @@ void UpdatePlanner::appendSetNodeProperty(
         auto rhs = setItems[i].second;
         // flatten rhs
         auto rhsDependentGroupsPos = plan.getSchema()->getDependentGroupsPos(rhs);
-        auto rhsGroupsPosToFlatten = FlattenAllButOneFactorizationSolver::getGroupsPosToFlatten(
+        auto rhsGroupsPosToFlatten = factorization::FlattenAllButOne::getGroupsPosToFlatten(
             rhsDependentGroupsPos, plan.getSchema());
         QueryPlanner::appendFlattens(rhsGroupsPosToFlatten, plan);
         // flatten lhs if needed