clean

src/include/planner/logical_plan/logical_operator/schema.h

@@ -36,6 +36,7 @@ class FactorizationGroup {
     inline uint64_t getMultiplier() const { return cardinalityMultiplier; }
 
     inline void insertExpression(const shared_ptr<Expression>& expression) {
+        assert(!expressionNameToPos.contains(expression->getUniqueName()));
         expressionNameToPos.insert({expression->getUniqueName(), expressions.size()});
         expressions.push_back(expression);
     }

src/include/processor/mapper/expression_mapper.h

@@ -3,7 +3,6 @@
 #include "binder/expression/expression.h"
 #include "expression_evaluator/base_evaluator.h"
 #include "processor/execution_context.h"
-#include "processor/mapper/mapper_context.h"
 #include "processor/result/result_set.h"
 #include "processor/result/result_set_descriptor.h"
 

src/include/processor/mapper/plan_mapper.h

@@ -3,7 +3,6 @@
 #include "binder/expression/node_expression.h"
 #include "planner/logical_plan/logical_plan.h"
 #include "processor/mapper/expression_mapper.h"
-#include "processor/mapper/mapper_context.h"
 #include "processor/operator/result_collector.h"
 #include "processor/physical_plan.h"
 #include "storage/storage_manager.h"

src/processor/mapper/map_create.cpp

@@ -9,23 +9,23 @@ namespace processor {
 unique_ptr<PhysicalOperator> PlanMapper::mapLogicalCreateNodeToPhysical(
     LogicalOperator* logicalOperator) {
     auto logicalCreateNode = (LogicalCreateNode*)logicalOperator;
-    auto schema = logicalCreateNode->getSchema();
-    auto childSchema = logicalCreateNode->getChild(0)->getSchema();
+    auto outSchema = logicalCreateNode->getSchema();
+    auto inSchema = logicalCreateNode->getChild(0)->getSchema();
     auto prevOperator = mapLogicalOperatorToPhysical(logicalOperator->getChild(0));
     auto& nodesStore = storageManager.getNodesStore();
     auto catalogContent = catalog->getReadOnlyVersion();
     vector<unique_ptr<CreateNodeInfo>> createNodeInfos;
     for (auto& [node, primaryKey] : logicalCreateNode->getNodeAndPrimaryKeys()) {
         auto nodeTableID = node->getSingleTableID();
         auto table = nodesStore.getNodeTable(nodeTableID);
-        auto primaryKeyEvaluator = expressionMapper.mapExpression(primaryKey, *childSchema);
+        auto primaryKeyEvaluator = expressionMapper.mapExpression(primaryKey, *inSchema);
         vector<RelTable*> relTablesToInit;
         for (auto& [relTableID, relTableSchema] : catalogContent->getRelTableSchemas()) {
             if (relTableSchema->edgeContainsNodeTable(nodeTableID)) {
                 relTablesToInit.push_back(storageManager.getRelsStore().getRelTable(relTableID));
             }
         }
-        auto outDataPos = DataPos(schema->getExpressionPos(*node->getInternalIDProperty()));
+        auto outDataPos = DataPos(outSchema->getExpressionPos(*node->getInternalIDProperty()));
         createNodeInfos.push_back(make_unique<CreateNodeInfo>(
             table, std::move(primaryKeyEvaluator), relTablesToInit, outDataPos));
     }

src/processor/mapper/map_delete.cpp

@@ -9,14 +9,14 @@ namespace processor {
 unique_ptr<PhysicalOperator> PlanMapper::mapLogicalDeleteNodeToPhysical(
     LogicalOperator* logicalOperator) {
     auto logicalDeleteNode = (LogicalDeleteNode*)logicalOperator;
-    auto schema = logicalDeleteNode->getSchema();
+    auto inSchema = logicalDeleteNode->getChild(0)->getSchema();
     auto prevOperator = mapLogicalOperatorToPhysical(logicalOperator->getChild(0));
     auto& nodesStore = storageManager.getNodesStore();
     vector<unique_ptr<DeleteNodeInfo>> deleteNodeInfos;
     for (auto& [node, primaryKey] : logicalDeleteNode->getNodeAndPrimaryKeys()) {
         auto nodeTable = nodesStore.getNodeTable(node->getSingleTableID());
-        auto nodeIDPos = DataPos(schema->getExpressionPos(*node->getInternalIDProperty()));
-        auto primaryKeyPos = DataPos(schema->getExpressionPos(*primaryKey));
+        auto nodeIDPos = DataPos(inSchema->getExpressionPos(*node->getInternalIDProperty()));
+        auto primaryKeyPos = DataPos(inSchema->getExpressionPos(*primaryKey));
         deleteNodeInfos.push_back(make_unique<DeleteNodeInfo>(nodeTable, nodeIDPos, primaryKeyPos));
     }
     return make_unique<DeleteNode>(std::move(deleteNodeInfos), std::move(prevOperator),
@@ -26,20 +26,20 @@ unique_ptr<PhysicalOperator> PlanMapper::mapLogicalDeleteNodeToPhysical(
 unique_ptr<PhysicalOperator> PlanMapper::mapLogicalDeleteRelToPhysical(
     LogicalOperator* logicalOperator) {
     auto logicalDeleteRel = (LogicalDeleteRel*)logicalOperator;
-    auto schema = logicalDeleteRel->getSchema();
+    auto inSchema = logicalDeleteRel->getChild(0)->getSchema();
     auto prevOperator = mapLogicalOperatorToPhysical(logicalOperator->getChild(0));
     auto& relStore = storageManager.getRelsStore();
     vector<unique_ptr<DeleteRelInfo>> createRelInfos;
     for (auto i = 0u; i < logicalDeleteRel->getNumRels(); ++i) {
         auto rel = logicalDeleteRel->getRel(i);
         auto table = relStore.getRelTable(rel->getSingleTableID());
         auto srcNodePos =
-            DataPos(schema->getExpressionPos(*rel->getSrcNode()->getInternalIDProperty()));
+            DataPos(inSchema->getExpressionPos(*rel->getSrcNode()->getInternalIDProperty()));
         auto srcNodeTableID = rel->getSrcNode()->getSingleTableID();
         auto dstNodePos =
-            DataPos(schema->getExpressionPos(*rel->getDstNode()->getInternalIDProperty()));
+            DataPos(inSchema->getExpressionPos(*rel->getDstNode()->getInternalIDProperty()));
         auto dstNodeTableID = rel->getDstNode()->getSingleTableID();
-        auto relIDPos = DataPos(schema->getExpressionPos(*rel->getInternalIDProperty()));
+        auto relIDPos = DataPos(inSchema->getExpressionPos(*rel->getInternalIDProperty()));
         createRelInfos.push_back(make_unique<DeleteRelInfo>(
             table, srcNodePos, srcNodeTableID, dstNodePos, dstNodeTableID, relIDPos));
     }

src/processor/mapper/map_distinct.cpp

@@ -16,8 +16,8 @@ unique_ptr<PhysicalOperator> PlanMapper::mapLogicalDistinctToPhysical(
     vector<DataType> emptyOutputAggVectorsDataTypes;
     return createHashAggregate(std::move(emptyAggregateFunctions), emptyInputAggVectorsPos,
         emptyOutputAggVectorsPos, emptyOutputAggVectorsDataTypes,
-        logicalDistinct.getExpressionsToDistinct(), std::move(prevOperator), *inSchema,
-        *outSchema, logicalDistinct.getExpressionsForPrinting());
+        logicalDistinct.getExpressionsToDistinct(), std::move(prevOperator), *inSchema, *outSchema,
+        logicalDistinct.getExpressionsForPrinting());
 }
 
 } // namespace processor

src/processor/mapper/map_expressions_scan.cpp

@@ -17,9 +17,9 @@ unique_ptr<PhysicalOperator> PlanMapper::mapLogicalExpressionsScanToPhysical(
     unique_ptr<FactorizedTableSchema> tableSchema = make_unique<FactorizedTableSchema>();
     vector<shared_ptr<ValueVector>> vectors;
     for (auto& expression : expressions) {
-        tableSchema->appendColumn(make_unique<ColumnSchema>(false,
-            0 /* all expressions are in the same datachunk*/,
-            Types::getDataTypeSize(expression->dataType)));
+        tableSchema->appendColumn(
+            make_unique<ColumnSchema>(false, 0 /* all expressions are in the same datachunk */,
+                Types::getDataTypeSize(expression->dataType)));
         auto expressionEvaluator = expressionMapper.mapExpression(expression, *inSchema);
         // expression can be evaluated statically and does not require an actual resultset to init
         expressionEvaluator->init(ResultSet(0) /* dummy resultset */, memoryManager);

src/processor/mapper/map_union.cpp

@@ -18,8 +18,8 @@ unique_ptr<PhysicalOperator> PlanMapper::mapLogicalUnionAllToPhysical(
         auto child = logicalOperator->getChild(i);
         auto childSchema = logicalUnionAll.getSchemaBeforeUnion(i);
         auto prevOperator = mapLogicalOperatorToPhysical(child);
-        auto resultCollector = appendResultCollector(childSchema->getExpressionsInScope(),
-            *childSchema, std::move(prevOperator));
+        auto resultCollector = appendResultCollector(
+            childSchema->getExpressionsInScope(), *childSchema, std::move(prevOperator));
         resultCollectorSharedStates.push_back(resultCollector->getSharedState());
         prevOperators.push_back(std::move(resultCollector));
     }