CMU15-445 Project3

CMU15-445 Project3

这个project主要考验了阅读工程代码的能力。像这种大型工程代码，推荐的阅读顺序是：先看测试代码，大概能够了解这个项目会用到哪些部分，用了哪些类，然后分层次去看这些类的头文件，搞清楚每个类的作用，而我们看类重点还是先看这些类中的成员变量

接下来先梳理一下bustub数据库中的一些类：

Catalog

下去了解一下emplace和move和智能指针方面的知识，还有atomic

这个类主要是用来创建/得到table和index的，在创建一个catalog的时候，我们需要把底层的一些基础架构传入，例如bufferpool,lockmanager,logmanager等等。

那么在Catalog中就要管理table和index，这就又会涉及到其他类。如果我们在Catalog中要存管理的table和index，我们不去直接存实例化对象，而是存指向这些对象的指针。而且不是普通的指针，是智能指针！用unique_ptr来存，在构造的时候用移动语义，也能解决效率问题。

当然table和index中会有一些元数据，因此我们实际存的是tableinfo和indexinfo，即在真正的table和index上面加了一层。

在GetIndex和GetTable中有多种可行的查询方式，这里可以直接重载！而不是重新命名例如GetIndexById和GetIndexByName，这也是一种设计模式。

TableInfo

存这个table的schema,name,tableheap实例（用unique_ptr）和这个table的id。

IndexInfo

存的信息和TableInfo差不多，只是这里的schema变成了key_schema，专门为key设计。

Schema

Schema是在Catalog中的结构，用来存Column和这些Column组合的信息。注意这里的Column不是指具体的这一列上的值，而是值这一列的值应该具有的某些属性。

Schema类中有四个成员变量：length_表示所有column总共占了多大空间。columns_作为存column的vector，还有uninlined_columns_作为存哪些column是uninlined的vector。

这里schema会存column，注意这两个都是元数据，不会保存真正的数据。真正的数据保存在tuple类中。

Column

存了关于这一列所存元素的元信息，例如列的名字，这一列元素的类型，这一列在tuple中的offset，还有一个对应的AbstractExpression，表示用这个表达式来生成了这一列。

几个设计点：

1.存元数据的这种类大部分的成员函数都是取一些信息啊之类的，尽量把成员函数的定义写在类里面。

2.涉及到STL的尽量用不要直接拷贝复制，Column类中，就算是String也是直接move初始化。

Table_heap

这个类就会接触到更低层的东西了，我们将table存在若干个page上，这些page用链表串联起来。table_heap主要负责查找我们要操作的page是哪一个以及进行什么操作，至于具体的操作就要留给page来实现。

在table_heap中，删除操作是markDelete的，也就是不会立即删除。

一个设计点：

因为可能涉及到遍历table_heap的操作，我们可以设计另外一个table_heap的迭代器类，而在table_heap中主要负责返回begin和end迭代器。

Table_iterator

因为iterator会有解引用操作，为了避免频繁进行磁盘IO，我们要将目前的tuple存下来。而且因为table_heap是以page的形式存储的，所以每次在++操作的时候要先看是否到了page的边界。

后置++运算符可以复用前置++运算符：

1
2
3
4
5
auto TableIterator::operator++(int) -> TableIterator {
  TableIterator clone(*this);
  ++(*this);
  return clone;
}

Tuple

1.这个Tuple设计的很有意思。我们的Tuple分为临时tuple和永久tuple。所谓的临时tuple，指的是用完就会销毁的，常用于创建一个临时的tuple来进行返回、传参。在成员中用allocated_来标记这个tuple是不是临时的，用于在拷贝、构造和析构时选择深拷贝还是浅拷贝、是否释放内存。

2.Tuple上是要存实际数据的，但是我们的数据可能有很多种，而且有的数据可能太大了在tuple上存不下。解决的方法是将所有的数据序列化后存到tuple上，即在tuple上定义一个char数组，对每种类型，在其内部定义序列化和反序列化函数。除此之外，还会有一些数据太大不能直接放到tuple上的，我们把这种数据成为uninlined，我们的做法是：在char数组的对应位置上（这个位置本来该存这个实际的数据）不再存放实际数据，而是存放这个实际数据的偏移，即我可以在哪个位置上找到这个数据。注意到char本身的特殊性（表示一个字节），可以用强制类型转换来做到这一点：

