sudo apt-get install build-essential clang-8 clang-format-8 clang-tidy-8 cmake doxygen git g++-7 pkg-config valgrind zlib1g-dev

[ 22%] Performing download step (git clone) for 'googletest'
Cloning into 'googletest-src'...
fatal: invalid reference: master
CMake Error at googletest-download/googletest-prefix/tmp/googletest-gitclone.cmake:40 (message):
  Failed to checkout tag: 'master'

$ cd build
$ make starter_test
$ ./test/starter_test

$ make format
$ make check-lint
$ make check-clang-tidy

LOG_INFO("# Pages: %d", num_pages);
LOG_DEBUG("Fetching page %d", page_id);

$ cd build
$ cmake -DCMAKE_BUILD_TYPE=DEBUG ..
$ make

// Log levels.
static constexpr int LOG_LEVEL_OFF = 1000;
static constexpr int LOG_LEVEL_ERROR = 500;
static constexpr int LOG_LEVEL_WARN = 400;
static constexpr int LOG_LEVEL_INFO = 300;
static constexpr int LOG_LEVEL_DEBUG = 200;
static constexpr int LOG_LEVEL_TRACE = 100;
static constexpr int LOG_LEVEL_ALL = 0;

cp --parents src/include/primer/p0_starter.h ~/Templates/

zip -r project0-submission.zip src

throw Exception(ExceptionType::OUT_OF_RANGE, "Index out of range.");

  /** The actual data that is stored within a page. */
  char data_[PAGE_SIZE]{};
  /** The ID of this page. */
  page_id_t page_id_ = INVALID_PAGE_ID;
  /** The pin count of this page. */
  int pin_count_ = 0;
  /** True if the page is dirty, i.e. it is different from its corresponding page on disk. */
  bool is_dirty_ = false;
  /** Page latch. */
  ReaderWriterLatch rwlatch_;

The autograder failed to execute correctly. Please ensure that your submission is valid. Contact your course staff for help in debugging this issue. Make sure to include a link to this page so that they can help you most effectively.

page.is_dirty_ |= is_dirty;

[ RUN      ] ParallelBufferPoolManagerTest.RoundRobinNewPage
/autograder/bustub/test/buffer/grading_parallel_buffer_pool_manager_test.cpp:1019: Failure
Expected equality of these values:
  unpin_page + num_instances
    Which is: 16
  page_id_temp
    Which is: 216
/autograder/bustub/test/buffer/grading_parallel_buffer_pool_manager_test.cpp:1029: Failure
Expected equality of these values:
  unpin_page + num_instances
    Which is: 17
  page_id_temp
    Which is: 217
/autograder/bustub/test/buffer/grading_parallel_buffer_pool_manager_test.cpp:1042: Failure
Expected equality of these values:
  unpin_page + num_instances
    Which is: 11
  page_id_temp
    Which is: 251
[  FAILED  ] ParallelBufferPoolManagerTest.RoundRobinNewPage (0 ms)

#define MappingType std::pair<KeyType, ValueType>
#define HASH_TABLE_BUCKET_TYPE HashTableBucketPage<KeyType, ValueType, KeyComparator>
#define DIRECTORY_ARRAY_SIZE 512
#define BUCKET_ARRAY_SIZE (4 * PAGE_SIZE / (4 * sizeof(MappingType) + 1))

 private:
  // For more on BUCKET_ARRAY_SIZE see storage/page/hash_table_page_defs.h
  char occupied_[(BUCKET_ARRAY_SIZE - 1) / 8 + 1];
  // 0 if tombstone/brand new (never occupied), 1 otherwise.
  char readable_[(BUCKET_ARRAY_SIZE - 1) / 8 + 1];
  // Do not add any members below array_, as they will overlap.
  MappingType array_[0];

只能合并空桶。
只有当它们的分割图像具有相同的局部深度时，桶才能与其分割图像合并。
只有局部深度大于 0 的桶才能被合并。

cd build
make -j hash_table_test
valgrind --trace-children=yes \
   --leak-check=full \
   --track-origins=yes \
   --soname-synonyms=somalloc=*jemalloc* \
   --error-exitcode=1 \
   --suppressions=../build_support/valgrind.supp \
   ./test/hash_table_test

uint32_t HashTableDirectoryPage::GetLocalHighBit(uint32_t bucket_idx) {
  // after increasing local depth
  return 1 << (GetLocalDepth(bucket_idx) - 1);
}

