Rewrite lookup index selection implementation

.github/workflows/pull_request.yml

@@ -138,17 +138,17 @@ jobs:
       - name: Pytest
         run: |
           make up
-          make RM_DIR=false J=${{ steps.cmake.outputs.j }} test
+          make RM_DIR=false DEBUG=false J=${{ steps.cmake.outputs.j }} test
           make down
         working-directory: tests/
         timeout-minutes: 15
       - name: TCK
         run: |
           make up
-          make RM_DIR=false J=${{ steps.cmake.outputs.j }} tck
+          make RM_DIR=false DEBUG=false J=${{ steps.cmake.outputs.j }} tck
           make down
         working-directory: tests/
-        timeout-minutes: 20
+        timeout-minutes: 25
       - name: Sanitizer
         if: ${{ always() }}
         run: |

src/context/ast/AstContext.h

@@ -12,11 +12,14 @@
 
 namespace nebula {
 namespace graph {
+
 struct AstContext {
     QueryContext*   qctx;
     Sentence*       sentence;
     SpaceInfo       space;
 };
+
 }  // namespace graph
 }  // namespace nebula
+
 #endif  // CONTEXT_ASTCONTEXT_H_

src/context/ast/QueryAstContext.h

@@ -106,6 +106,16 @@ struct GoContext final : AstContext {
     std::string                 inputVarName;
 };
 
+struct LookupContext final : public AstContext {
+    bool isEdge{false};
+    bool dedup{false};
+    bool isEmptyResultSet{false};
+    int32_t schemaId{-1};
+    int32_t limit{-1};
+    Expression* filter{nullptr};
+    // order by
+};
+
 }  // namespace graph
 }  // namespace nebula
 #endif  // CONTEXT_AST_QUERYASTCONTEXT_H_

src/executor/Executor.cpp

@@ -181,7 +181,13 @@ Executor *Executor::makeExecutor(QueryContext *qctx, const PlanNode *node) {
         case PlanNode::Kind::kUnwind: {
             return pool->add(new UnwindExecutor(node, qctx));
         }
-        case PlanNode::Kind::kIndexScan: {
+        case PlanNode::Kind::kIndexScan:
+        case PlanNode::Kind::kEdgeIndexFullScan:
+        case PlanNode::Kind::kEdgeIndexPrefixScan:
+        case PlanNode::Kind::kEdgeIndexRangeScan:
+        case PlanNode::Kind::kTagIndexFullScan:
+        case PlanNode::Kind::kTagIndexPrefixScan:
+        case PlanNode::Kind::kTagIndexRangeScan: {
             return pool->add(new IndexScanExecutor(node, qctx));
         }
         case PlanNode::Kind::kStart: {

src/executor/query/IndexScanExecutor.cpp

@@ -29,10 +29,10 @@ folly::Future<Status> IndexScanExecutor::indexScan() {
         return finish(ResultBuilder().value(Value(std::move(dataSet))).finish());
     }
     return storageClient->lookupIndex(lookup->space(),
-                                     *lookup->queryContext(),
+                                      lookup->queryContext(),
                                       lookup->isEdge(),
                                       lookup->schemaId(),
-                                     *lookup->returnColumns())
+                                      lookup->returnColumns())
         .via(runner())
         .thenValue([this](StorageRpcResponse<LookupIndexResp> &&rpcResp) {
             return handleResp(std::move(rpcResp));

src/optimizer/CMakeLists.txt

@@ -24,6 +24,14 @@ nebula_add_library(
     rule/PushFilterDownAggregateRule.cpp
     rule/PushFilterDownProjectRule.cpp
     rule/PushFilterDownLeftJoinRule.cpp
+    rule/PushFilterDownEdgeIndexScanRule.cpp
+    rule/PushFilterDownTagIndexScanRule.cpp
+    rule/UnionAllIndexScanBaseRule.cpp
+    rule/UnionAllTagIndexScanRule.cpp
+    rule/UnionAllEdgeIndexScanRule.cpp
+    rule/IndexFullScanBaseRule.cpp
+    rule/TagIndexFullScanRule.cpp
+    rule/EdgeIndexFullScanRule.cpp
 )
 
 nebula_add_subdirectory(test)

src/optimizer/OptRule.cpp

@@ -12,9 +12,26 @@
 #include "optimizer/OptGroup.h"
 #include "planner/plan/PlanNode.h"
 
+using nebula::graph::PlanNode;
+
 namespace nebula {
 namespace opt {
 
+const PlanNode *MatchedResult::planNode(const std::vector<int32_t> &pos) const {
+    if (pos.empty()) {
+        return DCHECK_NOTNULL(node)->node();
+    }
+
+    DCHECK_EQ(pos[0], 0);
+
+    const MatchedResult *result = this;
+    for (size_t i = 1; i < pos.size(); ++i) {
+        DCHECK_LT(pos[i], result->dependencies.size());
+        result = &result->dependencies[pos[i]];
+    }
+    return DCHECK_NOTNULL(result->node)->node();
+}
+
 Pattern Pattern::create(graph::PlanNode::Kind kind, std::initializer_list<Pattern> patterns) {
     Pattern pattern;
     pattern.kind_ = kind;

src/optimizer/OptRule.h

@@ -19,6 +19,7 @@ namespace nebula {
 
 namespace graph {
 class QueryContext;
+class PlanNode;
 }   // namespace graph
 
 namespace opt {
@@ -30,6 +31,16 @@ class OptGroup;
 struct MatchedResult {
     const OptGroupNode *node{nullptr};
     std::vector<MatchedResult> dependencies;
+
+    // params       | plan node
+    // -------------+------------
+    // {}           | this->node
+    // {0}          | this->node
+    // {1}          | error
+    // {0, 1}       | this->dependencies[1]
+    // {0, 1, 0}    | this->dependencies[1].dependencies[0]
+    // {0, 1, 0, 1} | this->dependencies[1].dependencies[0].dependencies[1]
+    const graph::PlanNode *planNode(const std::vector<int32_t> &pos = {}) const;
 };
 
 class Pattern final {