Optimizer refactor and cost model additions

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/cost_calculator_factory.h

@@ -0,0 +1,31 @@
+//===----------------------------------------------------------------------===//
+//
+//                         Peloton
+//
+// cost_calculator_factory.h
+//
+// Identification: src/include/optimizer/cost_calculator_factory.h
+//
+// Copyright (c) 2015-2018, Carnegie Mellon University Database Group
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+#include "optimizer/cost_calculator.h"
+
+#include "common/exception.h"
+
+namespace peloton {
+namespace optimizer {
+
+class CostCalculatorFactory {
+ public:
+  /*
+   * Creates the respective cost calculator given a cost calculator name
+   */
+  static std::unique_ptr<AbstractCostCalculator> CreateCostCalculator(
+      const std::string &cost_model_name);
+};
+
+}  // namespace peloton
+}  // namespace optimizer

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"
 
@@ -72,6 +73,7 @@ class Optimizer : public AbstractOptimizer {
   Optimizer &operator=(Optimizer &&) = delete;
 
   Optimizer();
+  Optimizer(std::unique_ptr<AbstractCostCalculator> cost_model);
 
   std::shared_ptr<planner::AbstractPlan> BuildPelotonPlanTree(
       const std::unique_ptr<parser::SQLStatementList> &parse_tree_list,
@@ -164,6 +166,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,8 @@
 #pragma once
 
 #include "common/timer.h"
+#include "optimizer/cost_calculator.h"
+#include "optimizer/cost_calculator_factory.h"
 #include "optimizer/memo.h"
 #include "optimizer/group_expression.h"
 #include "optimizer/rule.h"
@@ -35,9 +37,16 @@ class OptimizerMetadata {
             settings::SettingId::task_execution_timeout)),
         timer(Timer<std::milli>()) {}
 
+  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;

src/include/optimizer/postgres_cost_calculator.h

@@ -0,0 +1,71 @@
+//===----------------------------------------------------------------------===//
+//
+//                         Peloton
+//
+// postgres_cost_calculator.h
+//
+// Identification: src/include/optimizer/postgres_cost_calculator.h
+//
+// Copyright (c) 2015-2018, Carnegie Mellon University Database Group
+//
+//===----------------------------------------------------------------------===//
+
+
+#pragma once
+
+#include "optimizer/abstract_cost_calculator.h"
+
+// TODO: This is not fully reflective of the postgres cost model. Currently we
+// are attempting
+// to emulate their hash join cost model
+
+namespace peloton {
+namespace optimizer {
+
+class Memo;
+// Derive cost for a physical group expression
+class PostgresCostCalculator : public AbstractCostCalculator {
+ public:
+  double CalculateCost(GroupExpression *gexpr, Memo *memo,
+                       concurrency::TransactionContext *txn) override;
+
+  void Visit(const DummyScan *) override;
+  void Visit(const PhysicalSeqScan *) override;
+  void Visit(const PhysicalIndexScan *) 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;
+
+ private:
+  double HashCost();
+  double SortCost();
+  double GroupByCost();
+
+  /* Checks if keys for a join child only reference one table */
+  bool IsBaseTable(
+      const std::vector<std::unique_ptr<expression::AbstractExpression>> &keys);
+
+  GroupExpression *gexpr_;
+  Memo *memo_;
+  concurrency::TransactionContext *txn_;
+  double output_cost_ = 0;
+};
+
+}  // namespace optimizer
+}  // namespace peloton