[15721] Hash Join Cost Update

src/include/optimizer/abstract_cost_calculator.h

@@ -0,0 +1,29 @@
+//===----------------------------------------------------------------------===//
+//
+//                         Peloton
+//
+// abstract_cost_calculator.h
+//
+// Identification: src/include/optimizer/abstract_cost_calculator.h
+//
+// Copyright (c) 2015-18, 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

@@ -12,40 +12,42 @@
 
 #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 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_model_factory.h
+//
+// Identification: src/include/optimizer/cost_model_factory.h
+//
+// Copyright (c) 2015-18, 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"
 
@@ -38,9 +39,9 @@ class TransactionContext;
 }
 
 namespace test {
-  class OptimizerRuleTests_SimpleAssociativeRuleTest_Test;
-  class OptimizerRuleTests_SimpleAssociativeRuleTest2_Test;
-} 
+class OptimizerRuleTests_SimpleAssociativeRuleTest_Test;
+class OptimizerRuleTests_SimpleAssociativeRuleTest2_Test;
+}
 
 namespace optimizer {
 
@@ -60,16 +61,19 @@ class Optimizer : public AbstractOptimizer {
   friend class BindingIterator;
   friend class GroupBindingIterator;
 
-  friend class ::peloton::test::OptimizerRuleTests_SimpleAssociativeRuleTest_Test;
-  friend class ::peloton::test::OptimizerRuleTests_SimpleAssociativeRuleTest2_Test; 
+  friend class ::peloton::test::
+      OptimizerRuleTests_SimpleAssociativeRuleTest_Test;
+  friend class ::peloton::test::
+      OptimizerRuleTests_SimpleAssociativeRuleTest2_Test;
 
  public:
   Optimizer(const Optimizer &) = delete;
   Optimizer &operator=(const Optimizer &) = delete;
   Optimizer(Optimizer &&) = delete;
   Optimizer &operator=(Optimizer &&) = delete;
 
-  Optimizer();
+  Optimizer(){};
+  Optimizer(std::unique_ptr<AbstractCostCalculator> cost_calculator);
 
   std::shared_ptr<planner::AbstractPlan> BuildPelotonPlanTree(
       const std::unique_ptr<parser::SQLStatementList> &parse_tree,
@@ -83,14 +87,16 @@ class Optimizer : public AbstractOptimizer {
 
   OptimizerMetadata &GetMetadata() { return metadata_; }
 
+  AbstractCostCalculator *GetCostCalculator() { return cost_calculator_.get(); }
+
   /* For test purposes only */
-  std::shared_ptr<GroupExpression> TestInsertQueryTree(parser::SQLStatement *tree,
-  concurrency::TransactionContext *txn) {
+  std::shared_ptr<GroupExpression> TestInsertQueryTree(
+      parser::SQLStatement *tree, concurrency::TransactionContext *txn) {
     return InsertQueryTree(tree, txn);
   }
   /* For test purposes only */
   void TestExecuteTaskStack(OptimizerTaskStack &task_stack, int root_group_id,
-                        std::shared_ptr<OptimizeContext> root_context) {
+                            std::shared_ptr<OptimizeContext> root_context) {
     return ExecuteTaskStack(task_stack, root_group_id, root_context);
   }
 
@@ -153,6 +159,8 @@ class Optimizer : public AbstractOptimizer {
   //////////////////////////////////////////////////////////////////////////////
   /// Metadata
   OptimizerMetadata metadata_;
+  /// Cost Model
+  std::unique_ptr<AbstractCostCalculator> cost_calculator_;
 };
 
 }  // namespace optimizer

src/include/optimizer/optimizer_metadata.h

@@ -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"
@@ -27,20 +29,32 @@ namespace optimizer {
 class OptimizerTaskPool;
 class RuleSet;
 
+using SettingsManager = settings::SettingsManager;
+using SettingId = settings::SettingId;
+
 class OptimizerMetadata {
  public:
   OptimizerMetadata()
-      : timeout_limit(settings::SettingsManager::GetInt(
+      : cost_calculator(CostCalculatorFactory::CreateCostCalculator(
+            SettingsManager::GetString(SettingId::cost_calculator))),
+        timeout_limit(
+            SettingsManager::GetInt(SettingId::task_execution_timeout)),
+        timer(Timer<std::milli>()) {}
+
+  OptimizerMetadata(std::unique_ptr<AbstractCostCalculator> cost_calculator)
+      : cost_calculator(std::move(cost_calculator)),
+        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_calculator;
   catalog::CatalogCache *catalog_cache;
   unsigned int timeout_limit;
   Timer<std::milli> timer;
-  concurrency::TransactionContext* txn;
+  concurrency::TransactionContext *txn;
 
   void SetTaskPool(OptimizerTaskPool *task_pool) {
     this->task_pool = task_pool;

src/include/optimizer/optimizer_task.h

@@ -222,8 +222,7 @@ class OptimizeInputs : public OptimizerTask {
  */
 class DeriveStats : public OptimizerTask {
  public:
-  DeriveStats(GroupExpression *gexpr,
-              ExprSet required_cols,
+  DeriveStats(GroupExpression *gexpr, ExprSet required_cols,
               std::shared_ptr<OptimizeContext> context)
       : OptimizerTask(context, OptimizerTaskType::DERIVE_STATS),
         gexpr_(gexpr),

src/include/optimizer/postgres_cost_calculator.h

@@ -0,0 +1,70 @@
+//===----------------------------------------------------------------------===//
+//
+//                         Peloton
+//
+// cost_and_stats_calculator.h
+//
+// Identification: src/include/optimizer/cost_calculator.h
+//
+// Copyright (c) 2015-16, 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

src/include/optimizer/stats/column_stats.h

@@ -59,11 +59,24 @@ class ColumnStats {
 
   bool is_basetable;
 
-  std::string ToString() {
+  std::string ToString(bool verbose = false) {
     std::ostringstream os;
     os << "column_id :" << column_id << "\n"
        << "column_name :" << column_name << "\n"
        << "num_rows :" << num_rows << "\n";
+
+    if (verbose) {
+      os << "cardinality: " << cardinality << "\n"
+         << "frac_null: " << frac_null << "\n";
+
+      if (!most_common_vals.empty()) {
+        os << "most common value: " << most_common_vals[0] << "\n";
+      }
+
+      if (!most_common_freqs.empty()) {
+        os << "most common freq: " << most_common_freqs[0] << "\n";
+      }
+    }
     return os.str();
   }