实现执行引擎和执行器

执行引擎

我们使用迭代模型来实现执行引擎 ExecutionEngine， 该类最重要的方法就是 Execute, 包含执行的计划，需要返回的结果，事务，和执行上下文信息。该方法首先通过工厂方法来生产具体的执行器，然后不断调用Next方法获取执行的结果。

graph LR
    A[执行计划] ---> B{执行引擎} ---> C[查询结果]
    subgraph 执行
    D ---> |返回数据| B
    B ---> |查询数据| D[(数据库)]
    end

bool Execute(const AbstractPlanNode *plan, std::vector<Tuple>*result_set, 
             Transaction *txn, ExecutorContext *exec_ctx) {
  // construct executor
  auto executor = ExecutorFactory::CreateExecutor(exec_ctx, plan);
  // prepare
  executor->Init();
  // execute
  try {
    Tuple tuple;
    RID rid;
    while (executor->Next(&tuple, &rid)) {
      if (result_set != nullptr) {
        if (plan->GetType() == PlanType::Insert || 
            plan->GetType() == PlanType::Update ||
            plan->GetType() == PlanType::Delete) {
          continue;
        }
        result_set->push_back(tuple);
      }
    }
  } catch (Exception &e) {
    // TODO(student): handle exceptions
  }
  return true;
}

所有的执行器都需要实现抽象执行接口 AbstractExecutor, 具体的执行器有对应的基本执行操作实现, 如顺序扫描SeqScanExecutor、插入InsertExecutor、嵌套循环NestedLoopJoinExecutor等。

• Init(): 设置有关操作符调用的内部状态(例如，检索要扫描的对应表)。
• Next(): 提供迭代器接口，该接口在每次调用时返回一个元组和相应的 rid (如果没有更多的元组，则返回 null)

执行代价估计

• 磁盘上一个块的平均传输时间： $t_T$
• 磁盘上一个块的平均访问时间（磁盘寻道时间 + 旋转延迟时间）: $t_S$
• 如果一个操作传输了 $b$ 个块和进行了 $S$ 次随机 I/O 访问 则需要耗费: $ b * t_T + S * t_S $
• 关系 r 包含的块个数: $b_r$
• 关系 s 包含的块个数: $b_s$
• 关系 r 包含的元组个数: $n_r$
• 关系 s 包含的元组个数: $n_s$
• 缓冲区的块个数：$M$
• B+树索引的高度： $h_i$

顺序扫描(Sequential Scan)

顺序扫描也称为表扫描或线性扫描。顺序扫描执行器遍历一个表并一次返回它的元组。顺序扫描由SeqScanPlanNode 指定。plan节点指定要遍历哪个表。计划节点也可以包含谓词;如果一个元组不满足谓词，则跳过它。

顺序扫描的时间代价： $t_s+b_r\ast t_T$
关键码上等值条件的顺序扫描：$t_s+(b_r/2)\ast t_T$

提示:使用TableIterator对象时要小心。请务必理解前置自增操作符和后置自增操作符之间的区别。通过在 ++iter 和 iter++ 之间切换，你可能会发现自己得到奇怪的输出。

提示:你将希望在顺序扫描计划节点中使用谓词。特别是，看看AbstractExpression::Evaluate。注意，这会返回一个 Value，你可以使用 GetAs<bool>来获取布尔值。

提示:顺序扫描的输出应该是匹配元组的值副本及其原始记录ID

索引扫描(Index Scan)

索引扫描遍历索引以获得元组 rid 。这些 rid 用于在与索引对应的表中查找元组。最后，这些元组一次返回一个。索引扫描由 IndexScanPlanNode 指定。计划节点指定要遍历的索引。计划节点也可以包含谓词;如果一个元组不满足谓词，则跳过它。

聚簇B+树索引关键码上的等值查询时间代价：$(h_i+1)\ast (t_T+t_S)$， $h_i$次索引遍历, 额外加1次获取元组。

