refactor logical operator type

kuzudb · Dec 11, 2022 · d802335 · d802335
1 parent 2463999
commit d802335
Show file tree

Hide file tree

Showing 39 changed files with 303 additions and 290 deletions.
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
@@ -7,59 +7,56 @@ using namespace std;
 namespace kuzu {
 namespace planner {
 
-enum LogicalOperatorType : uint8_t {
-    LOGICAL_SCAN_NODE,
-    LOGICAL_INDEX_SCAN_NODE,
-    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,
+enum class LogicalOperatorType : uint8_t {
+    ACCUMULATE,
+    AGGREGATE,
+    COPY_CSV,
+    CREATE_NODE,
+    CREATE_REL,
+    CREATE_NODE_TABLE,
+    CREATE_REL_TABLE,
+    CROSS_PRODUCT,
+    DELETE_NODE,
+    DELETE_REL,
+    DISTINCT,
+    DROP_TABLE,
+    EXPRESSIONS_SCAN,
+    EXTEND,
+    FILTER,
+    FLATTEN,
+    FTABLE_SCAN,
+    HASH_JOIN,
+    INTERSECT,
+    LIMIT,
+    MULTIPLICITY_REDUCER,
+    ORDER_BY,
+    PROJECTION,
+    SCAN_NODE,
+    INDEX_SCAN_NODE,
+    SCAN_NODE_PROPERTY,
+    SEMI_MASKER,
+    SET_NODE_PROPERTY,
+    SKIP,
+    UNION_ALL,
+    UNWIND,
 };
 
-const string LogicalOperatorTypeNames[] = {"LOGICAL_SCAN_NODE", "LOGICAL_INDEX_SCAN_NODE",
-    "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 LogicalOperatorUtils {
+public:
+    static std::string logicalOperatorTypeToString(LogicalOperatorType type);
+};
 
 class LogicalOperator {
 public:
     // Leaf operator.
-    LogicalOperator() = default;
+    explicit LogicalOperator(LogicalOperatorType operatorType) : operatorType{operatorType} {}
     // Unary operator.
-    LogicalOperator(shared_ptr<LogicalOperator> child);
+    explicit LogicalOperator(LogicalOperatorType operatorType, shared_ptr<LogicalOperator> child);
     // Binary operator.
-    LogicalOperator(shared_ptr<LogicalOperator> left, shared_ptr<LogicalOperator> right);
-    LogicalOperator(vector<shared_ptr<LogicalOperator>> children);
+    explicit LogicalOperator(LogicalOperatorType operatorType, shared_ptr<LogicalOperator> left,
+        shared_ptr<LogicalOperator> right);
+    explicit LogicalOperator(
+        LogicalOperatorType operatorType, vector<shared_ptr<LogicalOperator>> children);
 
     virtual ~LogicalOperator() = default;
 
@@ -70,7 +67,7 @@ class LogicalOperator {
 
     inline shared_ptr<LogicalOperator> getChild(uint64_t idx) const { return children[idx]; }
 
-    virtual LogicalOperatorType getLogicalOperatorType() const = 0;
+    inline LogicalOperatorType getOperatorType() const { return operatorType; }
 
     virtual string getExpressionsForPrinting() const = 0;
 
@@ -83,6 +80,7 @@ class LogicalOperator {
     virtual unique_ptr<LogicalOperator> copy() = 0;
 
 protected:
+    LogicalOperatorType operatorType;
     vector<shared_ptr<LogicalOperator>> children;
 };
 

diff --git a/src/include/planner/logical_plan/logical_operator/logical_accumulate.h b/src/include/planner/logical_plan/logical_operator/logical_accumulate.h
@@ -10,12 +10,8 @@ class LogicalAccumulate : public LogicalOperator {
 public:
     LogicalAccumulate(expression_vector expressions, unique_ptr<Schema> schemaBeforeSink,
         shared_ptr<LogicalOperator> child)
-        : LogicalOperator{std::move(child)}, expressions{std::move(expressions)},
-          schemaBeforeSink{std::move(schemaBeforeSink)} {}
-
-    LogicalOperatorType getLogicalOperatorType() const override {
-        return LogicalOperatorType::LOGICAL_ACCUMULATE;
-    }
+        : LogicalOperator{LogicalOperatorType::ACCUMULATE, std::move(child)},
+          expressions{std::move(expressions)}, schemaBeforeSink{std::move(schemaBeforeSink)} {}
 
     string getExpressionsForPrinting() const override {
         return ExpressionUtil::toString(expressions);

diff --git a/src/include/planner/logical_plan/logical_operator/logical_aggregate.h b/src/include/planner/logical_plan/logical_operator/logical_aggregate.h
@@ -11,13 +11,10 @@ class LogicalAggregate : public LogicalOperator {
     LogicalAggregate(expression_vector expressionsToGroupBy,
         expression_vector expressionsToAggregate, unique_ptr<Schema> schemaBeforeAggregate,
         shared_ptr<LogicalOperator> child)
-        : LogicalOperator{move(child)}, expressionsToGroupBy{move(expressionsToGroupBy)},
-          expressionsToAggregate{move(expressionsToAggregate)}, schemaBeforeAggregate{
-                                                                    move(schemaBeforeAggregate)} {}
-
-    inline LogicalOperatorType getLogicalOperatorType() const override {
-        return LogicalOperatorType::LOGICAL_AGGREGATE;
-    }
+        : LogicalOperator{LogicalOperatorType::AGGREGATE, std::move(child)},
+          expressionsToGroupBy{std::move(expressionsToGroupBy)}, expressionsToAggregate{std::move(
+                                                                     expressionsToAggregate)},
+          schemaBeforeAggregate{std::move(schemaBeforeAggregate)} {}
 
     string getExpressionsForPrinting() const override;
 

diff --git a/src/include/planner/logical_plan/logical_operator/logical_copy_csv.h b/src/include/planner/logical_plan/logical_operator/logical_copy_csv.h
@@ -13,9 +13,8 @@ class LogicalCopyCSV : public LogicalOperator {
 
 public:
     LogicalCopyCSV(CSVDescription csvDescription, TableSchema tableSchema)
-        : LogicalOperator{}, csvDescription{move(csvDescription)}, tableSchema{move(tableSchema)} {}
-
-    inline LogicalOperatorType getLogicalOperatorType() const override { return LOGICAL_COPY_CSV; }
+        : LogicalOperator{LogicalOperatorType::COPY_CSV}, csvDescription{std::move(csvDescription)},
+          tableSchema{std::move(tableSchema)} {}
 
     inline string getExpressionsForPrinting() const override { return tableSchema.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
@@ -10,11 +10,8 @@ class LogicalCreateNode : public LogicalCreateOrDeleteNode {
     LogicalCreateNode(
         vector<pair<shared_ptr<NodeExpression>, shared_ptr<Expression>>> nodeAndPrimaryKeys,
         shared_ptr<LogicalOperator> child)
-        : LogicalCreateOrDeleteNode{std::move(nodeAndPrimaryKeys), std::move(child)} {}
-
-    LogicalOperatorType getLogicalOperatorType() const override {
-        return LogicalOperatorType::LOGICAL_CREATE_NODE;
-    }
+        : LogicalCreateOrDeleteNode{
+              LogicalOperatorType::CREATE_NODE, std::move(nodeAndPrimaryKeys), std::move(child)} {}
 
     unique_ptr<LogicalOperator> copy() override {
         return make_unique<LogicalCreateNode>(nodeAndPrimaryKeys, children[0]->copy());
@@ -25,12 +22,9 @@ class LogicalCreateRel : public LogicalCreateOrDeleteRel {
 public:
     LogicalCreateRel(vector<shared_ptr<RelExpression>> rels,
         vector<vector<expression_pair>> setItemsPerRel, shared_ptr<LogicalOperator> child)
-        : LogicalCreateOrDeleteRel{std::move(rels), std::move(child)}, setItemsPerRel{std::move(
-                                                                           setItemsPerRel)} {}
-
-    inline LogicalOperatorType getLogicalOperatorType() const override {
-        return LogicalOperatorType::LOGICAL_CREATE_REL;
-    }
+        : LogicalCreateOrDeleteRel{LogicalOperatorType::CREATE_REL, std::move(rels),
+              std::move(child)},
+          setItemsPerRel{std::move(setItemsPerRel)} {}
 
     inline vector<expression_pair> getSetItems(uint32_t idx) const { return setItemsPerRel[idx]; }
 

diff --git a/src/include/planner/logical_plan/logical_operator/logical_create_delete.h b/src/include/planner/logical_plan/logical_operator/logical_create_delete.h
@@ -8,12 +8,11 @@ namespace planner {
 
 class LogicalCreateOrDeleteNode : public LogicalOperator {
 public:
-    LogicalCreateOrDeleteNode(
+    LogicalCreateOrDeleteNode(LogicalOperatorType operatorType,
         vector<pair<shared_ptr<NodeExpression>, shared_ptr<Expression>>> nodeAndPrimaryKeys,
         shared_ptr<LogicalOperator> child)
-        : LogicalOperator{std::move(child)}, nodeAndPrimaryKeys{std::move(nodeAndPrimaryKeys)} {}
-
-    LogicalOperatorType getLogicalOperatorType() const override = 0;
+        : LogicalOperator{operatorType, std::move(child)}, nodeAndPrimaryKeys{
+                                                               std::move(nodeAndPrimaryKeys)} {}
 
     inline string getExpressionsForPrinting() const override {
         expression_vector expressions;
@@ -36,11 +35,9 @@ class LogicalCreateOrDeleteNode : public LogicalOperator {
 
 class LogicalCreateOrDeleteRel : public LogicalOperator {
 public:
-    LogicalCreateOrDeleteRel(
+    LogicalCreateOrDeleteRel(LogicalOperatorType operatorType,
         vector<shared_ptr<RelExpression>> rels, shared_ptr<LogicalOperator> child)
-        : LogicalOperator{std::move(child)}, rels{std::move(rels)} {}
-
-    LogicalOperatorType getLogicalOperatorType() const override = 0;
+        : LogicalOperator{operatorType, std::move(child)}, rels{std::move(rels)} {}
 
     inline string getExpressionsForPrinting() const override {
         expression_vector expressions;

diff --git a/src/include/planner/logical_plan/logical_operator/logical_create_node_table.h b/src/include/planner/logical_plan/logical_operator/logical_create_node_table.h
@@ -7,15 +7,12 @@ namespace kuzu {
 namespace planner {
 
 class LogicalCreateNodeTable : public LogicalDDL {
-
 public:
     LogicalCreateNodeTable(string tableName, vector<PropertyNameDataType> propertyNameDataTypes,
         uint32_t primaryKeyIdx)
-        : LogicalDDL{move(tableName), move(propertyNameDataTypes)}, primaryKeyIdx{primaryKeyIdx} {}
-
-    inline LogicalOperatorType getLogicalOperatorType() const override {
-        return LOGICAL_CREATE_NODE_TABLE;
-    }
+        : LogicalDDL{LogicalOperatorType::CREATE_NODE_TABLE, std::move(tableName),
+              std::move(propertyNameDataTypes)},
+          primaryKeyIdx{primaryKeyIdx} {}
 
     inline uint32_t getPrimaryKeyIdx() const { return primaryKeyIdx; }
 

diff --git a/src/include/planner/logical_plan/logical_operator/logical_create_rel_table.h b/src/include/planner/logical_plan/logical_operator/logical_create_rel_table.h
@@ -7,16 +7,12 @@ namespace kuzu {
 namespace planner {
 
 class LogicalCreateRelTable : public LogicalDDL {
-
 public:
     LogicalCreateRelTable(string tableName, vector<PropertyNameDataType> propertyNameDataTypes,
         RelMultiplicity relMultiplicity, vector<pair<table_id_t, table_id_t>> srcDstTableIDs)
-        : LogicalDDL{move(tableName), move(propertyNameDataTypes)},
-          relMultiplicity{relMultiplicity}, srcDstTableIDs{move(srcDstTableIDs)} {}
-
-    inline LogicalOperatorType getLogicalOperatorType() const override {
-        return LOGICAL_CREATE_REL_TABLE;
-    }
+        : LogicalDDL{LogicalOperatorType::CREATE_REL_TABLE, std::move(tableName),
+              std::move(propertyNameDataTypes)},
+          relMultiplicity{relMultiplicity}, srcDstTableIDs{std::move(srcDstTableIDs)} {}
 
     inline RelMultiplicity getRelMultiplicity() const { return relMultiplicity; }
 

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
@@ -9,13 +9,10 @@ class LogicalCrossProduct : public LogicalOperator {
 public:
     LogicalCrossProduct(unique_ptr<Schema> buildSideSchema,
         shared_ptr<LogicalOperator> probeSideChild, shared_ptr<LogicalOperator> buildSideChild)
-        : LogicalOperator{std::move(probeSideChild), std::move(buildSideChild)},
+        : LogicalOperator{LogicalOperatorType::CROSS_PRODUCT, std::move(probeSideChild),
+              std::move(buildSideChild)},
           buildSideSchema{std::move(buildSideSchema)} {}
 
-    inline LogicalOperatorType getLogicalOperatorType() const override {
-        return LogicalOperatorType::LOGICAL_CROSS_PRODUCT;
-    }
-
     inline string getExpressionsForPrinting() const override { return string(); }
 
     inline Schema* getBuildSideSchema() const { return buildSideSchema.get(); }

diff --git a/src/include/planner/logical_plan/logical_operator/logical_ddl.h b/src/include/planner/logical_plan/logical_operator/logical_ddl.h
@@ -8,11 +8,11 @@ namespace kuzu {
 namespace planner {
 
 class LogicalDDL : public LogicalOperator {
-
 public:
-    LogicalDDL(string tableName, vector<PropertyNameDataType> propertyNameDataTypes)
-        : LogicalOperator{}, tableName{move(tableName)}, propertyNameDataTypes{
-                                                             move(propertyNameDataTypes)} {}
+    LogicalDDL(LogicalOperatorType operatorType, string tableName,
+        vector<PropertyNameDataType> propertyNameDataTypes)
+        : LogicalOperator{operatorType}, tableName{std::move(tableName)},
+          propertyNameDataTypes{std::move(propertyNameDataTypes)} {}
 
     inline string getExpressionsForPrinting() const override { return tableName; }
 

diff --git a/src/include/planner/logical_plan/logical_operator/logical_delete.h b/src/include/planner/logical_plan/logical_operator/logical_delete.h
@@ -12,11 +12,8 @@ class LogicalDeleteNode : public LogicalCreateOrDeleteNode {
     LogicalDeleteNode(
         vector<pair<shared_ptr<NodeExpression>, shared_ptr<Expression>>> nodeAndPrimaryKeys,
         shared_ptr<LogicalOperator> child)
-        : LogicalCreateOrDeleteNode{std::move(nodeAndPrimaryKeys), std::move(child)} {}
-
-    inline LogicalOperatorType getLogicalOperatorType() const override {
-        return LogicalOperatorType::LOGICAL_DELETE_NODE;
-    }
+        : LogicalCreateOrDeleteNode{
+              LogicalOperatorType::DELETE_NODE, std::move(nodeAndPrimaryKeys), std::move(child)} {}
 
     inline unique_ptr<LogicalOperator> copy() override {
         return make_unique<LogicalDeleteNode>(nodeAndPrimaryKeys, children[0]->copy());
@@ -26,11 +23,8 @@ class LogicalDeleteNode : public LogicalCreateOrDeleteNode {
 class LogicalDeleteRel : public LogicalCreateOrDeleteRel {
 public:
     LogicalDeleteRel(vector<shared_ptr<RelExpression>> rels, shared_ptr<LogicalOperator> child)
-        : LogicalCreateOrDeleteRel{std::move(rels), std::move(child)} {}
-
-    inline LogicalOperatorType getLogicalOperatorType() const override {
-        return LogicalOperatorType::LOGICAL_DELETE_REL;
-    }
+        : LogicalCreateOrDeleteRel{
+              LogicalOperatorType::DELETE_REL, std::move(rels), std::move(child)} {}
 
     inline unique_ptr<LogicalOperator> copy() override {
         return make_unique<LogicalDeleteRel>(rels, children[0]->copy());

diff --git a/src/include/planner/logical_plan/logical_operator/logical_distinct.h b/src/include/planner/logical_plan/logical_operator/logical_distinct.h
@@ -10,10 +10,9 @@ class LogicalDistinct : public LogicalOperator {
 public:
     LogicalDistinct(expression_vector expressionsToDistinct,
         unique_ptr<Schema> schemaBeforeDistinct, shared_ptr<LogicalOperator> child)
-        : LogicalOperator{move(child)}, expressionsToDistinct{move(expressionsToDistinct)},
-          schemaBeforeDistinct{move(schemaBeforeDistinct)} {}
-
-    LogicalOperatorType getLogicalOperatorType() const override { return LOGICAL_DISTINCT; }
+        : LogicalOperator{LogicalOperatorType::DISTINCT, std::move(child)},
+          expressionsToDistinct{std::move(expressionsToDistinct)}, schemaBeforeDistinct{std::move(
+                                                                       schemaBeforeDistinct)} {}
 
     string getExpressionsForPrinting() const override;
 

diff --git a/src/include/planner/logical_plan/logical_operator/logical_drop_table.h b/src/include/planner/logical_plan/logical_operator/logical_drop_table.h
@@ -9,11 +9,7 @@ class LogicalDropTable : public LogicalOperator {
 
 public:
     explicit LogicalDropTable(TableSchema* tableSchema)
-        : LogicalOperator{}, tableSchema{tableSchema} {}
-
-    inline LogicalOperatorType getLogicalOperatorType() const override {
-        return LOGICAL_DROP_TABLE;
-    }
+        : LogicalOperator{LogicalOperatorType::DROP_TABLE}, tableSchema{tableSchema} {}
 
     inline TableSchema* getTableSchema() const { return tableSchema; }
 

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
@@ -10,11 +10,9 @@ class LogicalExpressionsScan : public LogicalOperator {
 public:
     // LogicalExpressionsScan does not take input from child operator. So its input expressions must
     // be evaluated statically i.e. must be literal.
-    LogicalExpressionsScan(expression_vector expressions) : expressions{std::move(expressions)} {}
-
-    inline LogicalOperatorType getLogicalOperatorType() const override {
-        return LogicalOperatorType::LOGICAL_EXPRESSIONS_SCAN;
-    }
+    explicit LogicalExpressionsScan(expression_vector expressions)
+        : LogicalOperator{LogicalOperatorType::EXPRESSIONS_SCAN}, expressions{
+                                                                      std::move(expressions)} {}
 
     inline string getExpressionsForPrinting() const override {
         return 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
@@ -12,14 +12,11 @@ class LogicalExtend : public LogicalOperator {
     LogicalExtend(shared_ptr<NodeExpression> boundNode, shared_ptr<NodeExpression> nbrNode,
         shared_ptr<RelExpression> rel, RelDirection direction, expression_vector properties,
         bool extendToNewGroup, shared_ptr<LogicalOperator> child)
-        : LogicalOperator{std::move(child)}, boundNode{std::move(boundNode)},
+        : LogicalOperator{LogicalOperatorType::EXTEND, std::move(child)}, boundNode{std::move(
+                                                                              boundNode)},
           nbrNode{std::move(nbrNode)}, rel{std::move(rel)}, direction{direction},
           properties{std::move(properties)}, extendToNewGroup{extendToNewGroup} {}
 
-    inline LogicalOperatorType getLogicalOperatorType() const override {
-        return LogicalOperatorType::LOGICAL_EXTEND;
-    }
-
     inline string getExpressionsForPrinting() const override {
         return boundNode->getRawName() + (direction == RelDirection::FWD ? "->" : "<-") +
                nbrNode->getRawName();