uint32_t HashTableDirectoryPage::GetSplitImageIndex(uint32_t bucket_idx) {
  // after increasing local depth
  if (GetLocalDepth(bucket_idx) == 0) {
    return 0;
  }
  uint32_t bucket_local_high_bit = GetLocalHighBit(bucket_idx);
  uint32_t split_image_idx;
  if ((bucket_idx & bucket_local_high_bit) == bucket_local_high_bit) {
    split_image_idx = bucket_idx & (~bucket_local_high_bit);
  } else {
    split_image_idx = bucket_idx | bucket_local_high_bit;
  }
  return split_image_idx;
}

  /** Zeroes out the data that is held within the page. */
  inline void ResetMemory() { memset(data_, OFFSET_PAGE_START, PAGE_SIZE); }

  /** The actual data that is stored within a page. */
  char data_[PAGE_SIZE]{};
  /** The ID of this page. */
  page_id_t page_id_ = INVALID_PAGE_ID;
  /** The pin count of this page. */
  int pin_count_ = 0;
  /** True if the page is dirty, i.e. it is different from its corresponding page on disk. */
  bool is_dirty_ = false;
  /** Page latch. */
  ReaderWriterLatch rwlatch_;

      // Table 1
      {"test_1",
       TEST1_SIZE,
       {{"colA", TypeId::INTEGER, false, Dist::Serial, 0, 0},
        {"colB", TypeId::INTEGER, false, Dist::Uniform, 0, 9},
        {"colC", TypeId::INTEGER, false, Dist::Uniform, 0, 9999},
        {"colD", TypeId::INTEGER, false, Dist::Uniform, 0, 99999}}},

  for (auto &table_meta : insert_meta) {
    // Create Schema
    std::vector<Column> cols{};
    cols.reserve(table_meta.col_meta_.size());
    for (const auto &col_meta : table_meta.col_meta_) {
      if (col_meta.type_ != TypeId::VARCHAR) {
        cols.emplace_back(col_meta.name_, col_meta.type_);
      } else {
        cols.emplace_back(col_meta.name_, col_meta.type_, TEST_VARLEN_SIZE);
      }
    }
    Schema schema(cols);
    auto info = exec_ctx_->GetCatalog()->CreateTable(exec_ctx_->GetTransaction(), table_meta.name_, schema);
    FillTable(info, &table_meta);
  }

enum TypeId { INVALID = 0, BOOLEAN, TINYINT, SMALLINT, INTEGER, BIGINT, DECIMAL, VARCHAR, TIMESTAMP };

  union Val {
    int8_t boolean_;
    int8_t tinyint_;
    int16_t smallint_;
    int32_t integer_;
    int64_t bigint_;
    double decimal_;
    uint64_t timestamp_;
    char *varlen_;
    const char *const_varlen_;
  } value_;

  bool Execute(const AbstractPlanNode *plan, std::vector<Tuple> *result_set, Transaction *txn,
               ExecutorContext *exec_ctx) {
    // Construct and executor for the plan
    auto executor = ExecutorFactory::CreateExecutor(exec_ctx, plan);

    // Prepare the root executor
    executor->Init();

    // Execute the query plan
    try {
      Tuple tuple;
      RID rid;
      while (executor->Next(&tuple, &rid)) {
        if (result_set != nullptr) {
          result_set->push_back(tuple);
        }
      }
    } catch (Exception &e) {
      // TODO(student): handle exceptions
    }

    return true;
  }

SeqScanExecutor 遍历一个表并一次一个地返回它的元组。顺序扫描由 SeqScanPlanNode 指定。计划节点指定执行扫描的表。计划节点还可以包含谓词；如果元组不满足谓词，则扫描不会产生它。

提示：使用 TableIterator 对象时要小心。确保您了解前置增量和后置增量运算符之间的区别。通过在 ++iter 和 iter++ 之间切换，您可能会发现自己得到奇怪的输出。

提示：您将希望在顺序扫描计划节点中使用谓词。特别是，看看 AbstractExpression::Evaluate。请注意，这将返回一个 Value，您可以在其上调用 GetAs<bool>() 以将结果评估为原生 C++ 布尔类型。

提示：顺序扫描的输出是每个匹配元组及其原始记录标识符 (RID) 的副本。

InsertExecutor 将元组插入到表中并更新索引。您的执行程序必须支持两种类型的插入。

