fix:explain sort

src/common/merge_sorter.h

@@ -15,7 +15,7 @@
 #include <memory>
 #include "config.h"
 #include "system/sm_meta.h"
-class MergeSorter {
+class MergeSort {
 private:
     ssize_t max_mem_size;
     ssize_t rcd_size;
@@ -33,8 +33,9 @@ private:
     bool isFull = true;
 
 public:
-    MergeSorter(ssize_t rcd_size, void *arg = nullptr)
-        :  rcd_size(rcd_size), arg_(arg) {}
+    MergeSort(ssize_t rcd_size, void *arg = nullptr)  :  rcd_size(rcd_size), arg_(arg) {}
+
+    MergeSort() = default;
 
     void beginSort(const char *record) {
         max_mem_size = (MAX_MEMORY - MAX_MEMORY % rcd_size);
@@ -66,13 +67,13 @@ public:
         return total_record == 0;
     }
 
-    MergeSorter(MergeSorter&& sorter) noexcept
+    MergeSort(MergeSort&& sorter) noexcept
     :  rcd_size(sorter.rcd_size), total_record(sorter.total_record),
         index(sorter.index), data(sorter.data),
         isFull(sorter.isFull), record_list(std::move(sorter.record_list)), heap(std::move(sorter.heap)),
         arg_(sorter.arg_), buffer_list(std::move(sorter.buffer_list)), opened_files(std::move(sorter.opened_files)), filenames_(std::move(sorter.filenames_)) {}
 
-    ~MergeSorter() {
+    ~MergeSort() {
         for (size_t i = 0; i < opened_files.size(); ++i) {
             if (opened_files[i].is_open()) {
                 opened_files[i].close();

src/execution/execution_sort.h

@@ -10,7 +10,6 @@ See the Mulan PSL v2 for more details. */
 
 #pragma once
 #include "common/config.h"
-#include "common/merge_sorter.h"
 #include "execution_defs.h"
 #include "execution_manager.h"
 #include "executor_abstract.h"
@@ -27,7 +26,6 @@ class SortExecutor : public AbstractExecutor {
     ColMeta cols_;                              // 框架中只支持一个键排序，需要自行修改数据结构支持多个键排序
     std::unique_ptr<RmRecord> current_tuple;
 
-    std::unique_ptr<MergeSorter> sorter;
     [[maybe_unused]] bool is_end_ = false;
 
     std::vector<RmRecord> records_;

src/execution/executor_merge_join.h

@@ -53,6 +53,7 @@ class MergeJoinExecutor : public AbstractExecutor {
         if (use_index_) {
             initializeExecutorsWithIndex();
         } else {
+            sleep(2);
             initializeExecutorsWithoutIndex();
         }
         nextTuple();
@@ -127,9 +128,9 @@ private:
         right_->beginTuple();
     }
 
-    std::vector<MergeSorter> sorters_; 
+    std::vector<MergeSort> sorters_; 
+    MergeSort L_sort, R_sort;
     void initializeExecutorsWithoutIndex() {
-        sleep(2);
         sorters_.push_back(startSort(left_, left_col_));
         sorters_.push_back(startSort(right_, right_col_));
     }
@@ -249,9 +250,9 @@ private:
         }
     }
 
-    MergeSorter startSort(std::unique_ptr<AbstractExecutor> &executor, const ColMeta &joined_col) {
+    MergeSort startSort(std::unique_ptr<AbstractExecutor> &executor, const ColMeta &joined_col) {
 
-        MergeSorter sorter(executor->tupleLen(), const_cast<void *>(static_cast<const void *>(&joined_col)));
+        MergeSort sorter(executor->tupleLen(), const_cast<void *>(static_cast<const void *>(&joined_col)));
 
         for (executor->beginTuple(); !executor->is_end(); executor->nextTuple()) {
             sorter.beginSort(executor->Next()->data);