Using AbstractNode throughout optimizer.

Abstract nodes were implemented in 209c46a. This is essentially just
refactoring and plugging in abstract nodes throughout the optimizer.
The abstract interface exposes OpType and ExpressionType for now,
which ideally will be fixed later. Work remaining for abstracting
OperatorExpression.

Author: newtoncx

src/include/optimizer/abstract_node.h

@@ -83,33 +83,44 @@ enum class OpType {
 class OperatorVisitor;
 
 struct AbstractNode {
-  AbstractNode() {}
+  AbstractNode(AbstractNode *node) : node(node) {}
 
   ~AbstractNode() {}
 
   virtual void Accept(OperatorVisitor *v) const = 0;
 
   virtual std::string GetName() const = 0;
 
-  // TODO(ncx): problematic dependence on OpType
-  virtual OpType GetType() const = 0;
+  // TODO(ncx): dependence on OpType and ExpressionType (ideally abstracted away)
+  virtual OpType GetOpType() const = 0;
+
+  virtual ExpressionType GetExpType() const = 0;
 
   virtual bool IsLogical() const = 0;
 
   virtual bool IsPhysical() const = 0;
 
   virtual hash_t Hash() const {
-    OpType t = GetType();
+    // TODO(ncx): hash should work for ExpressionType nodes
+    OpType t = GetOpType();
     return HashUtil::Hash(&t);
   }
 
   virtual bool operator==(const AbstractNode &r) {
-    return GetType() == r.GetType();
+    return GetOpType() == r.GetOpType() && GetExpType() == r.GetExpType();
   }
 
   virtual bool IsDefined() const { return node != nullptr; }
 
- private:
+  template <typename T>
+  const T *As() const {
+    if (node && typeid(*node) == typeid(T)) {
+      return (const T *)node.get();
+    }
+    return nullptr;
+  }
+
+ protected:
   std::shared_ptr<AbstractNode> node; 
 };
 

src/include/optimizer/cost_model/default_cost_model.h

@@ -34,7 +34,7 @@ class DefaultCostModel : public AbstractCostModel {
     gexpr_ = gexpr;
     memo_ = memo;
     txn_ = txn;
-    gexpr_->Op().Accept(this);
+    gexpr_->Op()->Accept(this);
     return output_cost_;
   }
 

src/include/optimizer/cost_model/postgres_cost_model.h

@@ -39,7 +39,7 @@ class PostgresCostModel : public AbstractCostModel {
     gexpr_ = gexpr;
     memo_ = memo;
     txn_ = txn;
-    gexpr_->Op().Accept(this);
+    gexpr_->Op()->Accept(this);
     return output_cost_;
   };
 
@@ -279,4 +279,4 @@ class PostgresCostModel : public AbstractCostModel {
 };
 
 }  // namespace optimizer
-}  // namespace peloton
+}  // namespace peloton

src/include/optimizer/cost_model/trivial_cost_model.h

@@ -41,7 +41,7 @@ class TrivialCostModel : public AbstractCostModel {
     gexpr_ = gexpr;
     memo_ = memo;
     txn_ = txn;
-    gexpr_->Op().Accept(this);
+    gexpr_->Op()->Accept(this);
     return output_cost_;
   };
 
@@ -116,4 +116,4 @@ class TrivialCostModel : public AbstractCostModel {
 };
 
 }  // namespace optimizer
-}  // namespace peloton
+}  // namespace peloton

src/include/optimizer/group_expression.h

@@ -12,7 +12,7 @@
 
 #pragma once
 
-#include "optimizer/operator_node.h"
+#include "optimizer/abstract_node.h"
 #include "optimizer/stats/stats.h"
 #include "optimizer/util.h"
 #include "optimizer/property_set.h"