第一种类型是插入操作，其中要插入的值直接嵌入到计划节点本身中。我们将这些称为原始插入。

第二种类型是从子执行器中获取要插入的值的插入。例如，您可能有一个带有 SeqScanPlanNode 的 InsertPlanNode 作为子节点来实现 INSERT INTO .. SELECT ...

您可以假设 InsertExecutor 始终位于它所在的查询计划的根目录。InsertExecutor 不应修改其结果集。

提示：您需要在执行器初始化期间查找插入目标的表信息。有关访问目录的更多信息，请参阅下面的系统目录部分。

提示：您需要更新插入元组的表的所有索引。有关详细信息，请参阅下面的索引更新部分。

提示：您将需要使用 TableHeap 类来执行表修改。

数据库维护一个内部目录以跟踪有关数据库的元数据。在这个项目中，您将与系统目录交互以查询有关表、索引及其模式的信息。

整个目录实现在 src/include/catalog.h 中。您应该特别注意成员函数 Catalog::GetTable() 和 Catalog::GetIndex()。您将在执行程序的实现中使用这些函数来查询表和索引的目录。

对于表修改执行器（InsertExecutor、UpdateExecutor 和 DeleteExecutor），您必须修改操作所针对的表的所有索引。您可能会发现 Catalog::GetTableIndexes() 函数对于查询为特定表定义的所有索引很有用。一旦您拥有每个表索引的 IndexInfo 实例，您就可以在底层索引结构上调用索引修改操作。

在这个项目中，我们使用您对项目 2 中可扩展哈希表的实现作为所有索引操作的基础数据结构。因此，该项目的成功完成依赖于可扩展哈希表的工作实现。

    // Construct index metdata
    auto meta = std::make_unique<IndexMetadata>(index_name, table_name, &schema, key_attrs);

    // Construct the index, take ownership of metadata
    // TODO(Kyle): We should update the API for CreateIndex
    // to allow specification of the index type itself, not
    // just the key, value, and comparator types
    auto index = std::make_unique<ExtendibleHashTableIndex<KeyType, ValueType, KeyComparator>>(std::move(meta), bpm_, hash_function);

Tuple Tuple::KeyFromTuple(const Schema &schema, const Schema &key_schema, const std::vector<uint32_t> &key_attrs) {
  std::vector<Value> values;
  values.reserve(key_attrs.size());
  for (auto idx : key_attrs) {
    values.emplace_back(this->GetValue(&schema, idx));
  }
  return Tuple(values, &key_schema);
}

UpdateExecutor 修改指定表中的现有元组并更新其索引。子执行器将提供更新执行器将修改的元组（及其 RID）。

与 InsertExecutor 不同，UpdateExecutor 总是从子执行程序中提取元组来执行更新。例如，UpdatePlanNode 将有一个 SeqScanPlanNode 作为其子节点。

您可以假设 UpdateExecutor 始终位于它所在的查询计划的根目录。UpdateExecutor 不应修改其结果集。

提示：我们为您提供了一个 GenerateUpdatedTuple，它根据计划节点中提供的更新属性为您构造一个更新的元组。

提示：您需要在执行器初始化期间查找更新目标的表信息。有关访问目录的更多信息，请参阅下面的系统目录部分。

提示：您将需要使用 TableHeap 类来执行表修改。

提示：您需要更新执行更新的表的所有索引。有关详细信息，请参阅下面的索引更新部分。

DeleteExecutor 从表中删除元组并从所有表索引中删除它们的条目。像更新一样，要删除的元组是从子执行器中提取的，例如 SeqScanExecutor 实例。

您可以假设 DeleteExecutor 始终位于它所在的查询计划的根目录。DeleteExecutor 不应修改其结果集。

提示：您只需要从子执行器获取 RID 并调用 TableHeap::MarkDelete() 即可有效删除元组。所有删除都将在事务提交时应用。

提示：您需要更新删除元组的表的所有索引。有关详细信息，请参阅下面的索引更新部分。

NestedLoopJoinExecutor 实现了一个基本的嵌套循环连接，它将来自其两个子执行器的元组组合在一起。

这个执行器应该实现讲座中介绍的简单嵌套循环连接算法。也就是说，对于连接外部表中的每个元组，您应该考虑连接内部表中的每个元组，如果满足连接谓词，则发出一个输出元组。

