update task3 and task4

Signed-off-by: Yuchen Liang <yuchenl3@andrew.cmu.edu>

Author: yliang412

src/execution/executor_factory.cpp

@@ -53,8 +53,8 @@ namespace bustub {
  * @param plan The plan node that needs to be executed
  * @return An executor for the given plan in the provided context
  */
-auto ExecutorFactory::CreateExecutor(ExecutorContext *exec_ctx,
-                                     const AbstractPlanNodeRef &plan) -> std::unique_ptr<AbstractExecutor> {
+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

src/execution/external_merge_sort_executor.cpp

@@ -11,23 +11,23 @@
 //===----------------------------------------------------------------------===//
 
 #include "execution/executors/external_merge_sort_executor.h"
-#include <iostream>
-#include <optional>
 #include <vector>
-#include "common/config.h"
+#include "common/macros.h"
 #include "execution/plans/sort_plan.h"
 
 namespace bustub {
 
 template <size_t K>
 ExternalMergeSortExecutor<K>::ExternalMergeSortExecutor(ExecutorContext *exec_ctx, const SortPlanNode *plan,
                                                         std::unique_ptr<AbstractExecutor> &&child_executor)
-    : AbstractExecutor(exec_ctx), cmp_(plan->GetOrderBy()) {}
+    : AbstractExecutor(exec_ctx), cmp_(plan->GetOrderBy()) {
+  UNIMPLEMENTED("TODO(P3): Add implementation.");
+}
 
 /** Initialize the external merge sort */
 template <size_t K>
 void ExternalMergeSortExecutor<K>::Init() {
-  throw NotImplementedException("ExternalMergeSortExecutor is not implemented");
+  UNIMPLEMENTED("TODO(P3): Add implementation.");
 }
 
 /**
@@ -38,7 +38,7 @@ void ExternalMergeSortExecutor<K>::Init() {
  */
 template <size_t K>
 auto ExternalMergeSortExecutor<K>::Next(Tuple *tuple, RID *rid) -> bool {
-  return false;
+  UNIMPLEMENTED("TODO(P3): Add implementation.");
 }
 
 template class ExternalMergeSortExecutor<2>;

src/execution/hash_join_executor.cpp

@@ -11,6 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "execution/executors/hash_join_executor.h"
+#include "common/macros.h"
 
 namespace bustub {
 
@@ -26,20 +27,21 @@ HashJoinExecutor::HashJoinExecutor(ExecutorContext *exec_ctx, const HashJoinPlan
                                    std::unique_ptr<AbstractExecutor> &&right_child)
     : AbstractExecutor(exec_ctx) {
   if (!(plan->GetJoinType() == JoinType::LEFT || plan->GetJoinType() == JoinType::INNER)) {
-    // Note for Fall 2024: You ONLY need to implement left join and inner join.
+    // Note for Spring 2025: You ONLY need to implement left join and inner join.
     throw bustub::NotImplementedException(fmt::format("join type {} not supported", plan->GetJoinType()));
   }
+  UNIMPLEMENTED("TODO(P3): Add implementation.");
 }
 
 /** Initialize the join */
-void HashJoinExecutor::Init() { throw NotImplementedException("HashJoinExecutor is not implemented"); }
+void HashJoinExecutor::Init() { UNIMPLEMENTED("TODO(P3): Add implementation."); }
 
 /**
  * Yield the next tuple from the join.
  * @param[out] tuple The next tuple produced by the join.
  * @param[out] rid The next tuple RID, not used by hash join.
  * @return `true` if a tuple was produced, `false` if there are no more tuples.
  */
-auto HashJoinExecutor::Next(Tuple *tuple, RID *rid) -> bool { return false; }
+auto HashJoinExecutor::Next(Tuple *tuple, RID *rid) -> bool { UNIMPLEMENTED("TODO(P3): Add implementation."); }
 
 }  // namespace bustub

src/execution/limit_executor.cpp

@@ -11,6 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "execution/executors/limit_executor.h"
+#include "common/macros.h"
 
 namespace bustub {
 
@@ -22,17 +23,19 @@ namespace bustub {
  */
 LimitExecutor::LimitExecutor(ExecutorContext *exec_ctx, const LimitPlanNode *plan,
                              std::unique_ptr<AbstractExecutor> &&child_executor)
-    : AbstractExecutor(exec_ctx) {}
+    : AbstractExecutor(exec_ctx) {
+  UNIMPLEMENTED("TODO(P3): Add implementation.");
+}
 
 /** Initialize the limit */
-void LimitExecutor::Init() { throw NotImplementedException("LimitExecutor is not implemented"); }
+void LimitExecutor::Init() { UNIMPLEMENTED("TODO(P3): Add implementation."); }
 
 /**
  * Yield the next tuple from the limit.
  * @param[out] tuple The next tuple produced by the limit
  * @param[out] rid The next tuple RID produced by the limit
  * @return `true` if a tuple was produced, `false` if there are no more tuples
  */
-auto LimitExecutor::Next(Tuple *tuple, RID *rid) -> bool { return false; }
+auto LimitExecutor::Next(Tuple *tuple, RID *rid) -> bool { UNIMPLEMENTED("TODO(P3): Add implementation."); }
 
 }  // namespace bustub

src/execution/seq_scan_executor.cpp

@@ -25,10 +25,7 @@ SeqScanExecutor::SeqScanExecutor(ExecutorContext *exec_ctx, const SeqScanPlanNod
 }
 
 /** Initialize the sequential scan */
-void SeqScanExecutor::Init() {
-  UNIMPLEMENTED("TODO(P3): Add implementation.");
-  ;
-}
+void SeqScanExecutor::Init() { UNIMPLEMENTED("TODO(P3): Add implementation."); }
 
 /**
  * Yield the next tuple from the sequential scan.

src/include/execution/executors/hash_join_executor.h

@@ -13,7 +13,6 @@
 #pragma once
 
 #include <memory>
-#include <utility>
 
 #include "execution/executor_context.h"
 #include "execution/executors/abstract_executor.h"

src/include/execution/expressions/abstract_expression.h

@@ -23,12 +23,12 @@
 #include "storage/table/tuple.h"
 #include "type/type.h"
 
-#define BUSTUB_EXPR_CLONE_WITH_CHILDREN(cname)                                                                   \
-  auto CloneWithChildren(std::vector<AbstractExpressionRef> children) const->std::unique_ptr<AbstractExpression> \
-      override {                                                                                                 \
-    auto expr = cname(*this);                                                                                    \
-    expr.children_ = children;                                                                                   \
-    return std::make_unique<cname>(std::move(expr));                                                             \
+#define BUSTUB_EXPR_CLONE_WITH_CHILDREN(cname)                                                                     \
+  auto CloneWithChildren(std::vector<AbstractExpressionRef> children) const -> std::unique_ptr<AbstractExpression> \
+      override {                                                                                                   \
+    auto expr = cname(*this);                                                                                      \
+    expr.children_ = children;                                                                                     \
+    return std::make_unique<cname>(std::move(expr));                                                               \
   }
 
 namespace bustub {

src/include/execution/plans/abstract_plan.h

@@ -22,12 +22,12 @@
 
 namespace bustub {
 
-#define BUSTUB_PLAN_NODE_CLONE_WITH_CHILDREN(cname)                                                          \
-  auto CloneWithChildren(std::vector<AbstractPlanNodeRef> children) const->std::unique_ptr<AbstractPlanNode> \
-      override {                                                                                             \
-    auto plan_node = cname(*this);                                                                           \
-    plan_node.children_ = children;                                                                          \
-    return std::make_unique<cname>(std::move(plan_node));                                                    \
+#define BUSTUB_PLAN_NODE_CLONE_WITH_CHILDREN(cname)                                                            \
+  auto CloneWithChildren(std::vector<AbstractPlanNodeRef> children) const -> std::unique_ptr<AbstractPlanNode> \
+      override {                                                                                               \
+    auto plan_node = cname(*this);                                                                             \
+    plan_node.children_ = children;                                                                            \
+    return std::make_unique<cname>(std::move(plan_node));                                                      \
   }
 
 /** PlanType represents the types of plans that we have in our system. */

src/optimizer/nlj_as_hash_join.cpp

@@ -36,7 +36,7 @@ namespace bustub {
  */
 auto Optimizer::OptimizeNLJAsHashJoin(const AbstractPlanNodeRef &plan) -> AbstractPlanNodeRef {
   // TODO(student): implement NestedLoopJoin -> HashJoin optimizer rule
-  // Note for 2023 Fall: You should support join keys of any number of conjunction of equi-conditions:
+  // Note for Spring 2025: You should support join keys of any number of conjunction of equi-conditions:
   // E.g. <column expr> = <column expr> AND <column expr> = <column expr> AND ...
   return plan;
 }

test/storage/page_guard_test.cpp

@@ -164,7 +164,9 @@ TEST(PageGuardTest, DISABLED_MoveTest) {
   ASSERT_EQ(1, bpm->GetPinCount(pid3));
 
   // This will hang if page 2 was not unlatched correctly.
-  { const auto temp_guard2 = bpm->WritePage(pid2); }
+  {
+    const auto temp_guard2 = bpm->WritePage(pid2);
+  }
 
   auto guard4 = bpm->WritePage(pid4);
   auto guard5 = bpm->WritePage(pid5);
@@ -187,7 +189,9 @@ TEST(PageGuardTest, DISABLED_MoveTest) {
   ASSERT_EQ(1, bpm->GetPinCount(pid5));
 
   // This will hang if page 4 was not unlatched correctly.
-  { const auto temp_guard4 = bpm->ReadPage(pid4); }
+  {
+    const auto temp_guard4 = bpm->ReadPage(pid4);
+  }
 
   // Test move constructor with invalid that
   {

test/txn/txn_scan_test.cpp

@@ -281,8 +281,12 @@ TEST(TxnScanTest, DISABLED_CollectUndoLogTest) {  // NOLINT
     ASSERT_TRUE(tuple.has_value());
     VerifyTuple(schema.get(), *tuple, {Int(2), Double(2.0), BoolNull()});
   }
-  { ASSERT_FALSE(undo_logs_3_for_txn_to_inspect.has_value()); }
-  { ASSERT_FALSE(undo_logs_4_for_txn_to_inspect.has_value()); }
+  {
+    ASSERT_FALSE(undo_logs_3_for_txn_to_inspect.has_value());
+  }
+  {
+    ASSERT_FALSE(undo_logs_4_for_txn_to_inspect.has_value());
+  }
   {
     ASSERT_TRUE(undo_logs_5_for_txn_to_inspect.has_value());
     auto tuple = ReconstructTuple(schema.get(), tuple_res_5.second, tuple_res_5.first, *undo_logs_5_for_txn_to_inspect);