Created class and constructor + check

Author: GustavoAngulo

src/include/common/internal_types.h

@@ -1304,6 +1304,7 @@ std::ostream &operator<<(std::ostream &os, const PropertyType &type);
 enum class RuleType : uint32_t {
   // Transformation rules (logical -> logical)
   INNER_JOIN_COMMUTE = 0,
+  INNER_JOIN_ASSOCIATE,
 
   // Don't move this one
   LogicalPhysicalDelimiter,

src/include/optimizer/rule_impls.h

@@ -38,6 +38,22 @@ class InnerJoinCommutativity : public Rule {
                  OptimizeContext *context) const override;
 };
 
+/**
+ * @brief (A join B) join C -> A join (B join C)
+ */
+
+class InnerJoinAssociativity : public Rule {
+ public:
+ InnerJoinAssociativity();
+
+  bool Check(std::shared_ptr<OperatorExpression> plan,
+             OptimizeContext *context) const override;
+
+  void Transform(std::shared_ptr<OperatorExpression> input,
+                 std::vector<std::shared_ptr<OperatorExpression>> &transformed,
+                 OptimizeContext *context) const override;
+};
+
 //===--------------------------------------------------------------------===//
 // Implementation rules
 //===--------------------------------------------------------------------===//

src/optimizer/rule_impls.cpp

@@ -68,6 +68,51 @@ void InnerJoinCommutativity::Transform(
   transformed.push_back(result_plan);
 }
 
+///////////////////////////////////////////////////////////////////////////////
+/// InnerJoinAssociativity
+InnerJoinAssociativity::InnerJoinAssociativity() {
+  type_ = RuleType::INNER_JOIN_ASSOCIATE;
+
+  // Create left nested join
+  auto left_child = std::make_shared<Pattern>(OpType::InnerJoin);
+  left_child->AddChild(std::make_shared<Pattern>(OpType::Leaf));
+  left_child->AddChild(std::make_shared<Pattern>(OpType::Leaf));
+
+  std::shared_ptr<Pattern> right_child(std::make_shared<Pattern>(OpType::Leaf));
+
+  match_pattern = std::make_shared<Pattern>(OpType::InnerJoin);
+  match_pattern->AddChild(left_child);
+  match_pattern->AddChild(right_child);
+}
+
+//TODO: As far as I know, theres nothing else that needs to be checked
+bool InnerJoinAssociativity::Check(std::shared_ptr<OperatorExpression> expr,
+                                   OptimizeContext *context) const {
+  (void)context;
+  (void)expr;
+  return true;
+}
+
+void InnerJoinAssociativity::Transform(
+    std::shared_ptr<OperatorExpression> input,
+    std::vector<std::shared_ptr<OperatorExpression>> &transformed,
+    UNUSED_ATTRIBUTE OptimizeContext *context) const {
+  auto join_op = input->Op().As<LogicalInnerJoin>();
+  auto join_predicates =
+      std::vector<AnnotatedExpression>(join_op->join_predicates);
+  auto result_plan = std::make_shared<OperatorExpression>(
+      LogicalInnerJoin::make(join_predicates));
+  std::vector<std::shared_ptr<OperatorExpression>> children = input->Children();
+  PL_ASSERT(children.size() == 2);
+  LOG_TRACE(
+      "Reorder left child with op %s and right child with op %s for inner join",
+      children[0]->Op().GetName().c_str(), children[1]->Op().GetName().c_str());
+  result_plan->PushChild(children[1]);
+  result_plan->PushChild(children[0]);
+
+  transformed.push_back(result_plan);
+}
+
 //===--------------------------------------------------------------------===//
 // Implementation rules
 //===--------------------------------------------------------------------===//