Adding AbstractNodeExpression interface.

Author: newtoncx

src/include/optimizer/abstract_node.h

@@ -83,7 +83,7 @@ enum class OpType {
 class OperatorVisitor;
 
 struct AbstractNode {
-  AbstractNode(AbstractNode *node) : node(node) {}
+  AbstractNode(std::shared_ptr<AbstractNode> node) : node(node) {}
 
   ~AbstractNode() {}
 

src/include/optimizer/abstract_node_expression.h

@@ -0,0 +1,44 @@
+//===----------------------------------------------------------------------===//
+//
+//                         Peloton
+//
+// abstract_node_expression.h
+//
+// Identification: src/include/optimizer/abstract_node_expression.h
+//
+// Copyright (c) 2015-19, Carnegie Mellon University Database Group
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "optimizer/abstract_node.h"
+
+#include <memory>
+#include <vector>
+
+namespace peloton {
+namespace optimizer {
+
+//===--------------------------------------------------------------------===//
+// Abstract Node Expression
+//===--------------------------------------------------------------------===//
+class AbstractNodeExpression {
+ public:
+  AbstractNodeExpression() {}
+
+  ~AbstractNodeExpression() {}
+
+  virtual void PushChild(std::shared_ptr<AbstractNodeExpression> child) = 0;
+
+  virtual void PopChild() = 0;
+
+  virtual const std::vector<std::shared_ptr<AbstractNodeExpression>> &Children() const = 0;
+
+  virtual const std::shared_ptr<AbstractNode> Node() const = 0;
+
+  virtual const std::string GetInfo() const = 0;
+};
+
+}  // namespace optimizer
+}  // namespace peloton

src/include/optimizer/binding.h

@@ -12,13 +12,14 @@
 
 #pragma once
 
+#include "operator_expression.h"
 #include "optimizer/operator_node.h"
 #include "optimizer/group.h"
 #include "optimizer/pattern.h"
+
 #include <map>
 #include <tuple>
 #include <memory>
-#include "operator_expression.h"
 
 namespace peloton {
 namespace optimizer {
@@ -37,7 +38,7 @@ class BindingIterator {
 
   virtual bool HasNext() = 0;
 
-  virtual std::shared_ptr<OperatorExpression> Next() = 0;
+  virtual std::shared_ptr<AbstractNodeExpression> Next() = 0;
 
  protected:
   Memo &memo_;
@@ -50,7 +51,7 @@ class GroupBindingIterator : public BindingIterator {
 
   bool HasNext() override;
 
-  std::shared_ptr<OperatorExpression> Next() override;
+  std::shared_ptr<AbstractNodeExpression> Next() override;
 
  private:
   GroupID group_id_;
@@ -70,16 +71,16 @@ class GroupExprBindingIterator : public BindingIterator {
 
   bool HasNext() override;
 
-  std::shared_ptr<OperatorExpression> Next() override;
+  std::shared_ptr<AbstractNodeExpression> Next() override;
 
  private:
   GroupExpression* gexpr_;
   std::shared_ptr<Pattern> pattern_;
 
   bool first_;
   bool has_next_;
-  std::shared_ptr<OperatorExpression> current_binding_;
-  std::vector<std::vector<std::shared_ptr<OperatorExpression>>>
+  std::shared_ptr<AbstractNodeExpression> current_binding_;
+  std::vector<std::vector<std::shared_ptr<AbstractNodeExpression>>>
       children_bindings_;
   std::vector<size_t> children_bindings_pos_;
 };

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_->Node()->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_->Node()->Accept(this);
     return output_cost_;
   };
 

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_->Node()->Accept(this);
     return output_cost_;
   };
 

src/include/optimizer/group_expression.h

@@ -46,7 +46,7 @@ class GroupExpression {
 
   GroupID GetChildGroupId(int child_idx) const;
 
-  std::shared_ptr<AbstractNode> Op() const;
+  std::shared_ptr<AbstractNode> Node() const;
 
   double GetCost(std::shared_ptr<PropertySet>& requirements) const;
 

src/include/optimizer/operator_expression.h

@@ -2,16 +2,17 @@
 //
 //                         Peloton
 //
-// op_expression.h
+// operator_expression.h
 //
-// Identification: src/include/optimizer/op_expression.h
+// Identification: src/include/optimizer/operator_expression.h
 //
-// Copyright (c) 2015-16, Carnegie Mellon University Database Group
+// Copyright (c) 2015-19, Carnegie Mellon University Database Group
 //
 //===----------------------------------------------------------------------===//
 
 #pragma once
 
+#include "optimizer/abstract_node_expression.h"
 #include "optimizer/operator_node.h"
 
 #include <memory>
@@ -21,25 +22,25 @@ namespace peloton {
 namespace optimizer {
 
 //===--------------------------------------------------------------------===//
-// Operator Expr
+// Operator Expression
 //===--------------------------------------------------------------------===//
-class OperatorExpression {
+class OperatorExpression : public AbstractNodeExpression {
  public:
-  OperatorExpression(Operator op);
+  OperatorExpression(std::shared_ptr<AbstractNode> node);
 
-  void PushChild(std::shared_ptr<OperatorExpression> op);
+  void PushChild(std::shared_ptr<AbstractNodeExpression> child);
 
   void PopChild();
 
-  const std::vector<std::shared_ptr<OperatorExpression>> &Children() const;
+  const std::vector<std::shared_ptr<AbstractNodeExpression>> &Children() const;
 
-  const Operator &Op() const;
+  const std::shared_ptr<AbstractNode> Node() const;
 
   const std::string GetInfo() const;
 
  private:
-  Operator op;
-  std::vector<std::shared_ptr<OperatorExpression>> children;
+  std::shared_ptr<AbstractNode> node;
+  std::vector<std::shared_ptr<AbstractNodeExpression>> children;
 };
 
 }  // namespace optimizer

src/include/optimizer/operator_node.h

@@ -57,7 +57,7 @@ class Operator : public AbstractNode {
  public:
   Operator();
 
-  Operator(AbstractNode *node);
+  Operator(std::shared_ptr<AbstractNode> node);
 
   void Accept(OperatorVisitor *v) const;