1
*reinterpret_cast<uint32_t *>(data_ + col.GetOffset()) = offset;

3.和schema以及column类联合起来，column中会存自身在tuple中的偏移，这也是面向对象设计的一个点，每个类存自身的信息。

Expression

用来执行运算的类，其中abstract_expression是一个抽象基类。计算表达式的时候将表达式组织成一棵表达式树。这里用:std::vector<const AbstractExpression *> children_来存。所有的表达式的返回结果都是一个Value。

column_value_expression

这个运算主要用于求一个tuple的某个特定列或者是join的join key。成员有tuple_idx_和col_idx_，分别表示join的时候这个tuple在左边还是右边，以及我们要取的是哪一列。也就是说，我们在创建这个表达式的时候，我们其实就知道了要取哪个位置上的Value，这个位置并不是在表达式中计算出来的。

constant_value_expression

这个就是直接返回一个Value。已经设定好的。

comparison_expression

递归执行左右儿子的表达式，然后将结果进行比较，返回一个bool值。比较的类型和结果类型都封装在一个Type类中。也就是所谓的类型封装。这里的思想是：我们完全可以把比较的类型看做是常量，在程序中尽量不要直接用常量，而是用名字去表示常量，并且把这些常量都封装到一个类中。

aggregate_value_expression

和column_value_expression差不多，返回指定列上的值，适用于aggregate操作。这里不进行aggregate操作的原因是在对应的aggregate_executor中，已经用hash table计算好了。

Execution

查询计划的执行可以看成由两部分组成，一部分是plan，另一部分是executor。这两部分都组成树结构。

当我们要执行一个查询计划的时候，步骤如下：

1.外部代码传给plan对应的信息，plan包含了对应的executor执行必须要有的特定信息。

2.初始化executor_context，包含了执行的上下文信息，例如transaction,catalog,bufferpool和lockmanager等。

3.executor_engine开始执行，先调用对应的executor的init函数，然后不停调用对应executor的next函数，如果返回结果是true，就把绑定参数的tuple和rid给存到结果中能够，否则结束操作。

接下来到我们的任务了，实现9个executor：

seq_scan_executor

每个executor要获得table,index等要操作的对象的信息(如果需要的话)。seq_scan_executor将从一个表中遍历，并按照自己指定的schema的形式输出tuple，因此我们要先对照output_schema来存最后的结果中每一列对应着原来schema中的哪一列。如果有predicate的话还要先检验一下是否满足条件。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
SeqScanExecutor::SeqScanExecutor(ExecutorContext *exec_ctx, const SeqScanPlanNode *plan)
    : AbstractExecutor(exec_ctx), plan_(plan), cur_(nullptr, RID{}, nullptr), end_(nullptr, RID{}, nullptr) {
  table_info_ = exec_ctx_->GetCatalog()->GetTable(plan_->GetTableOid());

  out_schema_idx_.reserve(plan_->OutputSchema()->GetColumnCount());
  try {
    for (uint32_t i = 0; i < plan_->OutputSchema()->GetColumnCount(); i++) {
      auto col_name = plan_->OutputSchema()->GetColumn(i).GetName();
      out_schema_idx_.push_back(table_info_->schema_.GetColIdx(col_name));
    }
  } catch (const std::logic_error &error) {
    for (uint32_t i = 0; i < plan_->OutputSchema()->GetColumnCount(); i++) {
      out_schema_idx_.push_back(i);
    }
  }

  if (plan_->GetPredicate() != nullptr) {
    predicate_ = plan_->GetPredicate();
  } else {
    is_alloc_ = true;
    predicate_ = new ConstantValueExpression(ValueFactory::GetBooleanValue(true));
  }
}

SeqScanExecutor::~SeqScanExecutor() {
  if (is_alloc_) {
    delete predicate_;
  }
  predicate_ = nullptr;
}

void SeqScanExecutor::Init() {
  cur_ = table_info_->table_->Begin(exec_ctx_->GetTransaction());
  end_ = table_info_->table_->End();
}

bool SeqScanExecutor::Next(Tuple *tuple, RID *rid) {
  while (cur_ != end_) {
    auto temp = cur_++;
    auto value = predicate_->Evaluate(&(*temp), &table_info_->schema_);
    if (value.GetAs<bool>()) {
      // Only keep the columns of the out schema
      std::vector<Value> values;
      values.reserve(out_schema_idx_.size());
      for (auto i : out_schema_idx_) {
        values.push_back(temp->GetValue(&table_info_->schema_, i));
      }
      *tuple = Tuple(values, plan_->OutputSchema());
      *rid = temp->GetRid();
      return true;
    }
  }
  return false;
}

