Templatized some of the core files:

- pattern
- rule
- ruleset
- group
- groupexpression
- binding
- memo
- optimize_context
- optimizer_task (TopDownRewrite/BottomUpRewrite)

Templates generally followed:
template <class Node, class OperatorType, class OperatorExpr>

The template instantiation associated with:
Node = Operator, OperatorType = OpType, OperatorExpr = OperatorExpression
is used primarily by the core Optimizer. All references to the templated
files/classes from core optimizer files were instantiated to that.

Note worth mentioning:
Operator class defines a public interface wrapper around BaseOperatorNode,
basically defines a single logical/physical operator.

OpType class defines the various logical/physical operations
OperatorExpression class is essentially a tree of Operator

Author: 17zhangw

src/include/optimizer/binding.h

@@ -24,63 +24,68 @@ namespace peloton {
 namespace optimizer {
 
 class Optimizer;
+
+template <class Node, class OperatorType, class OperatorExpr>
 class Memo;
 
 //===--------------------------------------------------------------------===//
 // Binding Iterator
 //===--------------------------------------------------------------------===//
+template <class Node, class OperatorType, class OperatorExpr>
 class BindingIterator {
  public:
-  BindingIterator(Memo& memo) : memo_(memo) {}
+  BindingIterator(Memo<Node,OperatorType,OperatorExpr>& memo) : memo_(memo) {}
 
   virtual ~BindingIterator(){};
 
   virtual bool HasNext() = 0;
 
-  virtual std::shared_ptr<OperatorExpression> Next() = 0;
+  virtual std::shared_ptr<OperatorExpr> Next() = 0;
 
  protected:
-  Memo &memo_;
+  Memo<Node,OperatorType,OperatorExpr> &memo_;
 };
 
-class GroupBindingIterator : public BindingIterator {
+template <class Node, class OperatorType, class OperatorExpr>
+class GroupBindingIterator : public BindingIterator<Node,OperatorType,OperatorExpr> {
  public:
-  GroupBindingIterator(Memo& memo, GroupID id,
-                       std::shared_ptr<Pattern> pattern);
+  GroupBindingIterator(Memo<Node,OperatorType,OperatorExpr>& memo, 
+                       GroupID id,
+                       std::shared_ptr<Pattern<OperatorType>> pattern);
 
   bool HasNext() override;
 
-  std::shared_ptr<OperatorExpression> Next() override;
+  std::shared_ptr<OperatorExpr> Next() override;
 
  private:
   GroupID group_id_;
-  std::shared_ptr<Pattern> pattern_;
-  Group *target_group_;
+  std::shared_ptr<Pattern<OperatorType>> pattern_;
+  Group<Node,OperatorType,OperatorExpr> *target_group_;
   size_t num_group_items_;
 
   size_t current_item_index_;
-  std::unique_ptr<BindingIterator> current_iterator_;
+  std::unique_ptr<BindingIterator<Node,OperatorType,OperatorExpr>> current_iterator_;
 };
 
-class GroupExprBindingIterator : public BindingIterator {
+template <class Node, class OperatorType, class OperatorExpr>
+class GroupExprBindingIterator : public BindingIterator<Node,OperatorType,OperatorExpr> {
  public:
-  GroupExprBindingIterator(Memo& memo,
-                      GroupExpression *gexpr,
-                      std::shared_ptr<Pattern> pattern);
+  GroupExprBindingIterator(Memo<Node,OperatorType,OperatorExpr>& memo,
+                           GroupExpression<Node,OperatorType,OperatorExpr> *gexpr,
+                           std::shared_ptr<Pattern<OperatorType>> pattern);
 
   bool HasNext() override;
 
-  std::shared_ptr<OperatorExpression> Next() override;
+  std::shared_ptr<OperatorExpr> Next() override;
 
  private:
-  GroupExpression* gexpr_;
-  std::shared_ptr<Pattern> pattern_;
+  GroupExpression<Node,OperatorType,OperatorExpr>* gexpr_;
+  std::shared_ptr<Pattern<OperatorType>> pattern_;
 
   bool first_;
   bool has_next_;
-  std::shared_ptr<OperatorExpression> current_binding_;
-  std::vector<std::vector<std::shared_ptr<OperatorExpression>>>
-      children_bindings_;
+  std::shared_ptr<OperatorExpr> current_binding_;
+  std::vector<std::vector<std::shared_ptr<OperatorExpr>>> children_bindings_;
   std::vector<size_t> children_bindings_pos_;
 };
 

src/include/optimizer/child_property_deriver.h

@@ -13,10 +13,12 @@
 #pragma once
 #include <memory>
 #include "optimizer/operator_visitor.h"
+#include "optimizer/operator_expression.h"
 
 namespace peloton {
 
 namespace optimizer {
+template <class Node, class OpType, class OperatorExpr>
 class Memo;
 }
 
@@ -33,8 +35,10 @@ class ChildPropertyDeriver : public OperatorVisitor {
  public:
   std::vector<std::pair<std::shared_ptr<PropertySet>,
                         std::vector<std::shared_ptr<PropertySet>>>>
-  GetProperties(GroupExpression *gexpr,
-                std::shared_ptr<PropertySet> requirements, Memo *memo);
+
+  GetProperties(GroupExpression<Operator,OpType,OperatorExpression> *gexpr,
+                std::shared_ptr<PropertySet> requirements,
+                Memo<Operator,OpType,OperatorExpression> *memo);
 
   void Visit(const DummyScan *) override;
   void Visit(const PhysicalSeqScan *) override;
@@ -74,8 +78,8 @@ class ChildPropertyDeriver : public OperatorVisitor {
    * @brief We need the memo and gexpr because some property may depend on
    *  child's schema
    */
-  Memo *memo_;
-  GroupExpression *gexpr_;
+  Memo<Operator,OpType,OperatorExpression> *memo_;
+  GroupExpression<Operator,OpType,OperatorExpression> *gexpr_;
 };
 
 }  // namespace optimizer

src/include/optimizer/cost_model/abstract_cost_model.h

@@ -13,10 +13,12 @@
 #pragma once
 
 #include "optimizer/operator_visitor.h"
+#include "optimizer/operator_expression.h"
 
 namespace peloton {
 namespace optimizer {
 
+template <class Node, class OperatorType, class OperatorExpr>
 class Memo;
 
 // Default cost when cost model cannot compute correct cost.
@@ -34,7 +36,8 @@ static constexpr double DEFAULT_OPERATOR_COST = 0.0025;
 
 class AbstractCostModel : public OperatorVisitor {
  public:
-  virtual double CalculateCost(GroupExpression *gexpr, Memo *memo,
+  virtual double CalculateCost(GroupExpression<Operator,OpType,OperatorExpression> *gexpr,
+                               Memo<Operator,OpType,OperatorExpression> *memo,
                                concurrency::TransactionContext *txn) = 0;
 };
 

src/include/optimizer/cost_model/default_cost_model.h

@@ -23,14 +23,17 @@
 namespace peloton {
 namespace optimizer {
 
+template <class Node, class OperatorType, class OperatorExpr>
 class Memo;
+
 // Derive cost for a physical group expression
 class DefaultCostModel : public AbstractCostModel {
  public:
   DefaultCostModel(){};
 
-  double CalculateCost(GroupExpression *gexpr, Memo *memo,
-                                       concurrency::TransactionContext *txn) {
+  double CalculateCost(GroupExpression<Operator,OpType,OperatorExpression> *gexpr,
+                       Memo<Operator,OpType,OperatorExpression> *memo,
+                       concurrency::TransactionContext *txn) {
     gexpr_ = gexpr;
     memo_ = memo;
     txn_ = txn;
@@ -151,8 +154,8 @@ class DefaultCostModel : public AbstractCostModel {
     return child_num_rows * DEFAULT_TUPLE_COST;
   }
 
-  GroupExpression *gexpr_;
-  Memo *memo_;
+  GroupExpression<Operator,OpType,OperatorExpression> *gexpr_;
+  Memo<Operator,OpType,OperatorExpression> *memo_;
   concurrency::TransactionContext *txn_;
   double output_cost_ = 0;
 };

src/include/optimizer/cost_model/postgres_cost_model.h

@@ -28,13 +28,16 @@
 namespace peloton {
 namespace optimizer {
 
+template <class Node, class OperatorType, class OperatorExpr>
 class Memo;
+
 // Derive cost for a physical group expression
 class PostgresCostModel : public AbstractCostModel {
  public:
   PostgresCostModel(){};
 
-  double CalculateCost(GroupExpression *gexpr, Memo *memo,
+  double CalculateCost(GroupExpression<Operator,OpType,OperatorExpression> *gexpr,
+                       Memo<Operator,OpType,OperatorExpression> *memo,
                        concurrency::TransactionContext *txn) override {
     gexpr_ = gexpr;
     memo_ = memo;
@@ -230,8 +233,8 @@ class PostgresCostModel : public AbstractCostModel {
   }
 
 
-  GroupExpression *gexpr_;
-  Memo *memo_;
+  GroupExpression<Operator,OpType,OperatorExpression> *gexpr_;
+  Memo<Operator,OpType,OperatorExpression> *memo_;
   concurrency::TransactionContext *txn_;
   double output_cost_ = 0;
 
@@ -279,4 +282,4 @@ class PostgresCostModel : public AbstractCostModel {
 };
 
 }  // namespace optimizer
-}  // namespace peloton
+}  // namespace peloton

src/include/optimizer/cost_model/trivial_cost_model.h

@@ -31,12 +31,15 @@
 namespace peloton {
 namespace optimizer {
 
+template <class Node, class OperatorType, class OperatorExpr>
 class Memo;
+
 class TrivialCostModel : public AbstractCostModel {
  public:
   TrivialCostModel(){};
 
-  double CalculateCost(GroupExpression *gexpr, Memo *memo,
+  double CalculateCost(GroupExpression<Operator,OpType,OperatorExpression> *gexpr,
+                       Memo<Operator,OpType,OperatorExpression> *memo,
                        concurrency::TransactionContext *txn) override {
     gexpr_ = gexpr;
     memo_ = memo;
@@ -109,11 +112,11 @@ class TrivialCostModel : public AbstractCostModel {
   }
 
  private:
-  GroupExpression *gexpr_;
-  Memo *memo_;
+  GroupExpression<Operator,OpType,OperatorExpression> *gexpr_;
+  Memo<Operator,OpType,OperatorExpression> *memo_;
   concurrency::TransactionContext *txn_;
   double output_cost_ = 0;
 };
 
 }  // namespace optimizer
-}  // namespace peloton
+}  // namespace peloton

src/include/optimizer/group.h

@@ -32,36 +32,38 @@ class ColumnStats;
 //===--------------------------------------------------------------------===//
 // Group
 //===--------------------------------------------------------------------===//
+template <class Node, class OperatorType, class OperatorExpr>
 class Group : public Printable {
  public:
   Group(GroupID id, std::unordered_set<std::string> table_alias);
 
   // If the GroupExpression is generated by applying a
   // property enforcer, we add them to enforced_exprs_
   // which will not be enumerated during OptimizeExpression
-  void AddExpression(std::shared_ptr<GroupExpression> expr, bool enforced);
+  void AddExpression(std::shared_ptr<GroupExpression<Node,OperatorType,OperatorExpr>> expr,
+                     bool enforced);
 
   void RemoveLogicalExpression(size_t idx) {
     logical_expressions_.erase(logical_expressions_.begin() + idx);
   }
 
-  bool SetExpressionCost(GroupExpression *expr, double cost,
+  bool SetExpressionCost(GroupExpression<Node,OperatorType,OperatorExpr> *expr, double cost,
                          std::shared_ptr<PropertySet> &properties);
 
-  GroupExpression *GetBestExpression(std::shared_ptr<PropertySet> &properties);
+  GroupExpression<Node,OperatorType,OperatorExpr> *GetBestExpression(std::shared_ptr<PropertySet> &properties);
 
   inline const std::unordered_set<std::string> &GetTableAliases() const {
     return table_aliases_;
   }
 
   // TODO: thread safety?
-  const std::vector<std::shared_ptr<GroupExpression>> GetLogicalExpressions()
+  const std::vector<std::shared_ptr<GroupExpression<Node,OperatorType,OperatorExpr>>> GetLogicalExpressions()
       const {
     return logical_expressions_;
   }
 
   // TODO: thread safety?
-  const std::vector<std::shared_ptr<GroupExpression>> GetPhysicalExpressions()
+  const std::vector<std::shared_ptr<GroupExpression<Node,OperatorType,OperatorExpr>>> GetPhysicalExpressions()
       const {
     return physical_expressions_;
   }
@@ -105,7 +107,7 @@ class Group : public Printable {
 
   // This should only be called in rewrite phase to retrieve the only logical
   // expr in the group
-  inline GroupExpression *GetLogicalExpression() {
+  inline GroupExpression<Node,OperatorType,OperatorExpr> *GetLogicalExpression() {
     PELOTON_ASSERT(logical_expressions_.size() == 1);
     PELOTON_ASSERT(physical_expressions_.size() == 0);
     return logical_expressions_[0].get();
@@ -117,15 +119,15 @@ class Group : public Printable {
   // TODO(boweic) Do not use string, store table alias id
   std::unordered_set<std::string> table_aliases_;
   std::unordered_map<std::shared_ptr<PropertySet>,
-                     std::tuple<double, GroupExpression *>, PropSetPtrHash,
+                     std::tuple<double, GroupExpression<Node,OperatorType,OperatorExpr> *>, PropSetPtrHash,
                      PropSetPtrEq> lowest_cost_expressions_;
 
   // Whether equivalent logical expressions have been explored for this group
   bool has_explored_;
 
-  std::vector<std::shared_ptr<GroupExpression>> logical_expressions_;
-  std::vector<std::shared_ptr<GroupExpression>> physical_expressions_;
-  std::vector<std::shared_ptr<GroupExpression>> enforced_exprs_;
+  std::vector<std::shared_ptr<GroupExpression<Node,OperatorType,OperatorExpr>>> logical_expressions_;
+  std::vector<std::shared_ptr<GroupExpression<Node,OperatorType,OperatorExpr>>> physical_expressions_;
+  std::vector<std::shared_ptr<GroupExpression<Node,OperatorType,OperatorExpr>>> enforced_exprs_;
 
   // We'll add stats lazily
   // TODO(boweic):

src/include/optimizer/group_expression.h

@@ -25,16 +25,18 @@
 namespace peloton {
 namespace optimizer {
 
+template <class Node, class OperatorType, class OperatorExpr>
 class Rule;
 
 using GroupID = int32_t;
 
 //===--------------------------------------------------------------------===//
 // Group Expression
 //===--------------------------------------------------------------------===//
+template <class Node, class OperatorType, class OperatorExpr>
 class GroupExpression {
  public:
-  GroupExpression(Operator op, std::vector<GroupID> child_groups);
+  GroupExpression(Node op, std::vector<GroupID> child_groups);
 
   GroupID GetGroupID() const;
 
@@ -46,7 +48,7 @@ class GroupExpression {
 
   GroupID GetChildGroupId(int child_idx) const;
 
-  Operator Op() const;
+  Node Op() const;
 
   double GetCost(std::shared_ptr<PropertySet>& requirements) const;
 
@@ -61,11 +63,11 @@ class GroupExpression {
 
   hash_t Hash() const;
 
-  bool operator==(const GroupExpression &r);
+  bool operator==(const GroupExpression<Node, OperatorType, OperatorExpr> &r);
 
-  void SetRuleExplored(Rule *rule);
+  void SetRuleExplored(Rule<Node,OperatorType,OperatorExpr> *rule);
 
-  bool HasRuleExplored(Rule *rule);
+  bool HasRuleExplored(Rule<Node,OperatorType,OperatorExpr> *rule);
 
   void SetDerivedStats() { stats_derived_ = true; }
 
@@ -75,7 +77,7 @@ class GroupExpression {
 
  private:
   GroupID group_id;
-  Operator op;
+  Node op;
   std::vector<GroupID> child_groups;
   std::bitset<static_cast<uint32_t>(RuleType::NUM_RULES)> rule_mask_;
   bool stats_derived_;
@@ -92,9 +94,9 @@ class GroupExpression {
 
 namespace std {
 
-template <>
-struct hash<peloton::optimizer::GroupExpression> {
-  typedef peloton::optimizer::GroupExpression argument_type;
+template <class Node, class OperatorType, class OperatorExpr>
+struct hash<peloton::optimizer::GroupExpression<Node,OperatorType,OperatorExpr>> {
+  typedef peloton::optimizer::GroupExpression<Node,OperatorType,OperatorExpr> argument_type;
   typedef std::size_t result_type;
   result_type operator()(argument_type const &s) const { return s.Hash(); }
 };