clean

src/include/planner/join_order/cardinality_estimator.h

@@ -40,8 +40,9 @@ class CardinalityEstimator {
 private:
     const storage::NodesStatisticsAndDeletedIDs& nodesStatistics;
     const storage::RelsStatistics& relsStatistics;
+    // The domain of nodeID is defined as the number of unique value of nodeID, i.e. num nodes.
     std::unordered_map<std::string, uint64_t> nodeIDName2domCardinality;
 };
 
 } // namespace planner
-} // namespace kuzu
+} // namespace kuzu

src/include/planner/join_order/cost_model.h

@@ -6,7 +6,6 @@ namespace planner {
 class CostModel {
 public:
     static uint64_t computeExtendCost(const LogicalPlan& childPlan);
-
     static uint64_t computeHashJoinCost(const binder::expression_vector& joinNodeIDs,
         const LogicalPlan& probe, const LogicalPlan& build);
     static uint64_t computeMarkJoinCost(const binder::expression_vector& joinNodeIDs,
@@ -16,4 +15,4 @@ class CostModel {
 };
 
 } // namespace planner
-} // namespace kuzu
+} // namespace kuzu

src/include/planner/join_order_enumerator.h

@@ -19,8 +19,7 @@ class JoinOrderEnumeratorContext;
  */
 class JoinOrderEnumerator {
 public:
-    JoinOrderEnumerator(const catalog::Catalog& catalog,
-         QueryPlanner* queryPlanner)
+    JoinOrderEnumerator(const catalog::Catalog& catalog, QueryPlanner* queryPlanner)
         : catalog{catalog},
           queryPlanner{queryPlanner}, context{std::make_unique<JoinOrderEnumeratorContext>()} {};
 
@@ -37,9 +36,8 @@ class JoinOrderEnumerator {
         std::shared_ptr<Expression> mark, LogicalPlan& probePlan, LogicalPlan& buildPlan) {
         planJoin(joinNodeIDs, common::JoinType::MARK, mark, probePlan, buildPlan);
     }
-    inline void planInnerHashJoin(
-        const std::vector<std::shared_ptr<NodeExpression>>& joinNodes, LogicalPlan& probePlan,
-        LogicalPlan& buildPlan) {
+    inline void planInnerHashJoin(const std::vector<std::shared_ptr<NodeExpression>>& joinNodes,
+        LogicalPlan& probePlan, LogicalPlan& buildPlan) {
         binder::expression_vector joinNodeIDs;
         for (auto& joinNode : joinNodes) {
             joinNodeIDs.push_back(joinNode->getInternalIDProperty());
@@ -101,8 +99,8 @@ class JoinOrderEnumerator {
 
     void planJoin(const binder::expression_vector& joinNodeIDs, common::JoinType joinType,
         std::shared_ptr<Expression> mark, LogicalPlan& probePlan, LogicalPlan& buildPlan);
-    void appendHashJoin(const binder::expression_vector& joinNodeIDs,
-        common::JoinType joinType, LogicalPlan& probePlan, LogicalPlan& buildPlan);
+    void appendHashJoin(const binder::expression_vector& joinNodeIDs, common::JoinType joinType,
+        LogicalPlan& probePlan, LogicalPlan& buildPlan);
     void appendMarkJoin(const binder::expression_vector& joinNodeIDs,
         const std::shared_ptr<Expression>& mark, LogicalPlan& probePlan, LogicalPlan& buildPlan);
     void appendIntersect(const std::shared_ptr<Expression>& intersectNodeID,

src/include/planner/logical_plan/logical_operator/logical_hash_join.h

@@ -41,8 +41,7 @@ class LogicalHashJoin : public LogicalOperator {
     void computeFlatSchema() override;
 
     inline std::string getExpressionsForPrinting() const override {
-        return binder::ExpressionUtil::toString(joinNodeIDs) ;
-        // + std::to_string(cost) + "|" + std::to_string(lc) + "|" + std::to_string(rc)
+        return binder::ExpressionUtil::toString(joinNodeIDs);
     }
 
     binder::expression_vector getExpressionsToMaterialize() const;
@@ -56,19 +55,10 @@ class LogicalHashJoin : public LogicalOperator {
     inline SidewaysInfoPassing getSIP() const { return sip; }
 
     inline std::unique_ptr<LogicalOperator> copy() override {
-        auto c = make_unique<LogicalHashJoin>(
+        return make_unique<LogicalHashJoin>(
             joinNodeIDs, joinType, mark, children[0]->copy(), children[1]->copy());
-        c->cost = cost;
-        c->lc = lc;
-        c->rc = rc;
-        return c;
     }
 
-public:
-    uint64_t cost;
-    uint64_t lc;
-    uint64_t rc;
-
 private:
     // Flat probe side key group in either of the following two cases:
     // 1. there are multiple join nodes;

src/include/planner/subplans_table.h

@@ -7,7 +7,6 @@
 #include "binder/query/reading_clause/query_graph.h"
 #include "planner/logical_plan/logical_plan.h"
 
-// TODO: remove
 using namespace kuzu::binder;
 
 namespace kuzu {

src/optimizer/optimizer.cpp

@@ -23,7 +23,7 @@ void Optimizer::optimize(planner::LogicalPlan* plan) {
 
     // ASP optimizer should be applied after optimizers that manipulate hash join.
     auto aspOptimizer = ASPOptimizer();
-//    aspOptimizer.rewrite(plan);
+    aspOptimizer.rewrite(plan);
 
     auto projectionPushDownOptimizer = ProjectionPushDownOptimizer();
     projectionPushDownOptimizer.rewrite(plan);

src/planner/join_order/cardinality_estimator.cpp

@@ -21,20 +21,23 @@ uint64_t CardinalityEstimator::estimateScanNode(LogicalOperator* op) {
     return atLeastOne(getNumNodes(scanNode->getNode()->getInternalIDPropertyName()));
 }
 
-static uint64_t getHashCardinality(const binder::expression_vector& joinNodeIDs, const LogicalPlan& plan) {
-    auto schema = plan.getSchema();
+// Although we may not flatten join key in Build operator computation. We do need to calculate join
+// cardinality based on flat join key cardinality.
+static uint64_t getJoinKeysFlatCardinality(
+    const binder::expression_vector& joinNodeIDs, const LogicalPlan& buildPlan) {
+    auto schema = buildPlan.getSchema();
     f_group_pos_set unFlatGroupsPos;
     for (auto& joinID : joinNodeIDs) {
         auto groupPos = schema->getGroupPos(*joinID);
         if (!schema->getGroup(groupPos)->isFlat()) {
             unFlatGroupsPos.insert(groupPos);
         }
     }
-    auto cost = plan.getCardinality();
+    auto cardinality = buildPlan.getCardinality();
     for (auto groupPos : unFlatGroupsPos) {
-        cost *= schema->getGroup(groupPos)->getMultiplier();
+        cardinality *= schema->getGroup(groupPos)->getMultiplier();
     }
-    return cost;
+    return cardinality;
 }
 
 uint64_t CardinalityEstimator::estimateHashJoin(const binder::expression_vector& joinNodeIDs,
@@ -43,7 +46,8 @@ uint64_t CardinalityEstimator::estimateHashJoin(const binder::expression_vector&
     for (auto& joinNodeID : joinNodeIDs) {
         denominator *= getNumNodes(joinNodeID->getUniqueName());
     }
-    return atLeastOne(probePlan.estCardinality * getHashCardinality(joinNodeIDs, buildPlan) / denominator);
+    return atLeastOne(probePlan.estCardinality *
+                      getJoinKeysFlatCardinality(joinNodeIDs, buildPlan) / denominator);
 }
 
 uint64_t CardinalityEstimator::estimateCrossProduct(
@@ -113,8 +117,8 @@ uint64_t CardinalityEstimator::getNumRels(const binder::RelExpression& rel) {
 
 double CardinalityEstimator::getExtensionRate(
     const binder::RelExpression& rel, const binder::NodeExpression& boundNode) {
-    auto numBoundNodes = (double )getNumNodes(boundNode);
-    auto numRels =  (double )getNumRels(rel);
+    auto numBoundNodes = (double)getNumNodes(boundNode);
+    auto numRels = (double)getNumRels(rel);
     return numRels / numBoundNodes;
 }
 

src/planner/join_order/cost_model.cpp

@@ -9,31 +9,13 @@ uint64_t CostModel::computeExtendCost(const LogicalPlan& childPlan) {
     return childPlan.estCardinality;
 }
 
-// Although we may not flatten join key in Build operator. The hash is computed on every flat tuple,
-// so the cost should also be measured on flat cardinality.
-static uint64_t getHashCost(const binder::expression_vector& joinNodeIDs, const LogicalPlan& plan) {
-    auto schema = plan.getSchema();
-    f_group_pos_set unFlatGroupsPos;
-    for (auto& joinID : joinNodeIDs) {
-        auto groupPos = schema->getGroupPos(*joinID);
-        if (!schema->getGroup(groupPos)->isFlat()) {
-            unFlatGroupsPos.insert(groupPos);
-        }
-    }
-    auto cost = plan.getCardinality();
-//    for (auto groupPos : unFlatGroupsPos) {
-//        cost *= schema->getGroup(groupPos)->getMultiplier();
-//    }
-    return cost;
-}
-
 uint64_t CostModel::computeHashJoinCost(const binder::expression_vector& joinNodeIDs,
     const LogicalPlan& probe, const LogicalPlan& build) {
     auto cost = 0u;
     cost += probe.getCost();
     cost += build.getCost();
     cost += probe.getCardinality();
-    cost += 2 * build.getCardinality();
+    cost += common::EnumeratorKnobs::BUILD_PENALTY * build.getCardinality();
     return cost;
 }
 
@@ -46,14 +28,14 @@ uint64_t CostModel::computeIntersectCost(const kuzu::planner::LogicalPlan& probe
     const std::vector<std::unique_ptr<LogicalPlan>>& buildPlans) {
     auto cost = 0u;
     cost += probePlan.getCost();
+    // TODO(Xiyang): think of how to calculate intersect cost such that it will be picked in worst
+    // case.
     cost += probePlan.getCardinality();
     for (auto& buildPlan : buildPlans) {
         cost += buildPlan->getCost();
-        // During planning we guarantee keys are already flatten on build side.
-//        cost += buildPlan->getCardinality();
     }
     return cost;
 }
 
 } // namespace planner
-} // namespace kuzu
+} // namespace kuzu

src/planner/join_order_enumerator.cpp

@@ -1,5 +1,6 @@
 #include "planner/join_order_enumerator.h"
 
+#include "planner/join_order/cost_model.h"
 #include "planner/logical_plan/logical_operator/logical_cross_product.h"
 #include "planner/logical_plan/logical_operator/logical_extend.h"
 #include "planner/logical_plan/logical_operator/logical_ftable_scan.h"
@@ -8,7 +9,6 @@
 #include "planner/logical_plan/logical_operator/logical_scan_node.h"
 #include "planner/projection_planner.h"
 #include "planner/query_planner.h"
-#include "planner/join_order/cost_model.h"
 
 using namespace kuzu::common;
 
@@ -495,9 +495,6 @@ void JoinOrderEnumerator::appendHashJoin(const expression_vector& joinNodeIDs, J
     hashJoin->computeFactorizedSchema();
     // update cost
     probePlan.setCost(CostModel::computeHashJoinCost(joinNodeIDs, probePlan, buildPlan));
-    hashJoin->cost = probePlan.getCost();
-    hashJoin->lc = probePlan.getCardinality();
-    hashJoin->rc = buildPlan.getCardinality();
     // update cardinality
     probePlan.setCardinality(
         queryPlanner->cardinalityEstimator->estimateHashJoin(joinNodeIDs, probePlan, buildPlan));

test/test_files/tinysnb/asp/asp.test

@@ -1,5 +1,5 @@
 -NAME AspBasic
--QUERY MATCH (a:person)-[e1:knows]->(b:person) WHERE a.age > 35 AND b.age > 0 RETURN b.fName
+-QUERY MATCH (a:person)-[e1:knows]->(b:person) WHERE a.age > 35 RETURN b.fName
 -ENCODED_JOIN HJ(b._id){E(b)S(a)}{S(b)}
 ---- 3
 Alice