注意区分Init和构造函数的作用。因为一个表可能会多次扫描，所以Init是用来进行重置状态的，而构造函数才是用来进行初始化的。

insert_executor

insert只有可能出现在executor树的最上层，并且不会改变result vector，所以它应该一次性执行完所有的插入操作，并且只会返回false。

主要是要注意index的插入，这里的tuple是要从原来的tuple中抽一些key value出来组成key_tuple，注意函数参数名的区别。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
InsertExecutor::InsertExecutor(ExecutorContext *exec_ctx, const InsertPlanNode *plan,
                               std::unique_ptr<AbstractExecutor> &&child_executor)
    : AbstractExecutor(exec_ctx), plan_(plan) {
  table_info_ = exec_ctx->GetCatalog()->GetTable(plan->TableOid());
  index_info_ = exec_ctx->GetCatalog()->GetTableIndexes(table_info_->name_);
  child_executor_ = std::move(child_executor);
}

void InsertExecutor::Init() {
  if (!plan_->IsRawInsert()) {
    child_executor_->Init();
  }
}

auto InsertExecutor::Next([[maybe_unused]] Tuple *tuple, RID *rid) -> bool {
  RID tuple_rid;
  if (plan_->IsRawInsert()) {
    auto tuples = plan_->RawValues();
    for (auto &value : tuples) {
      auto made_tuple = Tuple(value, &(table_info_->schema_));
      // insert into table
      if (!table_info_->table_->InsertTuple(made_tuple, &tuple_rid, exec_ctx_->GetTransaction())) {
        return false;
      }
      for (auto index_info : index_info_) {
        const auto index_tuple =
            made_tuple.KeyFromTuple(table_info_->schema_, index_info->key_schema_, index_info->index_->GetKeyAttrs());
        // 这里注意看参数名
        index_info->index_->InsertEntry(index_tuple, tuple_rid, exec_ctx_->GetTransaction());
      }
    }
  } else {
    Tuple child_tuple;
    while (child_executor_->Next(&child_tuple, &tuple_rid)) {
      if (!table_info_->table_->InsertTuple(child_tuple, &tuple_rid, exec_ctx_->GetTransaction())) {
        return false;
      }
      for (auto index_info : index_info_) {
        const auto index_tuple =
            child_tuple.KeyFromTuple(table_info_->schema_, index_info->key_schema_, index_info->index_->GetKeyAttrs());
        index_info->index_->InsertEntry(index_tuple, tuple_rid, exec_ctx_->GetTransaction());
      }
    }
  }
  return false;
}

delete_executor

和insert差不多，就是这里的删除操作并不是真正的删除，而是markdelete，只有当事务提交后才会被真正地删除掉。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
DeleteExecutor::DeleteExecutor(ExecutorContext *exec_ctx, const DeletePlanNode *plan,
                               std::unique_ptr<AbstractExecutor> &&child_executor)
    : AbstractExecutor(exec_ctx), plan_(plan) {
  child_executor_ = std::move(child_executor);
  table_info_ = exec_ctx->GetCatalog()->GetTable(plan->TableOid());
  index_info_ = exec_ctx->GetCatalog()->GetTableIndexes(table_info_->name_);
}

void DeleteExecutor::Init() { child_executor_->Init(); }

auto DeleteExecutor::Next([[maybe_unused]] Tuple *tuple, RID *rid) -> bool {
  Tuple child_tuple;
  RID child_tuple_rid;
  while (child_executor_->Next(&child_tuple, &child_tuple_rid)) {
    for (auto index_info : index_info_) {
      auto index_tuple =
          child_tuple.KeyFromTuple(table_info_->schema_, index_info->key_schema_, index_info->index_->GetKeyAttrs());
      index_info->index_->DeleteEntry(index_tuple, child_tuple_rid, exec_ctx_->GetTransaction());
    }
    table_info_->table_->MarkDelete(child_tuple_rid, exec_ctx_->GetTransaction());
  }
  return false;
}

update_executor

