Enabled rewriting of a single rule (constant = constant), check tests.

Possibly annoying problems w.r.t Peloton/terrier:
(1) Use of unique_ptr/raw pointer as opposed to shared_ptr in AbstractExpression
(2) AbstractExpression equality comparison method

Additional components needed:
- Dynamic/template/strategy rule evaluation (particularly comparison)
- Repeated/multi-level application of rules
- Layer to convert from memo -> AbstractExpression
- Some refactoring w.r.t templated code
- Better AbsExpr_Container/Expression indirection layer
  (intended to present a similar interface exposed by
   Operator/OperatorExpression relied upon by core logic)
- Proper memory management strategy (tightly coupled to problem #1)

Author: 17zhangw

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,146 @@
+//===----------------------------------------------------------------------===//
+//
+//                         Peloton
+//
+// absexpr_expression.h
+//
+// Identification: src/include/optimizer/absexpr_expression.h
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+// AbstractExpression Definition
+#include "expression/abstract_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;
+  }
+
+ 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/rewriter.h

@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//
+//                         Peloton
+//
+// rewriter.h
+//
+// Identification: src/include/optimizer/rewriter.h
+//
+// Copyright (c) 2015-2018, Carnegie Mellon University Database Group
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include <memory>
+
+#include "expression/abstract_expression.h"
+#include "optimizer/optimizer_metadata.h"
+#include "optimizer/optimizer_task_pool.h"
+#include "optimizer/absexpr_expression.h"
+
+namespace peloton {
+namespace optimizer {
+
+class Rewriter {
+
+ public:
+  Rewriter(const Rewriter &) = delete;
+  Rewriter &operator=(const Rewriter &) = delete;
+  Rewriter(Rewriter &&) = delete;
+  Rewriter &operator=(Rewriter &&) = delete;
+
+  Rewriter();
+
+  expression::AbstractExpression* RewriteExpression(const expression::AbstractExpression *expr);
+  void Reset();
+
+  OptimizerMetadata<AbsExpr_Container,ExpressionType,AbsExpr_Expression> &GetMetadata() { return metadata_; }
+
+  std::shared_ptr<AbsExpr_Expression> ConvertToAbsExpr(const expression::AbstractExpression *expr);
+
+ private:
+  void ExecuteTaskStack(OptimizerTaskStack<AbsExpr_Container,ExpressionType,AbsExpr_Expression> &task_stack);
+  void RewriteLoop(int root_group_id);
+  std::shared_ptr<GroupExpression<AbsExpr_Container,ExpressionType,AbsExpr_Expression>> ConvertTree(const expression::AbstractExpression *expr);
+  OptimizerMetadata<AbsExpr_Container,ExpressionType,AbsExpr_Expression> metadata_;
+};
+
+}  // namespace optimizer
+}  // namespace peloton

src/include/optimizer/rule.h

