Merge bb0593c into 3bc6d46

src/expression/abstract_expression.cpp

@@ -113,6 +113,13 @@ bool AbstractExpression::operator==(const AbstractExpression &rhs) const {
   if (exp_type_ != rhs.exp_type_ || children_.size() != rhs.children_.size())
     return false;
 
+  // TODO: Try sorting the children
+  // TODO: Extend this to other comparison predicates
+  if (exp_type_ == ExpressionType::COMPARE_EQUAL && children_.size() == 2 && rhs.children_.size() == 2) {
+    return (*children_[0] == *rhs.children_[0] && *children_[1] == *rhs.children_[1]) ||
+           (*children_[0] == *rhs.children_[1] && *children_[1] == *rhs.children_[0]);
+  }
+
   for (unsigned i = 0; i < children_.size(); i++) {
     if (*children_[i].get() != *rhs.children_[i].get()) return false;
   }

src/include/optimizer/abstract_cost_calculator.h

@@ -0,0 +1,30 @@
+//===----------------------------------------------------------------------===//
+//
+//                         Peloton
+//
+// abstract_cost_calculator.h
+//
+// Identification: src/include/optimizer/abstract_cost_calculator.h
+//
+// Copyright (c) 2015-2018, Carnegie Mellon University Database Group
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "optimizer/operator_visitor.h"
+
+namespace peloton {
+namespace optimizer {
+
+class Memo;
+
+class AbstractCostCalculator : public OperatorVisitor {
+ public:
+  virtual double CalculateCost(GroupExpression *gexpr, Memo *memo,
+                               concurrency::TransactionContext *txn) = 0;
+};
+
+}  // namespace optimizer
+}  // namespace peloton
+

src/include/optimizer/cost_calculator.h

@@ -2,51 +2,52 @@
 //
 //                         Peloton
 //
-// cost_and_stats_calculator.h
+// cost_calculator.h
 //
 // Identification: src/include/optimizer/cost_calculator.h
 //
-// Copyright (c) 2015-16, Carnegie Mellon University Database Group
+// Copyright (c) 2015-2018, Carnegie Mellon University Database Group
 //
 //===----------------------------------------------------------------------===//
 
 #pragma once
 
-#include "optimizer/operator_visitor.h"
+#include "optimizer/abstract_cost_calculator.h"
 
 namespace peloton {
 namespace optimizer {
 
 class Memo;
-// Derive cost for a physical group expressionh
-class CostCalculator : public OperatorVisitor {
+// Derive cost for a physical group expression
+class CostCalculator : public AbstractCostCalculator {
  public:
-  double CalculateCost(GroupExpression *gexpr, Memo *memo,
-                       concurrency::TransactionContext *txn);
-
-  void Visit(const DummyScan *) override;
-  void Visit(const PhysicalSeqScan *) override;
-  void Visit(const PhysicalIndexScan *) override;
-  void Visit(const ExternalFileScan *) override;
-  void Visit(const QueryDerivedScan *) override;
-  void Visit(const PhysicalOrderBy *) override;
-  void Visit(const PhysicalLimit *) override;
-  void Visit(const PhysicalInnerNLJoin *) override;
-  void Visit(const PhysicalLeftNLJoin *) override;
-  void Visit(const PhysicalRightNLJoin *) override;
-  void Visit(const PhysicalOuterNLJoin *) override;
-  void Visit(const PhysicalInnerHashJoin *) override;
-  void Visit(const PhysicalLeftHashJoin *) override;
-  void Visit(const PhysicalRightHashJoin *) override;
-  void Visit(const PhysicalOuterHashJoin *) override;
-  void Visit(const PhysicalInsert *) override;
-  void Visit(const PhysicalInsertSelect *) override;
-  void Visit(const PhysicalDelete *) override;
-  void Visit(const PhysicalUpdate *) override;
-  void Visit(const PhysicalHashGroupBy *) override;
-  void Visit(const PhysicalSortGroupBy *) override;
-  void Visit(const PhysicalDistinct *) override;
-  void Visit(const PhysicalAggregate *) override;
+  CostCalculator(){};
+
+  virtual double CalculateCost(GroupExpression *gexpr, Memo *memo,
+                               concurrency::TransactionContext *txn) override;
+
+  virtual void Visit(const DummyScan *) override;
+  virtual void Visit(const PhysicalSeqScan *) override;
+  virtual void Visit(const PhysicalIndexScan *) override;
+  virtual void Visit(const QueryDerivedScan *) override;
+  virtual void Visit(const PhysicalOrderBy *) override;
+  virtual void Visit(const PhysicalLimit *) override;
+  virtual void Visit(const PhysicalInnerNLJoin *) override;
+  virtual void Visit(const PhysicalLeftNLJoin *) override;
+  virtual void Visit(const PhysicalRightNLJoin *) override;
+  virtual void Visit(const PhysicalOuterNLJoin *) override;
+  virtual void Visit(const PhysicalInnerHashJoin *) override;
+  virtual void Visit(const PhysicalLeftHashJoin *) override;
+  virtual void Visit(const PhysicalRightHashJoin *) override;
+  virtual void Visit(const PhysicalOuterHashJoin *) override;
+  virtual void Visit(const PhysicalInsert *) override;
+  virtual void Visit(const PhysicalInsertSelect *) override;
+  virtual void Visit(const PhysicalDelete *) override;
+  virtual void Visit(const PhysicalUpdate *) override;
+  virtual void Visit(const PhysicalHashGroupBy *) override;
+  virtual void Visit(const PhysicalSortGroupBy *) override;
+  virtual void Visit(const PhysicalDistinct *) override;
+  virtual void Visit(const PhysicalAggregate *) override;
 
  private:
   double HashCost();

src/include/optimizer/optimizer.h

@@ -15,6 +15,7 @@
 #include <memory>
 
 #include "optimizer/abstract_optimizer.h"
+#include "optimizer/abstract_cost_calculator.h"
 #include "optimizer/property_set.h"
 #include "optimizer/optimizer_metadata.h"
 
@@ -53,6 +54,8 @@ struct QueryInfo {
   std::shared_ptr<PropertySet> physical_props;
 };
 
+enum CostModels {DEFAULT, POSTGRES};
+
 //===--------------------------------------------------------------------===//
 // Optimizer
 //===--------------------------------------------------------------------===//
@@ -71,7 +74,7 @@ class Optimizer : public AbstractOptimizer {
   Optimizer(Optimizer &&) = delete;
   Optimizer &operator=(Optimizer &&) = delete;
 
-  Optimizer();
+  Optimizer(const CostModels cost_model = CostModels::DEFAULT);
 
   std::shared_ptr<planner::AbstractPlan> BuildPelotonPlanTree(
       const std::unique_ptr<parser::SQLStatementList> &parse_tree_list,
@@ -164,6 +167,7 @@ class Optimizer : public AbstractOptimizer {
   //////////////////////////////////////////////////////////////////////////////
   /// Metadata
   OptimizerMetadata metadata_;
+  std::unique_ptr<AbstractCostCalculator> cost_model_;
 };
 
 }  // namespace optimizer

src/include/optimizer/optimizer_metadata.h

@@ -2,9 +2,9 @@
 //
 //                         Peloton
 //
-// optimizer.h
+// optimizer_metadata.h
 //
-// Identification: src/include/optimizer/optimizer.h
+// Identification: src/include/optimizer/optimizer_metadata.h
 //
 // Copyright (c) 2015-2018, Carnegie Mellon University Database Group
 //
@@ -13,6 +13,7 @@
 #pragma once
 
 #include "common/timer.h"
+#include "optimizer/cost_calculator.h"
 #include "optimizer/memo.h"
 #include "optimizer/group_expression.h"
 #include "optimizer/rule.h"
@@ -30,14 +31,16 @@ class RuleSet;
 
 class OptimizerMetadata {
  public:
-  OptimizerMetadata()
-      : timeout_limit(settings::SettingsManager::GetInt(
-            settings::SettingId::task_execution_timeout)),
+
+  OptimizerMetadata(std::unique_ptr<AbstractCostCalculator> cost_model)
+      : cost_model(std::move(cost_model)), timeout_limit(settings::SettingsManager::GetInt(
+      settings::SettingId::task_execution_timeout)),
         timer(Timer<std::milli>()) {}
 
   Memo memo;
   RuleSet rule_set;
   OptimizerTaskPool *task_pool;
+  std::unique_ptr<AbstractCostCalculator> cost_model;
   catalog::CatalogCache *catalog_cache;
   unsigned int timeout_limit;
   Timer<std::milli> timer;