和insert以及delete差不多，这里需要注意的一点是：因为我们每次从子节点next一个tuple上来，底层是用迭代器实现的，而在迭代器迭代的时候我们是不能够对一个表进行增删操作的。因此一开始删除我们要把这些tuple存下来，改完后一起插入。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
UpdateExecutor::UpdateExecutor(ExecutorContext *exec_ctx, const UpdatePlanNode *plan,
                               std::unique_ptr<AbstractExecutor> &&child_executor)
    : AbstractExecutor(exec_ctx), plan_(plan) {
  child_executor_ = std::move(child_executor);
  table_info_ = exec_ctx->GetCatalog()->GetTable(plan->TableOid());
  index_info_ = exec_ctx->GetCatalog()->GetTableIndexes(table_info_->name_);
}

void UpdateExecutor::Init() { child_executor_->Init(); }

auto UpdateExecutor::Next([[maybe_unused]] Tuple *tuple, RID *rid) -> bool {
  Tuple child_tuple;
  RID child_tuple_rid;
  std::vector<std::pair<Tuple, RID>> vec;
  while (child_executor_->Next(&child_tuple, &child_tuple_rid)) {
    table_info_->table_->MarkDelete(child_tuple_rid, exec_ctx_->GetTransaction());
    for (auto index_info : index_info_) {
      const auto index_tuple =
          child_tuple.KeyFromTuple(table_info_->schema_, index_info->key_schema_, index_info->index_->GetKeyAttrs());
      index_info->index_->DeleteEntry(index_tuple, child_tuple_rid, exec_ctx_->GetTransaction());
    }
    vec.emplace_back(child_tuple, child_tuple_rid);
  }
  for (auto &tuple_pair : vec) {
    child_tuple = tuple_pair.first;
    child_tuple_rid = tuple_pair.second;
    RID new_tupld_rid;
    auto new_tuple = GenerateUpdatedTuple(child_tuple);
    table_info_->table_->InsertTuple(new_tuple, &new_tupld_rid, exec_ctx_->GetTransaction());
    for (auto index_info : index_info_) {
      const auto index_tuple =
          new_tuple.KeyFromTuple(table_info_->schema_, index_info->key_schema_, index_info->index_->GetKeyAttrs());
      index_info->index_->InsertEntry(index_tuple, new_tupld_rid, exec_ctx_->GetTransaction());
    }
  }

  return false;
}

auto UpdateExecutor::GenerateUpdatedTuple(const Tuple &src_tuple) -> Tuple {
  const auto &update_attrs = plan_->GetUpdateAttr();
  Schema schema = table_info_->schema_;
  uint32_t col_count = schema.GetColumnCount();
  std::vector<Value> values;
  for (uint32_t idx = 0; idx < col_count; idx++) {
    if (update_attrs.find(idx) == update_attrs.cend()) {
      values.emplace_back(src_tuple.GetValue(&schema, idx));
    } else {
      const UpdateInfo info = update_attrs.at(idx);
      Value val = src_tuple.GetValue(&schema, idx);
      switch (info.type_) {
        case UpdateType::Add:
          values.emplace_back(val.Add(ValueFactory::GetIntegerValue(info.update_val_)));
          break;
        case UpdateType::Set:
          values.emplace_back(ValueFactory::GetIntegerValue(info.update_val_));
          break;
      }
    }
  }
  return Tuple{values, &schema};
}

nested_loop_join

注意这里nested_loop_join是可以实现流水线化的！我们保留outer tuple的状态，每次inner获取一个tuple。先判断能不能join，如果能join的话需要重组成一个新的tuple来输出。依据output_schema中每一column的tuple_id和col_id来决定每个value的位置。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
NestedLoopJoinExecutor::NestedLoopJoinExecutor(ExecutorContext *exec_ctx, const NestedLoopJoinPlanNode *plan,
                                               std::unique_ptr<AbstractExecutor> &&left_executor,
                                               std::unique_ptr<AbstractExecutor> &&right_executor)
    : AbstractExecutor(exec_ctx),
      plan_(plan),
      left_executor_(std::move(left_executor)),
      right_executor_(std::move(right_executor)),
      flag_(false) {}

void NestedLoopJoinExecutor::Init() {
  left_executor_->Init();
  right_executor_->Init();
}