@@ -113,7 +113,8 @@ struct RuleWithPromise {
 
 enum class RewriteRuleSetName : uint32_t {
   PREDICATE_PUSH_DOWN = 0,
-  UNNEST_SUBQUERY
+  UNNEST_SUBQUERY,
+  COMPARATOR_ELIMINATION
 };
 
 /**

src/include/optimizer/rule_rewrite.h

@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//
+//                         Peloton
+//
+// rule_rewrite.h
+//
+// Identification: src/include/optimizer/rule_rewrite.h
+//
+// Copyright (c) 2015-16, Carnegie Mellon University Database Group
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "optimizer/rule.h"
+#include "optimizer/absexpr_expression.h"
+
+#include <memory>
+
+namespace peloton {
+namespace optimizer {
+
+class ComparatorElimination: public Rule<AbsExpr_Container,ExpressionType,AbsExpr_Expression> {
+ public:
+  ComparatorElimination();
+
+  int Promise(GroupExpression<AbsExpr_Container,ExpressionType,AbsExpr_Expression> *group_expr,
+              OptimizeContext<AbsExpr_Container,ExpressionType,AbsExpr_Expression> *context) const override;
+
+  bool Check(std::shared_ptr<AbsExpr_Expression> plan,
+             OptimizeContext<AbsExpr_Container,ExpressionType,AbsExpr_Expression> *context) const override;
+
+  void Transform(std::shared_ptr<AbsExpr_Expression> input,
+                 std::vector<std::shared_ptr<AbsExpr_Expression>> &transformed,
+                 OptimizeContext<AbsExpr_Container,ExpressionType,AbsExpr_Expression> *context) const override;
+};
+}  // namespace optimizer
+}  // namespace peloton

src/optimizer/binding.cpp

@@ -15,6 +15,7 @@
 #include "common/logger.h"
 #include "optimizer/operator_visitor.h"
 #include "optimizer/optimizer.h"
+#include "optimizer/absexpr_expression.h"
 
 namespace peloton {
 namespace optimizer {
@@ -38,9 +39,41 @@ GroupBindingIterator<Node,OperatorType,OperatorExpr>::GroupBindingIterator(
 
 template <class Node, class OperatorType, class OperatorExpr>
 bool GroupBindingIterator<Node,OperatorType,OperatorExpr>::HasNext() {
+  //(TODO): refactor this and specialization to reduce duplicated code
+  if (current_iterator_) {
+    // Check if still have bindings in current item
+    if (!current_iterator_->HasNext()) {
+      current_iterator_.reset(nullptr);
+      current_item_index_++;
+    }
+  }
+
+  if (current_iterator_ == nullptr) {
+    // Keep checking item iterators until we find a match
+    while (current_item_index_ < num_group_items_) {
+      current_iterator_.reset(new GroupExprBindingIterator<Node,OperatorType,OperatorExpr>(
+          this->memo_,
+          target_group_->GetLogicalExpressions()[current_item_index_].get(),
+          pattern_));
+
+      if (current_iterator_->HasNext()) {
+        break;
+      }
+
+      current_iterator_.reset(nullptr);
+      current_item_index_++;
+    }
+  }
+
+  std::cout << "Is there a group bind: " << (current_iterator_ != nullptr) << "\n";
+  return current_iterator_ != nullptr;
+}
+
+// Specialization
+template <>
+bool GroupBindingIterator<Operator,OpType,OperatorExpression>::HasNext() {
   LOG_TRACE("HasNext");
 
-  //(TODO): GroupBindingIterator::HasNext() probably needs specialization
   if (pattern_->Type() == OpType::Leaf) {
     return current_item_index_ == 0;
   }
@@ -56,7 +89,7 @@ bool GroupBindingIterator<Node,OperatorType,OperatorExpr>::HasNext() {
   if (current_iterator_ == nullptr) {
     // Keep checking item iterators until we find a match
     while (current_item_index_ < num_group_items_) {
-      current_iterator_.reset(new GroupExprBindingIterator<Node,OperatorType,OperatorExpr>(
+      current_iterator_.reset(new GroupExprBindingIterator<Operator,OpType,OperatorExpression>(
           this->memo_,
           target_group_->GetLogicalExpressions()[current_item_index_].get(),
           pattern_));
@@ -75,10 +108,16 @@ bool GroupBindingIterator<Node,OperatorType,OperatorExpr>::HasNext() {
 
 template <class Node, class OperatorType, class OperatorExpr>
 std::shared_ptr<OperatorExpr> GroupBindingIterator<Node,OperatorType,OperatorExpr>::Next() {
-  //(TODO): GroupBindingIterator::Next() probably needs specialization
+  std::cout << "Fetching next iterator\n";
+  return current_iterator_->Next();
+}
+
+// Specialization
+template <>
+std::shared_ptr<OperatorExpression> GroupBindingIterator<Operator,OpType,OperatorExpression>::Next() {
   if (pattern_->Type() == OpType::Leaf) {
     current_item_index_ = num_group_items_;
-    return std::make_shared<OperatorExpr>(LeafOperator::make(group_id_));
+    return std::make_shared<OperatorExpression>(LeafOperator::make(group_id_));
   }
   return current_iterator_->Next();
 }
@@ -189,5 +228,8 @@ std::shared_ptr<OperatorExpr> GroupExprBindingIterator<Node,OperatorType,Operato
 template class GroupBindingIterator<Operator,OpType,OperatorExpression>;
 template class GroupExprBindingIterator<Operator,OpType,OperatorExpression>;
 
+template class GroupBindingIterator<AbsExpr_Container,ExpressionType,AbsExpr_Expression>;
+template class GroupExprBindingIterator<AbsExpr_Container,ExpressionType,AbsExpr_Expression>;
+
 }  // namespace optimizer
 }  // namespace peloton

src/optimizer/group.cpp

@@ -12,6 +12,7 @@
 
 #include "optimizer/group.h"
 #include "optimizer/operator_expression.h"
+#include "optimizer/absexpr_expression.h"
 
 #include "common/logger.h"
 
@@ -171,6 +172,7 @@ bool Group<Node, OperatorType, OperatorExpr>::HasColumnStats(std::string column_
 
 // Explicitly instantiate
 template class Group<Operator,OpType,OperatorExpression>;
+template class Group<AbsExpr_Container,ExpressionType,AbsExpr_Expression>;
 
 }  // namespace optimizer
 }  // namespace peloton

src/optimizer/group_expression.cpp

@@ -11,6 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "common/internal_types.h"
+#include "optimizer/absexpr_expression.h"
 #include "optimizer/group_expression.h"
 #include "optimizer/group.h"
 #include "optimizer/rule.h"
@@ -112,6 +113,7 @@ bool GroupExpression<Node,OperatorType,OperatorExpr>::HasRuleExplored(Rule<Node,
 
 // Explicitly instantiate to prevent linker errors
 template class GroupExpression<Operator,OpType,OperatorExpression>;
+template class GroupExpression<AbsExpr_Container,ExpressionType,AbsExpr_Expression>;
 
 }  // namespace optimizer
 }  // namespace peloton