Project 3 DONE, Leaderboard tasks soon ✨

Author: AyoubKaz07

src/execution/aggregation_executor.cpp

@@ -18,11 +18,54 @@ namespace bustub {
 
 AggregationExecutor::AggregationExecutor(ExecutorContext *exec_ctx, const AggregationPlanNode *plan,
                                          std::unique_ptr<AbstractExecutor> &&child)
-    : AbstractExecutor(exec_ctx) {}
+    : AbstractExecutor(exec_ctx),
+      plan_(plan),
+      child_(std::move(child)),
+      aht_(plan_->GetAggregates(), plan_->GetAggregateTypes()),
+      aht_iterator_(aht_.Begin()) {}
 
-void AggregationExecutor::Init() {}
+void AggregationExecutor::Init() {
+  // BUILD PHASE
+  child_->Init();
+  Tuple tuple_;
+  RID rid_;
 
-auto AggregationExecutor::Next(Tuple *tuple, RID *rid) -> bool { return false; }
+  while (child_->Next(&tuple_, &rid_)) {
+    // make the group bys from the group by expressions (the key)
+    AggregateKey key = MakeAggregateKey(&tuple_);
+    // get the aggregate values from the aggregate expressions (the value) out of the tuple
+    AggregateValue value = MakeAggregateValue(&tuple_);
+    aht_.InsertCombine(key, value);
+  }
+  aht_iterator_ = aht_.Begin();
+}
+
+auto AggregationExecutor::Next(Tuple *tuple, RID *rid) -> bool {
+  // ITERATE PHASE
+  Schema schema(*plan_->output_schema_);
+  if (aht_iterator_ != aht_.End()) {
+    // get the group bys from the key
+    std::vector<Value> values(aht_iterator_.Key().group_bys_);
+    // for each aggregate, push the aggregate value into the values vector to make the tuple
+    for (auto &agg : aht_iterator_.Val().aggregates_) {
+      values.push_back(agg);
+    }
+    *tuple = Tuple(values, &schema);
+    ++aht_iterator_;
+    is_successful = true;
+    return true;
+  }
+  // EMPTY TABLE
+  if (!is_successful) {
+    is_successful = true;
+    if (plan_->GetGroupBys().empty()) {
+      std::vector<Value> values(aht_.GenerateInitialAggregateValue().aggregates_);
+      *tuple = Tuple(values, &schema);
+      return true;
+    }
+  }
+  return false;
+}
 
 auto AggregationExecutor::GetChildExecutor() const -> const AbstractExecutor * { return child_.get(); }
 

src/execution/delete_executor.cpp

@@ -18,10 +18,59 @@ namespace bustub {
 
 DeleteExecutor::DeleteExecutor(ExecutorContext *exec_ctx, const DeletePlanNode *plan,
                                std::unique_ptr<AbstractExecutor> &&child_executor)
-    : AbstractExecutor(exec_ctx) {}
+    : AbstractExecutor(exec_ctx), plan_(plan), child_executor_(std::move(child_executor)) {}
 
-void DeleteExecutor::Init() { throw NotImplementedException("DeleteExecutor is not implemented"); }
+void DeleteExecutor::Init() {
+  // Get the table to delete from
+  table_info_ = exec_ctx_->GetCatalog()->GetTable(plan_->table_oid_);
+  table_ = table_info_->table_.get();
+  table_name_ = table_info_->name_;
 
-auto DeleteExecutor::Next([[maybe_unused]] Tuple *tuple, RID *rid) -> bool { return false; }
+  // Initialize the child executor
+  child_executor_->Init();
+}
+
+auto DeleteExecutor::Next(Tuple *tuple, RID *rid) -> bool {
+  // We return only once
+  if (is_successful_) {
+    return false;
+  }
+  RID rid_;
+  Tuple tup;
+
+  int num_deleted = 0;
+
+  while (child_executor_->Next(&tup, &rid_)) {
+    if (!table_->MarkDelete(rid_, this->GetExecutorContext()->GetTransaction())) {
+      return false;
+    }
+    auto indexes = this->GetExecutorContext()->GetCatalog()->GetTableIndexes(table_name_);
+    for (auto i : indexes) {
+      auto key = tup.KeyFromTuple(table_info_->schema_, i->key_schema_, i->index_->GetKeyAttrs());
+      i->index_->DeleteEntry(key, rid_, this->GetExecutorContext()->GetTransaction());
+    }
+    num_deleted++;
+  }
+
+  // prepare schema of one column of type integer
+  // Schema: "":(INTEGER)
+  std::vector<Column> cols;
+  Column col("", INTEGER);
+  cols.push_back(col);
+  Schema schema(cols);
+
+  // value of only one tuple (num of tuples deleted)
+  Value val(INTEGER, num_deleted);
+  std::vector<Value> values;
+  values.push_back(val);
+  *tuple = Tuple(values, &schema);
+
+  /* RESULT TUPLE: Schema:        "":INTEGER
+   *               TUPLE/ROW 0    num_deleted
+   */
+
+  is_successful_ = true;
+  return true;
+}
 
 }  // namespace bustub

src/execution/index_scan_executor.cpp

@@ -13,10 +13,25 @@
 
 namespace bustub {
 IndexScanExecutor::IndexScanExecutor(ExecutorContext *exec_ctx, const IndexScanPlanNode *plan)
-    : AbstractExecutor(exec_ctx) {}
+    : AbstractExecutor(exec_ctx), plan_(plan) {}
 
-void IndexScanExecutor::Init() { throw NotImplementedException("IndexScanExecutor is not implemented"); }
+void IndexScanExecutor::Init() {
+  auto index_info_ = exec_ctx_->GetCatalog()->GetIndex(plan_->GetIndexOid());
+  index_ = reinterpret_cast<BPlusTreeIndex<GenericKey<4>, RID, GenericComparator<4>> *>(index_info_->index_.get());
+  iter_ = std::make_unique<IndexIterator<GenericKey<4>, RID, GenericComparator<4>>>(index_->GetBeginIterator());
+  table_ = exec_ctx_->GetCatalog()->GetTable(index_info_->table_name_)->table_.get();
+}
 
-auto IndexScanExecutor::Next(Tuple *tuple, RID *rid) -> bool { return false; }
+auto IndexScanExecutor::Next(Tuple *tuple, RID *rid) -> bool {
+  if (*iter_ == index_->GetEndIterator()) {
+    return false;
+  }
+  *rid = (*(*iter_)).second;
+  if (!table_->GetTuple(*rid, tuple, this->GetExecutorContext()->GetTransaction())) {
+    return false;
+  }
+  ++(*iter_);
+  return true;
+}
 
 }  // namespace bustub

src/execution/insert_executor.cpp

@@ -18,10 +18,60 @@ namespace bustub {
 
 InsertExecutor::InsertExecutor(ExecutorContext *exec_ctx, const InsertPlanNode *plan,
                                std::unique_ptr<AbstractExecutor> &&child_executor)
-    : AbstractExecutor(exec_ctx) {}
+    : AbstractExecutor(exec_ctx), plan_(plan), child_executor_(std::move(child_executor)) {}
 
-void InsertExecutor::Init() { throw NotImplementedException("InsertExecutor is not implemented"); }
+void InsertExecutor::Init() {
+  // Get the table to insert into
+  table_info_ = exec_ctx_->GetCatalog()->GetTable(plan_->table_oid_);
+  table_ = table_info_->table_.get();
+  table_name_ = table_info_->name_;
 
-auto InsertExecutor::Next([[maybe_unused]] Tuple *tuple, RID *rid) -> bool { return false; }
+  // Initialize the child executor
+  child_executor_->Init();
+}
+
+auto InsertExecutor::Next(Tuple *tuple, RID *rid) -> bool {
+  // We return only once
+  if (is_successful_) {
+    return false;
+  }
+  RID rid_;
+  Tuple tup;
+
+  int num_inserted = 0;
+
+  while (child_executor_->Next(&tup, &rid_)) {
+    if (!table_->InsertTuple(tup, &rid_, this->GetExecutorContext()->GetTransaction())) {
+      return false;
+    }
+    auto indexes = this->GetExecutorContext()->GetCatalog()->GetTableIndexes(table_name_);
+    for (auto i : indexes) {
+      auto key = tup.KeyFromTuple(table_info_->schema_, i->key_schema_, i->index_->GetKeyAttrs());
+      i->index_->InsertEntry(key, rid_, this->GetExecutorContext()->GetTransaction());
+    }
+    num_inserted++;
+  }
+
+  // prepare schema of one column of type integer
+  // Schema: "":(INTEGER)
+  std::vector<Column> cols;
+  Column col("", INTEGER);
+  cols.push_back(col);
+  Schema schema(cols);
+
+  // value of only one tuple (num of tuples inserted)
+  // Value: num_inserted
+  std::vector<Value> values;
+  Value val(INTEGER, num_inserted);
+  values.push_back(val);
+
+  Tuple t(values, &schema);
+  *tuple = t;
+  /*  RESULT TUPLE: Schema:         "":INTEGER
+   *                TUPLE/ROW 0     num_inserted */
+
+  is_successful_ = true;
+  return true;
+}
 
 }  // namespace bustub

src/execution/limit_executor.cpp

@@ -16,10 +16,16 @@ namespace bustub {
 
 LimitExecutor::LimitExecutor(ExecutorContext *exec_ctx, const LimitPlanNode *plan,
                              std::unique_ptr<AbstractExecutor> &&child_executor)
-    : AbstractExecutor(exec_ctx) {}
+    : AbstractExecutor(exec_ctx), plan_(plan), child_executor_(std::move(child_executor)) {}
 
-void LimitExecutor::Init() { throw NotImplementedException("LimitExecutor is not implemented"); }
+void LimitExecutor::Init() { child_executor_->Init(); }
 
-auto LimitExecutor::Next(Tuple *tuple, RID *rid) -> bool { return false; }
+auto LimitExecutor::Next(Tuple *tuple, RID *rid) -> bool {
+  if (num_tuples_ >= plan_->GetLimit()) {
+    return false;
+  }
+  num_tuples_++;
+  return child_executor_->Next(tuple, rid);
+}
 
 }  // namespace bustub

src/execution/nested_index_join_executor.cpp

@@ -11,20 +11,69 @@
 //===----------------------------------------------------------------------===//
 
 #include "execution/executors/nested_index_join_executor.h"
+#include "type/value_factory.h"
 
 namespace bustub {
 
 NestIndexJoinExecutor::NestIndexJoinExecutor(ExecutorContext *exec_ctx, const NestedIndexJoinPlanNode *plan,
                                              std::unique_ptr<AbstractExecutor> &&child_executor)
-    : AbstractExecutor(exec_ctx) {
+    : AbstractExecutor(exec_ctx), plan_(plan), child_executor_(std::move(child_executor)) {
   if (!(plan->GetJoinType() == JoinType::LEFT || plan->GetJoinType() == JoinType::INNER)) {
     // Note for 2022 Fall: You ONLY need to implement left join and inner join.
     throw bustub::NotImplementedException(fmt::format("join type {} not supported", plan->GetJoinType()));
   }
 }
 
-void NestIndexJoinExecutor::Init() { throw NotImplementedException("NestIndexJoinExecutor is not implemented"); }
+void NestIndexJoinExecutor::Init() {
+  index_info_ = exec_ctx_->GetCatalog()->GetIndex(plan_->GetIndexOid());
+  index_ = reinterpret_cast<BPlusTreeIndex<GenericKey<4>, RID, GenericComparator<4>> *>(index_info_->index_.get());
+  table_info_ = exec_ctx_->GetCatalog()->GetTable(plan_->GetInnerTableOid());
+  table_ = table_info_->table_.get();
+  child_executor_->Init();
+}
+
+auto NestIndexJoinExecutor::Next(Tuple *tuple, RID *rid) -> bool {
+  Tuple left_tuple;
+  RID left_rid;
+  while (child_executor_->Next(&left_tuple, &left_rid)) {
+    auto probe_key_schema = index_info_->index_->GetKeySchema();
+    auto value = plan_->KeyPredicate()->Evaluate(&left_tuple, child_executor_->GetOutputSchema());
+    std::vector<Value> values;
+    values.push_back(value);
+    Tuple probe_key(values, probe_key_schema);
 
-auto NestIndexJoinExecutor::Next(Tuple *tuple, RID *rid) -> bool { return false; }
+    std::vector<RID> rids;
+    index_->ScanKey(probe_key, &rids, exec_ctx_->GetTransaction());
+    // MATCH
+    if (!rids.empty()) {
+      for (auto rid : rids) {
+        Tuple right_tuple;
+        if (table_->GetTuple(rid, &right_tuple, exec_ctx_->GetTransaction())) {
+          std::vector<Value> tuple_values;
+          for (uint32_t i = 0; i < child_executor_->GetOutputSchema().GetColumnCount(); i++) {
+            tuple_values.push_back(left_tuple.GetValue(&child_executor_->GetOutputSchema(), i));
+          }
+          for (uint32_t i = 0; i < table_info_->schema_.GetColumnCount(); i++) {
+            tuple_values.push_back(right_tuple.GetValue(&table_info_->schema_, i));
+          }
+          *tuple = Tuple(tuple_values, &plan_->OutputSchema());
+          return true;
+        }
+      }
+    }
+    if (plan_->GetJoinType() == JoinType::LEFT) {
+      std::vector<Value> tuple_values;
+      for (uint32_t i = 0; i < child_executor_->GetOutputSchema().GetColumnCount(); i++) {
+        tuple_values.push_back(left_tuple.GetValue(&child_executor_->GetOutputSchema(), i));
+      }
+      for (uint32_t i = 0; i < table_info_->schema_.GetColumnCount(); i++) {
+        tuple_values.push_back(ValueFactory::GetNullValueByType(table_info_->schema_.GetColumn(i).GetType()));
+      }
+      *tuple = Tuple(tuple_values, &plan_->OutputSchema());
+      return true;
+    }
+  }
+  return false;
+}
 
 }  // namespace bustub