聚簇B+树索引非关键码上的等值查询时间代价：$h_i\ast (t_T+t_S)+t_s+b\ast t_T$， $h_i$次索引遍历, 额外加1次记录的访问, 这里 $b$ 代表满足条件的记录的块数。

提示: 一旦从索引中检索了 RID，请确保从表中检索元组。记住要使用目录来查找表。

提示: 利用 B+ 树的迭代器来同时支持点查询和范围扫描。

提示:对于这个项目，可以安全地假设索引的键值类型是 <GenericKey<8>, RID, GenericComparator<8>> ;不要担心模板，不过也欢迎更通用的解决方案

插入(Insert)

插入执行器将元组插入到表中并更新索引。有两种类型的插入，第一种插入是将插入的值直接嵌入到计划节点本身中；另一种是获取从子执行程序获取要插入的值。例如，可以使用其子节点为 SeqScanPlanNode 或 IndexScanPlanNode 的 InsertPlanNode 将一个表复制到另一个表中。

提示: 你将希望在执行器构造期间查找表和索引信息，并在执行期间必要时插入索引。

更新(Update)

修改指定表中的现有元组并更新其索引。子执行程序将提供更新执行程序将修改的元组(及其RID)。例如，一个 UpdatePlanNode 可以有一个 SeqScanPlanNode 或 IndexScanPlanNode 来提供目标元组。

提示:我们提供了一个 GenerateUpdatedTuple，它为你构造了一个更新的元组。

删除(Delete)

从表中删除元组，并从索引中删除它们的条目。与更新类似，目标元组集来自子执行器，如 SeqScanExecutor 或 IndexScanExecutor。

提示:你只需要从子执行器中获取 RID，并调用 MarkDelete (src/include/storage/table/table_heap.h) 使其不可见。删除将在事务提交时应用。

嵌套循环连接

$$R(X,Y){\bowtie }_{\theta }S(Y,Z)$$

基于元组的嵌套循环连接算法

嵌套循环的系列算法中最简单的形式是其中的循环是对所涉及关系的各个元组来进行的。

for each tuple tr in r do begin
    for each tuple ts in s do begin
        test pair (tr, ts) to see if they satisfy the join condition θ
        if they do, add tr ⋅ ts to the result;
    end
end

如果我们不在内存中缓存下 关系 $r$ 和 $s$ 的块，则这种算法需要的磁盘 I/O 可多达 $t_r\ast t_s$。

嵌套循环连接的一个优点是它非常适用于迭代器结构，下面给出迭代函数的代码：

Init() {
   r_executor->Init();
   s_executor->Init();
   r_tuple = r_executor->Next();
}
Next() {
    while (r_tuple is not null) {
        s_tuple =  s_executor->Next();
        if (s_tuple is null) {
            r_tuple = r_executor->Next();
            if (r_tuple is null) {
                return null;
            }
            s_executor->Init();
            s_tuple =  s_executor->Next();
        }
        if (r_tuple and s_tuple can join on predicate condition) {
            resule_tuple = Join(r_tuple, s_tuple);
            return   resule_tuple;
        }
    }
    return null;
}
Close() {
    r_executor->close();
    s_executor->close();
}

提示: 嵌套循环连接计划节点中使用谓词。具体来说，请查看 AbstractExpression::EvaluateJoin，它处理左元组和右元组及其各自的模式。这会返回一个 Value，你可以使用 GetAs<bool>来获取布尔值。

基于块的嵌套循环连接算法

基于块的的嵌套循环对两个关系的访问均按块访问。我们先考虑使用内存来缓存块的最坏和最好情况。最坏情况下，缓冲中只能发下每个关系的一个块，则需要传输的块个数为：$b_r+n_r\ast b_s$ , 内部关系 $s$ 是顺序读取需要进行 $n_r$ 次访问，对外部关系 $b_r$ 是随机读取需要进行 $b_r$ 次访问，所以总的访问块个数为: $n_r+b_r$。最好情况下，缓冲中有足够的内存来存放所有关系，这样就只需要访问$2$次磁盘和进行 $b_r+b_s$ 个块的传输。

