Feature/optimizer trait match

src/graph/optimizer/CMakeLists.txt

@@ -40,24 +40,12 @@ nebula_add_library(
     rule/TagIndexFullScanRule.cpp
     rule/EdgeIndexFullScanRule.cpp
     rule/PushLimitDownIndexScanRule.cpp
-    rule/PushLimitDownTagIndexFullScanRule.cpp
-    rule/PushLimitDownTagIndexPrefixScanRule.cpp
-    rule/PushLimitDownTagIndexRangeScanRule.cpp
-    rule/PushLimitDownEdgeIndexFullScanRule.cpp
-    rule/PushLimitDownEdgeIndexPrefixScanRule.cpp
-    rule/PushLimitDownEdgeIndexRangeScanRule.cpp
     rule/PushLimitDownProjectRule.cpp
     rule/EliminateRowCollectRule.cpp
     rule/PushLimitDownScanAppendVerticesRule.cpp
     rule/GetEdgesTransformRule.cpp
     rule/PushLimitDownScanEdgesAppendVerticesRule.cpp
     rule/PushTopNDownIndexScanRule.cpp
-    rule/PushTopNDownTagIndexFullScanRule.cpp
-    rule/PushTopNDownTagIndexPrefixScanRule.cpp
-    rule/PushTopNDownTagIndexRangeScanRule.cpp
-    rule/PushTopNDownEdgeIndexFullScanRule.cpp
-    rule/PushTopNDownEdgeIndexPrefixScanRule.cpp
-    rule/PushTopNDownEdgeIndexRangeScanRule.cpp
 )
 
 nebula_add_subdirectory(test)

src/graph/optimizer/OptRule.cpp

@@ -32,16 +32,16 @@ const PlanNode *MatchedResult::planNode(const std::vector<int32_t> &pos) const {
 }
 
 Pattern Pattern::create(graph::PlanNode::Kind kind, std::initializer_list<Pattern> patterns) {
-  Pattern pattern;
-  pattern.kind_ = kind;
-  for (auto &p : patterns) {
-    pattern.dependencies_.emplace_back(p);
-  }
-  return pattern;
+  return Pattern(kind, std::move(patterns));
+}
+
+/*static*/ Pattern Pattern::create(std::initializer_list<graph::PlanNode::Kind> kinds,
+                                   std::initializer_list<Pattern> patterns) {
+  return Pattern(std::move(kinds), std::move(patterns));
 }
 
 StatusOr<MatchedResult> Pattern::match(const OptGroupNode *groupNode) const {
-  if (groupNode->node()->kind() != kind_) {
+  if (!node_.match(groupNode->node())) {
     return Status::Error();
   }
 

src/graph/optimizer/OptRule.h

@@ -42,17 +42,39 @@ struct MatchedResult {
   const graph::PlanNode *planNode(const std::vector<int32_t> &pos = {}) const;
 };
 
+// Match plan node by trait or kind of plan node.
+class MatchNode {
+ public:
+  explicit MatchNode(graph::PlanNode::Kind kind) : node_({kind}) {}
+  explicit MatchNode(std::initializer_list<graph::PlanNode::Kind> kinds)
+      : node_(std::move(kinds)) {}
+
+  bool match(const graph::PlanNode *node) const {
+    auto find = node_.find(node->kind());
+    return find != node_.end();
+  }
+
+ private:
+  std::unordered_set<graph::PlanNode::Kind> node_;
+};
+
 class Pattern final {
  public:
   static Pattern create(graph::PlanNode::Kind kind, std::initializer_list<Pattern> patterns = {});
+  static Pattern create(std::initializer_list<graph::PlanNode::Kind> kinds,
+                        std::initializer_list<Pattern> patterns = {});
 
   StatusOr<MatchedResult> match(const OptGroupNode *groupNode) const;
 
  private:
-  Pattern() = default;
+  explicit Pattern(graph::PlanNode::Kind kind, std::initializer_list<Pattern> patterns = {})
+      : node_(kind), dependencies_(patterns) {}
+  explicit Pattern(std::initializer_list<graph::PlanNode::Kind> kinds,
+                   std::initializer_list<Pattern> patterns = {})
+      : node_(std::move(kinds)), dependencies_(patterns) {}
   StatusOr<MatchedResult> match(const OptGroup *group) const;
 
-  graph::PlanNode::Kind kind_;
+  MatchNode node_;
   std::vector<Pattern> dependencies_;
 };