该项目的学习目标之一是让您了解逻辑运算符的不同物理实现的优缺点。出于这个原因，重要的是您的 NestedLoopJoinExecutor 实际上实现了嵌套循环连接算法，而不是例如为哈希连接执行器重用您的实现（见下文）。为此，我们将测试您的 NestedLoopJoinExecutor 的 IO 成本，以确定它是否正确实现了算法。

提示：您将希望在嵌套循环连接计划节点中使用谓词。特别是，看看 AbstractExpression::EvaluateJoin，它处理左元组和右元组及其各自的模式。请注意，这将返回一个 Value，您可以在其上调用 GetAs<bool>() 以将结果评估为原生 C++ 布尔类型。

HashJoinExecutor 实现了一个哈希连接操作，它将来自它的两个子执行器的元组组合在一起。

顾名思义（正如讲座中所讨论的），哈希连接操作是在哈希表的帮助下实现的。出于本项目的目的，我们做了一个简化假设，即连接哈希表完全适合内存。这意味着您无需担心在您的实现中将构建侧表的临时分区溢出到磁盘。

与 NestedLoopJoinExecutor 一样，我们将测试您的 HashJoinExecutor 的 IO 成本，以确定它是否正确实现了哈希连接算法。

提示：您的实现应该正确处理多个元组（在连接的任一侧）共享一个公共连接键的情况。

提示：HashJoinPlanNode 定义了 GetLeftJoinKey() 和 GetRightJoinKey() 成员函数；您应该使用这些访问器返回的表达式分别为连接的左侧和右侧构造连接键。

提示：您将需要一种方法来散列具有多个属性的元组以构造唯一键。作为起点，看一下 AggregationExecutor 中的 SimpleAggregationHashTable 如何实现此功能。

提示：回想一下，在查询计划的上下文中，哈希连接的构建端是管道中断器。这可能会影响您在实现中使用 HashJoinExecutor::Init() 和 HashJoinExecutor::Next() 函数的方式。特别要考虑join的Build阶段是应该在HashJoinExecutor::Init()还是HashJoinExecutor::Next()中进行。

namespace bustub {

struct HashJoinKey {
  std::vector<Value> values_;

  bool operator==(const HashJoinKey &other) const {
    for (uint32_t i = 0; i < other.values_.size(); i++) {
      if (values_[i].CompareEquals(other.values_[i]) != CmpBool::CmpTrue) {
        return false;
      }
    }
    return true;
  }
};

struct HashJoinValue {
  std::vector<Tuple> tuples_;
};

}  // namespace bustub

namespace std {

/** Implements std::hash on HashJoinKey */
template <>
struct hash<bustub::HashJoinKey> {
  std::size_t operator()(const bustub::HashJoinKey &key) const {
    size_t curr_hash = 0;
    for (const auto &key : key.values_) {
      if (!key.IsNull()) {
        curr_hash = bustub::HashUtil::CombineHashes(curr_hash, bustub::HashUtil::HashValue(&key));
      }
    }
    return curr_hash;
  }
};

}  // namespace std

std::unordered_map<HashJoinKey, HashJoinValue> map_;

const ColumnValueExpression *column_expr = dynamic_cast<const ColumnValueExpression *>(column.GetExpr());
uint32_t column_idx = column_expr->GetColIdx();
Value value = tuple_ori.GetValue(schema_, column_idx);

Value value = column.GetExpr()->Evaluate(&tuple_ori, schema_);

该执行器将来自单个子执行器的多个元组结果组合成一个元组。在这个项目中，我们要求您实现 COUNT、SUM、MIN 和 MAX 聚合。您的 AggregationExecutor 还必须支持 GROUP BY 和 HAVING 子句。

正如讲座中所讨论的，实现聚合的常见策略是使用哈希表。这是您将在本项目中使用的方法，但是，我们做一个简化假设，即聚合哈希表完全适合内存。这意味着您无需担心为散列聚合实现两阶段（分区、重新散列）策略，而是可以假设您的所有聚合结果都可以驻留在内存中的散列表中。

此外，我们为您提供了 SimpleAggregationHashTable 数据结构，该结构公开了内存中的哈希表 (std::unordered_map)，但具有设计用于计算聚合的接口。此类还公开了可用于遍历哈希表的 SimpleAggregationHashTable::Iterator 类型。