auto NestedLoopJoinExecutor::Next(Tuple *tuple, RID *rid) -> bool {
  if (!flag_) {
    flag_ = true;
    if (!left_executor_->Next(&left_tuple_, &left_tuple_rid_)) {
      return false;
    }
  }
  Tuple right_tuple;
  RID right_tuple_rid;
  while (true) {
    bool can_join = false;
    while (right_executor_->Next(&right_tuple, &right_tuple_rid)) {
      if (plan_->Predicate()
              ->EvaluateJoin(&left_tuple_, plan_->GetLeftPlan()->OutputSchema(), &right_tuple,
                             plan_->GetRightPlan()->OutputSchema())
              .GetAs<bool>()) {
        can_join = true;
        break;
      }
    }
    if (!can_join) {
      right_executor_->Init();
      if (!left_executor_->Next(&left_tuple_, &left_tuple_rid_)) {
        return false;
      }
    } else {
      std::vector<Value> values;
      values.reserve(plan_->OutputSchema()->GetColumnCount());
      for (const auto &column : plan_->OutputSchema()->GetColumns()) {
        auto column_expr = dynamic_cast<const ColumnValueExpression *>(column.GetExpr());
        if (column_expr->GetTupleIdx() == 0) {
          values.push_back(left_tuple_.GetValue(plan_->GetLeftPlan()->OutputSchema(), column_expr->GetColIdx()));
        } else {
          values.push_back(right_tuple.GetValue(plan_->GetRightPlan()->OutputSchema(), column_expr->GetColIdx()));
        }
      }
      *tuple = Tuple(values, plan_->OutputSchema());
      *rid = left_tuple_.GetRid();
      return true;
    }
  }
}

hash_join_executor

选用unordered_map来作为hash表，这里与map不同的是，前者是hashmap，后者是treemap，因此如果要让一种类作为key，必须要给这个类重载==运算符和定义hash函数。我们把hash_key（实质上是一个Value）封装成一个类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
namespace bustub {

struct HashJoinKey {
  Value value_;
  bool operator==(const HashJoinKey &other) const { return value_.CompareEquals(other.value_) == CmpBool::CmpTrue; }
};
}  // namespace bustub

namespace std {

template <>
struct hash<bustub::HashJoinKey> {
  auto operator()(const bustub::HashJoinKey &hash_join_key) const -> std::size_t {
    size_t curr_hash = 0;
    const auto &key = hash_join_key.value_;
    if (!key.IsNull()) {
      curr_hash = bustub::HashUtil::CombineHashes(curr_hash, bustub::HashUtil::HashValue(&key));
    }
    return curr_hash;
  }
};
}  // namespace std

必须要在一开始的bustub作用域中定义hashjoinkey类，然后在std作用域中定义偏特化hash类。这里偏特化的意思是指只有bustub::HashJoinKey作为模板参数时，这个类才能被创建。在其中定义调用运算符，返回一个hash值。

接着在后面的bustub作用域中正常实现HashJoinExecutor的定义。顺序是：bustub–std–bustub。而不能是bustub–std，即将std放在最后。因为我们会在HashJoinExecutor中定义一个unordered_map，它会去查找hash类的实现，因此我们要把hash类的定义放在unorderde_map的定义前面。

hash_join是pipeline blocker，我们在init阶段为outer table构建hash table，每次next我们会定位到一个hash table中的一个条目中，这个条目中可能会有多个tuple，因此我们的实现中会保存指向这个条目的指针和一个此条目的迭代器。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
HashJoinExecutor::HashJoinExecutor(ExecutorContext *exec_ctx, const HashJoinPlanNode *plan,
                                   std::unique_ptr<AbstractExecutor> &&left_child,
                                   std::unique_ptr<AbstractExecutor> &&right_child)
    : AbstractExecutor(exec_ctx),
      plan_(plan),
      left_child_(std::move(left_child)),
      right_child_(std::move(right_child)),
      hash_page_(nullptr),
      is_scanned_(false) {}

void HashJoinExecutor::Init() {
  left_child_->Init();
  right_child_->Init();
  // build hash table
  Tuple left_tuple;
  RID left_rid;
  while (left_child_->Next(&left_tuple, &left_rid)) {
    auto value = plan_->LeftJoinKeyExpression()->Evaluate(&left_tuple, plan_->GetLeftPlan()->OutputSchema());
    HashJoinKey hash_join_key{value};  // 可以直接这样初始化？
    if (hash_table_.count(hash_join_key) > 0) {
      hash_table_[hash_join_key].emplace_back(std::move(left_tuple));
    } else {
      hash_table_.insert({hash_join_key, {left_tuple}});
    }
  }
}

