feat(p3): add leaderboard tests (#441)

Signed-off-by: Alex Chi <[email protected]>

Author: skyzh

src/execution/mock_scan_executor.cpp

@@ -11,6 +11,8 @@
 //===----------------------------------------------------------------------===//
 
 #include "execution/executors/mock_scan_executor.h"
+#include <algorithm>
+#include <random>
 
 #include "common/exception.h"
 #include "common/util/string_util.h"
@@ -31,16 +33,15 @@ static const char *course_on_date[] = {"Monday", "Tuesday", "Wednesday", "Thursd
 
 static int course_on_bool[] = {0, 1, 0, 1, 0, 1, 1};
 
-const char *mock_table_list[] = {"__mock_table_1",
-                                 "__mock_table_2",
-                                 "__mock_table_3",
-                                 "__mock_table_tas_2022",
-                                 "__mock_agg_input_small",
-                                 "__mock_agg_input_big",
-                                 "__mock_table_schedule_2022",
-                                 "__mock_table_123",
-                                 "__mock_graph",
-                                 nullptr};
+const char *mock_table_list[] = {"__mock_table_1", "__mock_table_2", "__mock_table_3", "__mock_table_tas_2022",
+                                 "__mock_agg_input_small", "__mock_agg_input_big", "__mock_table_schedule_2022",
+                                 "__mock_table_123", "__mock_graph",
+                                 // For leaderboard Q1
+                                 "__mock_t1_50k", "__mock_t2_100k", "__mock_t3_1k",
+                                 // For leaderboard Q2
+                                 "__mock_t4_1m", "__mock_t5_1m", "__mock_t6_1m",
+                                 // For leaderboard Q3
+                                 "__mock_t7", "__mock_t8", nullptr};
 
 static const int GRAPH_NODE_CNT = 10;
 
@@ -81,51 +82,111 @@ auto GetMockTableSchemaOf(const std::string &table) -> Schema {
     return Schema{std::vector{Column{"number", TypeId::INTEGER}}};
   }
 
+  if (table == "__mock_t1_50k" || table == "__mock_t2_100k" || table == "__mock_t3_1k" || table == "__mock_t4_1m" ||
+      table == "__mock_t5_1m" || table == "__mock_t6_1m") {
+    return Schema{std::vector{Column{"x", TypeId::INTEGER}, Column{"y", TypeId::INTEGER}}};
+  }
+
+  if (table == "__mock_t7") {
+    return Schema{
+        std::vector{Column{"v", TypeId::INTEGER}, Column{"v1", TypeId::INTEGER}, Column{"v2", TypeId::INTEGER}}};
+  }
+
+  if (table == "__mock_t8") {
+    return Schema{std::vector{Column{"v4", TypeId::INTEGER}}};
+  }
+
   throw bustub::Exception(fmt::format("mock table {} not found", table));
 }
 
 auto GetSizeOf(const MockScanPlanNode *plan) -> size_t {
-  if (plan->GetTable() == "__mock_table_1") {
+  const auto &table = plan->GetTable();
+
+  if (table == "__mock_table_1") {
     return 100;
   }
 
-  if (plan->GetTable() == "__mock_table_2") {
+  if (table == "__mock_table_2") {
     return 100;
   }
 
-  if (plan->GetTable() == "__mock_table_3") {
+  if (table == "__mock_table_3") {
     return 100;
   }
 
-  if (plan->GetTable() == "__mock_table_tas_2022") {
+  if (table == "__mock_table_tas_2022") {
     return sizeof(ta_list_2022) / sizeof(ta_list_2022[0]);
   }
 
-  if (plan->GetTable() == "__mock_table_schedule_2022") {
+  if (table == "__mock_table_schedule_2022") {
     return sizeof(course_on_date) / sizeof(course_on_date[0]);
   }
 
-  if (plan->GetTable() == "__mock_agg_input_small") {
+  if (table == "__mock_agg_input_small") {
     return 1000;
   }
 
-  if (plan->GetTable() == "__mock_agg_input_big") {
+  if (table == "__mock_agg_input_big") {
     return 10000;
   }
 
-  if (plan->GetTable() == "__mock_graph") {
+  if (table == "__mock_graph") {
     return GRAPH_NODE_CNT * GRAPH_NODE_CNT;
   }
 
-  if (plan->GetTable() == "__mock_table_123") {
+  if (table == "__mock_table_123") {
     return 3;
   }
 
-  return 100;
+  if (table == "__mock_t1_50k") {
+    return 50000;
+  }
+
+  if (table == "__mock_t2_100k") {
+    return 100000;
+  }
+
+  if (table == "__mock_t3_1k") {
+    return 1000;
+  }
+
+  if (table == "__mock_t4_1m" || table == "__mock_t5_1m" || table == "__mock_t6_1m") {
+    return 1000000;
+  }
+
+  if (table == "__mock_t7") {
+    return 1000000;
+  }
+
+  if (table == "__mock_t8") {
+    return 10;
+  }
+
+  return 0;
+}
+
+auto GetShuffled(const MockScanPlanNode *plan) -> bool {
+  const auto &table = plan->GetTable();
+
+  if (table == "__mock_t1_50k") {
+    return true;
+  }
+
+  if (table == "__mock_t2_100k") {
+    return true;
+  }
+
+  if (table == "__mock_t3_1k") {
+    return true;
+  }
+
+  return false;
 }
 
 auto GetFunctionOf(const MockScanPlanNode *plan) -> std::function<Tuple(size_t)> {
-  if (plan->GetTable() == "__mock_table_1") {
+  const auto &table = plan->GetTable();
+
+  if (table == "__mock_table_1") {
     return [plan](size_t cursor) {
       std::vector<Value> values{};
       values.reserve(2);
@@ -135,7 +196,7 @@ auto GetFunctionOf(const MockScanPlanNode *plan) -> std::function<Tuple(size_t)>
     };
   }
 
-  if (plan->GetTable() == "__mock_table_2") {
+  if (table == "__mock_table_2") {
     return [plan](size_t cursor) {
       std::vector<Value> values{};
       values.reserve(2);
@@ -146,7 +207,7 @@ auto GetFunctionOf(const MockScanPlanNode *plan) -> std::function<Tuple(size_t)>
     };
   }
 
-  if (plan->GetTable() == "__mock_table_3") {
+  if (table == "__mock_table_3") {
     return [plan](size_t cursor) {
       std::vector<Value> values{};
       values.reserve(2);
@@ -160,7 +221,7 @@ auto GetFunctionOf(const MockScanPlanNode *plan) -> std::function<Tuple(size_t)>
     };
   }
 
-  if (plan->GetTable() == "__mock_table_tas_2022") {
+  if (table == "__mock_table_tas_2022") {
     return [plan](size_t cursor) {
       std::vector<Value> values{};
       values.push_back(ValueFactory::GetVarcharValue(ta_list_2022[cursor]));
@@ -169,7 +230,7 @@ auto GetFunctionOf(const MockScanPlanNode *plan) -> std::function<Tuple(size_t)>
     };
   }
 
-  if (plan->GetTable() == "__mock_table_schedule_2022") {
+  if (table == "__mock_table_schedule_2022") {
     return [plan](size_t cursor) {
       std::vector<Value> values{};
       values.push_back(ValueFactory::GetVarcharValue(course_on_date[cursor]));
@@ -178,7 +239,7 @@ auto GetFunctionOf(const MockScanPlanNode *plan) -> std::function<Tuple(size_t)>
     };
   }
 
-  if (plan->GetTable() == "__mock_agg_input_small") {
+  if (table == "__mock_agg_input_small") {
     return [plan](size_t cursor) {
       std::vector<Value> values{};
       values.push_back(ValueFactory::GetIntegerValue((cursor + 2) % 10));
@@ -192,7 +253,7 @@ auto GetFunctionOf(const MockScanPlanNode *plan) -> std::function<Tuple(size_t)>
     };
   }
 
-  if (plan->GetTable() == "__mock_agg_input_big") {
+  if (table == "__mock_agg_input_big") {
     return [plan](size_t cursor) {
       std::vector<Value> values{};
       values.push_back(ValueFactory::GetIntegerValue((cursor + 2) % 10));
@@ -206,15 +267,15 @@ auto GetFunctionOf(const MockScanPlanNode *plan) -> std::function<Tuple(size_t)>
     };
   }
 
-  if (plan->GetTable() == "__mock_table_123") {
+  if (table == "__mock_table_123") {
     return [plan](size_t cursor) {
       std::vector<Value> values{};
       values.push_back(ValueFactory::GetIntegerValue(cursor + 1));
       return Tuple{values, &plan->OutputSchema()};
     };
   }
 
-  if (plan->GetTable() == "__mock_graph") {
+  if (table == "__mock_graph") {
     return [plan](size_t cursor) {
       std::vector<Value> values{};
       int src = cursor % GRAPH_NODE_CNT;
@@ -232,6 +293,81 @@ auto GetFunctionOf(const MockScanPlanNode *plan) -> std::function<Tuple(size_t)>
     };
   }
 
+  if (table == "__mock_t1_50k") {
+    return [plan](size_t cursor) {
+      std::vector<Value> values{};
+      values.push_back(ValueFactory::GetIntegerValue(cursor * 10));
+      values.push_back(ValueFactory::GetIntegerValue(cursor * 1000));
+      return Tuple{values, &plan->OutputSchema()};
+    };
+  }
+
+  if (table == "__mock_t2_100k") {
+    return [plan](size_t cursor) {
+      std::vector<Value> values{};
+      values.push_back(ValueFactory::GetIntegerValue(cursor));
+      values.push_back(ValueFactory::GetIntegerValue(cursor * 100));
+      return Tuple{values, &plan->OutputSchema()};
+    };
+  }
+
+  if (table == "__mock_t3_1k") {
+    return [plan](size_t cursor) {
+      std::vector<Value> values{};
+      values.push_back(ValueFactory::GetIntegerValue(cursor * 100));
+      values.push_back(ValueFactory::GetIntegerValue(cursor * 10000));
+      return Tuple{values, &plan->OutputSchema()};
+    };
+  }
+
+  if (table == "__mock_t4_1m") {
+    return [plan](size_t cursor) {
+      std::vector<Value> values{};
+      cursor = cursor % 500000;
+      values.push_back(ValueFactory::GetIntegerValue(cursor));
+      values.push_back(ValueFactory::GetIntegerValue(cursor * 10));
+      return Tuple{values, &plan->OutputSchema()};
+    };
+  }
+
+  if (table == "__mock_t5_1m") {
+    return [plan](size_t cursor) {
+      std::vector<Value> values{};
+      cursor = (cursor + 30000) % 500000;
+      values.push_back(ValueFactory::GetIntegerValue(cursor));
+      values.push_back(ValueFactory::GetIntegerValue(cursor * 10));
+      return Tuple{values, &plan->OutputSchema()};
+    };
+  }
+
+  if (table == "__mock_t6_1m") {
+    return [plan](size_t cursor) {
+      std::vector<Value> values{};
+      cursor = (cursor + 60000) % 500000;
+      values.push_back(ValueFactory::GetIntegerValue(cursor));
+      values.push_back(ValueFactory::GetIntegerValue(cursor * 10));
+      return Tuple{values, &plan->OutputSchema()};
+    };
+  }
+
+  if (table == "__mock_t7") {
+    return [plan](size_t cursor) {
+      std::vector<Value> values{};
+      values.push_back(ValueFactory::GetIntegerValue(cursor % 20));
+      values.push_back(ValueFactory::GetIntegerValue(cursor));
+      values.push_back(ValueFactory::GetIntegerValue(cursor));
+      return Tuple{values, &plan->OutputSchema()};
+    };
+  }
+
+  if (table == "__mock_t8") {
+    return [plan](size_t cursor) {
+      std::vector<Value> values{};
+      values.push_back(ValueFactory::GetIntegerValue(cursor));
+      return Tuple{values, &plan->OutputSchema()};
+    };
+  }
+
   // By default, return table of all 0.
   return [plan](size_t cursor) {
     std::vector<Value> values{};
@@ -244,7 +380,16 @@ auto GetFunctionOf(const MockScanPlanNode *plan) -> std::function<Tuple(size_t)>
 }
 
 MockScanExecutor::MockScanExecutor(ExecutorContext *exec_ctx, const MockScanPlanNode *plan)
-    : AbstractExecutor{exec_ctx}, plan_{plan}, func_(GetFunctionOf(plan)), size_(GetSizeOf(plan)) {}
+    : AbstractExecutor{exec_ctx}, plan_{plan}, func_(GetFunctionOf(plan)), size_(GetSizeOf(plan)) {
+  if (GetShuffled(plan)) {
+    for (size_t i = 0; i < size_; i++) {
+      shuffled_idx_.push_back(i);
+    }
+    std::random_device rd;
+    std::mt19937 g(rd());
+    std::shuffle(shuffled_idx_.begin(), shuffled_idx_.end(), g);
+  }
+}
 
 void MockScanExecutor::Init() {
   // Reset the cursor
@@ -256,7 +401,11 @@ auto MockScanExecutor::Next(Tuple *tuple, RID *rid) -> bool {
     // Scan complete
     return EXECUTOR_EXHAUSTED;
   }
-  *tuple = func_(cursor_);
+  if (shuffled_idx_.empty()) {
+    *tuple = func_(cursor_);
+  } else {
+    *tuple = func_(shuffled_idx_[cursor_]);
+  }
   ++cursor_;
   *rid = MakeDummyRID();
   return EXECUTOR_ACTIVE;

src/include/common/bustub_instance.h

@@ -57,6 +57,19 @@ class ResultWriter {
   bool simplified_output_{false};
 };
 
+class NoopWriter : public ResultWriter {
+ public:
+  NoopWriter() = default;
+  void WriteCell(const std::string &cell) override {}
+  void WriteHeaderCell(const std::string &cell) override {}
+  void BeginHeader() override {}
+  void EndHeader() override {}
+  void BeginRow() override {}
+  void EndRow() override {}
+  void BeginTable(bool simplified_output) override {}
+  void EndTable() override {}
+};
+
 class SimpleStreamWriter : public ResultWriter {
  public:
   explicit SimpleStreamWriter(std::ostream &stream, bool disable_header = false, const char *separator = "\t")

src/include/execution/executors/mock_scan_executor.h

@@ -76,6 +76,9 @@ class MockScanExecutor : public AbstractExecutor {
 
   /** The size of the mock table */
   std::size_t size_;
+
+  /** The shuffled output */
+  std::vector<size_t> shuffled_idx_;
 };
 
 }  // namespace bustub

src/include/optimizer/optimizer.h

@@ -82,6 +82,15 @@ class Optimizer {
    */
   auto OptimizeSortLimitAsTopN(const AbstractPlanNodeRef &plan) -> AbstractPlanNodeRef;
 
+  /**
+   * @brief get the estimated cardinality for a table based on the table name. Useful when join reordering. BusTub
+   * doesn't support statistics for now, so it's the only way for you to get the table size :(
+   *
+   * @param table_name
+   * @return std::optional<size_t>
+   */
+  auto EstimatedCardinality(const std::string &table_name) -> std::optional<size_t>;
+
   /** Catalog will be used during the planning process. USERS SHOULD ENSURE IT OUTLIVES
    * OPTIMIZER, otherwise it's a dangling reference.
    */