refactor INL-join planning

kuzudb · Mar 25, 2023 · 8729d7e · 8729d7e
1 parent 4dc00f0
commit 8729d7e
Show file tree

Hide file tree

Showing 7 changed files with 182 additions and 101 deletions.
diff --git a/src/include/planner/join_order_enumerator.h b/src/include/planner/join_order_enumerator.h
@@ -18,8 +18,6 @@ class JoinOrderEnumeratorContext;
  *      filter push down
  */
 class JoinOrderEnumerator {
-    friend class ASPOptimizer;
-
 public:
     JoinOrderEnumerator(const catalog::Catalog& catalog,
         const storage::NodesStatisticsAndDeletedIDs& nodesStatistics,
@@ -32,8 +30,7 @@ class JoinOrderEnumerator {
 
     inline void resetState() { context->resetState(); }
 
-    std::unique_ptr<JoinOrderEnumeratorContext> enterSubquery(LogicalPlan* outerPlan,
-        binder::expression_vector expressionsToScan,
+    std::unique_ptr<JoinOrderEnumeratorContext> enterSubquery(
         binder::expression_vector nodeIDsToScanFromInnerAndOuter);
     void exitSubquery(std::unique_ptr<JoinOrderEnumeratorContext> prevContext);
 
@@ -70,13 +67,13 @@ class JoinOrderEnumerator {
     std::vector<std::unique_ptr<LogicalPlan>> enumerate(
         QueryGraph* queryGraph, binder::expression_vector& predicates);
 
-    void planTableScan();
-
+    // Level 1 contains base table scans.
+    void planBaseTableScan();
     void planNodeScan(uint32_t nodePos);
+    void appendScanNodeAndFilter(std::shared_ptr<NodeExpression> node, LogicalPlan& plan);
     void planRelScan(uint32_t relPos);
-
-    void planExtendAndFilters(std::shared_ptr<RelExpression> rel, common::RelDirection direction,
-        binder::expression_vector& predicates, LogicalPlan& plan);
+    void appendExtendAndFilter(
+        std::shared_ptr<RelExpression> rel, common::RelDirection direction, LogicalPlan& plan);
 
     void planLevel(uint32_t level);
     void planLevelExactly(uint32_t level);
@@ -89,6 +86,9 @@ class JoinOrderEnumerator {
 
     void planInnerJoin(uint32_t leftLevel, uint32_t rightLevel);
 
+    bool tryPlanINLJoin(const SubqueryGraph& subgraph, const SubqueryGraph& otherSubgraph,
+        const std::vector<std::shared_ptr<NodeExpression>>& joinNodes);
+
     bool canApplyINLJoin(const SubqueryGraph& subgraph, const SubqueryGraph& otherSubgraph,
         const std::vector<std::shared_ptr<NodeExpression>>& joinNodes);
     void planInnerINLJoin(const SubqueryGraph& subgraph, const SubqueryGraph& otherSubgraph,
@@ -98,7 +98,7 @@ class JoinOrderEnumerator {
     // Filter push down for hash join.
     void planFiltersForHashJoin(binder::expression_vector& predicates, LogicalPlan& plan);
 
-    void appendScanNode(std::shared_ptr<NodeExpression>& node, LogicalPlan& plan);
+    void appendScanNodeID(std::shared_ptr<NodeExpression>& node, LogicalPlan& plan);
 
     bool needExtendToNewGroup(
         RelExpression& rel, NodeExpression& boundNode, common::RelDirection direction);

diff --git a/src/include/planner/join_order_enumerator_context.h b/src/include/planner/join_order_enumerator_context.h
@@ -13,11 +13,20 @@ class JoinOrderEnumeratorContext {
 public:
     JoinOrderEnumeratorContext()
         : currentLevel{0}, maxLevel{0}, subPlansTable{std::make_unique<SubPlansTable>()},
-          queryGraph{nullptr}, outerPlan{nullptr} {}
+          queryGraph{nullptr} {}
 
-    void init(QueryGraph* queryGraph, expression_vector& predicates);
+    void init(QueryGraph* queryGraph, const expression_vector& predicates);
+    void initPredicateCollection(const expression_vector& predicates);
 
-    inline expression_vector getWhereExpressions() { return whereExpressionsSplitOnAND; }
+    inline expression_vector getSingleVarPredicates(const Expression& expression) const {
+        if (!predicateSet->varName2Predicates.contains(expression.getUniqueName())) {
+            return expression_vector{};
+        }
+        return predicateSet->varName2Predicates.at(expression.getUniqueName());
+    }
+    inline expression_vector getMultiVarPredicates() const {
+        return predicateSet->multiVarPredicates;
+    }
 
     inline bool containPlans(const SubqueryGraph& subqueryGraph) const {
         return subPlansTable->containSubgraphPlans(subqueryGraph);
@@ -47,16 +56,22 @@ class JoinOrderEnumeratorContext {
     void resetState();
 
 private:
-    expression_vector whereExpressionsSplitOnAND;
+    struct PredicateSet {
+        // Single-variable predicates
+        std::unordered_map<std::string, expression_vector> varName2Predicates;
+        // Multi-variable predicates
+        expression_vector multiVarPredicates;
+    };
+
+private:
+    std::unique_ptr<PredicateSet> predicateSet;
 
     uint32_t currentLevel;
     uint32_t maxLevel;
 
     std::unique_ptr<SubPlansTable> subPlansTable;
     QueryGraph* queryGraph;
 
-    LogicalPlan* outerPlan;
-    expression_vector expressionsToScanFromOuter;
     expression_vector nodeIDsToScanFromInnerAndOuter;
 };
 

diff --git a/src/include/planner/logical_plan/logical_plan_util.h b/src/include/planner/logical_plan/logical_plan_util.h
@@ -8,16 +8,11 @@ namespace planner {
 
 class LogicalPlanUtil {
 public:
-    // Return the node whose ID has sequential guarantee on the plan.
-    static std::shared_ptr<binder::NodeExpression> getSequentialNode(LogicalPlan& plan);
-
     static inline std::string encodeJoin(LogicalPlan& logicalPlan) {
         return encodeJoin(logicalPlan.getLastOperator().get());
     }
 
 private:
-    static LogicalOperator* getCurrentPipelineSourceOperator(LogicalPlan& plan);
-
     static std::string encodeJoin(LogicalOperator* logicalOperator) {
         std::string result;
         encodeJoinRecursive(logicalOperator, result);