@@ -34,7 +34,7 @@ using GroupID = int32_t;
 //===--------------------------------------------------------------------===//
 class GroupExpression {
  public:
-  GroupExpression(Operator op, std::vector<GroupID> child_groups);
+  GroupExpression(std::shared_ptr<AbstractNode> node, std::vector<GroupID> child_groups);
 
   GroupID GetGroupID() const;
 
@@ -46,7 +46,7 @@ class GroupExpression {
 
   GroupID GetChildGroupId(int child_idx) const;
 
-  Operator Op() const;
+  std::shared_ptr<AbstractNode> Op() const;
 
   double GetCost(std::shared_ptr<PropertySet>& requirements) const;
 
@@ -75,7 +75,7 @@ class GroupExpression {
 
  private:
   GroupID group_id;
-  Operator op;
+  std::shared_ptr<AbstractNode> node;
   std::vector<GroupID> child_groups;
   std::bitset<static_cast<uint32_t>(RuleType::NUM_RULES)> rule_mask_;
   bool stats_derived_;

src/include/optimizer/operator_node.h

@@ -28,26 +28,29 @@ namespace optimizer {
 class OperatorVisitor;
 
 // Curiously recurring template pattern
-// TODO(ncx): this templating would be nice to clean up
 template <typename T>
 struct OperatorNode : public AbstractNode {
-  OperatorNode() {}
+  OperatorNode() : AbstractNode(nullptr) {}
 
   virtual ~OperatorNode() {}
 
   void Accept(OperatorVisitor *v) const;
 
-  virtual std::string GetName() const { return name_; }
+  std::string GetName() const { return name_; }
 
-  virtual OpType GetType() const { return type_; }
+  OpType GetOpType() const { return op_type_; }
+
+  ExpressionType GetExpType() const { return exp_type_; }
 
   bool IsLogical() const;
 
   bool IsPhysical() const;
 
   static std::string name_;
 
-  static OpType type_;
+  static OpType op_type_;
+
+  static ExpressionType exp_type_;
 };
 
 class Operator : public AbstractNode {
@@ -60,7 +63,9 @@ class Operator : public AbstractNode {
 
   std::string GetName() const;
 
-  OpType GetType() const;
+  OpType GetOpType() const;
+
+  ExpressionType GetExpType() const;
 
   bool IsLogical() const;
 
@@ -71,21 +76,6 @@ class Operator : public AbstractNode {
   bool operator==(const Operator &r);
 
   bool IsDefined() const;
-
-  template <typename T>
-  const T *As() const {
-    if (node && typeid(*node) == typeid(T)) {
-      return (const T *)node.get();
-    }
-    return nullptr;
-  }
-
-  static std::string name_;
-
-  static OpType type_;
-
- private:
-  std::shared_ptr<AbstractNode> node;
 };
 
 }  // namespace optimizer

src/include/optimizer/optimizer_metadata.h

@@ -19,6 +19,8 @@
 #include "optimizer/rule.h"
 #include "settings/settings_manager.h"
 
+#include <memory>
+
 namespace peloton {
 namespace catalog {
 class Catalog;
@@ -58,7 +60,7 @@ class OptimizerMetadata {
       memo.InsertExpression(gexpr, false);
       child_groups.push_back(gexpr->GetGroupID());
     }
-    return std::make_shared<GroupExpression>(expr->Op(),
+    return std::make_shared<GroupExpression>(std::make_shared<Operator>(expr->Op()),
                                              std::move(child_groups));
   }
 

src/optimizer/binding.cpp

@@ -85,8 +85,9 @@ GroupExprBindingIterator::GroupExprBindingIterator(
       pattern_(pattern),
       first_(true),
       has_next_(false),
-      current_binding_(std::make_shared<OperatorExpression>(gexpr->Op())) {
-  if (gexpr->Op().GetType() != pattern->Type()) {
+      // TODO(ncx): fix once OperatorExpression is abstracted
+      current_binding_(std::make_shared<OperatorExpression>(*(Operator *)gexpr->Op().get())) {
+  if (gexpr->Op()->GetOpType() != pattern->Type()) {
     return;
   }
 
@@ -100,7 +101,7 @@ GroupExprBindingIterator::GroupExprBindingIterator(
   LOG_TRACE(
       "Attempting to bind on group %d with expression of type %s, children "
       "size %lu",
-      gexpr->GetGroupID(), gexpr->Op().GetName().c_str(), child_groups.size());
+      gexpr->GetGroupID(), gexpr->Op()->GetName().c_str(), child_groups.size());
 
   // Find all bindings for children
   children_bindings_.resize(child_groups.size(), {});

src/optimizer/child_property_deriver.cpp

@@ -38,7 +38,7 @@ ChildPropertyDeriver::GetProperties(GroupExpression *gexpr,
   output_.clear();
   memo_ = memo;
   gexpr_ = gexpr;
-  gexpr->Op().Accept(this);
+  gexpr->Op()->Accept(this);
   return move(output_);
 }
 

src/optimizer/group.cpp

@@ -31,7 +31,7 @@ void Group::AddExpression(std::shared_ptr<GroupExpression> expr,
   expr->SetGroupID(id_);
   if (enforced)
     enforced_exprs_.push_back(expr);
-  else if (expr->Op().IsPhysical())
+  else if (expr->Op()->IsPhysical())
     physical_expressions_.push_back(expr);
   else
     logical_expressions_.push_back(expr);
@@ -40,7 +40,7 @@ void Group::AddExpression(std::shared_ptr<GroupExpression> expr,
 bool Group::SetExpressionCost(GroupExpression *expr, double cost,
                               std::shared_ptr<PropertySet> &properties) {
   LOG_TRACE("Adding expression cost on group %d with op %s, req %s",
-            expr->GetGroupID(), expr->Op().GetName().c_str(),
+            expr->GetGroupID(), expr->Op()->GetName().c_str(),
             properties->ToString().c_str());
   auto it = lowest_cost_expressions_.find(properties);
   if (it == lowest_cost_expressions_.end() || std::get<0>(it->second) > cost) {
@@ -86,7 +86,7 @@ const std::string Group::GetInfo(int num_indent) const {
 
     for (auto expr : logical_expressions_) {
         os << StringUtil::Indent(num_indent + 4)
-           << expr->Op().GetName() << std::endl;
+           << expr->Op()->GetName() << std::endl;
         const std::vector<GroupID> ChildGroupIDs = expr->GetChildGroupIDs();
         if (ChildGroupIDs.size() > 0) {        
             os << StringUtil::Indent(num_indent + 6)
@@ -102,7 +102,7 @@ const std::string Group::GetInfo(int num_indent) const {
            << "physical_expressions_: \n";
     for (auto expr : physical_expressions_) {
         os << StringUtil::Indent(num_indent + 4)
-           << expr->Op().GetName() << std::endl;
+           << expr->Op()->GetName() << std::endl;
         const std::vector<GroupID> ChildGroupIDs = expr->GetChildGroupIDs();
         if (ChildGroupIDs.size() > 0) {
             os << StringUtil::Indent(num_indent + 6)
@@ -119,7 +119,7 @@ const std::string Group::GetInfo(int num_indent) const {
            << "enforced_exprs_: \n";
     for (auto expr : enforced_exprs_) {
         os << StringUtil::Indent(num_indent + 4)
-           << expr->Op().GetName() << std::endl;
+           << expr->Op()->GetName() << std::endl;
         const std::vector<GroupID> ChildGroupIDs = expr->GetChildGroupIDs();
         if (ChildGroupIDs.size() > 0) {
             os << StringUtil::Indent(num_indent + 6)