for each block Br of r do begin
    for each block Bs of s do begin
        for each tuple tr in Br do begin
            for each tuple ts in Bs do begin
                test pair (tr, ts) to see if they satisfy the join condition
                if they do, add tr ⋅ ts to the result;
            end
        end
    end
end

对于一般情况，我们假设 $b_r<b_s$, 我们再假定 $M<b_r$，这样的话，任何一个关系都不能完整地装入内存。对上面给出地块嵌套算法进行改进我们可以不使用磁盘块作为外部关系的块单元，而是使用尽可能多的内存来存储外层关系 $r$ 中的元组，同时为内部关系和输出的缓冲区留出足够的空间。换句话说，如果内存有$M$个块，我们一次读取$M-2$个外部关系的块，当我们读取每个内部关系的块时，我们把它与所有的$M-2$个外部关系的块连接起来。

for read M-2 block of r do begin
    for each block Bs of s do begin
        for each tuple ts in Bs do begin
            tr from M-2 block
            test pair (tr, ts) to see if they satisfy the join condition, 
            if they do, add tr ⋅ ts to the result;
        end
    end
end

这样地话总的传输块为： $b_r+\lceil b_r/(M-2)\rceil \ast b_s$， 磁盘访问次数为: $2\lceil b_r/(M-2)\rceil$

索引循环嵌套连接

假设 $S$ 在属性集 $Y$ 上存在索引

$$b_r\ast (t_T+t_S)+n_r\ast c$$

如果一个索引在内部循环的join属性上可用，我们可以用更有效的索引查找代替表扫描

其中 $c$ 是使用连接条件对内层关系 $s$ 进行一次选择的代价。

1. fetch the tuple from the outer table
2. construct the index probe key by looking up the column value and index key schema
3. look up the RID in the index to retrieve the corresponding tuple for the inner table.

提示:从外部表中获取元组，通过查找列值和索引键模式来构造索引探测键，然后在索引中查找RID来检索内部表的相应元组。

提示:可以假设内部元组总是有效的(即没有谓词)

聚合（Aggregation）

该执行器将来自单个子执行器的多个元组结果组合为单个元组。在这个项目中，我们要求您实现 COUNT、SUM、MIN 和 MAX 。我们提供了一个SimpleAggregationHashTable，它具有所有必要的聚合功能。

您还需要实现有HAVING的GROUP BY子句。我们提供了一个SimpleAggregationHashTable Iterator，它可以遍历散列表。

提示： 您将希望聚合结果并使用 HAVING 作为约束。特别是，请查看AbstractExpression::EvaluateAggregate，它处理不同类型表达式的聚合求值。注意，这会返回一个Value，你可以使用 GetAs<bool> 将其转换成 bool 值

如果结果的所有元组都放入内存，那么基于排序和基于散列的实现不需要将任何元组写入磁盘。当元组被读入时，可以将它们插入有序树结构或散列索引中。当我们使用动态聚合技术时，每个组只需要存储一个元组。因此，有序树结构或散列索引适合内存，并且聚合可以通过 $b_r$ 块传输(和1次访问)来处理，而不是使用 $3b_r$ 传输(最坏的情况是 $2b_r$ 次访问)，否则就需要 $3b_r$ 传输。

$$b_r\ast t_T+t_S$$

有限数目(Limit)

最后，这个执行器限制了单个子执行器的输出数量。offset值表示执行器在发出元组之前需要跳过的元组数量。

一些坑：

1. you should check the executor type in execution_engine.h to make sure that you don’t insert tuple into result_set for insert/update/delete.
2. You will need to evaluate all the columns of the output schema on the input tuple/schema to produce the output values, then construct the new tuple with those values + the output schema