test(p3): add topn check (#530)

Author: christopherlim98

src/execution/CMakeLists.txt

@@ -19,6 +19,7 @@ add_library(
         seq_scan_executor.cpp
         sort_executor.cpp
         topn_executor.cpp
+        topn_check_executor.cpp
         update_executor.cpp
         values_executor.cpp
 )

src/execution/executor_factory.cpp

@@ -30,6 +30,7 @@
 #include "execution/executors/projection_executor.h"
 #include "execution/executors/seq_scan_executor.h"
 #include "execution/executors/sort_executor.h"
+#include "execution/executors/topn_check_executor.h"
 #include "execution/executors/topn_executor.h"
 #include "execution/executors/update_executor.h"
 #include "execution/executors/values_executor.h"
@@ -46,6 +47,7 @@ namespace bustub {
 
 auto ExecutorFactory::CreateExecutor(ExecutorContext *exec_ctx, const AbstractPlanNodeRef &plan)
     -> std::unique_ptr<AbstractExecutor> {
+  auto check_options_set = exec_ctx->GetCheckOptions()->check_options_set_;
   switch (plan->GetType()) {
     // Create a new sequential scan executor
     case PlanType::SeqScan: {
@@ -97,7 +99,6 @@ auto ExecutorFactory::CreateExecutor(ExecutorContext *exec_ctx, const AbstractPl
       auto nested_loop_join_plan = dynamic_cast<const NestedLoopJoinPlanNode *>(plan.get());
       auto left = ExecutorFactory::CreateExecutor(exec_ctx, nested_loop_join_plan->GetLeftPlan());
       auto right = ExecutorFactory::CreateExecutor(exec_ctx, nested_loop_join_plan->GetRightPlan());
-      auto check_options_set = exec_ctx->GetCheckOptions()->check_options_set_;
       if (check_options_set.find(CheckOption::ENABLE_NLJ_CHECK) != check_options_set.end()) {
         auto left_init_check_plan = dynamic_cast<const InitCheckPlanNode *>(nested_loop_join_plan->GetLeftPlan().get());
         auto right_init_check_plan =
@@ -164,6 +165,12 @@ auto ExecutorFactory::CreateExecutor(ExecutorContext *exec_ctx, const AbstractPl
     case PlanType::TopN: {
       const auto *topn_plan = dynamic_cast<const TopNPlanNode *>(plan.get());
       auto child = ExecutorFactory::CreateExecutor(exec_ctx, topn_plan->GetChildPlan());
+      if (check_options_set.find(CheckOption::ENABLE_TOPN_CHECK) != check_options_set.end()) {
+        auto topn_executor = std::make_unique<TopNExecutor>(exec_ctx, topn_plan, nullptr);
+        auto check = std::make_unique<TopNCheckExecutor>(exec_ctx, topn_plan, std::move(child), topn_executor.get());
+        topn_executor->SetChildExecutor(std::move(check));
+        return topn_executor;
+      }
       return std::make_unique<TopNExecutor>(exec_ctx, topn_plan, std::move(child));
     }
 

src/execution/topn_check_executor.cpp

@@ -0,0 +1,48 @@
+//===----------------------------------------------------------------------===//
+//
+//                         BusTub
+//
+// topn_check_executor.cpp
+//
+// Identification: src/execution/topn_check_executor.cpp
+//
+// Copyright (c) 2015-2021, Carnegie Mellon University Database Group
+//
+//===----------------------------------------------------------------------===//
+
+#include "execution/executors/topn_check_executor.h"
+#include "execution/executors/topn_executor.h"
+
+namespace bustub {
+
+TopNCheckExecutor::TopNCheckExecutor(ExecutorContext *exec_ctx, const TopNPlanNode *plan,
+                                     std::unique_ptr<AbstractExecutor> &&child_executor, TopNExecutor *topn_executor)
+    : AbstractExecutor{exec_ctx},
+      plan_(plan),
+      child_executor_{std::move(child_executor)},
+      topn_executor_(topn_executor) {}
+
+void TopNCheckExecutor::Init() {
+  if (!child_executor_) {
+    return;
+  }
+  prev_ = 0;
+  // Initialize the child executor
+  child_executor_->Init();
+}
+
+auto TopNCheckExecutor::Next(Tuple *tuple, RID *rid) -> bool {
+  if (!child_executor_) {
+    return EXECUTOR_EXHAUSTED;
+  }
+
+  BUSTUB_ASSERT(topn_executor_->GetNumInHeap() <= plan_->GetN(), "Cannot store more than N elements");
+  if (prev_ > 0 && prev_ < plan_->GetN()) {
+    BUSTUB_ASSERT(topn_executor_->GetNumInHeap() - prev_ == 1, "Did you implement GetNumInHeap() properly?");
+  }
+  prev_ = topn_executor_->GetNumInHeap();
+  // Emit the next tuple
+  return child_executor_->Next(tuple, rid);
+}
+
+}  // namespace bustub

src/execution/topn_executor.cpp

@@ -10,4 +10,6 @@ void TopNExecutor::Init() { throw NotImplementedException("TopNExecutor is not i
 
 auto TopNExecutor::Next(Tuple *tuple, RID *rid) -> bool { return false; }
 
+auto TopNExecutor::GetNumInHeap() -> size_t { throw NotImplementedException("TopNExecutor is not implemented"); };
+
 }  // namespace bustub

src/include/execution/executors/topn_check_executor.h

@@ -0,0 +1,67 @@
+//===----------------------------------------------------------------------===//
+//
+//                         BusTub
+//
+// topn_check_executor.h
+//
+// Identification: src/include/execution/executors/topn_check_executor.h
+//
+// Copyright (c) 2015-2021, Carnegie Mellon University Database Group
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include <memory>
+#include <utility>
+
+#include "execution/executors/abstract_executor.h"
+#include "execution/executors/topn_executor.h"
+#include "execution/plans/topn_plan.h"
+
+namespace bustub {
+
+/**
+ * TopNCheckExecutor checks the number of items in topn executor container
+ */
+class TopNCheckExecutor : public AbstractExecutor {
+ public:
+  /**
+   * Construct a new TopNCheckExecutor instance.
+   * @param exec_ctx The executor context
+   * @param plan The TopN plan to be executed
+   * @param child_executor The topn child executor
+   */
+  TopNCheckExecutor(ExecutorContext *exec_ctx, const TopNPlanNode *plan,
+                    std::unique_ptr<AbstractExecutor> &&child_executor, TopNExecutor *topn_executor);
+
+  /** Initialize the TopNCheck */
+  void Init() override;
+
+  /**
+   * Yield the next tuple from the child executor.
+   * @param[out] tuple The next tuple produced by the child executor
+   * @param[out] rid The next tuple RID produced by the child executor
+   * @return `true` if a tuple was produced, `false` if there are no more tuples
+   */
+  auto Next(Tuple *tuple, RID *rid) -> bool override;
+
+  /** @return The output schema for the child executor */
+  auto GetOutputSchema() const -> const Schema & override { return plan_->OutputSchema(); };
+
+ private:
+  /** TopNCheckExecutor returns `false` when child executor is exhausted */
+  constexpr static const bool EXECUTOR_EXHAUSTED{false};
+
+  /** The TopNPlanNode to be executed */
+  const TopNPlanNode *plan_;
+
+  std::size_t prev_{0};
+
+  /** The child executor from which tuples are obtained */
+  std::unique_ptr<AbstractExecutor> child_executor_;
+
+  TopNExecutor *topn_executor_;
+};
+
+}  // namespace bustub

src/include/execution/executors/topn_executor.h

@@ -13,6 +13,7 @@
 #pragma once
 
 #include <memory>
+#include <utility>
 #include <vector>
 
 #include "execution/executor_context.h"
@@ -49,8 +50,18 @@ class TopNExecutor : public AbstractExecutor {
   /** @return The output schema for the topn */
   auto GetOutputSchema() const -> const Schema & override { return plan_->OutputSchema(); }
 
+  /** Sets new child executor (for testing only) */
+  void SetChildExecutor(std::unique_ptr<AbstractExecutor> &&child_executor) {
+    child_executor_ = std::move(child_executor);
+  }
+
+  /** @return The size of top_entries_ container, which will be called on each child_executor->Next(). */
+  auto GetNumInHeap() -> size_t;
+
  private:
   /** The topn plan node to be executed */
   const TopNPlanNode *plan_;
+  /** The child executor from which tuples are obtained */
+  std::unique_ptr<AbstractExecutor> child_executor_;
 };
 }  // namespace bustub