提示：您需要汇总结果并使用 HAVING 子句进行约束。特别是，看看 AbstractExpression::EvaluateAggregate，它处理不同类型表达式的聚合评估。请注意，这将返回一个 Value，您可以在其上调用 GetAs<bool>() 以将结果评估为原生 C++ 布尔类型。

提示：回想一下，在查询计划的上下文中，聚合是管道破坏者。这可能会影响您在实现中使用 AggregationExecutor::Init() 和 AggregationExecutor::Next() 函数的方式。特别要考虑聚合的 Build 阶段是应该在 AggregationExecutor::Init() 还是 AggregationExecutor::Next() 中执行。

LimitExecutor 限制来自其子执行器的输出元组的数量。如果其子执行器生成的元组数小于 LimitPlanNode 中指定的限制，则此执行器无效并产生它接收到的所有元组。

DistinctExecutor 消除从其子执行器接收到的重复元组。在确定唯一性时，您的 DistinctExecutor 应该考虑输入元组的所有列。

与聚合一样，不同的运算符通常是在哈希表的帮助下实现的（这是一个哈希不同的操作）。这是您将在本项目中使用的方法。与在 AggregationExecutor 和 HashJoinExecutor 中一样，您可以假设用于实现 DistinctExecutor 的哈希表完全适合内存。

提示：您将需要一种方法来散列具有潜在许多属性的元组，以便构造唯一键。作为起点，看一下 AggregationExecutor 中的 SimpleAggregationHashTable 如何实现此功能。

LOG_DEBUG("%d", static_cast<std::underlying_type_t<TypeId>>(column.GetType()));

为了确保事务操作的正确交错，DBMS 将使用锁管理器 (LM) 来控制何时允许事务访问数据项。LM 的基本思想是它维护一个关于当前由活动事务持有的锁的内部数据结构。然后事务在被允许访问数据项之前向 LM 发出锁定请求。LM 将向调用事务授予锁、阻止该事务或中止它。

在您的实现中，将有一个用于整个系统的全局 LM（类似于您的缓冲池管理器）。每当事务想要访问/修改元组时，TableHeap 和 Executor 类将使用您的 LM 获取元组记录上的锁（通过记录 id RID）。

此任务需要您实现一个元组级 LM，它支持三种常见的隔离级别：READ_UNCOMMITED、READ_COMMITTED 和 REPEATABLE_READ。锁管理器应根据事务的隔离级别授予或释放锁。详情请参阅讲座幻灯片。

在存储库中，我们为您提供了带有隔离级别属性（即 READ_UNCOMMITED、READ_COMMITTED 和 REPEATABLE_READ）的事务上下文句柄 (include/concurrency/transaction.h) 以及有关其获取的锁的信息。LM 将需要检查事务的隔离级别并公开锁定/解锁请求的正确行为。任何失败的锁定操作都应导致 ABORTED 事务状态（隐式中止）并引发异常。事务管理器将进一步捕获此异常并回滚事务执行的写操作。

虽然您的锁管理器需要使用死锁预防，但我们建议您首先实现您的锁管理器而不进行任何死锁处理，然后在您验证它正确锁定并在没有死锁发生时解锁后添加预防机制。

您将需要一些方法来跟踪哪些事务正在等待锁定。查看 lock_manager.h 中的 LockRequestQueue 类。

LockUpgrade 对 LockRequestQueue 的操作意味着什么？

您将需要一些方法来通知正在等待的事务何时可能要获取锁。我们建议使用 std::condition_variable

虽然某些隔离级别是通过确保严格的两阶段锁定的属性来实现的，但您的锁管理器的实现只需要确保两阶段锁定的属性。严格 2PL 的概念将通过您的执行器和事务管理器中的逻辑来实现。看看那里的 Commit 和 Abort 方法。

您还应该维护交易状态。例如，由于解锁操作，事务的状态可能会从 GROWING 阶段变为 SHRINKING 阶段（提示：查看 transaction.h 中的方法）

您还应该使用 shared_lock_set_ 和 exclusive_lock_set_ 跟踪事务获取的共享/独占锁，以便当 TransactionManager 想要提交/中止事务时，LM 可以正确释放它们。

将事务的状态设置为 ABORTED 会隐式中止它，但在调用 TransactionManager::Abort 之前不会显式中止。你应该通读这个函数来理解它的作用，以及你的锁管理器是如何在中止过程中使用的。

lock_table_.emplace(std::piecewise_construct, std::make_tuple(rid), std::make_tuple());

