kuzudb · andyfengHKU · Mar 8, 2023 · Mar 5, 2023
diff --git a/src/include/optimizer/projection_push_down_optimizer.h b/src/include/optimizer/projection_push_down_optimizer.h
@@ -37,6 +37,9 @@ class ProjectionPushDownOptimizer : public LogicalOperatorVisitor {
 
     binder::expression_vector pruneExpressions(const binder::expression_vector& expressions);
 
+    void preAppendProjection(
+        planner::LogicalOperator* op, uint32_t childIdx, binder::expression_vector expressions);
+
 private:
     binder::expression_set propertiesInUse;
 };

diff --git a/src/include/planner/logical_plan/logical_operator/base_logical_operator.h b/src/include/planner/logical_plan/logical_operator/base_logical_operator.h
@@ -77,7 +77,8 @@ class LogicalOperator {
     inline LogicalOperatorType getOperatorType() const { return operatorType; }
 
     inline Schema* getSchema() const { return schema.get(); }
-    virtual void computeSchema() = 0;
+    virtual void computeFactorizedSchema() = 0;
+    virtual void computeFlatSchema() = 0;
 
     virtual std::string getExpressionsForPrinting() const = 0;
 

diff --git a/src/include/planner/logical_plan/logical_operator/logical_accumulate.h b/src/include/planner/logical_plan/logical_operator/logical_accumulate.h
@@ -7,28 +7,21 @@ namespace planner {
 
 class LogicalAccumulate : public LogicalOperator {
 public:
-    LogicalAccumulate(binder::expression_vector expressions, std::shared_ptr<LogicalOperator> child)
-        : LogicalOperator{LogicalOperatorType::ACCUMULATE, std::move(child)}, expressions{std::move(
-                                                                                  expressions)} {}
+    LogicalAccumulate(std::shared_ptr<LogicalOperator> child)
+        : LogicalOperator{LogicalOperatorType::ACCUMULATE, std::move(child)} {}
 
-    void computeSchema() override;
+    void computeFactorizedSchema() override;
+    void computeFlatSchema() override;
 
-    inline std::string getExpressionsForPrinting() const override {
-        return binder::ExpressionUtil::toString(expressions);
-    }
+    inline std::string getExpressionsForPrinting() const override { return std::string{}; }
 
-    inline void setExpressions(binder::expression_vector expressions_) {
-        expressions = std::move(expressions_);
+    inline binder::expression_vector getExpressions() const {
+        return children[0]->getSchema()->getExpressionsInScope();
     }
-    inline binder::expression_vector getExpressions() const { return expressions; }
-    inline Schema* getSchemaBeforeSink() const { return children[0]->getSchema(); }
 
     inline std::unique_ptr<LogicalOperator> copy() override {
-        return make_unique<LogicalAccumulate>(expressions, children[0]->copy());
+        return make_unique<LogicalAccumulate>(children[0]->copy());
     }
-
-private:
-    binder::expression_vector expressions;
 };
 
 } // namespace planner

diff --git a/src/include/planner/logical_plan/logical_operator/logical_aggregate.h b/src/include/planner/logical_plan/logical_operator/logical_aggregate.h
@@ -13,11 +13,12 @@ class LogicalAggregate : public LogicalOperator {
           expressionsToGroupBy{std::move(expressionsToGroupBy)}, expressionsToAggregate{std::move(
                                                                      expressionsToAggregate)} {}
 
+    void computeFactorizedSchema() override;
+    void computeFlatSchema() override;
+
     f_group_pos_set getGroupsPosToFlattenForGroupBy();
     f_group_pos_set getGroupsPosToFlattenForAggregate();
 
-    void computeSchema() override;
-
     std::string getExpressionsForPrinting() const override;
 
     inline bool hasExpressionsToGroupBy() const { return !expressionsToGroupBy.empty(); }

diff --git a/src/include/planner/logical_plan/logical_operator/logical_copy.h b/src/include/planner/logical_plan/logical_operator/logical_copy.h
@@ -15,7 +15,8 @@ class LogicalCopy : public LogicalOperator {
         : LogicalOperator{LogicalOperatorType::COPY_CSV},
           copyDescription{copyDescription}, tableID{tableID}, tableName{std::move(tableName)} {}
 
-    inline void computeSchema() override { createEmptySchema(); }
+    inline void computeFactorizedSchema() override { createEmptySchema(); }
+    inline void computeFlatSchema() override { createEmptySchema(); }
 
     inline std::string getExpressionsForPrinting() const override { return tableName; }
 

diff --git a/src/include/planner/logical_plan/logical_operator/logical_create.h b/src/include/planner/logical_plan/logical_operator/logical_create.h
@@ -14,7 +14,8 @@ class LogicalCreateNode : public LogicalUpdateNode {
           primaryKeys{std::move(primaryKeys)} {}
     ~LogicalCreateNode() override = default;
 
-    void computeSchema() override;
+    void computeFactorizedSchema() override;
+    void computeFlatSchema() override;
 
     inline f_group_pos_set getGroupsPosToFlatten() {
         // Flatten all inputs. E.g. MATCH (a) CREATE (b). We need to create b for each tuple in the
@@ -45,6 +46,9 @@ class LogicalCreateRel : public LogicalUpdateRel {
           setItemsPerRel{std::move(setItemsPerRel)} {}
     ~LogicalCreateRel() override = default;
 
+    inline void computeFactorizedSchema() override { copyChildSchema(0); }
+    inline void computeFlatSchema() override { copyChildSchema(0); }
+
     inline f_group_pos_set getGroupsPosToFlatten() {
         auto childSchema = children[0]->getSchema();
         return factorization::FlattenAll::getGroupsPosToFlatten(

diff --git a/src/include/planner/logical_plan/logical_operator/logical_cross_product.h b/src/include/planner/logical_plan/logical_operator/logical_cross_product.h
@@ -13,7 +13,8 @@ class LogicalCrossProduct : public LogicalOperator {
         : LogicalOperator{LogicalOperatorType::CROSS_PRODUCT, std::move(probeSideChild),
               std::move(buildSideChild)} {}
 
-    void computeSchema() override;
+    void computeFactorizedSchema() override;
+    void computeFlatSchema() override;
 
     inline std::string getExpressionsForPrinting() const override { return std::string(); }
 

diff --git a/src/include/planner/logical_plan/logical_operator/logical_ddl.h b/src/include/planner/logical_plan/logical_operator/logical_ddl.h
@@ -12,20 +12,16 @@ class LogicalDDL : public LogicalOperator {
         : LogicalOperator{operatorType}, tableName{std::move(tableName)},
           outputExpression{std::move(outputExpression)} {}
 
+    void computeFactorizedSchema() override;
+    void computeFlatSchema() override;
+
     inline std::string getTableName() const { return tableName; }
     inline std::shared_ptr<binder::Expression> getOutputExpression() const {
         return outputExpression;
     }
 
     inline std::string getExpressionsForPrinting() const override { return tableName; }
 
-    inline void computeSchema() override {
-        schema = std::make_unique<Schema>();
-        auto groupPos = schema->createGroup();
-        schema->insertToGroupAndScope(outputExpression, groupPos);
-        schema->setGroupAsSingleState(groupPos);
-    }
-
 protected:
     std::string tableName;
     std::shared_ptr<binder::Expression> outputExpression;

diff --git a/src/include/planner/logical_plan/logical_operator/logical_delete.h b/src/include/planner/logical_plan/logical_operator/logical_delete.h
@@ -14,6 +14,9 @@ class LogicalDeleteNode : public LogicalUpdateNode {
           primaryKeys{std::move(primaryKeys)} {}
     ~LogicalDeleteNode() override = default;
 
+    inline void computeFactorizedSchema() override { copyChildSchema(0); }
+    inline void computeFlatSchema() override { copyChildSchema(0); }
+
     inline std::shared_ptr<binder::Expression> getPrimaryKey(size_t idx) const {
         return primaryKeys[idx];
     }
@@ -33,6 +36,9 @@ class LogicalDeleteRel : public LogicalUpdateRel {
         : LogicalUpdateRel{LogicalOperatorType::DELETE_REL, std::move(rels), std::move(child)} {}
     ~LogicalDeleteRel() override = default;
 
+    inline void computeFactorizedSchema() override { copyChildSchema(0); }
+    inline void computeFlatSchema() override { copyChildSchema(0); }
+
     inline f_group_pos_set getGroupsPosToFlatten(uint32_t relIdx) {
         f_group_pos_set result;
         auto rel = rels[relIdx];

diff --git a/src/include/planner/logical_plan/logical_operator/logical_distinct.h b/src/include/planner/logical_plan/logical_operator/logical_distinct.h
@@ -13,9 +13,10 @@ class LogicalDistinct : public LogicalOperator {
         : LogicalOperator{LogicalOperatorType::DISTINCT, std::move(child)},
           expressionsToDistinct{std::move(expressionsToDistinct)} {}
 
-    f_group_pos_set getGroupsPosToFlatten();
+    void computeFactorizedSchema() override;
+    void computeFlatSchema() override;
 
-    void computeSchema() override;
+    f_group_pos_set getGroupsPosToFlatten();
 
     std::string getExpressionsForPrinting() const override;
 

diff --git a/src/include/planner/logical_plan/logical_operator/logical_expressions_scan.h b/src/include/planner/logical_plan/logical_operator/logical_expressions_scan.h
@@ -14,7 +14,8 @@ class LogicalExpressionsScan : public LogicalOperator {
         : LogicalOperator{LogicalOperatorType::EXPRESSIONS_SCAN}, expressions{
                                                                       std::move(expressions)} {}
 
-    void computeSchema() override;
+    void computeFactorizedSchema() override;
+    void computeFlatSchema() override;
 
     inline std::string getExpressionsForPrinting() const override {
         return binder::ExpressionUtil::toString(expressions);

diff --git a/src/include/planner/logical_plan/logical_operator/logical_extend.h b/src/include/planner/logical_plan/logical_operator/logical_extend.h
@@ -19,7 +19,8 @@ class LogicalExtend : public LogicalOperator {
 
     f_group_pos_set getGroupsPosToFlatten();
 
-    void computeSchema() override;
+    void computeFactorizedSchema() override;
+    void computeFlatSchema() override;
 
     inline std::string getExpressionsForPrinting() const override {
         return boundNode->toString() + (direction == common::RelDirection::FWD ? "->" : "<-") +

diff --git a/src/include/planner/logical_plan/logical_operator/logical_filter.h b/src/include/planner/logical_plan/logical_operator/logical_filter.h
@@ -13,9 +13,10 @@ class LogicalFilter : public LogicalOperator {
         : LogicalOperator{LogicalOperatorType::FILTER, std::move(child)}, expression{std::move(
                                                                               expression)} {}
 
-    f_group_pos_set getGroupsPosToFlatten();
+    inline void computeFactorizedSchema() override { copyChildSchema(0); }
+    inline void computeFlatSchema() override { copyChildSchema(0); }
 
-    inline void computeSchema() override { copyChildSchema(0); }
+    f_group_pos_set getGroupsPosToFlatten();
 
     inline std::string getExpressionsForPrinting() const override { return expression->toString(); }
 

diff --git a/src/include/planner/logical_plan/logical_operator/logical_flatten.h b/src/include/planner/logical_plan/logical_operator/logical_flatten.h
@@ -11,7 +11,8 @@ class LogicalFlatten : public LogicalOperator {
     LogicalFlatten(f_group_pos groupPos, std::shared_ptr<LogicalOperator> child)
         : LogicalOperator{LogicalOperatorType::FLATTEN, std::move(child)}, groupPos{groupPos} {}
 
-    void computeSchema() override;
+    void computeFactorizedSchema() override;
+    void computeFlatSchema() override;
 
     inline std::string getExpressionsForPrinting() const override { return std::string{}; }
 

diff --git a/src/include/planner/logical_plan/logical_operator/logical_ftable_scan.h b/src/include/planner/logical_plan/logical_operator/logical_ftable_scan.h
@@ -13,7 +13,8 @@ class LogicalFTableScan : public LogicalOperator {
           expressionsToScan{std::move(expressionsToScan)}, schemaToScanFrom{
                                                                std::move(schemaToScanFrom)} {}
 
-    void computeSchema() override;
+    void computeFactorizedSchema() override;
+    void computeFlatSchema() override;
 
     inline std::string getExpressionsForPrinting() const override {
         return binder::ExpressionUtil::toString(expressionsToScan);

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
@@ -14,46 +14,38 @@ class LogicalHashJoin : public LogicalOperator {
 public:
     // Inner and left join.
     LogicalHashJoin(binder::expression_vector joinNodeIDs, common::JoinType joinType,
-        bool isProbeAcc, binder::expression_vector expressionsToMaterialize,
-        std::shared_ptr<LogicalOperator> probeSideChild,
+        bool isProbeAcc, std::shared_ptr<LogicalOperator> probeSideChild,
         std::shared_ptr<LogicalOperator> buildSideChild)
         : LogicalHashJoin{std::move(joinNodeIDs), joinType, nullptr, isProbeAcc,
-              std::move(expressionsToMaterialize), std::move(probeSideChild),
-              std::move(buildSideChild)} {}
+              std::move(probeSideChild), std::move(buildSideChild)} {}
 
     // Mark join.
     LogicalHashJoin(binder::expression_vector joinNodeIDs, std::shared_ptr<binder::Expression> mark,
         bool isProbeAcc, std::shared_ptr<LogicalOperator> probeSideChild,
         std::shared_ptr<LogicalOperator> buildSideChild)
         : LogicalHashJoin{std::move(joinNodeIDs), common::JoinType::MARK, std::move(mark),
-              isProbeAcc, binder::expression_vector{} /* expressionsToMaterialize */,
-              std::move(probeSideChild), std::move(buildSideChild)} {}
+              isProbeAcc, std::move(probeSideChild), std::move(buildSideChild)} {}
 
     LogicalHashJoin(binder::expression_vector joinNodeIDs, common::JoinType joinType,
         std::shared_ptr<binder::Expression> mark, bool isProbeAcc,
-        binder::expression_vector expressionsToMaterialize,
         std::shared_ptr<LogicalOperator> probeSideChild,
         std::shared_ptr<LogicalOperator> buildSideChild)
         : LogicalOperator{LogicalOperatorType::HASH_JOIN, std::move(probeSideChild),
               std::move(buildSideChild)},
           joinNodeIDs(std::move(joinNodeIDs)), joinType{joinType}, mark{std::move(mark)},
-          isProbeAcc{isProbeAcc}, expressionsToMaterialize{std::move(expressionsToMaterialize)} {}
+          isProbeAcc{isProbeAcc} {}
 
     f_group_pos_set getGroupsPosToFlattenOnProbeSide();
     f_group_pos_set getGroupsPosToFlattenOnBuildSide();
 
-    void computeSchema() override;
+    void computeFactorizedSchema() override;
+    void computeFlatSchema() override;
 
     inline std::string getExpressionsForPrinting() const override {
         return binder::ExpressionUtil::toString(joinNodeIDs);
     }
 
-    inline void setExpressionsToMaterialize(binder::expression_vector expressions) {
-        expressionsToMaterialize = std::move(expressions);
-    }
-    inline binder::expression_vector getExpressionsToMaterialize() const {
-        return expressionsToMaterialize;
-    }
+    binder::expression_vector getExpressionsToMaterialize() const;
     inline binder::expression_vector getJoinNodeIDs() const { return joinNodeIDs; }
     inline common::JoinType getJoinType() const { return joinType; }
 
@@ -62,11 +54,10 @@ class LogicalHashJoin : public LogicalOperator {
         return mark;
     }
     inline bool getIsProbeAcc() const { return isProbeAcc; }
-    inline Schema* getBuildSideSchema() const { return children[1]->getSchema(); }
 
     inline std::unique_ptr<LogicalOperator> copy() override {
-        return make_unique<LogicalHashJoin>(joinNodeIDs, joinType, mark, isProbeAcc,
-            expressionsToMaterialize, children[0]->copy(), children[1]->copy());
+        return make_unique<LogicalHashJoin>(
+            joinNodeIDs, joinType, mark, isProbeAcc, children[0]->copy(), children[1]->copy());
     }
 
 private:
@@ -86,7 +77,6 @@ class LogicalHashJoin : public LogicalOperator {
     common::JoinType joinType;
     std::shared_ptr<binder::Expression> mark; // when joinType is Mark
     bool isProbeAcc;
-    binder::expression_vector expressionsToMaterialize;
 };
 
 } // namespace planner

diff --git a/src/include/planner/logical_plan/logical_operator/logical_intersect.h b/src/include/planner/logical_plan/logical_operator/logical_intersect.h
@@ -7,34 +7,13 @@
 namespace kuzu {
 namespace planner {
 
-struct LogicalIntersectBuildInfo {
-    LogicalIntersectBuildInfo(
-        std::shared_ptr<binder::Expression> keyNodeID, binder::expression_vector expressions)
-        : keyNodeID{std::move(keyNodeID)}, expressionsToMaterialize{std::move(expressions)} {}
-
-    inline void setExpressionsToMaterialize(binder::expression_vector expressions) {
-        expressionsToMaterialize = std::move(expressions);
-    }
-    inline binder::expression_vector getExpressionsToMaterialize() const {
-        return expressionsToMaterialize;
-    }
-
-    inline std::unique_ptr<LogicalIntersectBuildInfo> copy() {
-        return make_unique<LogicalIntersectBuildInfo>(keyNodeID, expressionsToMaterialize);
-    }
-
-    std::shared_ptr<binder::Expression> keyNodeID;
-    binder::expression_vector expressionsToMaterialize;
-};
-
 class LogicalIntersect : public LogicalOperator {
 public:
     LogicalIntersect(std::shared_ptr<binder::Expression> intersectNodeID,
-        std::shared_ptr<LogicalOperator> probeChild,
-        std::vector<std::shared_ptr<LogicalOperator>> buildChildren,
-        std::vector<std::unique_ptr<LogicalIntersectBuildInfo>> buildInfos)
+        binder::expression_vector keyNodeIDs, std::shared_ptr<LogicalOperator> probeChild,
+        std::vector<std::shared_ptr<LogicalOperator>> buildChildren)
         : LogicalOperator{LogicalOperatorType::INTERSECT, std::move(probeChild)},
-          intersectNodeID{std::move(intersectNodeID)}, buildInfos{std::move(buildInfos)} {
+          intersectNodeID{std::move(intersectNodeID)}, keyNodeIDs{std::move(keyNodeIDs)} {
         for (auto& child : buildChildren) {
             children.push_back(std::move(child));
         }
@@ -43,23 +22,25 @@ class LogicalIntersect : public LogicalOperator {
     f_group_pos_set getGroupsPosToFlattenOnProbeSide();
     f_group_pos_set getGroupsPosToFlattenOnBuildSide(uint32_t buildIdx);
 
-    void computeSchema() override;
+    void computeFactorizedSchema() override;
+    void computeFlatSchema() override;
 
     std::string getExpressionsForPrinting() const override { return intersectNodeID->toString(); }
 
     inline std::shared_ptr<binder::Expression> getIntersectNodeID() const {
         return intersectNodeID;
     }
-    inline LogicalIntersectBuildInfo* getBuildInfo(uint32_t idx) const {
-        return buildInfos[idx].get();
+
+    inline uint32_t getNumBuilds() const { return keyNodeIDs.size(); }
+    inline std::shared_ptr<binder::Expression> getKeyNodeID(uint32_t idx) const {
+        return keyNodeIDs[idx];
     }
-    inline uint32_t getNumBuilds() const { return buildInfos.size(); }
 
     std::unique_ptr<LogicalOperator> copy() override;
 
 private:
     std::shared_ptr<binder::Expression> intersectNodeID;
-    std::vector<std::unique_ptr<LogicalIntersectBuildInfo>> buildInfos;
+    binder::expression_vector keyNodeIDs;
 };
 
 } // namespace planner

diff --git a/src/include/planner/logical_plan/logical_operator/logical_limit.h b/src/include/planner/logical_plan/logical_operator/logical_limit.h
@@ -13,7 +13,8 @@ class LogicalLimit : public LogicalOperator {
 
     f_group_pos_set getGroupsPosToFlatten();
 
-    inline void computeSchema() override { copyChildSchema(0); }
+    inline void computeFactorizedSchema() override { copyChildSchema(0); }
+    inline void computeFlatSchema() override { copyChildSchema(0); }
 
     inline std::string getExpressionsForPrinting() const override {
         return std::to_string(limitNumber);

diff --git a/src/include/planner/logical_plan/logical_operator/logical_multiplcity_reducer.h b/src/include/planner/logical_plan/logical_operator/logical_multiplcity_reducer.h
@@ -10,7 +10,8 @@ class LogicalMultiplicityReducer : public LogicalOperator {
     explicit LogicalMultiplicityReducer(std::shared_ptr<LogicalOperator> child)
         : LogicalOperator(LogicalOperatorType::MULTIPLICITY_REDUCER, std::move(child)) {}
 
-    inline void computeSchema() override { copyChildSchema(0); }
+    inline void computeFactorizedSchema() override { copyChildSchema(0); }
+    inline void computeFlatSchema() override { copyChildSchema(0); }
 
     inline std::string getExpressionsForPrinting() const override { return std::string(); }