Rename bijoin plan node (vesoft-inc#4977)

* Rename BiJoin to HashJoin * Rename cartesian product to cross join * Fix compile
codesigner · Dec 5, 2022 · 8c7c677 · 8c7c677
1 parent cae3fe2
commit 8c7c677
Show file tree

Hide file tree

Showing 25 changed files with 155 additions and 153 deletions.
diff --git a/src/graph/executor/Executor.cpp b/src/graph/executor/Executor.cpp
@@ -530,14 +530,14 @@ Executor *Executor::makeExecutor(QueryContext *qctx, const PlanNode *node) {
     case PlanNode::Kind::kAppendVertices: {
       return pool->makeAndAdd<AppendVerticesExecutor>(node, qctx);
     }
-    case PlanNode::Kind::kBiLeftJoin: {
-      return pool->makeAndAdd<BiLeftJoinExecutor>(node, qctx);
+    case PlanNode::Kind::kHashLeftJoin: {
+      return pool->makeAndAdd<HashLeftJoinExecutor>(node, qctx);
     }
-    case PlanNode::Kind::kBiInnerJoin: {
-      return pool->makeAndAdd<BiInnerJoinExecutor>(node, qctx);
+    case PlanNode::Kind::kHashInnerJoin: {
+      return pool->makeAndAdd<HashInnerJoinExecutor>(node, qctx);
     }
-    case PlanNode::Kind::kBiCartesianProduct: {
-      return pool->makeAndAdd<BiCartesianProductExecutor>(node, qctx);
+    case PlanNode::Kind::kCrossJoin: {
+      return pool->makeAndAdd<CrossJoinExecutor>(node, qctx);
     }
     case PlanNode::Kind::kRollUpApply: {
       return pool->makeAndAdd<RollUpApplyExecutor>(node, qctx);

diff --git a/src/graph/executor/algo/CartesianProductExecutor.cpp b/src/graph/executor/algo/CartesianProductExecutor.cpp
@@ -50,20 +50,20 @@ void CartesianProductExecutor::doCartesianProduct(const DataSet& lds,
   }
 }
 
-BiCartesianProductExecutor::BiCartesianProductExecutor(const PlanNode* node, QueryContext* qctx)
+CrossJoinExecutor::CrossJoinExecutor(const PlanNode* node, QueryContext* qctx)
     : CartesianProductExecutor(node, qctx) {
-  name_ = "BiCartesianProductExecutor";
+  name_ = "CrossJoinExecutor";
 }
 
-folly::Future<Status> BiCartesianProductExecutor::execute() {
+folly::Future<Status> CrossJoinExecutor::execute() {
   SCOPED_TIMER(&execTime_);
 
-  auto* BiCP = asNode<BiCartesianProduct>(node());
-  const auto& lds = ectx_->getResult(BiCP->leftInputVar()).value().getDataSet();
-  const auto& rds = ectx_->getResult(BiCP->rightInputVar()).value().getDataSet();
+  auto* cj = asNode<CrossJoin>(node());
+  const auto& lds = ectx_->getResult(cj->leftInputVar()).value().getDataSet();
+  const auto& rds = ectx_->getResult(cj->rightInputVar()).value().getDataSet();
   DataSet result;
   doCartesianProduct(lds, rds, result);
-  result.colNames = BiCP->colNames();
+  result.colNames = cj->colNames();
   return finish(ResultBuilder().value(Value(std::move(result))).build());
 }
 }  // namespace graph

diff --git a/src/graph/executor/algo/CartesianProductExecutor.h b/src/graph/executor/algo/CartesianProductExecutor.h
@@ -23,9 +23,9 @@ class CartesianProductExecutor : public Executor {
   std::vector<std::vector<std::string>> colNames_;
 };
 
-class BiCartesianProductExecutor : public CartesianProductExecutor {
+class CrossJoinExecutor : public CartesianProductExecutor {
  public:
-  BiCartesianProductExecutor(const PlanNode* node, QueryContext* qctx);
+  CrossJoinExecutor(const PlanNode* node, QueryContext* qctx);
 
   folly::Future<Status> execute() override;
 };

diff --git a/src/graph/executor/query/InnerJoinExecutor.cpp b/src/graph/executor/query/InnerJoinExecutor.cpp
@@ -245,29 +245,29 @@ void InnerJoinExecutor::buildNewRow(const std::unordered_map<T, std::vector<cons
 }
 
 const std::string& InnerJoinExecutor::leftVar() const {
-  if (node_->kind() == PlanNode::Kind::kBiInnerJoin) {
-    return node_->asNode<BiJoin>()->leftInputVar();
+  if (node_->kind() == PlanNode::Kind::kHashInnerJoin) {
+    return node_->asNode<HashJoin>()->leftInputVar();
   } else {
     return node_->asNode<Join>()->leftVar().first;
   }
 }
 
 const std::string& InnerJoinExecutor::rightVar() const {
-  if (node_->kind() == PlanNode::Kind::kBiInnerJoin) {
-    return node_->asNode<BiJoin>()->rightInputVar();
+  if (node_->kind() == PlanNode::Kind::kHashInnerJoin) {
+    return node_->asNode<HashJoin>()->rightInputVar();
   } else {
     return node_->asNode<Join>()->rightVar().first;
   }
 }
 
-BiInnerJoinExecutor::BiInnerJoinExecutor(const PlanNode* node, QueryContext* qctx)
+HashInnerJoinExecutor::HashInnerJoinExecutor(const PlanNode* node, QueryContext* qctx)
     : InnerJoinExecutor(node, qctx) {
-  name_ = "BiInnerJoinExecutor";
+  name_ = "HashInnerJoinExecutor";
 }
 
-folly::Future<Status> BiInnerJoinExecutor::execute() {
+folly::Future<Status> HashInnerJoinExecutor::execute() {
   SCOPED_TIMER(&execTime_);
-  auto* joinNode = asNode<BiJoin>(node());
+  auto* joinNode = asNode<HashJoin>(node());
   NG_RETURN_IF_ERROR(checkBiInputDataSets());
   return join(joinNode->hashKeys(), joinNode->probeKeys(), joinNode->colNames());
 }

diff --git a/src/graph/executor/query/InnerJoinExecutor.h b/src/graph/executor/query/InnerJoinExecutor.h
@@ -60,9 +60,9 @@ class InnerJoinExecutor : public JoinExecutor {
 
 // No diffrence with inner join in processing data, but the dependencies would be executed in
 // paralell.
-class BiInnerJoinExecutor final : public InnerJoinExecutor {
+class HashInnerJoinExecutor final : public InnerJoinExecutor {
  public:
-  BiInnerJoinExecutor(const PlanNode* node, QueryContext* qctx);
+  HashInnerJoinExecutor(const PlanNode* node, QueryContext* qctx);
 
   folly::Future<Status> execute() override;
 };

diff --git a/src/graph/executor/query/JoinExecutor.cpp b/src/graph/executor/query/JoinExecutor.cpp
@@ -33,7 +33,7 @@ Status JoinExecutor::checkInputDataSets() {
 }
 
 Status JoinExecutor::checkBiInputDataSets() {
-  auto* join = asNode<BiJoin>(node());
+  auto* join = asNode<HashJoin>(node());
   lhsIter_ = ectx_->getResult(join->leftInputVar()).iter();
   DCHECK(!!lhsIter_);
   if (lhsIter_->isGetNeighborsIter() || lhsIter_->isDefaultIter()) {

diff --git a/src/graph/executor/query/LeftJoinExecutor.cpp b/src/graph/executor/query/LeftJoinExecutor.cpp
@@ -221,14 +221,14 @@ void LeftJoinExecutor::buildNewRow(const std::unordered_map<T, std::vector<const
   }
 }
 
-BiLeftJoinExecutor::BiLeftJoinExecutor(const PlanNode* node, QueryContext* qctx)
+HashLeftJoinExecutor::HashLeftJoinExecutor(const PlanNode* node, QueryContext* qctx)
     : LeftJoinExecutor(node, qctx) {
-  name_ = "BiLeftJoinExecutor";
+  name_ = "HashLeftJoinExecutor";
 }
 
-folly::Future<Status> BiLeftJoinExecutor::execute() {
+folly::Future<Status> HashLeftJoinExecutor::execute() {
   SCOPED_TIMER(&execTime_);
-  auto* joinNode = asNode<BiJoin>(node());
+  auto* joinNode = asNode<HashJoin>(node());
   auto& rhsResult = ectx_->getResult(joinNode->rightInputVar());
   rightColSize_ = rhsResult.valuePtr()->getDataSet().colNames.size();
   NG_RETURN_IF_ERROR(checkBiInputDataSets());

diff --git a/src/graph/executor/query/LeftJoinExecutor.h b/src/graph/executor/query/LeftJoinExecutor.h
@@ -56,9 +56,9 @@ class LeftJoinExecutor : public JoinExecutor {
 
 // No diffrence with left join in processing data, but the dependencies would be executed in
 // paralell.
-class BiLeftJoinExecutor final : public LeftJoinExecutor {
+class HashLeftJoinExecutor final : public LeftJoinExecutor {
  public:
-  BiLeftJoinExecutor(const PlanNode* node, QueryContext* qctx);
+  HashLeftJoinExecutor(const PlanNode* node, QueryContext* qctx);
 
   folly::Future<Status> execute() override;
 };

diff --git a/src/graph/executor/test/JoinTest.cpp b/src/graph/executor/test/JoinTest.cpp
@@ -209,7 +209,7 @@ TEST_F(JoinTest, InnerJoin) {
   testInnerJoin("var2", "var1", expected, __LINE__);
 }
 
-TEST_F(JoinTest, BiInnerJoin) {
+TEST_F(JoinTest, HashInnerJoin) {
   DataSet expected;
   expected.colNames = {"v1", "e1", "v2", "v3", "e2"};
   Row row1;
@@ -243,9 +243,10 @@ TEST_F(JoinTest, BiInnerJoin) {
   rhs->setOutputVar("var5");
   rhs->setColNames({"v2", "e2", "v3"});
 
-  auto* join = BiInnerJoin::make(qctx_.get(), lhs, rhs, std::move(hashKeys), std::move(probeKeys));
+  auto* join =
+      HashInnerJoin::make(qctx_.get(), lhs, rhs, std::move(hashKeys), std::move(probeKeys));
 
-  auto joinExe = std::make_unique<BiInnerJoinExecutor>(join, qctx_.get());
+  auto joinExe = std::make_unique<HashInnerJoinExecutor>(join, qctx_.get());
   auto future = joinExe->execute();
   auto status = std::move(future).get();
   EXPECT_TRUE(status.ok());
@@ -380,7 +381,7 @@ TEST_F(JoinTest, LeftJoin) {
   testLeftJoin("var1", "var2", expected, __LINE__);
 }
 
-TEST_F(JoinTest, BiLeftJoin) {
+TEST_F(JoinTest, HashLeftJoin) {
   DataSet expected;
   expected.colNames = {"v2", "e2", "v3", "v1", "e1"};
   Row row1;
@@ -422,9 +423,9 @@ TEST_F(JoinTest, BiLeftJoin) {
   rhs->setOutputVar("var4");
   rhs->setColNames({"v1", "e1", "v2", "v3"});
 
-  auto* join = BiLeftJoin::make(qctx_.get(), lhs, rhs, std::move(hashKeys), std::move(probeKeys));
+  auto* join = HashLeftJoin::make(qctx_.get(), lhs, rhs, std::move(hashKeys), std::move(probeKeys));
 
-  auto joinExe = std::make_unique<BiLeftJoinExecutor>(join, qctx_.get());
+  auto joinExe = std::make_unique<HashLeftJoinExecutor>(join, qctx_.get());
   auto future = joinExe->execute();
   auto status = std::move(future).get();
   EXPECT_TRUE(status.ok());

diff --git a/src/graph/optimizer/rule/RemoveNoopProjectRule.cpp b/src/graph/optimizer/rule/RemoveNoopProjectRule.cpp
@@ -57,9 +57,9 @@ namespace opt {
     PlanNode::Kind::kDataCollect,
     PlanNode::Kind::kLeftJoin,
     PlanNode::Kind::kInnerJoin,
-    PlanNode::Kind::kBiLeftJoin,
-    PlanNode::Kind::kBiInnerJoin,
-    PlanNode::Kind::kBiCartesianProduct,
+    PlanNode::Kind::kHashLeftJoin,
+    PlanNode::Kind::kHashInnerJoin,
+    PlanNode::Kind::kCrossJoin,
     PlanNode::Kind::kRollUpApply,
     PlanNode::Kind::kArgument};
 

diff --git a/src/graph/planner/match/MatchPlanner.cpp b/src/graph/planner/match/MatchPlanner.cpp
@@ -133,7 +133,7 @@ Status MatchPlanner::connectMatchPlan(SubPlan& queryPlan, MatchClauseContext* ma
       queryPlan = SegmentsConnector::innerJoin(matchCtx->qctx, queryPlan, matchPlan, interAliases);
     }
   } else {
-    queryPlan.root = BiCartesianProduct::make(matchCtx->qctx, queryPlan.root, matchPlan.root);
+    queryPlan.root = CrossJoin::make(matchCtx->qctx, queryPlan.root, matchPlan.root);
   }
 
   return Status::OK();

diff --git a/src/graph/planner/match/SegmentsConnector.cpp b/src/graph/planner/match/SegmentsConnector.cpp
@@ -16,7 +16,7 @@ SubPlan SegmentsConnector::innerJoin(QueryContext* qctx,
                                      const SubPlan& right,
                                      const std::unordered_set<std::string>& intersectedAliases) {
   SubPlan newPlan = left;
-  auto innerJoin = BiInnerJoin::make(qctx, left.root, right.root);
+  auto innerJoin = HashInnerJoin::make(qctx, left.root, right.root);
   std::vector<Expression*> hashKeys;
   std::vector<Expression*> probeKeys;
   auto pool = qctx->objPool();
@@ -39,7 +39,7 @@ SubPlan SegmentsConnector::leftJoin(QueryContext* qctx,
                                     const SubPlan& right,
                                     const std::unordered_set<std::string>& intersectedAliases) {
   SubPlan newPlan = left;
-  auto leftJoin = BiLeftJoin::make(qctx, left.root, right.root);
+  auto leftJoin = HashLeftJoin::make(qctx, left.root, right.root);
   std::vector<Expression*> hashKeys;
   std::vector<Expression*> probeKeys;
   auto pool = qctx->objPool();
@@ -61,7 +61,7 @@ SubPlan SegmentsConnector::cartesianProduct(QueryContext* qctx,
                                             const SubPlan& left,
                                             const SubPlan& right) {
   SubPlan newPlan = left;
-  newPlan.root = BiCartesianProduct::make(qctx, left.root, right.root);
+  newPlan.root = CrossJoin::make(qctx, left.root, right.root);
   return newPlan;
 }
 

diff --git a/src/graph/planner/match/ShortestPathPlanner.cpp b/src/graph/planner/match/ShortestPathPlanner.cpp
@@ -34,7 +34,7 @@ ShortestPathPlanner::ShortestPathPlanner(CypherClauseContextBase* ctx, const Pat
 //             +------------+---------------+
 //                          |
 //                 +--------+---------+
-//                 |BiCartesianProduct|
+//                 |    CrossJoin     |
 //                 +--------+---------+
 //                          |
 //                 +--------+---------+
@@ -95,7 +95,7 @@ StatusOr<SubPlan> ShortestPathPlanner::transform(WhereClauseContext* bindWhereCl
   auto& leftPlan = plans.front();
   auto& rightPlan = plans.back();
 
-  auto cp = BiCartesianProduct::make(qctx, leftPlan.root, rightPlan.root);
+  auto cp = CrossJoin::make(qctx, leftPlan.root, rightPlan.root);
 
   auto shortestPath = ShortestPath::make(qctx, cp, spaceId, singleShortest);
   auto vertexProp = SchemaUtil::getAllVertexProp(qctx, spaceId, true);

diff --git a/src/graph/planner/plan/Algo.cpp b/src/graph/planner/plan/Algo.cpp
@@ -104,34 +104,33 @@ std::vector<std::string> CartesianProduct::inputVars() const {
   return varNames;
 }
 
-std::unique_ptr<PlanNodeDescription> BiCartesianProduct::explain() const {
+std::unique_ptr<PlanNodeDescription> CrossJoin::explain() const {
   return BinaryInputNode::explain();
 }
 
-PlanNode* BiCartesianProduct::clone() const {
+PlanNode* CrossJoin::clone() const {
   auto* node = make(qctx_);
   node->cloneMembers(*this);
   return node;
 }
 
-void BiCartesianProduct::cloneMembers(const BiCartesianProduct& r) {
+void CrossJoin::cloneMembers(const CrossJoin& r) {
   BinaryInputNode::cloneMembers(r);
 }
 
-BiCartesianProduct::BiCartesianProduct(QueryContext* qctx, PlanNode* left, PlanNode* right)
-    : BinaryInputNode(qctx, Kind::kBiCartesianProduct, left, right) {
+CrossJoin::CrossJoin(QueryContext* qctx, PlanNode* left, PlanNode* right)
+    : BinaryInputNode(qctx, Kind::kCrossJoin, left, right) {
   auto lColNames = left->colNames();
   auto rColNames = right->colNames();
   lColNames.insert(lColNames.end(), rColNames.begin(), rColNames.end());
   setColNames(lColNames);
 }
 
-void BiCartesianProduct::accept(PlanNodeVisitor* visitor) {
+void CrossJoin::accept(PlanNodeVisitor* visitor) {
   visitor->visit(this);
 }
 
-BiCartesianProduct::BiCartesianProduct(QueryContext* qctx)
-    : BinaryInputNode(qctx, Kind::kBiCartesianProduct) {}
+CrossJoin::CrossJoin(QueryContext* qctx) : BinaryInputNode(qctx, Kind::kCrossJoin) {}
 
 std::unique_ptr<PlanNodeDescription> Subgraph::explain() const {
   auto desc = SingleDependencyNode::explain();

diff --git a/src/graph/planner/plan/Algo.h b/src/graph/planner/plan/Algo.h
@@ -367,10 +367,10 @@ class Subgraph final : public SingleInputNode {
   std::unique_ptr<std::vector<EdgeProp>> edgeProps_;
 };
 
-class BiCartesianProduct final : public BinaryInputNode {
+class CrossJoin final : public BinaryInputNode {
  public:
-  static BiCartesianProduct* make(QueryContext* qctx, PlanNode* left, PlanNode* right) {
-    return qctx->objPool()->makeAndAdd<BiCartesianProduct>(qctx, left, right);
+  static CrossJoin* make(QueryContext* qctx, PlanNode* left, PlanNode* right) {
+    return qctx->objPool()->makeAndAdd<CrossJoin>(qctx, left, right);
   }
 
   std::unique_ptr<PlanNodeDescription> explain() const override;
@@ -383,15 +383,15 @@ class BiCartesianProduct final : public BinaryInputNode {
   friend ObjectPool;
 
   // used for clone only
-  static BiCartesianProduct* make(QueryContext* qctx) {
-    return qctx->objPool()->makeAndAdd<BiCartesianProduct>(qctx);
+  static CrossJoin* make(QueryContext* qctx) {
+    return qctx->objPool()->makeAndAdd<CrossJoin>(qctx);
   }
 
-  void cloneMembers(const BiCartesianProduct& r);
+  void cloneMembers(const CrossJoin& r);
 
-  BiCartesianProduct(QueryContext* qctx, PlanNode* left, PlanNode* right);
+  CrossJoin(QueryContext* qctx, PlanNode* left, PlanNode* right);
   // use for clone
-  explicit BiCartesianProduct(QueryContext* qctx);
+  explicit CrossJoin(QueryContext* qctx);
 };
 }  // namespace graph
 }  // namespace nebula

diff --git a/src/graph/planner/plan/PlanNode.cpp b/src/graph/planner/plan/PlanNode.cpp
@@ -288,12 +288,12 @@ const char* PlanNode::toString(PlanNode::Kind kind) {
       return "Traverse";
     case Kind::kAppendVertices:
       return "AppendVertices";
-    case Kind::kBiLeftJoin:
-      return "BiLeftJoin";
-    case Kind::kBiInnerJoin:
-      return "BiInnerJoin";
-    case Kind::kBiCartesianProduct:
-      return "BiCartesianProduct";
+    case Kind::kHashLeftJoin:
+      return "HashLeftJoin";
+    case Kind::kHashInnerJoin:
+      return "HashInnerJoin";
+    case Kind::kCrossJoin:
+      return "CrossJoin";
     case Kind::kShortestPath:
       return "ShortestPath";
     case Kind::kArgument:

diff --git a/src/graph/planner/plan/PlanNode.h b/src/graph/planner/plan/PlanNode.h
@@ -65,9 +65,9 @@ class PlanNode {
     kDataCollect,
     kLeftJoin,
     kInnerJoin,
-    kBiLeftJoin,
-    kBiInnerJoin,
-    kBiCartesianProduct,
+    kHashLeftJoin,
+    kHashInnerJoin,
+    kCrossJoin,
     kRollUpApply,
     kArgument,
 

diff --git a/src/graph/planner/plan/PlanNodeVisitor.h b/src/graph/planner/plan/PlanNodeVisitor.h
@@ -24,10 +24,10 @@ class PlanNodeVisitor {
   virtual void visit(Traverse *node) = 0;
   virtual void visit(ScanEdges *node) = 0;
   virtual void visit(AppendVertices *node) = 0;
-  virtual void visit(BiJoin *node) = 0;
+  virtual void visit(HashJoin *node) = 0;
   virtual void visit(Union *node) = 0;
   virtual void visit(Unwind *node) = 0;
-  virtual void visit(BiCartesianProduct *node) = 0;
+  virtual void visit(CrossJoin *node) = 0;
 };
 
 }  // namespace graph