Merge branch 'templatize' into abstract.

Still need to make fixes to Pattern to support both OpType and ExpType
without templatizing. Will also need to clean up code after before build
will work.

Author: newtoncx

src/include/common/internal_types.h

@@ -1383,6 +1383,10 @@ enum class RuleType : uint32_t {
   PULL_FILTER_THROUGH_MARK_JOIN,
   PULL_FILTER_THROUGH_AGGREGATION,
 
+  // AST rewrite rules (logical -> logical)
+  // Removes ConstantValueExpression = ConstantValueExpression
+  COMP_EQUALITY_ELIMINATION,
+
   // Place holder to generate number of rules compile time
   NUM_RULES
 

src/include/optimizer/absexpr_expression.h

@@ -0,0 +1,183 @@
+//===----------------------------------------------------------------------===//
+//
+//                         Peloton
+//
+// absexpr_expression.h
+//
+// Identification: src/include/optimizer/absexpr_expression.h
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+// AbstractExpression Definition
+#include "expression/abstract_expression.h"
+#include "expression/conjunction_expression.h"
+#include "expression/comparison_expression.h"
+#include "expression/constant_value_expression.h"
+
+#include <memory>
+#include <vector>
+
+namespace peloton {
+namespace optimizer {
+
+// (TODO): rethink the AbsExpr_Container/Expression approach in comparion to abstract
+// Most of the core rule/optimizer code relies on the concept of an Operator /
+// OperatorExpression and the interface that the two functions respectively expose.
+//
+// The annoying part is that an AbstractExpression blends together an Operator
+// and OperatorExpression. Second part, the AbstractExpression does not export the
+// correct interface that the rest of the system depends on.
+//
+// As an extreme level of simplification (sort of hacky), an AbsExpr_Container is
+// analogous to Operator and wraps a single AbstractExpression node. AbsExpr_Expression
+// is analogous to OperatorExpression.
+//
+// AbsExpr_Container does *not* handle memory correctly w.r.t internal instantiations
+// from Rule transformation. This is since Peloton itself mixes unique_ptrs and
+// hands out raw pointers which makes adding a shared_ptr here extremely problematic.
+// terrier uses only shared_ptr when dealing with AbstractExpression trees.
+
+class AbsExpr_Container {
+ public:
+  AbsExpr_Container();
+
+  AbsExpr_Container(const expression::AbstractExpression *expr) {
+    node = expr;
+  }
+
+  // Return operator type
+  ExpressionType GetType() const {
+    if (IsDefined()) {
+      return node->GetExpressionType();
+    }
+    return ExpressionType::INVALID;
+  }
+
+  const expression::AbstractExpression *GetExpr() const {
+    return node;
+  }
+
+  // Operator contains Logical node
+  bool IsLogical() const {
+    return true;
+  }
+
+  // Operator contains Physical node
+  bool IsPhysical() const {
+    return false;
+  }
+
+  std::string GetName() const {
+    if (IsDefined()) {
+      return node->GetExpressionName();
+    }
+
+    return "Undefined";
+  }
+
+  hash_t Hash() const {
+    if (IsDefined()) {
+      return node->Hash();
+    }
+    return 0;
+  }
+
+  bool operator==(const AbsExpr_Container &r) {
+    if (IsDefined() && r.IsDefined()) {
+      // (TODO): need a better way to determine deep equality
+
+      // NOTE:
+      // Without proper equality determinations, the groups will
+      // not be assigned correctly. Arguably, terrier does this
+      // better because a blind ExactlyEquals on different types
+      // of ConstantValueExpression under Peloton will crash!
+
+      // For now, just return (false).
+      // I don't anticipate this will affect correctness, just
+      // performance, since duplicate trees will have to evaluated
+      // over and over again, rather than being able to "borrow"
+      // a previous tree's rewrite.
+      //
+      // Probably not worth to create a "validator" since porting
+      // this to terrier anyways (?). == does not check Value
+      // so it's broken. ExactlyEqual requires precondition checking.
+      return false;
+    } else if (!IsDefined() && !r.IsDefined()) {
+      return true;
+    }
+    return false;
+  }
+
+  // Operator contains physical or logical operator node
+  bool IsDefined() const {
+    return node != nullptr;
+  }
+
+  //(TODO): fix memory management once go to terrier
+  expression::AbstractExpression *Rebuild(std::vector<expression::AbstractExpression*> children) {
+    switch (GetType()) {
+      case ExpressionType::COMPARE_EQUAL:
+      case ExpressionType::COMPARE_NOTEQUAL:
+      case ExpressionType::COMPARE_LESSTHAN:
+      case ExpressionType::COMPARE_GREATERTHAN:
+      case ExpressionType::COMPARE_LESSTHANOREQUALTO:
+      case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
+      case ExpressionType::COMPARE_LIKE:
+      case ExpressionType::COMPARE_NOTLIKE:
+      case ExpressionType::COMPARE_IN:
+      case ExpressionType::COMPARE_DISTINCT_FROM: {
+        PELOTON_ASSERT(children.size() == 2);
+        return new expression::ComparisonExpression(GetType(), children[0], children[1]);
+      }
+      case ExpressionType::CONJUNCTION_AND:
+      case ExpressionType::CONJUNCTION_OR: {
+        PELOTON_ASSERT(children.size() == 2);
+        return new expression::ConjunctionExpression(GetType(), children[0], children[1]);
+      }
+      case ExpressionType::VALUE_CONSTANT: {
+        PELOTON_ASSERT(children.size() == 0);
+        auto cve = static_cast<const expression::ConstantValueExpression*>(node);
+        return new expression::ConstantValueExpression(cve->GetValue());
+      }
+      default: {
+        int type = static_cast<int>(GetType());
+        LOG_ERROR("Unimplemented Rebuild() for %d found", type);
+        return nullptr;
+      }
+    }
+  }
+
+ private:
+  const expression::AbstractExpression *node;
+};
+
+class AbsExpr_Expression {
+ public:
+  AbsExpr_Expression(AbsExpr_Container op): op(op) {};
+
+  void PushChild(std::shared_ptr<AbsExpr_Expression> op) {
+    children.push_back(op);
+  }
+
+  void PopChild() {
+    children.pop_back();
+  }
+
+  const std::vector<std::shared_ptr<AbsExpr_Expression>> &Children() const {
+    return children;
+  }
+
+  const AbsExpr_Container &Op() const {
+    return op;
+  }
+
+ private:
+  AbsExpr_Container op;
+  std::vector<std::shared_ptr<AbsExpr_Expression>> children;
+};
+
+}  // namespace optimizer
+}  // namespace peloton
+

src/include/optimizer/binding.h

@@ -46,6 +46,7 @@ class BindingIterator {
 
 class GroupBindingIterator : public BindingIterator {
  public:
+  // TODO(ncx): pattern
   GroupBindingIterator(Memo& memo, GroupID id,
                        std::shared_ptr<Pattern> pattern);
 
@@ -59,21 +60,25 @@ class GroupBindingIterator : public BindingIterator {
   Group *target_group_;
   size_t num_group_items_;
 
+  // Internal function for HasNext()
+  bool HasNextBinding();
+
   size_t current_item_index_;
   std::unique_ptr<BindingIterator> current_iterator_;
 };
 
 class GroupExprBindingIterator : public BindingIterator {
  public:
-  GroupExprBindingIterator(Memo& memo,
-                      GroupExpression *gexpr,
-                      std::shared_ptr<Pattern> pattern);
+  // TODO(ncx): pattern
+  GroupExprBindingIterator(Memo& memo, GroupExpression *gexpr,
+                           std::shared_ptr<Pattern> pattern);
 
   bool HasNext() override;
 
   std::shared_ptr<AbstractNodeExpression> Next() override;
 
  private:
+  // TODO(ncx): pattern
   GroupExpression* gexpr_;
   std::shared_ptr<Pattern> pattern_;
 

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

@@ -24,13 +24,14 @@ namespace peloton {
 namespace optimizer {
 
 class Memo;
+
 // Derive cost for a physical group expression
 class DefaultCostModel : public AbstractCostModel {
  public:
   DefaultCostModel(){};
 
   double CalculateCost(GroupExpression *gexpr, Memo *memo,
-                                       concurrency::TransactionContext *txn) {
+                       concurrency::TransactionContext *txn) {
     gexpr_ = gexpr;
     memo_ = memo;
     txn_ = txn;

src/include/optimizer/cost_model/postgres_cost_model.h

@@ -29,6 +29,7 @@ namespace peloton {
 namespace optimizer {
 
 class Memo;
+
 // Derive cost for a physical group expression
 class PostgresCostModel : public AbstractCostModel {
  public:

src/include/optimizer/cost_model/trivial_cost_model.h

@@ -32,6 +32,7 @@ namespace peloton {
 namespace optimizer {
 
 class Memo;
+
 class TrivialCostModel : public AbstractCostModel {
  public:
   TrivialCostModel(){};

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):