* remove Logical operator related to "Inner" and "Outer" since we use one operator with a JoinType to represent them all.

* Clang-format.
* Update the optimizer_rule_test and optimizer_test to use new operators.

Author: zhaoguoquan94

src/include/common/internal_types.h

@@ -77,7 +77,7 @@ extern int TEST_TUPLES_PER_TILEGROUP;
 enum class CmpBool {
   CmpFalse = 0,
   CmpTrue = 1,
-  NULL_ = 2 // Note the underscore suffix
+  NULL_ = 2  // Note the underscore suffix
 };
 
 //===--------------------------------------------------------------------===//
@@ -1210,7 +1210,8 @@ std::ostream &operator<<(std::ostream &os, const RWType &type);
 typedef CuckooMap<ItemPointer, RWType, ItemPointerHasher, ItemPointerComparator>
     ReadWriteSet;
 
-typedef tbb::concurrent_unordered_set<ItemPointer, ItemPointerHasher, ItemPointerComparator> WriteSet;
+typedef tbb::concurrent_unordered_set<ItemPointer, ItemPointerHasher,
+                                      ItemPointerComparator> WriteSet;
 
 // this enum is to identify why the version should be GC'd.
 enum class GCVersionType {
@@ -1236,7 +1237,8 @@ enum class DDLType {
   CREATE,
   DROP,
 };
-typedef tbb::concurrent_vector<std::tuple<oid_t, oid_t, oid_t, DDLType>> CreateDropSet;
+typedef tbb::concurrent_vector<std::tuple<oid_t, oid_t, oid_t, DDLType>>
+    CreateDropSet;
 typedef std::vector<std::tuple<oid_t, oid_t, oid_t>> GCObjectSet;
 
 //===--------------------------------------------------------------------===//
@@ -1318,8 +1320,6 @@ enum class RuleType : uint32_t {
   // Transformation rules (logical -> logical)
   JOIN_COMMUTE = 0,
   JOIN_ASSOCIATE,
-  INNER_JOIN_COMMUTE,
-  INNER_JOIN_ASSOCIATE,
 
   // Don't move this one
   LogicalPhysicalDelimiter,

src/include/optimizer/child_stats_deriver.h

@@ -27,22 +27,17 @@ class Memo;
 // expression
 class ChildStatsDeriver : public OperatorVisitor {
  public:
-  std::vector<ExprSet> DeriveInputStats(
-      GroupExpression *gexpr,
-      ExprSet required_cols, Memo *memo);
+  std::vector<ExprSet> DeriveInputStats(GroupExpression *gexpr,
+                                        ExprSet required_cols, Memo *memo);
 
   void Visit(const LogicalQueryDerivedGet *) override;
   void Visit(const LogicalJoin *) override;
-  void Visit(const LogicalInnerJoin *) override;
-  void Visit(const LogicalLeftJoin *) override;
-  void Visit(const LogicalRightJoin *) override;
-  void Visit(const LogicalOuterJoin *) override;
   void Visit(const LogicalSemiJoin *) override;
   void Visit(const LogicalAggregateAndGroupBy *) override;
 
  private:
   void PassDownRequiredCols();
-  void PassDownColumn(expression::AbstractExpression* col);
+  void PassDownColumn(expression::AbstractExpression *col);
   ExprSet required_cols_;
   GroupExpression *gexpr_;
   Memo *memo_;

src/include/optimizer/operator_node.h

@@ -34,10 +34,6 @@ enum class OpType {
   LogicalDependentJoin,
   LogicalSingleJoin,
   LogicalJoin,
-  InnerJoin,
-  LeftJoin,
-  RightJoin,
-  OuterJoin,
   SemiJoin,
   LogicalAggregateAndGroupBy,
   LogicalInsert,

src/include/optimizer/operator_visitor.h

@@ -61,10 +61,6 @@ class OperatorVisitor {
   virtual void Visit(const LogicalSingleJoin *) {}
   virtual void Visit(const LogicalDependentJoin *) {}
   virtual void Visit(const LogicalJoin *) {}
-  virtual void Visit(const LogicalInnerJoin *) {}
-  virtual void Visit(const LogicalLeftJoin *) {}
-  virtual void Visit(const LogicalRightJoin *) {}
-  virtual void Visit(const LogicalOuterJoin *) {}
   virtual void Visit(const LogicalSemiJoin *) {}
   virtual void Visit(const LogicalAggregateAndGroupBy *) {}
   virtual void Visit(const LogicalInsert *) {}

src/include/optimizer/operators.h

@@ -31,7 +31,7 @@ class UpdateClause;
 }
 
 namespace catalog {
-  class TableCatalogObject;
+class TableCatalogObject;
 }
 
 namespace optimizer {
@@ -51,10 +51,10 @@ class LeafOperator : OperatorNode<LeafOperator> {
 //===--------------------------------------------------------------------===//
 class LogicalGet : public OperatorNode<LogicalGet> {
  public:
-  static Operator make(oid_t get_id = 0,
-                       std::vector<AnnotatedExpression> predicates = {},
-                       std::shared_ptr<catalog::TableCatalogObject> table = nullptr,
-                       std::string alias = "", bool update = false);
+  static Operator make(
+      oid_t get_id = 0, std::vector<AnnotatedExpression> predicates = {},
+      std::shared_ptr<catalog::TableCatalogObject> table = nullptr,
+      std::string alias = "", bool update = false);
 
   bool operator==(const BaseOperatorNode &r) override;
 
@@ -169,7 +169,8 @@ class LogicalJoin : public OperatorNode<LogicalJoin> {
  public:
   static Operator make(JoinType _type);
 
-  static Operator make(JoinType _type, std::vector<AnnotatedExpression> &conditions);
+  static Operator make(JoinType _type,
+                       std::vector<AnnotatedExpression> &conditions);
 
   bool operator==(const BaseOperatorNode &r) override;
 
@@ -179,52 +180,6 @@ class LogicalJoin : public OperatorNode<LogicalJoin> {
   JoinType type;
 };
 
-//===--------------------------------------------------------------------===//
-// InnerJoin
-//===--------------------------------------------------------------------===//
-class LogicalInnerJoin : public OperatorNode<LogicalInnerJoin> {
- public:
-  static Operator make();
-
-  static Operator make(std::vector<AnnotatedExpression> &conditions);
-
-  bool operator==(const BaseOperatorNode &r) override;
-
-  hash_t Hash() const override;
-
-  std::vector<AnnotatedExpression> join_predicates;
-};
-
-//===--------------------------------------------------------------------===//
-// LeftJoin
-//===--------------------------------------------------------------------===//
-class LogicalLeftJoin : public OperatorNode<LogicalLeftJoin> {
- public:
-  static Operator make(expression::AbstractExpression *condition = nullptr);
-
-  std::shared_ptr<expression::AbstractExpression> join_predicate;
-};
-
-//===--------------------------------------------------------------------===//
-// RightJoin
-//===--------------------------------------------------------------------===//
-class LogicalRightJoin : public OperatorNode<LogicalRightJoin> {
- public:
-  static Operator make(expression::AbstractExpression *condition = nullptr);
-
-  std::shared_ptr<expression::AbstractExpression> join_predicate;
-};
-
-//===--------------------------------------------------------------------===//
-// OuterJoin
-//===--------------------------------------------------------------------===//
-class LogicalOuterJoin : public OperatorNode<LogicalOuterJoin> {
- public:
-  static Operator make(expression::AbstractExpression *condition = nullptr);
-
-  std::shared_ptr<expression::AbstractExpression> join_predicate;
-};
-
 //===--------------------------------------------------------------------===//
 // SemiJoin
 //===--------------------------------------------------------------------===//
@@ -263,7 +218,8 @@ class LogicalAggregateAndGroupBy
 class LogicalInsert : public OperatorNode<LogicalInsert> {
  public:
   static Operator make(
-      std::shared_ptr<catalog::TableCatalogObject> target_table, const std::vector<std::string> *columns,
+      std::shared_ptr<catalog::TableCatalogObject> target_table,
+      const std::vector<std::string> *columns,
       const std::vector<std::vector<
           std::unique_ptr<expression::AbstractExpression>>> *values);
 
@@ -275,7 +231,8 @@ class LogicalInsert : public OperatorNode<LogicalInsert> {
 
 class LogicalInsertSelect : public OperatorNode<LogicalInsertSelect> {
  public:
-  static Operator make(std::shared_ptr<catalog::TableCatalogObject> target_table);
+  static Operator make(
+      std::shared_ptr<catalog::TableCatalogObject> target_table);
 
   std::shared_ptr<catalog::TableCatalogObject> target_table;
 };
@@ -303,7 +260,8 @@ class LogicalLimit : public OperatorNode<LogicalLimit> {
 //===--------------------------------------------------------------------===//
 class LogicalDelete : public OperatorNode<LogicalDelete> {
  public:
-  static Operator make(std::shared_ptr<catalog::TableCatalogObject> target_table);
+  static Operator make(
+      std::shared_ptr<catalog::TableCatalogObject> target_table);
 
   std::shared_ptr<catalog::TableCatalogObject> target_table;
 };
@@ -334,7 +292,8 @@ class DummyScan : public OperatorNode<DummyScan> {
 //===--------------------------------------------------------------------===//
 class PhysicalSeqScan : public OperatorNode<PhysicalSeqScan> {
  public:
-  static Operator make(oid_t get_id, std::shared_ptr<catalog::TableCatalogObject> table,
+  static Operator make(oid_t get_id,
+                       std::shared_ptr<catalog::TableCatalogObject> table,
                        std::string alias,
                        std::vector<AnnotatedExpression> predicates,
                        bool update);
@@ -356,7 +315,8 @@ class PhysicalSeqScan : public OperatorNode<PhysicalSeqScan> {
 //===--------------------------------------------------------------------===//
 class PhysicalIndexScan : public OperatorNode<PhysicalIndexScan> {
  public:
-  static Operator make(oid_t get_id, std::shared_ptr<catalog::TableCatalogObject> table,
+  static Operator make(oid_t get_id,
+                       std::shared_ptr<catalog::TableCatalogObject> table,
                        std::string alias,
                        std::vector<AnnotatedExpression> predicates, bool update,
                        oid_t index_id, std::vector<oid_t> key_column_id_list,
@@ -430,8 +390,7 @@ class PhysicalLimit : public OperatorNode<PhysicalLimit> {
 class PhysicalNLJoin : public OperatorNode<PhysicalNLJoin> {
  public:
   static Operator make(
-      JoinType _type,
-      std::vector<AnnotatedExpression> conditions,
+      JoinType _type, std::vector<AnnotatedExpression> conditions,
       std::vector<std::unique_ptr<expression::AbstractExpression>> &left_keys,
       std::vector<std::unique_ptr<expression::AbstractExpression>> &right_keys);
 
@@ -452,8 +411,7 @@ class PhysicalNLJoin : public OperatorNode<PhysicalNLJoin> {
 class PhysicalHashJoin : public OperatorNode<PhysicalHashJoin> {
  public:
   static Operator make(
-      JoinType _type,
-      std::vector<AnnotatedExpression> conditions,
+      JoinType _type, std::vector<AnnotatedExpression> conditions,
       std::vector<std::unique_ptr<expression::AbstractExpression>> &left_keys,
       std::vector<std::unique_ptr<expression::AbstractExpression>> &right_keys);
 
@@ -574,7 +532,8 @@ class PhysicalOuterHashJoin : public OperatorNode<PhysicalOuterHashJoin> {
 class PhysicalInsert : public OperatorNode<PhysicalInsert> {
  public:
   static Operator make(
-      std::shared_ptr<catalog::TableCatalogObject> target_table, const std::vector<std::string> *columns,
+      std::shared_ptr<catalog::TableCatalogObject> target_table,
+      const std::vector<std::string> *columns,
       const std::vector<std::vector<
           std::unique_ptr<expression::AbstractExpression>>> *values);
 
@@ -586,7 +545,8 @@ class PhysicalInsert : public OperatorNode<PhysicalInsert> {
 
 class PhysicalInsertSelect : public OperatorNode<PhysicalInsertSelect> {
  public:
-  static Operator make(std::shared_ptr<catalog::TableCatalogObject> target_table);
+  static Operator make(
+      std::shared_ptr<catalog::TableCatalogObject> target_table);
 
   std::shared_ptr<catalog::TableCatalogObject> target_table;
 };
@@ -596,7 +556,8 @@ class PhysicalInsertSelect : public OperatorNode<PhysicalInsertSelect> {
 //===--------------------------------------------------------------------===//
 class PhysicalDelete : public OperatorNode<PhysicalDelete> {
  public:
-  static Operator make(std::shared_ptr<catalog::TableCatalogObject> target_table);
+  static Operator make(
+      std::shared_ptr<catalog::TableCatalogObject> target_table);
   std::shared_ptr<catalog::TableCatalogObject> target_table;
 };
 

src/include/optimizer/rule_impls.h

@@ -53,37 +53,6 @@ class JoinAssociativity : public Rule {
                  OptimizeContext *context) const override;
 };
 
-/**
- * @brief (A join B) -> (B join A)
- */
-class InnerJoinCommutativity : public Rule {
- public:
-  InnerJoinCommutativity();
-
-  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;
-};
-
-/**
- * @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
 //===--------------------------------------------------------------------===//
@@ -269,36 +238,6 @@ class JoinToHashJoin : public Rule {
                  OptimizeContext *context) const override;
 };
 
-/**
- * @brief (Logical Inner Join -> Inner Nested-Loop Join)
- */
-class InnerJoinToInnerNLJoin : public Rule {
- public:
-  InnerJoinToInnerNLJoin();
-
-  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;
-};
-
-/**
- * @brief (Logical Inner Join -> Inner Hash Join)
- */
-class InnerJoinToInnerHashJoin : public Rule {
- public:
-  InnerJoinToInnerHashJoin();
-
-  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;
-};
-
 /**
  * @brief (Logical Distinct -> Physical Distinct)
  */
@@ -401,7 +340,8 @@ class EmbedFilterIntoGet : public Rule {
 ///////////////////////////////////////////////////////////////////////////////
 /// Unnesting rules
 // We use this promise to determine which rules should be applied first if
-// multiple rules are applicable, we need to first pull filters up through mark-join
+// multiple rules are applicable, we need to first pull filters up through
+// mark-join
 // then turn mark-join into a regular join operator
 enum class UnnestPromise { Low = 1, High };
 // TODO(boweic): MarkJoin and SingleJoin should not be transformed into inner

src/include/optimizer/stats_calculator.h

@@ -26,16 +26,12 @@ class TableStats;
  */
 class StatsCalculator : public OperatorVisitor {
  public:
-  void CalculateStats(GroupExpression *gexpr, ExprSet required_cols,
-                      Memo *memo, concurrency::TransactionContext* txn);
+  void CalculateStats(GroupExpression *gexpr, ExprSet required_cols, Memo *memo,
+                      concurrency::TransactionContext *txn);
 
   void Visit(const LogicalGet *) override;
   void Visit(const LogicalQueryDerivedGet *) override;
   void Visit(const LogicalJoin *) override;
-  void Visit(const LogicalInnerJoin *) override;
-  void Visit(const LogicalLeftJoin *) override;
-  void Visit(const LogicalRightJoin *) override;
-  void Visit(const LogicalOuterJoin *) override;
   void Visit(const LogicalSemiJoin *) override;
   void Visit(const LogicalAggregateAndGroupBy *) override;
   void Visit(const LogicalLimit *) override;
@@ -65,8 +61,8 @@ class StatsCalculator : public OperatorVisitor {
    */
   void UpdateStatsForFilter(
       size_t num_rows,
-      std::unordered_map<std::string, std::shared_ptr<ColumnStats>>
-          &predicate_stats,
+      std::unordered_map<std::string, std::shared_ptr<ColumnStats>> &
+          predicate_stats,
       const std::vector<AnnotatedExpression> &predicates);
 
   double CalculateSelectivityForPredicate(
@@ -76,7 +72,7 @@ class StatsCalculator : public OperatorVisitor {
   GroupExpression *gexpr_;
   ExprSet required_cols_;
   Memo *memo_;
-  concurrency::TransactionContext* txn_;
+  concurrency::TransactionContext *txn_;
 };
 
 }  // namespace optimizer