lock_table_.emplace(rid, LockRequestQueue())

std::unique_lock<std::mutex> lck(latch);
search->second.cv_.wait(lck, [&] { ... });

如果您的锁管理器被告知使用预防，您的锁管理器应该使用 WOUND-WAIT 算法来决定要中止哪些事务。

获取锁时，您将需要查看相应的 LockRequestQueue 以查看它将等待哪些事务。

仔细阅读幻灯片，了解如何实施 Wound-Wait。

中止事务时，请确保使用 SetState 正确设置其状态

如果事务正在升级（等待获取 X 锁），它仍然可以中止。您必须正确处理此问题。

当一个事务正在等待另一个事务时，等待图绘制边。请记住，如果多个事务持有共享锁，则单个事务可能正在等待多个事务。

当事务中止时，确保将事务的状态设置为 ABORTED 并在锁管理器中抛出异常。事务管理器将处理显式中止和回滚更改。

由于伤口等待预防策略，等待锁定的事务可能会被另一个线程中止。您必须有一种方法来通知等待的事务它们已被中止。

在并发查询执行期间，执行器需要适当地锁定/解锁元组，以达到相应事务中指定的隔离级别。为了简化此任务，您可以忽略并发索引执行而只关注表元组。

您将需要更新项目 3 中实现的某些执行程序（顺序扫描、插入、更新、删除、嵌套循环连接和聚合）的 Next() 方法。请注意，当锁定/解锁失败时，事务将中止。虽然没有并发索引执行的要求，但我们仍然需要在事务中止时适当地撤消之前对表元组和索引的所有写入操作。为此，您需要维护事务中的写入集，这是事务管理器的 Abort() 方法所要求的。

你不应该假设一个事务只包含一个查询。具体来说，这意味着一个元组可能在一个事务中被不同的查询访问不止一次。想想你应该如何在不同的隔离级别下处理这个问题。

  /**
   * Insert a tuple into the table. If the tuple is too large (>= page_size), return false.
   * @param tuple tuple to insert
   * @param[out] rid the rid of the inserted tuple
   * @param txn the transaction performing the insert
   * @return true iff the insert is successful
   */
  bool InsertTuple(const Tuple &tuple, RID *rid, Transaction *txn);

  // Update the transaction's write set.
  txn->GetWriteSet()->emplace_back(*rid, WType::INSERT, Tuple{}, this);

IndexWriteRecord record(ret_rid, table_info_->oid_, WType::INSERT, target_tuple, index_info->index_oid_, exec_ctx_->GetCatalog());
exec_ctx_->GetTransaction()->AppendTableWriteRecord(record);

$ cmake -DCMAKE_BUILD_TYPE=DEBUG ..

(gdb) info threads
(gdb) break location thread id
(gdb) thread apply id command

$ zip project4-submission.zip \
src/include/buffer/lru_replacer.h \
src/buffer/lru_replacer.cpp \
src/include/buffer/buffer_pool_manager_instance.h \
src/buffer/buffer_pool_manager_instance.cpp \
src/include/storage/page/hash_table_directory_page.h \
src/storage/page/hash_table_directory_page.cpp \
src/include/storage/page/hash_table_bucket_page.h \
src/storage/page/hash_table_bucket_page.cpp \
src/include/container/hash/extendible_hash_table.h \
src/container/hash/extendible_hash_table.cpp \
src/include/execution/execution_engine.h \
src/include/execution/executors/seq_scan_executor.h \
src/include/execution/executors/insert_executor.h \
src/include/execution/executors/update_executor.h \
src/include/execution/executors/delete_executor.h \
src/include/execution/executors/nested_loop_join_executor.h \
src/include/execution/executors/hash_join_executor.h \
src/include/execution/executors/aggregation_executor.h \
src/include/execution/executors/limit_executor.h \
src/include/execution/executors/distinct_executor.h \
src/execution/seq_scan_executor.cpp \
src/execution/insert_executor.cpp \
src/execution/update_executor.cpp \
src/execution/delete_executor.cpp \
src/execution/nested_loop_join_executor.cpp \
src/execution/hash_join_executor.cpp \
src/execution/aggregation_executor.cpp \
src/execution/limit_executor.cpp \
src/execution/distinct_executor.cpp \
src/include/concurrency/lock_manager.h \
src/concurrency/lock_manager.cpp