kuzudb · andyfengHKU · Dec 11, 2022 · Dec 9, 2022
diff --git a/src/include/planner/join_order_enumerator.h b/src/include/planner/join_order_enumerator.h
@@ -73,16 +73,8 @@ class JoinOrderEnumerator {
 
     void planRelScan(uint32_t relPos);
 
-    void planExtendFiltersAndPropertyScans(shared_ptr<RelExpression> rel, RelDirection direction,
+    void planExtendAndFilters(shared_ptr<RelExpression> rel, RelDirection direction,
         expression_vector& predicates, LogicalPlan& plan);
-    // Filter push down for rel table.
-    void planFiltersForRel(const expression_vector& predicates,
-        shared_ptr<NodeExpression> boundNode, shared_ptr<NodeExpression> nbrNode,
-        shared_ptr<RelExpression> rel, RelDirection direction, LogicalPlan& plan);
-    // Property push down for rel table.
-    void planPropertyScansForRel(const expression_vector& properties,
-        shared_ptr<NodeExpression> boundNode, shared_ptr<NodeExpression> nbrNode,
-        shared_ptr<RelExpression> rel, RelDirection direction, LogicalPlan& plan);
 
     void planLevel(uint32_t level);
 

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
@@ -12,13 +12,11 @@ enum LogicalOperatorType : uint8_t {
     LOGICAL_INDEX_SCAN_NODE,
     LOGICAL_UNWIND,
     LOGICAL_EXTEND,
-    LOGICAL_GENERIC_EXTEND,
     LOGICAL_FLATTEN,
     LOGICAL_FILTER,
     LOGICAL_INTERSECT,
     LOGICAL_PROJECTION,
     LOGICAL_SCAN_NODE_PROPERTY,
-    LOGICAL_SCAN_REL_PROPERTY,
     LOGICAL_CROSS_PRODUCT,
     LOGICAL_SEMI_MASKER,
     LOGICAL_HASH_JOIN,
@@ -44,15 +42,14 @@ enum LogicalOperatorType : uint8_t {
 };
 
 const string LogicalOperatorTypeNames[] = {"LOGICAL_SCAN_NODE", "LOGICAL_INDEX_SCAN_NODE",
-    "LOGICAL_UNWIND", "LOGICAL_EXTEND", "LOGICAL_GENERIC_EXTEND", "LOGICAL_FLATTEN",
-    "LOGICAL_FILTER", "LOGICAL_INTERSECT", "LOGICAL_PROJECTION", "LOGICAL_SCAN_NODE_PROPERTY",
-    "LOGICAL_SCAN_REL_PROPERTY", "LOGICAL_CROSS_PRODUCT", "LOGICAL_SEMI_MASKER",
-    "LOGICAL_HASH_JOIN", "LOGICAL_MULTIPLICITY_REDUCER", "LOGICAL_LIMIT", "LOGICAL_SKIP",
-    "LOGICAL_AGGREGATE", "LOGICAL_ORDER_BY", "LOGICAL_UNION_ALL", "LOGICAL_DISTINCT",
-    "LOGICAL_CREATE_NODE", "LOGICAL_CREATE_REL", "LOGICAL_SET_NODE_PROPERTY", "LOGICAL_DELETE_NODE",
-    "LOGICAL_DELETE_REL", "LOGICAL_ACCUMULATE", "LOGICAL_EXPRESSIONS_SCAN", "LOGICAL_FTABLE_SCAN",
-    "LOGICAL_CREATE_NODE_TABLE", "LOGICAL_CREATE_REL_TABLE", "LOGICAL_COPY_CSV",
-    "LOGICAL_DROP_TABLE"};
+    "LOGICAL_UNWIND", "LOGICAL_EXTEND", "LOGICAL_FLATTEN", "LOGICAL_FILTER", "LOGICAL_INTERSECT",
+    "LOGICAL_PROJECTION", "LOGICAL_SCAN_NODE_PROPERTY", "LOGICAL_CROSS_PRODUCT",
+    "LOGICAL_SEMI_MASKER", "LOGICAL_HASH_JOIN", "LOGICAL_MULTIPLICITY_REDUCER", "LOGICAL_LIMIT",
+    "LOGICAL_SKIP", "LOGICAL_AGGREGATE", "LOGICAL_ORDER_BY", "LOGICAL_UNION_ALL",
+    "LOGICAL_DISTINCT", "LOGICAL_CREATE_NODE", "LOGICAL_CREATE_REL", "LOGICAL_SET_NODE_PROPERTY",
+    "LOGICAL_DELETE_NODE", "LOGICAL_DELETE_REL", "LOGICAL_ACCUMULATE", "LOGICAL_EXPRESSIONS_SCAN",
+    "LOGICAL_FTABLE_SCAN", "LOGICAL_CREATE_NODE_TABLE", "LOGICAL_CREATE_REL_TABLE",
+    "LOGICAL_COPY_CSV", "LOGICAL_DROP_TABLE"};
 
 class LogicalOperator {
 public:

diff --git a/src/include/planner/logical_plan/logical_operator/logical_extend.h b/src/include/planner/logical_plan/logical_operator/logical_extend.h
@@ -10,22 +10,22 @@ using namespace kuzu::binder;
 class LogicalExtend : public LogicalOperator {
 public:
     LogicalExtend(shared_ptr<NodeExpression> boundNode, shared_ptr<NodeExpression> nbrNode,
-        shared_ptr<RelExpression> rel, RelDirection direction, bool extendToNewGroup,
-        shared_ptr<LogicalOperator> child)
-        : LogicalOperator{std::move(child)}, boundNode{std::move(boundNode)}, nbrNode{std::move(
-                                                                                  nbrNode)},
-          rel{std::move(rel)}, direction{direction}, extendToNewGroup{extendToNewGroup} {}
+        shared_ptr<RelExpression> rel, RelDirection direction, expression_vector properties,
+        bool extendToNewGroup, shared_ptr<LogicalOperator> child)
+        : LogicalOperator{std::move(child)}, boundNode{std::move(boundNode)},
+          nbrNode{std::move(nbrNode)}, rel{std::move(rel)}, direction{direction},
+          properties{std::move(properties)}, extendToNewGroup{extendToNewGroup} {}
 
-    LogicalOperatorType getLogicalOperatorType() const override {
+    inline LogicalOperatorType getLogicalOperatorType() const override {
         return LogicalOperatorType::LOGICAL_EXTEND;
     }
 
-    string getExpressionsForPrinting() const override {
+    inline string getExpressionsForPrinting() const override {
         return boundNode->getRawName() + (direction == RelDirection::FWD ? "->" : "<-") +
                nbrNode->getRawName();
     }
 
-    inline virtual void computeSchema(Schema& schema) {
+    inline void computeSchema(Schema& schema) {
         auto boundGroupPos = schema.getGroupPos(boundNode->getInternalIDPropertyName());
         uint32_t nbrGroupPos = 0u;
         if (!extendToNewGroup) {
@@ -35,58 +35,31 @@ class LogicalExtend : public LogicalOperator {
             nbrGroupPos = schema.createGroup();
         }
         schema.insertToGroupAndScope(nbrNode->getInternalIDProperty(), nbrGroupPos);
+        for (auto& property : properties) {
+            schema.insertToGroupAndScope(property, nbrGroupPos);
+        }
     }
 
     inline shared_ptr<NodeExpression> getBoundNode() const { return boundNode; }
     inline shared_ptr<NodeExpression> getNbrNode() const { return nbrNode; }
     inline shared_ptr<RelExpression> getRel() const { return rel; }
     inline RelDirection getDirection() const { return direction; }
+    inline expression_vector getProperties() const { return properties; }
 
     unique_ptr<LogicalOperator> copy() override {
         return make_unique<LogicalExtend>(
-            boundNode, nbrNode, rel, direction, extendToNewGroup, children[0]->copy());
+            boundNode, nbrNode, rel, direction, properties, extendToNewGroup, children[0]->copy());
     }
 
 protected:
     shared_ptr<NodeExpression> boundNode;
     shared_ptr<NodeExpression> nbrNode;
     shared_ptr<RelExpression> rel;
     RelDirection direction;
+    expression_vector properties;
     // When extend might increase cardinality (i.e. n * m), we extend to a new factorization group.
     bool extendToNewGroup;
 };
 
-class LogicalGenericExtend : public LogicalExtend {
-public:
-    LogicalGenericExtend(shared_ptr<NodeExpression> boundNode, shared_ptr<NodeExpression> nbrNode,
-        shared_ptr<RelExpression> rel, RelDirection direction, bool extendToNewGroup,
-        expression_vector properties, shared_ptr<LogicalOperator> child)
-        : LogicalExtend(std::move(boundNode), std::move(nbrNode), std::move(rel), direction,
-              extendToNewGroup, std::move(child)),
-          properties{std::move(properties)} {}
-
-    inline LogicalOperatorType getLogicalOperatorType() const override {
-        return LogicalOperatorType::LOGICAL_GENERIC_EXTEND;
-    }
-
-    inline void computeSchema(Schema& schema) override {
-        LogicalExtend::computeSchema(schema);
-        auto nbrNodePos = schema.getGroupPos(nbrNode->getInternalIDPropertyName());
-        for (auto& property : properties) {
-            schema.insertToGroupAndScope(property, nbrNodePos);
-        }
-    }
-
-    inline expression_vector getProperties() const { return properties; }
-
-    unique_ptr<LogicalOperator> copy() override {
-        return make_unique<LogicalGenericExtend>(
-            boundNode, nbrNode, rel, direction, extendToNewGroup, properties, children[0]->copy());
-    }
-
-private:
-    expression_vector properties;
-};
-
 } // namespace planner
 } // namespace kuzu
diff --git a/src/include/planner/logical_plan/logical_operator/logical_scan_rel_property.h b/src/include/planner/logical_plan/logical_operator/logical_scan_rel_property.h
@@ -1,49 +0,0 @@
-#pragma once
-
-#include "base_logical_operator.h"
-#include "binder/expression/rel_expression.h"
-
-namespace kuzu {
-namespace planner {
-
-class LogicalScanRelProperty : public LogicalOperator {
-public:
-    LogicalScanRelProperty(shared_ptr<NodeExpression> boundNode, shared_ptr<NodeExpression> nbrNode,
-        shared_ptr<RelExpression> rel, RelDirection direction, shared_ptr<Expression> property,
-        shared_ptr<LogicalOperator> child)
-        : LogicalOperator{std::move(child)}, boundNode{std::move(boundNode)}, nbrNode{std::move(
-                                                                                  nbrNode)},
-          rel{std::move(rel)}, direction{direction}, property{std::move(property)} {}
-
-    inline LogicalOperatorType getLogicalOperatorType() const override {
-        return LogicalOperatorType::LOGICAL_SCAN_REL_PROPERTY;
-    }
-
-    inline string getExpressionsForPrinting() const override { return property->getRawName(); }
-
-    inline void computeSchema(Schema& schema) {
-        auto nbrGroupPos = schema.getGroupPos(nbrNode->getInternalIDPropertyName());
-        schema.insertToGroupAndScope(property, nbrGroupPos);
-    }
-
-    inline shared_ptr<NodeExpression> getBoundNode() const { return boundNode; }
-    inline shared_ptr<NodeExpression> getNbrNode() const { return nbrNode; }
-    inline shared_ptr<RelExpression> getRel() const { return rel; }
-    inline RelDirection getDirection() const { return direction; }
-    inline shared_ptr<Expression> getProperty() const { return property; }
-
-    unique_ptr<LogicalOperator> copy() override {
-        return make_unique<LogicalScanRelProperty>(
-            boundNode, nbrNode, rel, direction, property, children[0]->copy());
-    }
-
-private:
-    shared_ptr<NodeExpression> boundNode;
-    shared_ptr<NodeExpression> nbrNode;
-    shared_ptr<RelExpression> rel;
-    RelDirection direction;
-    shared_ptr<Expression> property;
-};
-
-} // namespace planner
-} // namespace kuzu

diff --git a/src/include/planner/query_planner.h b/src/include/planner/query_planner.h
@@ -78,17 +78,6 @@ class QueryPlanner {
     void appendScanNodePropIfNecessary(const expression_vector& propertyExpressions,
         shared_ptr<NodeExpression> node, LogicalPlan& plan);
 
-    inline void appendScanRelPropsIfNecessary(shared_ptr<NodeExpression> boundNode,
-        shared_ptr<NodeExpression> nbrNode, shared_ptr<RelExpression> rel, RelDirection direction,
-        const expression_vector& properties, LogicalPlan& plan) {
-        for (auto& property : properties) {
-            appendScanRelPropIfNecessary(boundNode, nbrNode, rel, direction, property, plan);
-        }
-    }
-    void appendScanRelPropIfNecessary(shared_ptr<NodeExpression> boundNode,
-        shared_ptr<NodeExpression> nbrNode, shared_ptr<RelExpression> rel, RelDirection direction,
-        shared_ptr<Expression> property, LogicalPlan& plan);
-
     unique_ptr<LogicalPlan> createUnionPlan(
         vector<unique_ptr<LogicalPlan>>& childrenPlans, bool isUnionAll);
 

diff --git a/src/include/processor/mapper/plan_mapper.h b/src/include/processor/mapper/plan_mapper.h
@@ -38,8 +38,6 @@ class PlanMapper {
         LogicalOperator* logicalOperator, MapperContext& mapperContext);
     unique_ptr<PhysicalOperator> mapLogicalExtendToPhysical(
         LogicalOperator* logicalOperator, MapperContext& mapperContext);
-    unique_ptr<PhysicalOperator> mapLogicalGenericExtendToPhysical(
-        LogicalOperator* logicalOperator, MapperContext& mapperContext);
     unique_ptr<PhysicalOperator> mapLogicalFlattenToPhysical(
         LogicalOperator* logicalOperator, MapperContext& mapperContext);
     unique_ptr<PhysicalOperator> mapLogicalFilterToPhysical(
@@ -48,8 +46,6 @@ class PlanMapper {
         LogicalOperator* logicalOperator, MapperContext& mapperContext);
     unique_ptr<PhysicalOperator> mapLogicalScanNodePropertyToPhysical(
         LogicalOperator* logicalOperator, MapperContext& mapperContext);
-    unique_ptr<PhysicalOperator> mapLogicalScanRelPropertyToPhysical(
-        LogicalOperator* logicalOperator, MapperContext& mapperContext);
     unique_ptr<PhysicalOperator> mapLogicalSemiMaskerToPhysical(
         LogicalOperator* logicalOperator, MapperContext& mapperContext);
     unique_ptr<PhysicalOperator> mapLogicalHashJoinToPhysical(

diff --git a/src/include/processor/operator/base_extend.h b/src/include/processor/operator/base_extend.h
@@ -0,0 +1,32 @@
+#pragma once
+
+#include "processor/operator/physical_operator.h"
+
+namespace kuzu {
+namespace processor {
+
+class BaseExtendAndScanRelProperties : public PhysicalOperator {
+protected:
+    BaseExtendAndScanRelProperties(const DataPos& inNodeIDVectorPos,
+        const DataPos& outNodeIDVectorPos, vector<DataPos> outPropertyVectorsPos,
+        unique_ptr<PhysicalOperator> child, uint32_t id, const string& paramsString)
+        : PhysicalOperator{std::move(child), id, paramsString},
+          inNodeIDVectorPos{inNodeIDVectorPos}, outNodeIDVectorPos{outNodeIDVectorPos},
+          outPropertyVectorsPos{std::move(outPropertyVectorsPos)} {}
+    virtual ~BaseExtendAndScanRelProperties() override = default;
+
+    void initLocalStateInternal(ResultSet* resultSet, ExecutionContext* context) override;
+
+protected:
+    // vector positions
+    DataPos inNodeIDVectorPos;
+    DataPos outNodeIDVectorPos;
+    vector<DataPos> outPropertyVectorsPos;
+    // vectors
+    shared_ptr<ValueVector> inNodeIDVector;
+    shared_ptr<ValueVector> outNodeIDVector;
+    vector<shared_ptr<ValueVector>> outPropertyVectors;
+};
+
+} // namespace processor
+} // namespace kuzu
diff --git a/src/include/processor/operator/generic_extend.h b/src/include/processor/operator/generic_extend.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "processor/operator/physical_operator.h"
+#include "processor/operator/base_extend.h"
 #include "storage/storage_structure/column.h"
 #include "storage/storage_structure/lists/lists.h"
 
@@ -52,6 +52,8 @@ class AdjAndPropertyCollection {
     bool scanList(uint32_t idx, const shared_ptr<ValueVector>& inVector,
         const shared_ptr<ValueVector>& outNodeVector,
         const vector<shared_ptr<ValueVector>>& outPropertyVectors, Transaction* transaction);
+    void scanPropertyList(uint32_t idx, const vector<shared_ptr<ValueVector>>& outPropertyVectors,
+        Transaction* transaction);
 
 private:
     unique_ptr<ColumnAndListCollection> adjCollection;
@@ -69,18 +71,17 @@ class AdjAndPropertyCollection {
     unique_ptr<ListSyncState> listSyncState = nullptr;
 };
 
-class GenericExtend : public PhysicalOperator {
+class GenericExtendAndScanRelProperties : public BaseExtendAndScanRelProperties {
 public:
-    GenericExtend(const DataPos& inVectorPos, const DataPos& outNodeVectorPos,
-        vector<DataPos> outPropertyVectorsPos,
+    GenericExtendAndScanRelProperties(const DataPos& inNodeIDVectorPos,
+        const DataPos& outNodeIDVectorPos, vector<DataPos> outPropertyVectorsPos,
         unordered_map<table_id_t, unique_ptr<AdjAndPropertyCollection>>
             adjAndPropertyCollectionPerNodeTable,
         unique_ptr<PhysicalOperator> child, uint32_t id, const string& paramsString)
-        : PhysicalOperator{std::move(child), id, paramsString}, inVectorPos{inVectorPos},
-          outNodeVectorPos{outNodeVectorPos}, outPropertyVectorsPos{std::move(
-                                                  outPropertyVectorsPos)},
+        : BaseExtendAndScanRelProperties{inNodeIDVectorPos, outNodeIDVectorPos,
+              std::move(outPropertyVectorsPos), std::move(child), id, paramsString},
           adjAndPropertyCollectionPerNodeTable{std::move(adjAndPropertyCollectionPerNodeTable)} {}
-    ~GenericExtend() override = default;
+    ~GenericExtendAndScanRelProperties() override = default;
 
     inline PhysicalOperatorType getOperatorType() override {
         return PhysicalOperatorType::GENERIC_EXTEND;
@@ -95,24 +96,16 @@ class GenericExtend : public PhysicalOperator {
         for (auto& [tableID, adjAndPropertyCollection] : adjAndPropertyCollectionPerNodeTable) {
             clonedCollections.insert({tableID, adjAndPropertyCollection->clone()});
         }
-        return make_unique<GenericExtend>(inVectorPos, outNodeVectorPos, outPropertyVectorsPos,
-            std::move(clonedCollections), children[0]->clone(), id, paramsString);
+        return make_unique<GenericExtendAndScanRelProperties>(inNodeIDVectorPos, outNodeIDVectorPos,
+            outPropertyVectorsPos, std::move(clonedCollections), children[0]->clone(), id,
+            paramsString);
     }
 
 private:
     bool scanCurrentAdjAndPropertyCollection();
     void initCurrentAdjAndPropertyCollection(const nodeID_t& nodeID);
 
 private:
-    // vector positions
-    DataPos inVectorPos;
-    DataPos outNodeVectorPos;
-    vector<DataPos> outPropertyVectorsPos;
-    // vectors
-    shared_ptr<ValueVector> inVector;
-    shared_ptr<ValueVector> outNodeVector;
-    vector<shared_ptr<ValueVector>> outPropertyVectors;
-    // storage structures
     unordered_map<table_id_t, unique_ptr<AdjAndPropertyCollection>>
         adjAndPropertyCollectionPerNodeTable;
     AdjAndPropertyCollection* currentAdjAndPropertyCollection = nullptr;

diff --git a/src/include/processor/operator/scan_column/adj_column_extend.h b/src/include/processor/operator/scan_column/adj_column_extend.h
@@ -1,33 +1,38 @@
 #pragma once
 
+#include "processor/operator/base_extend.h"
 #include "processor/operator/filtering_operator.h"
-#include "processor/operator/scan_column/scan_column.h"
 #include "storage/storage_structure/column.h"
 
 namespace kuzu {
 namespace processor {
 
-class AdjColumnExtend : public ScanSingleColumn, public FilteringOperator {
-
+class ColumnExtendAndScanRelProperties : public BaseExtendAndScanRelProperties,
+                                         public FilteringOperator {
 public:
-    AdjColumnExtend(const DataPos& inputNodeIDVectorPos, const DataPos& outputNodeIDVectorPos,
-        Column* nodeIDColumn, unique_ptr<PhysicalOperator> child, uint32_t id,
+    ColumnExtendAndScanRelProperties(const DataPos& inNodeIDVectorPos,
+        const DataPos& outNodeIDVectorPos, vector<DataPos> outPropertyVectorsPos, Column* adjColumn,
+        vector<Column*> propertyColumns, unique_ptr<PhysicalOperator> child, uint32_t id,
         const string& paramsString)
-        : ScanSingleColumn{inputNodeIDVectorPos, outputNodeIDVectorPos, move(child), id,
-              paramsString},
-          FilteringOperator{1 /* numStatesToSave */}, nodeIDColumn{nodeIDColumn} {}
+        : BaseExtendAndScanRelProperties{inNodeIDVectorPos, outNodeIDVectorPos,
+              std::move(outPropertyVectorsPos), std::move(child), id, paramsString},
+          FilteringOperator{1 /* numStatesToSave */}, adjColumn{adjColumn},
+          propertyColumns{std::move(propertyColumns)} {}
+    ~ColumnExtendAndScanRelProperties() override = default;
 
-    PhysicalOperatorType getOperatorType() override { return COLUMN_EXTEND; }
+    inline PhysicalOperatorType getOperatorType() override { return COLUMN_EXTEND; }
 
     bool getNextTuplesInternal() override;
 
-    unique_ptr<PhysicalOperator> clone() override {
-        return make_unique<AdjColumnExtend>(inputNodeIDVectorPos, outputVectorPos, nodeIDColumn,
-            children[0]->clone(), id, paramsString);
+    inline unique_ptr<PhysicalOperator> clone() override {
+        return make_unique<ColumnExtendAndScanRelProperties>(inNodeIDVectorPos, outNodeIDVectorPos,
+            outPropertyVectorsPos, adjColumn, propertyColumns, children[0]->clone(), id,
+            paramsString);
     }
 
 private:
-    Column* nodeIDColumn;
+    Column* adjColumn;
+    vector<Column*> propertyColumns;
 };
 
 } // namespace processor