auto HashJoinExecutor::Next(Tuple *tuple, RID *rid) -> bool {
  if (!is_scanned_) {
    is_scanned_ = true;
    if (!right_child_->Next(&unhashed_tuple_, rid)) {
      return false;
    }
    unhashed_tuple_key_ =
        HashJoinKey{plan_->RightJoinKeyExpression()->Evaluate(&unhashed_tuple_, plan_->GetRightPlan()->OutputSchema())};
    hash_page_ = &hash_table_[unhashed_tuple_key_];
    cur_ = hash_page_->begin();
  }

  while (true) {
    Tuple left_tuple;
    while (cur_ != hash_page_->end()) {
      auto left_join_key =
          HashJoinKey{plan_->LeftJoinKeyExpression()->Evaluate(&*cur_, plan_->GetLeftPlan()->OutputSchema())};
      left_tuple = *cur_;
      cur_++;
      if (left_join_key == unhashed_tuple_key_) {
        std::vector<Value> values;
        values.reserve(plan_->OutputSchema()->GetColumnCount());
        for (const auto &column : plan_->OutputSchema()->GetColumns()) {
          auto column_expr = dynamic_cast<const ColumnValueExpression *>(column.GetExpr());
          if (column_expr->GetTupleIdx() == 0) {
            values.push_back(left_tuple.GetValue(plan_->GetLeftPlan()->OutputSchema(), column_expr->GetColIdx()));
          } else {
            values.push_back(unhashed_tuple_.GetValue(plan_->GetRightPlan()->OutputSchema(), column_expr->GetColIdx()));
          }
        }
        *tuple = Tuple(values, plan_->OutputSchema());
        *rid = left_tuple.GetRid();
        return true;
      }
    }
    if (!right_child_->Next(&unhashed_tuple_, rid)) {
      return false;
    }
    unhashed_tuple_key_ =
        HashJoinKey{plan_->RightJoinKeyExpression()->Evaluate(&unhashed_tuple_, plan_->GetRightPlan()->OutputSchema())};
    hash_page_ = &hash_table_[unhashed_tuple_key_];
    cur_ = hash_page_->begin();
  }
}

aggregation_executor

和hash_join_executor差不多，当我们把一个元素插入到hash_table的时候，hash_table的条目维护的aggregation的结果，每当我要往这个条目中插入一个新的元素的时候，就会去更新这个条目的信息。

aggregation可能会有having语句，这里的having语句是先根据group_by划分出组后，再来判断每组是否满足条件。

而aggregation是可以pipeline的，因此先把hash_table建好，保存好迭代器信息。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
AggregationExecutor::AggregationExecutor(ExecutorContext *exec_ctx, const AggregationPlanNode *plan,
                                         std::unique_ptr<AbstractExecutor> &&child)
    : AbstractExecutor(exec_ctx),
      plan_(plan),
      child_(std::move(child)),
      aht_(plan->GetAggregates(), plan->GetAggregateTypes()),
      aht_iterator_(aht_.Begin()) {}

void AggregationExecutor::Init() {
  child_->Init();
  Tuple child_tuple;
  RID child_rid;
  aht_.GenerateInitialAggregateValue();
  while (child_->Next(&child_tuple, &child_rid)) {
    aht_.InsertCombine(MakeAggregateKey(&child_tuple), MakeAggregateValue(&child_tuple));
  }
  aht_iterator_ = aht_.Begin();
}

auto AggregationExecutor::Next(Tuple *tuple, RID *rid) -> bool {
  while (aht_iterator_ != aht_.End()) {
    auto temp_iter = aht_iterator_;
    ++aht_iterator_;
    if (plan_->GetHaving() != nullptr &&
        !plan_->GetHaving()->EvaluateAggregate(temp_iter.Key().group_bys_, temp_iter.Val().aggregates_).GetAs<bool>()) {
      continue;
    }
    std::vector<Value> values;
    values.reserve(plan_->OutputSchema()->GetColumnCount());
    for (const auto &column : plan_->OutputSchema()->GetColumns()) {
      auto agg_expr = dynamic_cast<const AggregateValueExpression *>(column.GetExpr());
      values.push_back(agg_expr->EvaluateAggregate(temp_iter.Key().group_bys_, temp_iter.Val().aggregates_));
    }
    *tuple = Tuple(values, plan_->OutputSchema());
    return true;
  }
  return false;
}
赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家