![Nebula Graph 原始碼解讀系列 ｜ Vol.04 基於 RBO 的 Optimizer 實現](https://www-cdn.nebula-graph.com.cn/nebula-blog/nebula-graph-source-code-reading-04.png)

上篇我們講述了一個執行計劃是如何生成的，這次我們來看下這個生成的執行計劃是被 Optimizer 最佳化的。

## 概述

Optimizer，最佳化器，顧名思義就是一個用來最佳化執行計劃的元件。資料庫的最佳化器通常分為兩類，一類是基於規則的最佳化器 RBO（Rule-basd optimizer），一類是基於代價的最佳化 CBO（Cost-based optimizer），前者完全基於預設的最佳化規則進行最佳化，匹配的條件和最佳化的結果都比較固定；後者則會根據收集的資料統計資訊計算不同執行計劃的執行代價，儘量選擇代價最小的執行計劃。

目前 Nebula Graph 主要實現得是 RBO，所以本文也主要集中講述 Nebula Graph 中的 RBO 實現。

## 原始碼定位

最佳化器的原始碼實現都在`src/optimizer`目錄下面，其中的檔案結構如下所示：

```shell
.
├── CMakeLists.txt
├── OptContext.cpp
├── OptContext.h
├── OptGroup.cpp
├── OptGroup.h
├── Optimizer.cpp
├── Optimizer.h
├── OptimizerUtils.cpp
├── OptimizerUtils.h
├── OptRule.cpp
├── OptRule.h
├── rule
│   ├── CombineFilterRule.cpp
│   ├── CombineFilterRule.h
│   ├── EdgeIndexFullScanRule.cpp
│   ├── EdgeIndexFullScanRule.h
|    ....
|
└── test
    ├── CMakeLists.txt
    ├── IndexBoundValueTest.cpp
    └── IndexScanRuleTest.cpp
```

其中`test`目錄是測試，`rule`目錄則是預設的規則集，其他的原始檔則是最佳化器的具體實現。

而最佳化器最佳化查詢的入口則在`src/service/QueryInstance.cpp`檔案中，如下所示：

```C++
Status QueryInstance::validateAndOptimize() {
    auto *rctx = qctx()->rctx();
    VLOG(1) << "Parsing query: " << rctx->query();
    auto result = GQLParser(qctx()).parse(rctx->query());
    NG_RETURN_IF_ERROR(result);
    sentence_ = std::move(result).value();

NG_RETURN_IF_ERROR(Validator::validate(sentence_.get(), qctx()));
    NG_RETURN_IF_ERROR(findBestPlan());

return Status::OK();
}
```

`findBestPlan`函式會呼叫最佳化器，最佳化並返回一個全新的最佳化過的執行計劃。

## 最佳化過程簡述

Nebula Graph 目前設計的執行計劃從拓撲角度來講是一個**有向無環圖**，透過每個節點指向它的依賴節點來組織，理論上每個節點可以指定任意節點的結果作為輸入，但是使用一個還沒執行的節點的結果是沒有意義的，所以在生成執行計劃的時候會**限制只能使用已經執行過的節點作為輸入**。同時，執行計劃也執行迴圈和條件分支這樣的特殊節點。如圖1 所示，該執行計劃由查詢語句`GO 2 STEPS FROM 'Tim Duncan' OVER like`產生。

![Nebula Graph 原始碼解讀系列 ｜ 基於 RBO 的 Optimizer 實現](https://www-cdn.nebula-graph.com.cn/nebula-blog/optimizer-plan-generator.png)

圖1

最佳化器目前的主要功能就是根據預設模式在執行計劃中進行匹配，如果匹配成功，再呼叫相應的轉換函式將匹配到的部分執行計劃按預設的規則進行轉換。比如，將 `GetNeighbor` → `Limit` 形式的執行計劃轉換成 limit 下推的`GetNeighbor`運算元，實現運算元下推最佳化。

## 具體實現

首先，最佳化器不會直接在執行計劃上操作，而是先將執行執行計劃轉換成`OptGroup`、`OptGroupNode`。`OptGroup` 代表的是一個單獨的最佳化組（通常指一個或多個同等的運算元），`OptGroupNode` 則是代表一個獨立的運算元，同時還有指向依賴以及分支的指標，也就是說`OptGroupNode` **保留了執行計劃的拓撲結構**。之所以要做這樣的結構轉換，主要是抽象出執行計劃的拓撲結構，遮蔽掉一些不需要執行細節（比如迴圈和條件分支），以及在新的結構中方便儲存一些規則匹配的上下文。

轉換過程基本上是一個簡單的**先序遍歷**，並在遍歷的過程中把運算元轉換成對應的`OptGroup`以及`OptGroupNode`。為了方便描述，這裡把`OptGroup`以及`OptGroupNode`組成的結構稱為最佳化計劃，和執行計劃做區分。

轉換完成後就會開始匹配規則以及做相應的最佳化計劃轉換。這裡會遍歷所有預定義的規則，而每個規則都會在在最佳化計劃上做一個 Bottom-Up 的遍歷匹配，具體來說就是從最葉子層`OptGroup`開始，一直到根節點的`OptGroup`，在每個`OptGroup`節點上對節點內的`OptGroupNode`做 Top-Down 的遍歷來進行規則模式的匹配。

如圖2 所示，這裡要匹配的模式是`Limit`->`Project`→`GetNeighbors`，按照 Bottom-Up 的順序，首先在`Start`節點按照 Top-Down 的順序匹配，`Start`不等於`Limit`匹配失敗，然後從`GetNeighbors`開始同樣 Top-Down 匹配失敗，直到`Limit`開始才匹配成功。匹配成功後，會根據規則定義的`transform`函式，將匹配到的部分最佳化計劃進行轉換，比如圖2 會將`Limit`和`GetNeighbors`合併。

![Nebula Graph 原始碼解讀系列 ｜ 基於 RBO 的 Optimizer 實現](https://www-cdn.nebula-graph.com.cn/nebula-blog/optimizer-transform.jpeg)

圖2

最後，最佳化器會把已經完成最佳化的最佳化計劃重新轉換成執行計劃，這裡和第一步相反，不過也是一個**遞迴遍歷轉換**的過程。

## 如何新增新規則

在前面的文章中，我們瞭解整個最佳化器元件的實現部分，不過對於新增最佳化規則來說並不需要了解太多最佳化器的實現細節，只需要瞭解如何定義新規則即可。這裡，我們以`Limit`下推為例講解一個典型的最佳化規則的實現。`Limit`下推規則的原始碼詳見`src/optimizer/rule/LimitPushDownRule.cpp`檔案：

```C++

std::unique_ptr<optrule> LimitPushDownRule::kInstance =
    std::unique_ptr<limitpushdownrule>(new LimitPushDownRule());

LimitPushDownRule::LimitPushDownRule() {
    RuleSet::QueryRules().addRule(this);
}

const Pattern &LimitPushDownRule::pattern() const {
    static Pattern pattern =
        Pattern::create(graph::PlanNode::Kind::kLimit,
                        {Pattern::create(graph::PlanNode::Kind::kProject,
                                         {Pattern::create(graph::PlanNode::Kind::kGetNeighbors)})});
    return pattern;
}
```

```C++
StatusOr<:transformresult> LimitPushDownRule::transform(
    OptContext *octx,
    const MatchedResult &matched) const {
    auto limitGroupNode = matched.node;
    auto projGroupNode = matched.dependencies.front().node;
    auto gnGroupNode = matched.dependencies.front().dependencies.front().node;

const auto limit = static_cast<const limit="">(limitGroupNode->node());
    const auto proj = static_cast<const project="">(projGroupNode->node());
    const auto gn = static_cast<const getneighbors="">(gnGroupNode->node());

int64_t limitRows = limit->offset() + limit->count();
    if (gn->limit() >= 0 && limitRows >= gn->limit()) {
        return TransformResult::noTransform();
    }

auto newLimit = static_cast<limit>(limit->clone());
    auto newLimitGroupNode = OptGroupNode::create(octx, newLimit, limitGroupNode->group());

auto newProj = static_cast<project>(proj->clone());
    auto newProjGroup = OptGroup::create(octx);
    auto newProjGroupNode = newProjGroup->makeGroupNode(newProj);

auto newGn = static_cast<getneighbors>(gn->clone());
    newGn->setLimit(limitRows);
    auto newGnGroup = OptGroup::create(octx);
    auto newGnGroupNode = newGnGroup->makeGroupNode(newGn);

newLimitGroupNode->dependsOn(newProjGroup);
    newProjGroupNode->dependsOn(newGnGroup);
    for (auto dep : gnGroupNode->dependencies()) {
        newGnGroupNode->dependsOn(dep);
    }

TransformResult result;
    result.eraseAll = true;
    result.newGroupNodes.emplace_back(newLimitGroupNode);
    return result;
}

std::string LimitPushDownRule::toString() const {
    return "LimitPushDownRule";
}
```

定義一個規則首先先繼承`OptRule`類。然後，實現`pattern`介面，這裡要求返回需要匹配的模式，模式是運算元和運算元的依賴組成，比如`Limit`->`Project`->`GetNeighbors`。然後需要實現`transform`介面，`transform`介面會傳入一個匹配的最佳化計劃，我們根據預定義的模式來解析匹配到的最佳化計劃，並對最佳化計劃做相應的最佳化轉換，比如把`Limit`運算元合併到`GetNeighbors`運算元，最後返回最佳化過的最佳化計劃計劃即可。

只需要正確實現這兩個介面，我們的新的最佳化規則就可以正常工作了。

以上，為 Nebula Graph Optimizer 的介紹。

交流圖資料庫技術？加入 Nebula 交流群請先[填寫下你的 Nebula 名片](https://wj.qq.com/s2/8321168/8e2f/)，Nebula 小助手會拉你進群~~

【活動】Nebula Hackathon 2021 進行中，一起來探索未知，領取 ¥ 150,000 獎金 →→ [https://nebula-graph.com.cn/hackathon/](https://nebula-graph.com.cn/hackathon/)</getneighbors></project></limit></const></const></const></:transformresult></limitpushdownrule></optrule>

Nebula Graph 原始碼解讀系列｜ Vol.04 基於 RBO 的 Optimizer 實現

相關文章

Nebula Graph 原始碼解讀系列 ｜ Vol.04 基於 RBO 的 Optimizer 實現

相關文章

Nebula Graph 原始碼解讀系列｜ Vol.04 基於 RBO 的 Optimizer 實現