clean up

kuzudb · Dec 2, 2022 · e5b78d0 · e5b78d0
1 parent 83bf4b2
commit e5b78d0
Show file tree

Hide file tree

Showing 11 changed files with 22 additions and 23 deletions.
diff --git a/src/include/planner/logical_plan/logical_operator/logical_extend.h b/src/include/planner/logical_plan/logical_operator/logical_extend.h
@@ -31,7 +31,7 @@ class LogicalExtend : public LogicalOperator {
         if (!extendToNewGroup) {
             nbrGroupPos = boundGroupPos;
         } else {
-            assert(schema.getGroup(boundGroupPos)->getIsFlat());
+            assert(schema.getGroup(boundGroupPos)->isFlat());
             nbrGroupPos = schema.createGroup();
         }
         schema.insertToGroupAndScope(nbrNode->getInternalIDProperty(), nbrGroupPos);

diff --git a/src/include/planner/logical_plan/logical_operator/logical_hash_join.h b/src/include/planner/logical_plan/logical_operator/logical_hash_join.h
@@ -67,8 +67,8 @@ class LogicalHashJoin : public LogicalOperator {
 
     inline unique_ptr<LogicalOperator> copy() override {
         return make_unique<LogicalHashJoin>(joinNodes, joinType, mark, isProbeAcc,
-            buildSideSchema->copy(), expressionsToMaterialize,
-            children[0]->copy(), children[1]->copy());
+            buildSideSchema->copy(), expressionsToMaterialize, children[0]->copy(),
+            children[1]->copy());
     }
 
 private:

diff --git a/src/include/planner/logical_plan/logical_operator/schema.h b/src/include/planner/logical_plan/logical_operator/schema.h
@@ -23,15 +23,13 @@ class FactorizationGroup {
         assert(!flat);
         flat = true;
     }
-    // TODO: remove
-    inline bool getIsFlat() const { return flat;}
     inline bool isFlat() const { return flat; }
     inline void setSingleState() {
         assert(!singleState);
         singleState = true;
         setFlat();
     }
-    inline bool isSingleState() const {return singleState;}
+    inline bool isSingleState() const { return singleState; }
 
     inline void setMultiplier(uint64_t multiplier) { cardinalityMultiplier = multiplier; }
     inline uint64_t getMultiplier() const { return cardinalityMultiplier; }

diff --git a/src/planner/operator/sink_util.cpp b/src/planner/operator/sink_util.cpp
@@ -23,7 +23,7 @@ void SinkOperatorUtil::mergeSchema(
     }
     for (auto& payloadGroupPos : getGroupsPosIgnoringKeyGroups(inputSchema, keys)) {
         auto payloadGroup = inputSchema.getGroup(payloadGroupPos);
-        if (!payloadGroup->getIsFlat()) {
+        if (!payloadGroup->isFlat()) {
             auto payloads = inputSchema.getExpressionsInScope(payloadGroupPos);
             auto outputGroupPos = appendPayloadsToNewGroup(result, payloads);
             result.getGroup(outputGroupPos)->setMultiplier(payloadGroup->getMultiplier());
@@ -42,7 +42,7 @@ void SinkOperatorUtil::mergeSchema(const Schema& inputSchema, Schema& result) {
         }
         for (auto& payloadGroupPos : inputSchema.getGroupsPosInScope()) {
             auto payloadGroup = inputSchema.getGroup(payloadGroupPos);
-            if (!payloadGroup->getIsFlat()) {
+            if (!payloadGroup->isFlat()) {
                 auto payloads = inputSchema.getExpressionsInScope(payloadGroupPos);
                 auto outputGroupPos = appendPayloadsToNewGroup(result, payloads);
                 result.getGroup(outputGroupPos)->setMultiplier(payloadGroup->getMultiplier());
@@ -83,7 +83,7 @@ expression_vector SinkOperatorUtil::getFlatPayloads(
     const Schema& schema, const unordered_set<uint32_t>& payloadGroupsPos) {
     expression_vector result;
     for (auto& payloadGroupPos : payloadGroupsPos) {
-        if (schema.getGroup(payloadGroupPos)->getIsFlat()) {
+        if (schema.getGroup(payloadGroupPos)->isFlat()) {
             for (auto& payload : schema.getExpressionsInScope(payloadGroupPos)) {
                 result.push_back(payload);
             }
@@ -95,7 +95,7 @@ expression_vector SinkOperatorUtil::getFlatPayloads(
 bool SinkOperatorUtil::hasUnFlatPayload(
     const Schema& schema, const unordered_set<uint32_t>& payloadGroupsPos) {
     for (auto& payloadGroupPos : payloadGroupsPos) {
-        if (!schema.getGroup(payloadGroupPos)->getIsFlat()) {
+        if (!schema.getGroup(payloadGroupPos)->isFlat()) {
             return true;
         }
     }

diff --git a/src/planner/projection_planner.cpp b/src/planner/projection_planner.cpp
@@ -112,7 +112,8 @@ void ProjectionPlanner::appendProjection(
             uint32_t outputPos;
             if (dependentGroupsPos.empty()) { // e.g. constant that does not depend on any input.
                 outputPos = schema->createGroup();
-                schema->flattenGroup(outputPos); // Mark group holding constant as flat.
+                // Mark group holding constant as single state.
+                schema->setGroupAsSingleState(outputPos);
             } else {
                 outputPos = QueryPlanner::appendFlattensButOne(dependentGroupsPos, plan);
             }

diff --git a/src/planner/query_planner.cpp b/src/planner/query_planner.cpp
@@ -278,7 +278,7 @@ void QueryPlanner::appendExpressionsScan(const expression_vector& expressions, L
     assert(plan.isEmpty());
     auto schema = plan.getSchema();
     auto groupPos = schema->createGroup();
-    schema->setGroupAsSingleState(groupPos);
+    schema->setGroupAsSingleState(groupPos); // Mark group holding constant as single state.
     for (auto& expression : expressions) {
         // No need to insert repeated constant.
         if (schema->isExpressionInScope(*expression)) {
@@ -334,7 +334,7 @@ uint32_t QueryPlanner::appendFlattensButOne(
     }
     vector<uint32_t> unFlatGroupsPos;
     for (auto& groupPos : groupsPos) {
-        if (!plan.getSchema()->getGroup(groupPos)->getIsFlat()) {
+        if (!plan.getSchema()->getGroup(groupPos)->isFlat()) {
             unFlatGroupsPos.push_back(groupPos);
         }
     }
@@ -351,7 +351,7 @@ void QueryPlanner::appendFlattenIfNecessary(
     const shared_ptr<Expression>& expression, LogicalPlan& plan) {
     auto schema = plan.getSchema();
     auto group = schema->getGroup(expression);
-    if (group->getIsFlat()) {
+    if (group->isFlat()) {
         return;
     }
     auto flatten = make_shared<LogicalFlatten>(expression, plan.getLastOperator());
@@ -427,7 +427,7 @@ unique_ptr<LogicalPlan> QueryPlanner::createUnionPlan(
         for (auto& childPlan : childrenPlans) {
             auto childSchema = childPlan->getSchema();
             auto expressionName = childSchema->getExpressionsInScope()[i]->getUniqueName();
-            hasFlatExpression |= childSchema->getGroup(expressionName)->getIsFlat();
+            hasFlatExpression |= childSchema->getGroup(expressionName)->isFlat();
         }
         if (hasFlatExpression) {
             for (auto& childPlan : childrenPlans) {

diff --git a/src/planner/update_planner.cpp b/src/planner/update_planner.cpp
@@ -48,12 +48,12 @@ void UpdatePlanner::planSetItem(expression_pair setItem, LogicalPlan& plan) {
     assert(lhs->getChild(0)->dataType.typeID == NODE);
     auto nodeExpression = static_pointer_cast<NodeExpression>(lhs->getChild(0));
     auto lhsGroupPos = schema->getGroupPos(nodeExpression->getInternalIDPropertyName());
-    auto isLhsFlat = schema->getGroup(lhsGroupPos)->getIsFlat();
+    auto isLhsFlat = schema->getGroup(lhsGroupPos)->isFlat();
     // Check RHS
     auto rhsDependentGroupsPos = schema->getDependentGroupsPos(rhs);
     if (!rhsDependentGroupsPos.empty()) { // RHS is not constant
         auto rhsPos = QueryPlanner::appendFlattensButOne(rhsDependentGroupsPos, plan);
-        auto isRhsFlat = schema->getGroup(rhsPos)->getIsFlat();
+        auto isRhsFlat = schema->getGroup(rhsPos)->isFlat();
         // If both are unflat and from different groups, we flatten LHS.
         if (!isRhsFlat && !isLhsFlat && lhsGroupPos != rhsPos) {
             QueryPlanner::appendFlattenIfNecessary(lhsGroupPos, plan);

diff --git a/src/processor/mapper/map_aggregate.cpp b/src/processor/mapper/map_aggregate.cpp
@@ -104,7 +104,7 @@ void PlanMapper::appendGroupByExpressions(const expression_vector& groupByExpres
     vector<DataType>& outputGroupByKeyVectorsDataTypes, MapperContext& mapperContextBeforeAggregate,
     MapperContext& mapperContext, Schema* schema, vector<bool>& isInputGroupByHashKeyVectorFlat) {
     for (auto& expression : groupByExpressions) {
-        if (schema->getGroup(expression->getUniqueName())->getIsFlat()) {
+        if (schema->getGroup(expression->getUniqueName())->isFlat()) {
             inputGroupByHashKeyVectorsPos.push_back(
                 mapperContextBeforeAggregate.getDataPos(expression->getUniqueName()));
             outputGroupByKeyVectorsPos.push_back(
@@ -116,7 +116,7 @@ void PlanMapper::appendGroupByExpressions(const expression_vector& groupByExpres
     }
 
     for (auto& expression : groupByExpressions) {
-        if (!schema->getGroup(expression->getUniqueName())->getIsFlat()) {
+        if (!schema->getGroup(expression->getUniqueName())->isFlat()) {
             inputGroupByHashKeyVectorsPos.push_back(
                 mapperContextBeforeAggregate.getDataPos(expression->getUniqueName()));
             outputGroupByKeyVectorsPos.push_back(

diff --git a/src/processor/mapper/map_hash_join.cpp b/src/processor/mapper/map_hash_join.cpp
@@ -159,8 +159,8 @@ unique_ptr<PhysicalOperator> PlanMapper::mapLogicalHashJoinToPhysical(
         probeDataInfo.markDataPos = markOutputPos;
     }
     auto hashJoinProbe = make_unique<HashJoinProbe>(sharedState, hashJoin->getJoinType(),
-        probeDataInfo, std::move(probeSidePrevOperator),
-        std::move(hashJoinBuild), getOperatorID(), paramsString);
+        probeDataInfo, std::move(probeSidePrevOperator), std::move(hashJoinBuild), getOperatorID(),
+        paramsString);
     if (hashJoin->getIsProbeAcc()) {
         if (containASPOnPipeline(hashJoin)) {
             mapASPJoin(hashJoin->getJoinNodes()[0].get(), hashJoinProbe.get());

diff --git a/src/processor/mapper/map_order_by.cpp b/src/processor/mapper/map_order_by.cpp
@@ -29,7 +29,7 @@ unique_ptr<PhysicalOperator> PlanMapper::mapLogicalOrderByToPhysical(
         auto expressionName = expression->getUniqueName();
         payloadsPosAndType.emplace_back(
             mapperContextBeforeOrderBy.getDataPos(expressionName), expression->dataType);
-        isPayloadFlat.push_back(schemaBeforeOrderBy.getGroup(expressionName)->getIsFlat());
+        isPayloadFlat.push_back(schemaBeforeOrderBy.getGroup(expressionName)->isFlat());
         outVectorPosAndTypes.emplace_back(
             mapperContext.getDataPos(expressionName), expression->dataType);
         mapperContext.addComputedExpressions(expressionName);

diff --git a/src/processor/mapper/plan_mapper.cpp b/src/processor/mapper/plan_mapper.cpp
@@ -138,7 +138,7 @@ unique_ptr<ResultCollector> PlanMapper::appendResultCollector(
     for (auto& expression : expressionsToCollect) {
         auto expressionName = expression->getUniqueName();
         auto dataPos = mapperContext.getDataPos(expressionName);
-        auto isFlat = schema.getGroup(expressionName)->getIsFlat();
+        auto isFlat = schema.getGroup(expressionName)->isFlat();
         payloadsPosAndType.emplace_back(dataPos, expression->dataType);
         isPayloadFlat.push_back(isFlat);
     }