diff --git a/docs-2.0/3.ngql-guide/7.general-query-statements/2.match.md b/docs-2.0/3.ngql-guide/7.general-query-statements/2.match.md
index 21b3e98ead..0a0d58ff37 100644
--- a/docs-2.0/3.ngql-guide/7.general-query-statements/2.match.md
+++ b/docs-2.0/3.ngql-guide/7.general-query-statements/2.match.md
@@ -2,9 +2,9 @@
 
 `MATCH`语句提供基于模式（pattern）匹配的搜索功能。
 
-一个`MATCH`语句定义了一个[搜索模式](../1.nGQL-overview/3.graph-patterns.md)，用该模式匹配存储在Nebula Graph中的数据，然后用`RETURN`子句检索数据。
+一个`MATCH`语句定义了一个 [搜索模式](../1.nGQL-overview/3.graph-patterns.md)，用该模式匹配存储在 Nebula Graph 中的数据，然后用`RETURN`子句检索数据。
 
-本文示例使用测试数据集[basketballplayer](../1.nGQL-overview/1.overview.md#basketballplayer)进行演示。
+本文示例使用测试数据集 [basketballplayer](../1.nGQL-overview/1.overview.md#basketballplayer) 进行演示。
 
 ## 语法
 
@@ -14,36 +14,36 @@
 MATCH <pattern> [<WHERE clause>] RETURN <output>;
 ```
 
-## MATCH工作流程
+## MATCH 工作流程
 
-1. `MATCH`语句使用原生索引查找起始点或边，起始点或边可以在模式的任何位置。即一个有效的`MATCH`语句，**必须有一个属性、Tag或Edge type已经创建索引，或者在`WHERE`子句中用id()函数指定了特定点的VID**。如何创建索引，请参见[创建原生索引](../14.native-index-statements/1.create-native-index.md)。
+1. `MATCH`语句使用原生索引查找起始点或边，起始点或边可以在模式的任何位置。即一个有效的`MATCH`语句，**必须有一个属性、Tag 或 Edge type 已经创建索引，或者在`WHERE`子句中用 id() 函数指定了特定点的 VID**。如何创建索引，请参见 [创建原生索引](../14.native-index-statements/1.create-native-index.md)。
 
 2. `MATCH`语句在模式中搜索，寻找匹配的边或点。
 
   !!! note
 
-        `MATCH`语句采用的路径类型是`trail`，即遍历时只有点可以重复，边不可以重复。详情请参见[路径](../../1.introduction/2.1.path.md)。
+        `MATCH`语句采用的路径类型是`trail`，即遍历时只有点可以重复，边不可以重复。详情请参见 [路径](../../1.introduction/2.1.path.md)。
 
 3. `MATCH`语句根据`RETURN`子句检索数据。
 
-## openCypher兼容性
+## openCypher 兼容性
 
-- nGQL不支持遍历所有点和边，例如`MATCH (v) RETURN v`。但是，建立相应Tag的索引后，可以遍历对应Tag的所有点，例如`MATCH (v:T1) RETURN v`。
+- nGQL 不支持遍历所有点和边，例如`MATCH (v) RETURN v`。但是，建立相应 Tag 的索引后，可以遍历对应 Tag 的所有点，例如`MATCH (v:T1) RETURN v`。
 
-- WHERE子句内不支持图模式。
+- WHERE 子句内不支持图模式。
 
 ## 使用模式（pattern）
 
 ### 前提条件
 
-请确保`MATCH`语句有至少一个索引可用，或者其中指定了VID。如果需要创建索引，但是已经有相关的点、边或属性，用户必须在创建索引后重建索引，索引才能生效。
+请确保`MATCH`语句有至少一个索引可用，或者其中指定了 VID。如果需要创建索引，但是已经有相关的点、边或属性，用户必须在创建索引后重建索引，索引才能生效。
 
 !!! caution
 
-    索引会导致写性能大幅降低（降低90%甚至更多）。请**不要随意**在生产环境中使用索引，除非很清楚使用索引对业务的影响。
+    索引会导致写性能大幅降低（降低 90%甚至更多）。请**不要随意**在生产环境中使用索引，除非很清楚使用索引对业务的影响。
 
 ```ngql
-# 在Tag player的name属性和Edge type follow上创建索引。
+# 在 Tag player 的 name 属性和 Edge type follow 上创建索引。
 nebula> CREATE TAG INDEX IF NOT EXISTS name ON player(name(20));
 nebula> CREATE EDGE INDEX IF NOT EXISTS follow_index on follow();
 
@@ -62,7 +62,6 @@ nebula> REBUILD EDGE INDEX follow_index;
 | 122        |
 +------------+
 
-
 # 确认重建索引成功。
 nebula> SHOW JOB 121;
 +----------------+---------------------+------------+----------------------------+----------------------------+
@@ -95,7 +94,7 @@ nebula> SHOW JOB 122;
 
     匹配 Tag 的前提是 Tag 本身有索引或者 Tag 的某个属性有索引，否则，用户无法基于该 Tag 执行 `MATCH` 语句。
 
-用户可以在点的右侧用`:<tag_name>`表示模式中的Tag。
+用户可以在点的右侧用`:<tag_name>`表示模式中的 Tag。
 
 ```ngql
 nebula> MATCH (v:player) \
@@ -115,10 +114,10 @@ nebula> MATCH (v:player) \
 
     匹配点的属性的前提是 Tag 本身有对应属性的索引，否则，用户无法执行 `MATCH` 语句匹配该属性。
 
-用户可以在Tag的右侧用`{<prop_name>: <prop_value>}`表示模式中点的属性。
+用户可以在 Tag 的右侧用`{<prop_name>: <prop_value>}`表示模式中点的属性。
 
 ```ngql
-# 使用属性name搜索匹配的点。
+# 使用属性 name 搜索匹配的点。
 nebula> MATCH (v:player{name:"Tim Duncan"}) \
         RETURN v;
 +----------------------------------------------------+
@@ -141,13 +140,13 @@ nebula> MATCH (v:player) \
 +----------------------------------------------------+
 ```
 
-!!! compatibility "openCypher兼容性"
+!!! compatibility "openCypher 兼容性"
 
-    在openCypher 9中，`=`是相等运算符，在nGQL中，`==`是相等运算符，`=`是赋值运算符。
+    在 openCypher 9 中，`=`是相等运算符，在 nGQL 中，`==`是相等运算符，`=`是赋值运算符。
 
-### 匹配点ID
+### 匹配点 ID
 
-用户可以使用点ID去匹配点。`id()`函数可以检索点的ID。
+用户可以使用点 ID 去匹配点。`id()`函数可以检索点的 ID。
 
 ```ngql
 nebula> MATCH (v) \
@@ -160,7 +159,7 @@ nebula> MATCH (v) \
 +-----------------------------------------------------+
 ```
 
-要匹配多个点的ID，可以用`WHERE id(v) IN [vid_list]`。
+要匹配多个点的 ID，可以用`WHERE id(v) IN [vid_list]`。
 
 ```ngql
 nebula> MATCH (v:player { name: 'Tim Duncan' })--(v2) \
@@ -170,7 +169,6 @@ nebula> MATCH (v:player { name: 'Tim Duncan' })--(v2) \
 | v2                                                        |
 +-----------------------------------------------------------+
 | ("player101" :player{age: 36, name: "Tony Parker"})       |
-| ("player101" :player{age: 36, name: "Tony Parker"})       |
 | ("player102" :player{age: 33, name: "LaMarcus Aldridge"}) |
 +-----------------------------------------------------------+
 ```
@@ -181,7 +179,7 @@ nebula> MATCH (v:player { name: 'Tim Duncan' })--(v2) \
 
 !!! compatibility "历史版本兼容性"
 
-    在nGQL 1.x中，`--`符号用于行内注释，在nGQL 2.x中，`--`符号表示出边或入边，不再用于注释。
+    在 nGQL 1.x 中，`--`符号用于行内注释，在 nGQL 2.x 中，`--`符号表示出边或入边，不再用于注释。
 
 ```ngql
 nebula> MATCH (v:player{name:"Tim Duncan"})--(v2) \
@@ -199,7 +197,7 @@ nebula> MATCH (v:player{name:"Tim Duncan"})--(v2) \
 用户可以在`--`符号上增加`<`或`>`符号指定边的方向。
 
 ```ngql
-# -->表示边从v开始，指向v2。对于点v来说是出边，对于点v2来说是入边。
+# -->表示边从 v 开始，指向 v2。对于点 v 来说是出边，对于点 v2 来说是入边。
 nebula> MATCH (v:player{name:"Tim Duncan"})-->(v2) \
         RETURN v2.name AS Name;
 +-----------------+
@@ -255,9 +253,9 @@ nebula> MATCH p=(v:player{name:"Tim Duncan"})-->(v2) \
 +--------------------------------------------------------------------------------------------------------------------------------------+
 ```
 
-!!! compatibility "openCypher兼容性"
+!!! compatibility "openCypher 兼容性"
 
-    在nGQL中，`@`符号表示边的rank，在openCypher中，没有rank概念。
+    在 nGQL 中，`@`符号表示边的 rank，在 openCypher 中，没有 rank 概念。
 
 ### 匹配边
 
@@ -275,9 +273,9 @@ nebula> MATCH (v:player{name:"Tim Duncan"})-[e]-(v2) \
 ...
 ```
 
-### 匹配Edge type
+### 匹配 Edge type
 
-和点一样，用户可以用`:<edge_type>`表示模式中的Edge type，例如`-[e:follow]-`。
+和点一样，用户可以用`:<edge_type>`表示模式中的 Edge type，例如`-[e:follow]-`。
 
 ```ngql
 nebula> MATCH ()-[e:follow]-() \
@@ -297,7 +295,7 @@ nebula> MATCH ()-[e:follow]-() \
 
     匹配边的属性的前提是 Edge type 本身有对应属性的索引，否则，用户无法执行 `MATCH` 语句匹配该属性。
 
-用户可以用`{<prop_name>: <prop_value>}`表示模式中Edge type的属性，例如`[e:follow{likeness:95}]`。
+用户可以用`{<prop_name>: <prop_value>}`表示模式中 Edge type 的属性，例如`[e:follow{likeness:95}]`。
 
 ```ngql
 nebula> MATCH (v:player{name:"Tim Duncan"})-[e:follow{degree:95}]->(v2) \
@@ -310,9 +308,9 @@ nebula> MATCH (v:player{name:"Tim Duncan"})-[e:follow{degree:95}]->(v2) \
 +--------------------------------------------------------+
 ```
 
-### 匹配多个Edge type
+### 匹配多个 Edge type
 
-使用`|`可以匹配多个Edge type，例如`[e:follow|:serve]`。第一个Edge type前的英文冒号（:）不可省略，后续Edge type前的英文冒号可以省略，例如`[e:follow|serve]`。
+使用`|`可以匹配多个 Edge type，例如`[e:follow|:serve]`。第一个 Edge type 前的英文冒号（:）不可省略，后续 Edge type 前的英文冒号可以省略，例如`[e:follow|serve]`。
 
 ```ngql
 nebula> MATCH (v:player{name:"Tim Duncan"})-[e:follow|:serve]->(v2) \
@@ -358,7 +356,7 @@ nebula> MATCH p=(v:player{name:"Tim Duncan"})-[e:follow*2]->(v2) \
 +-----------------------------------------------------------+
 ```
 
-如果`hop`为0，模式会匹配路径上的起始点。
+如果`hop`为 0，模式会匹配路径上的起始点。
 
 ```ngql
 nebula> MATCH (v:player{name:"Tim Duncan"}) -[*0]-> (v2) \
@@ -376,12 +374,12 @@ nebula> MATCH (v:player{name:"Tim Duncan"}) -[*0]-> (v2) \
 
 |参数|说明|
 |:---|:---|
-|`minHop`|可选项。表示路径的最小长度。`minHop`必须是一个非负整数，默认值为1。|
+|`minHop`|可选项。表示路径的最小长度。`minHop`必须是一个非负整数，默认值为 1。|
 |`maxHop`|必选项。表示路径的最大长度。`maxHop`必须是一个非负整数，没有默认值。|
 
-!!! compatibility "openCypher兼容性"
+!!! compatibility "openCypher 兼容性"
 
-    在openCypher中，`maxHop`是可选项，默认为无穷大。当没有设置时，`..`可以省略。在nGQL中，`maxHop`是必选项，而且`..`不可以省略。
+    在 openCypher 中，`maxHop`是可选项，默认为无穷大。当没有设置时，`..`可以省略。在 nGQL 中，`maxHop`是必选项，而且`..`不可以省略。
 
 ```ngql
 nebula> MATCH p=(v:player{name:"Tim Duncan"})-[e:follow*1..3]->(v2) \
@@ -425,9 +423,9 @@ nebula> MATCH p=(v:player{name:"Tim Duncan"})-[e:follow*0..3]->(v2:player) \
 +-----------------------------------------------------------+-----------+
 ```
 
-### 匹配多个Edge type的变长路径
+### 匹配多个 Edge type 的变长路径
 
-用户可以在变长或定长模式中指定多个Edge type。`hop`、`minHop`和`maxHop`对所有Edge type都生效。
+用户可以在变长或定长模式中指定多个 Edge type。`hop`、`minHop`和`maxHop`对所有 Edge type 都生效。
 
 ```ngql
 nebula> MATCH p=(v:player{name:"Tim Duncan"})-[e:follow|serve*2]->(v2) \
@@ -469,9 +467,9 @@ nebula> MATCH (v:player{name:"Tim Duncan"})-[e]->(v2) \
 +-----------------------------------------------------------------------+
 ```
 
-### 检索点ID
+### 检索点 ID
 
-使用`id()`函数检索点ID。
+使用`id()`函数检索点 ID。
 
 ```ngql
 nebula> MATCH (v:player{name:"Tim Duncan"}) \
@@ -483,9 +481,9 @@ nebula> MATCH (v:player{name:"Tim Duncan"}) \
 +-------------+
 ```
 
-### 检索Tag
+### 检索 Tag
 
-使用`labels()`函数检索点上的Tag列表。
+使用`labels()`函数检索点上的 Tag 列表。
 
 ```ngql
 nebula> MATCH (v:player{name:"Tim Duncan"}) \
@@ -497,7 +495,7 @@ nebula> MATCH (v:player{name:"Tim Duncan"}) \
 +------------+
 ```
 
-检索列表`labels(v)`中的第N个元素，可以使用`labels(v)[n-1]`。例如下面示例使用`labels(v)[0]`检索第一个元素。
+检索列表`labels(v)`中的第 N 个元素，可以使用`labels(v)[n-1]`。例如下面示例使用`labels(v)[0]`检索第一个元素。
 
 ```ngql
 nebula> MATCH (v:player{name:"Tim Duncan"}) \
@@ -551,9 +549,9 @@ nebula> MATCH p=(v:player{name:"Tim Duncan"})-[]->(v2) \
 +----------------------------------+
 ```
 
-### 检索Edge type
+### 检索 Edge type
 
-使用`type()`函数检索匹配的Edge type。
+使用`type()`函数检索匹配的 Edge type。
 
 ```ngql
 nebula> MATCH p=(v:player{name:"Tim Duncan"})-[e]->() \
@@ -640,4 +638,4 @@ nebula> MATCH p=(v:player{name:"Tim Duncan"})-[*..2]->(v2) \
 
 !!! Performance
 
-    Nebula Graph中`MATCH`语句的性能和资源占用得到了优化，但对性能要求较高时，仍建议使用 `GO`, `LOOKUP`, `|` 和 `FETCH` 等来替代`MATCH`。
+    Nebula Graph 中`MATCH`语句的性能和资源占用得到了优化，但对性能要求较高时，仍建议使用 `GO`, `LOOKUP`, `|` 和 `FETCH` 等来替代`MATCH`。
diff --git a/docs-2.0/3.ngql-guide/7.general-query-statements/3.go.md b/docs-2.0/3.ngql-guide/7.general-query-statements/3.go.md
index d7fa4c0b7e..7550bbf2f0 100644
--- a/docs-2.0/3.ngql-guide/7.general-query-statements/3.go.md
+++ b/docs-2.0/3.ngql-guide/7.general-query-statements/3.go.md
@@ -2,9 +2,9 @@
 
 `GO`用指定的过滤条件遍历图，并返回结果。
 
-## openCypher兼容性
+## openCypher 兼容性
 
-本文操作仅适用于原生nGQL。
+本文操作仅适用于原生 nGQL。
 
 ## 语法
 
@@ -29,46 +29,46 @@ OVER <edge_type_list> [{REVERSELY | BIDIRECT}]
     <col_name> [AS <col_alias>] [, <col_name> [AS <col_alias>] ...]
 ```
 
-- `<N> STEPS`：指定跳数。如果没有指定跳数，默认值`N`为`1`。如果`N`为`0`，Nebula Graph不会检索任何边。
+- `<N> STEPS`：指定跳数。如果没有指定跳数，默认值`N`为`1`。如果`N`为`0`，Nebula Graph 不会检索任何边。
 
   !!! note
 
-        `GO`语句采用的路径类型是`walk`，即遍历时点和边可以重复。详情参见[路径](../../1.introduction/2.1.path.md)。
+        `GO`语句采用的路径类型是`walk`，即遍历时点和边可以重复。详情参见 [路径](../../1.introduction/2.1.path.md)。
 
 - `M TO N STEPS`：遍历`M~N`跳的边。如果`M`为`0`，输出结果和`M`为`1`相同，即`GO 0 TO 2`和`GO 1 TO 2`是相同的。
 
-- `<vertex_list>`：用逗号分隔的点ID列表，或特殊的引用符`$-.id`。详情参见[管道符](../5.operators/4.pipe.md)。
+- `<vertex_list>`：用逗号分隔的点 ID 列表，或特殊的引用符`$-.id`。详情参见 [管道符](../5.operators/4.pipe.md)。
 
-- `<edge_type_list>`：遍历的Edge type列表。
+- `<edge_type_list>`：遍历的 Edge type 列表。
 
 - `REVERSELY | BIDIRECT`：默认情况下检索的是`<vertex_list>`的出边（正向），`REVERSELY`表示反向，即检索入边；`BIDIRECT` 为双向，即检索正向和反向，通过返回 `<edge_type>._type` 字段判断方向，其正数为正向，负数为反向。
 
-- `WHERE <conditions>`：指定遍历的过滤条件。用户可以在起始点、目的点和边使用`WHERE`子句，还可以结合`AND`、`OR`、`NOT`、`XOR`一起使用。详情参见[WHERE](../8.clauses-and-options/where.md)。
+- `WHERE <conditions>`：指定遍历的过滤条件。用户可以在起始点、目的点和边使用`WHERE`子句，还可以结合`AND`、`OR`、`NOT`、`XOR`一起使用。详情参见 [WHERE](../8.clauses-and-options/where.md)。
 
   !!! Note
 
-        遍历多个Edge type时，`WHERE`子句有一些限制。例如不支持`WHERE edge1.prop1 > edge2.prop2`。
+        遍历多个 Edge type 时，`WHERE`子句有一些限制。例如不支持`WHERE edge1.prop1 > edge2.prop2`。
 
-- `YIELD [DISTINCT] <return_list>`：定义需要返回的输出。` <return_list>`建议使用[Schema函数](../6.functions-and-expressions/4.schema.md)，当前支持`src(edge)`、`dst(edge)`、`type(edge)`、`rank(edge)`、`properties(edge)`、`id(vertex)`、`properties(vertex)`，暂不支持嵌套函数。详情参见[YIELD](../8.clauses-and-options/yield.md)。如果没有指定，默认返回目的点ID。
+- `YIELD [DISTINCT] <return_list>`：定义需要返回的输出。` <return_list>`建议使用 [Schema 函数](../6.functions-and-expressions/4.schema.md)，当前支持`src(edge)`、`dst(edge)`、`type(edge)`、`rank(edge)`、`properties(edge)`、`id(vertex)`、`properties(vertex)`，暂不支持嵌套函数。详情参见 [YIELD](../8.clauses-and-options/yield.md)。如果没有指定，默认返回目的点 ID。
 
-- `SAMPLE <sample_list>`：用于在结果集中取样。详情参见[SAMPLE](../8.clauses-and-options/sample.md)。
+- `SAMPLE <sample_list>`：用于在结果集中取样。详情参见 [SAMPLE](../8.clauses-and-options/sample.md)。
 
-- `LIMIT <limit_list>`：用于在遍历过程中逐步限制输出数量。详情参见[LIMIT](../8.clauses-and-options/limit.md)。
+- `LIMIT <limit_list>`：用于在遍历过程中逐步限制输出数量。详情参见 [LIMIT](../8.clauses-and-options/limit.md)。
 
-- `GROUP BY`：根据指定属性的值将输出分组。详情参见[GROUP BY](../8.clauses-and-options/group-by.md)。分组后需要再次使用`YIELD`定义需要返回的输出。
+- `GROUP BY`：根据指定属性的值将输出分组。详情参见 [GROUP BY](../8.clauses-and-options/group-by.md)。分组后需要再次使用`YIELD`定义需要返回的输出。
 
-- `ORDER BY`：指定输出结果的排序规则。详情参见[ORDER BY](../8.clauses-and-options/order-by.md)。
+- `ORDER BY`：指定输出结果的排序规则。详情参见 [ORDER BY](../8.clauses-and-options/order-by.md)。
 
   !!! Note
 
         没有指定排序规则时，输出结果的顺序不是固定的。
 
-- `LIMIT  [<offset>,] <number_rows>]`：限制输出结果的行数。详情参见[LIMIT](../8.clauses-and-options/limit.md)。
+- `LIMIT  [<offset>,] <number_rows>]`：限制输出结果的行数。详情参见 [LIMIT](../8.clauses-and-options/limit.md)。
 
 ## 示例
 
 ```ngql
-# 返回player102所属队伍。
+# 返回 player102 所属队伍。
 nebula> GO FROM "player102" OVER serve;
 +------------+
 | serve._dst |
@@ -79,7 +79,7 @@ nebula> GO FROM "player102" OVER serve;
 ```
 
 ```ngql
-# 返回距离player102两跳的朋友。
+# 返回距离 player102 两跳的朋友。
 nebula> GO 2 STEPS FROM "player102" OVER follow;
 +-------------+
 | follow._dst |
@@ -106,20 +106,19 @@ nebula> GO FROM "player100", "player102" OVER serve \
 ```
 
 ```ngql
-# 遍历多个Edge type。属性没有值时，会显示UNKNOWN_PROP。
+# 遍历多个 Edge type。属性没有值时，会显示 UNKNOWN_PROP。
 nebula> GO FROM "player100" OVER follow, serve \
         YIELD properties(edge).degree, properties(edge).start_year;
 +-------------------------+-----------------------------+
 | properties(EDGE).degree | properties(EDGE).start_year |
 +-------------------------+-----------------------------+
 | 95                      | UNKNOWN_PROP                |
-| 95                      | UNKNOWN_PROP                |
 | UNKNOWN_PROP            | 1997                        |
 +-------------------------+-----------------------------+
 ```
 
 ```ngql
-# 返回player100入方向的邻居点。
+# 返回 player100 入方向的邻居点。
 nebula> GO FROM "player100" OVER follow REVERSELY \
         YIELD src(edge) AS destination;
 +-------------+
@@ -130,7 +129,7 @@ nebula> GO FROM "player100" OVER follow REVERSELY \
 +-------------+
 ...
 
-# 该MATCH查询与上一个GO查询具有相同的语义。
+# 该 MATCH 查询与上一个 GO 查询具有相同的语义。
 nebula> MATCH (v)<-[e:follow]- (v2) WHERE id(v) == 'player100' \
         RETURN id(v2) AS destination;
 +-------------+
@@ -143,7 +142,7 @@ nebula> MATCH (v)<-[e:follow]- (v2) WHERE id(v) == 'player100' \
 ```
 
 ```ngql
-# 查询player100的朋友和朋友所属队伍。
+# 查询 player100 的朋友和朋友所属队伍。
 nebula> GO FROM "player100" OVER follow REVERSELY \
         YIELD src(edge) AS id | \
         GO FROM $-.id OVER serve \
@@ -157,7 +156,7 @@ nebula> GO FROM "player100" OVER follow REVERSELY \
 | "Boris Diaw"        | "Suns"          |
 ...
 
-# 该MATCH查询与上一个GO查询具有相同的语义。
+# 该 MATCH 查询与上一个 GO 查询具有相同的语义。
 nebula> MATCH (v)<-[e:follow]- (v2)-[e2:serve]->(v3)  \
         WHERE id(v) == 'player100' \
         RETURN v2.name AS FriendOf, v3.name AS Team;
@@ -171,7 +170,7 @@ nebula> MATCH (v)<-[e:follow]- (v2)-[e2:serve]->(v3)  \
 ```
 
 ```ngql
-# 查询player100 1~2跳内的朋友。
+# 查询 player100 1~2 跳内的朋友。
 nebula> GO 1 TO 2 STEPS FROM "player100" OVER follow \
         YIELD dst(edge) AS destination;
 +-------------+
@@ -181,7 +180,7 @@ nebula> GO 1 TO 2 STEPS FROM "player100" OVER follow \
 | "player125" |
 ...
 
-# 该MATCH查询与上一个GO查询具有相同的语义。
+# 该 MATCH 查询与上一个 GO 查询具有相同的语义。
 nebula> MATCH (v) -[e:follow*1..2]->(v2) \
         WHERE id(v) == "player100" \
         RETURN id(v2) AS destination;
@@ -223,7 +222,7 @@ nebula> $a = GO FROM "player100" OVER follow YIELD src(edge) AS src, dst(edge) A
 ```
 
 ```ngql
-# 在多个边上通过IS NOT EMPTY进行判断。
+# 在多个边上通过 IS NOT EMPTY 进行判断。
 nebula> GO FROM "player100" OVER follow WHERE properties($$).name IS NOT EMPTY YIELD dst(edge);
 +-------------+
 | dst(EDGE)   |
diff --git a/docs-2.0/3.ngql-guide/7.general-query-statements/4.fetch.md b/docs-2.0/3.ngql-guide/7.general-query-statements/4.fetch.md
index 571fa7c51c..2a38839774 100644
--- a/docs-2.0/3.ngql-guide/7.general-query-statements/4.fetch.md
+++ b/docs-2.0/3.ngql-guide/7.general-query-statements/4.fetch.md
@@ -1,12 +1,12 @@
 # FETCH
 
-<!-- 3.0强制使用YIELD后需要修改本文档，参考 https://confluence.nebula-graph.io/pages/viewpage.action?pageId=10723963 -->
+<!-- 3.0 强制使用 YIELD 后需要修改本文档，参考 https://confluence.nebula-graph.io/pages/viewpage.action?pageId=10723963 -->
 
 `FETCH`可以获取指定点或边的属性值。
 
-## openCypher兼容性
+## openCypher 兼容性
 
-本文操作仅适用于原生nGQL。
+本文操作仅适用于原生 nGQL。
 
 ## 获取点的属性值
 
@@ -20,15 +20,15 @@ FETCH PROP ON {<tag_name>[, tag_name ...] | *}
 
 |参数|说明|
 |:---|:---|
-|`tag_name`|Tag名称。|
-|`*`|表示当前图空间中的所有Tag。|
-|`vid`|点ID。|
-|`YIELD`|定义需要返回的输出。除了返回定义的属性，额外返回`VertexID`。详情请参见[`YIELD`](../8.clauses-and-options/yield.md)。如果没有`YIELD`子句，默认返回`vertices_`，包含点的所有信息。|
+|`tag_name`|Tag 名称。|
+|`*`|表示当前图空间中的所有 Tag。|
+|`vid`|点 ID。|
+|`YIELD`|定义需要返回的输出。除了返回定义的属性，额外返回`VertexID`。详情请参见 [`YIELD`](../8.clauses-and-options/yield.md)。如果没有`YIELD`子句，默认返回`vertices_`，包含点的所有信息。|
 |`AS`| 设置别名。|
 
-### 基于Tag获取点的属性值
+### 基于 Tag 获取点的属性值
 
-在`FETCH`语句中指定Tag获取对应点的属性值。
+在`FETCH`语句中指定 Tag 获取对应点的属性值。
 
 ```ngql
 nebula> FETCH PROP ON player "player100";
@@ -55,7 +55,7 @@ nebula> FETCH PROP ON player "player100" \
 
 ### 获取多个点的属性值
 
-指定多个点ID获取多个点的属性值，点之间用英文逗号（,）分隔。
+指定多个点 ID 获取多个点的属性值，点之间用英文逗号（,）分隔。
 
 ```ngql
 nebula> FETCH PROP ON player "player101", "player102", "player103";
@@ -68,18 +68,18 @@ nebula> FETCH PROP ON player "player101", "player102", "player103";
 +-----------------------------------------------------------+
 ```
 
-### 基于多个Tag获取点的属性值
+### 基于多个 Tag 获取点的属性值
 
-在`FETCH`语句中指定多个Tag获取属性值。Tag之间用英文逗号（,）分隔。
+在`FETCH`语句中指定多个 Tag 获取属性值。Tag 之间用英文逗号（,）分隔。
 
 ```ngql
-# 创建新Tag t1。
+# 创建新 Tag t1。
 nebula> CREATE TAG IF NOT EXISTS t1(a string, b int);
 
-# 为点player100添加Tag t1。
+# 为点 player100 添加 Tag t1。
 nebula> INSERT VERTEX t1(a, b) VALUE "player100":("Hello", 100);
 
-# 基于Tag player和t1获取点player100上的属性值。
+# 基于 Tag player 和 t1 获取点 player100 上的属性值。
 nebula> FETCH PROP ON player, t1 "player100";
 +----------------------------------------------------------------------------+
 | vertices_                                                                  |
@@ -88,7 +88,7 @@ nebula> FETCH PROP ON player, t1 "player100";
 +----------------------------------------------------------------------------+
 ```
 
- 用户可以在`FETCH`语句中组合多个Tag和多个点。
+ 用户可以在`FETCH`语句中组合多个 Tag 和多个点。
 
 ```ngql
 nebula> FETCH PROP ON player, t1 "player100", "player103";
@@ -126,16 +126,16 @@ FETCH PROP ON <edge_type> <src_vid> -> <dst_vid>[@<rank>] [, <src_vid> -> <dst_v
 
 |参数|说明|
 |:---|:---|
-|`edge_type`|Edge type名称。|
-|`src_vid`|起始点ID，表示边的起点。|
-|`dst_vid`|目的点ID，表示边的终点。|
-|`rank`|边的rank。可选参数，默认值为`0`。起始点、目的点、Edge type和rank可以唯一确定一条边。|
-|`YIELD`|定义需要返回的输出。除了返回定义的属性，额外返回`起始点ID`、`目的点ID`和`rank`。详情请参见[`YIELD`](../8.clauses-and-options/yield.md)。如果没有`YIELD`子句，默认返回`edges_`，包含边的所有信息。|
+|`edge_type`|Edge type 名称。|
+|`src_vid`|起始点 ID，表示边的起点。|
+|`dst_vid`|目的点 ID，表示边的终点。|
+|`rank`|边的 rank。可选参数，默认值为`0`。起始点、目的点、Edge type 和 rank 可以唯一确定一条边。|
+|`YIELD`|定义需要返回的输出。除了返回定义的属性，额外返回`起始点 ID`、`目的点 ID`和`rank`。详情请参见 [`YIELD`](../8.clauses-and-options/yield.md)。如果没有`YIELD`子句，默认返回`edges_`，包含边的所有信息。|
 
 ### 获取边的所有属性值
 
 ```ngql
-# 获取连接player100和team204的边serve的所有属性值。
+# 获取连接 player100 和 team204 的边 serve 的所有属性值。
 nebula> FETCH PROP ON serve "player100" -> "team204";
 +-----------------------------------------------------------------------+
 | edges_                                                                |
@@ -160,7 +160,7 @@ nebula> FETCH PROP ON serve "player100" -> "team204"    \
 
 ### 获取多条边的属性值
 
-指定多个边模式(`<src_vid> -> <dst_vid>[@<rank>]`)获取多个边的属性值。模式之间用英文逗号（,）分隔。
+指定多个边模式 (`<src_vid> -> <dst_vid>[@<rank>]`) 获取多个边的属性值。模式之间用英文逗号（,）分隔。
 
 ```ngql
 nebula> FETCH PROP ON serve "player100" -> "team204", "player133" -> "team202";
@@ -172,19 +172,19 @@ nebula> FETCH PROP ON serve "player100" -> "team204", "player133" -> "team202";
 +-----------------------------------------------------------------------+
 ```
 
-### 基于rank获取属性值
+### 基于 rank 获取属性值
 
-如果有多条边，起始点、目的点和Edge type都相同，可以通过指定rank获取正确的边属性值。
+如果有多条边，起始点、目的点和 Edge type 都相同，可以通过指定 rank 获取正确的边属性值。
 
 ```ngql
-# 插入不同属性值、不同rank的边。
+# 插入不同属性值、不同 rank 的边。
 nebula> insert edge serve(start_year,end_year) \
         values "player100"->"team204"@1:(1998, 2017);
 
 nebula> insert edge serve(start_year,end_year) \
         values "player100"->"team204"@2:(1990, 2018);
 
-# 默认返回rank为0的边。
+# 默认返回 rank 为 0 的边。
 nebula> FETCH PROP ON serve "player100" -> "team204";
 +-----------------------------------------------------------------------+
 | edges_                                                                |
@@ -192,7 +192,7 @@ nebula> FETCH PROP ON serve "player100" -> "team204";
 | [:serve "player100"->"team204" @0 {end_year: 2016, start_year: 1997}] |
 +-----------------------------------------------------------------------+
 
-# 要获取rank不为0的边，请在FETCH语句中设置rank。
+# 要获取 rank 不为 0 的边，请在 FETCH 语句中设置 rank。
 nebula> FETCH PROP ON serve "player100" -> "team204"@1;
 +-----------------------------------------------------------------------+
 | edges_                                                                |
@@ -201,12 +201,12 @@ nebula> FETCH PROP ON serve "player100" -> "team204"@1;
 +-----------------------------------------------------------------------+
 ```
 
-## 复合语句中使用FETCH
+## 复合语句中使用 FETCH
 
-将`FETCH`与原生nGQL结合使用是一种常见的方式，例如和`GO`一起。
+将`FETCH`与原生 nGQL 结合使用是一种常见的方式，例如和`GO`一起。
 
 ```ngql
-# 返回从点player101开始的follow边的degree值。
+# 返回从点 player101 开始的 follow 边的 degree 值。
 nebula> GO FROM "player101" OVER follow \
         YIELD src(edge) AS s, dst(edge) AS d \
         | FETCH PROP ON follow $-.s -> $-.d \
@@ -236,4 +236,4 @@ nebula> $var = GO FROM "player101" OVER follow \
 +-------------+-------------+--------------+-------------------------+
 ```
 
-更多复合语句的详情，请参见[复合查询（子句结构）](../4.variable-and-composite-queries/1.composite-queries.md)。
+更多复合语句的详情，请参见 [复合查询（子句结构）](../4.variable-and-composite-queries/1.composite-queries.md)。
diff --git a/docs-2.0/3.ngql-guide/7.general-query-statements/5.lookup.md b/docs-2.0/3.ngql-guide/7.general-query-statements/5.lookup.md
index 2cbdad4273..f2b261763a 100644
--- a/docs-2.0/3.ngql-guide/7.general-query-statements/5.lookup.md
+++ b/docs-2.0/3.ngql-guide/7.general-query-statements/5.lookup.md
@@ -1,24 +1,24 @@
 # LOOKUP
 
-<!-- 3.0强制使用YIELD后需要修改本文档，参考 https://confluence.nebula-graph.io/pages/viewpage.action?pageId=10723963 -->
+<!-- 3.0 强制使用 YIELD 后需要修改本文档，参考 https://confluence.nebula-graph.io/pages/viewpage.action?pageId=10723963 -->
 
 `LOOKUP`根据索引遍历数据。用户可以使用`LOOKUP`实现如下功能：
 
 - 根据`WHERE`子句搜索特定数据。
 
-- 通过Tag列出点：检索指定Tag的所有点ID。
+- 通过 Tag 列出点：检索指定 Tag 的所有点 ID。
 
-- 通过Edge type列出边：检索指定Edge type的所有边的起始点、目的点和rank。
+- 通过 Edge type 列出边：检索指定 Edge type 的所有边的起始点、目的点和 rank。
 
-- 统计包含指定Tag的点或属于指定Edge type的边的数量。
+- 统计包含指定 Tag 的点或属于指定 Edge type 的边的数量。
 
-## OpenCypher兼容性
+## OpenCypher 兼容性
 
-本文操作仅适用于原生nGQL。
+本文操作仅适用于原生 nGQL。
 
 ## 注意事项
 
-- 索引会导致写性能大幅降低（降低90%甚至更多）。请不要随意在生产环境中使用索引，除非很清楚使用索引对业务的影响。
+- 索引会导致写性能大幅降低（降低 90%甚至更多）。请不要随意在生产环境中使用索引，除非很清楚使用索引对业务的影响。
 
 - 如果用`LOOKUP`语句基于指定属性查询时该属性没有索引，系统会在可用的索引中随机选择一个。
 
@@ -30,7 +30,7 @@
 
 ## 前提条件
 
-请确保`LOOKUP`语句有至少一个索引可用。如果需要创建索引，但是已经有相关的点、边或属性，用户必须在创建索引后[重建索引](../14.native-index-statements/4.rebuild-native-index.md)，才能使其生效。
+请确保`LOOKUP`语句有至少一个索引可用。如果需要创建索引，但是已经有相关的点、边或属性，用户必须在创建索引后 [重建索引](../14.native-index-statements/4.rebuild-native-index.md)，才能使其生效。
 
 ## 语法
 
@@ -43,28 +43,28 @@ LOOKUP ON {<vertex_tag> | <edge_type>}
     <prop_name> [AS <col_alias>] [, <prop_name> [AS <prop_alias>] ...];
 ```
 
-- `WHERE <expression>`：指定遍历的过滤条件，还可以结合布尔运算符AND和OR一起使用。详情请参见[WHERE](../8.clauses-and-options/where.md)。
+- `WHERE <expression>`：指定遍历的过滤条件，还可以结合布尔运算符 AND 和 OR 一起使用。详情请参见 [WHERE](../8.clauses-and-options/where.md)。
 
 - `YIELD`：定义需要返回的输出。
 
-  - `LOOKUP`Tag时，除了返回定义的属性，额外返回`VertexID`。如果没有`YIELD`子句，返回`VertexID`。
-  - `LOOKUP`Edge type时，除了返回定义的属性，额外返回`起始点ID`、`目的点ID`和`rank`。如果没有`YIELD`子句，返回`起始点ID`、`目的点ID`和`rank`。
+  - `LOOKUP`Tag 时，除了返回定义的属性，额外返回`VertexID`。如果没有`YIELD`子句，返回`VertexID`。
+  - `LOOKUP`Edge type 时，除了返回定义的属性，额外返回`起始点 ID`、`目的点 ID`和`rank`。如果没有`YIELD`子句，返回`起始点 ID`、`目的点 ID`和`rank`。
 
 - `AS`：设置别名。
 
-## WHERE语句限制
+## WHERE 语句限制
 
 在`LOOKUP`语句中使用`WHERE`子句，不支持如下操作：
 
 - `$-`和`$^`。
 - 在关系表达式中，不支持运算符两边都有字段名，例如`tagName.prop1 > tagName.prop2`。
-- 不支持运算表达式和函数表达式中嵌套AliasProp表达式。
-- 不支持XOR和NOT运算符。
+- 不支持运算表达式和函数表达式中嵌套 AliasProp 表达式。
+- 不支持 XOR 和 NOT 运算符。
 - 不支持除`STARTS WITH`之外的字符串操作。
 
 ## 检索点
 
-返回Tag为`player`且`name`为`Tony Parker`的点。
+返回 Tag 为`player`且`name`为`Tony Parker`的点。
 
 ```ngql
 nebula> CREATE TAG INDEX IF NOT EXISTS index_player ON player(name(30), age);
@@ -127,7 +127,7 @@ nebula> LOOKUP ON player \
 
 ## 检索边
 
-返回Edge type为`follow`且`degree`为`90`的边。
+返回 Edge type 为`follow`且`degree`为`90`的边。
 
 ```ngql
 nebula> CREATE EDGE INDEX IF NOT EXISTS index_follow ON follow(degree);
@@ -174,13 +174,13 @@ nebula> LOOKUP ON follow \
 +-------------+------------------------------+---------------------------+---------------------+
 ```
 
-## 通过Tag列出所有的对应的点/通过Edge type列出边
+## 通过 Tag 列出所有的对应的点/通过 Edge type 列出边
 
-如果需要通过Tag列出所有的点，或通过Edge type列出边，则Tag、Edge type或属性上必须有至少一个索引。
+如果需要通过 Tag 列出所有的点，或通过 Edge type 列出边，则 Tag、Edge type 或属性上必须有至少一个索引。
 
-例如一个Tag `player`有属性`name`和`age`，为了遍历所有包含Tag `player`的点ID，Tag `player`、属性`name`或属性`age`中必须有一个已经创建索引。
+例如一个 Tag `player`有属性`name`和`age`，为了遍历所有包含 Tag `player`的点 ID，Tag `player`、属性`name`或属性`age`中必须有一个已经创建索引。
 
-- 查找所有Tag为`player`的点 VID。
+- 查找所有 Tag 为`player`的点 VID。
 
     ```ngql
     nebula> CREATE TAG IF NOT EXISTS player(name string,age int);
@@ -208,7 +208,7 @@ nebula> LOOKUP ON follow \
     +-------------+
     ```
 
-- 查找Edge type为`follow`的所有边的信息。
+- 查找 Edge type 为`follow`的所有边的信息。
 
     ```ngql
     nebula> CREATE EDGE IF NOT EXISTS follow(degree int);
@@ -237,7 +237,7 @@ nebula> LOOKUP ON follow \
 
 ## 统计点或边
 
-统计Tag为`player`的点和Edge type为`follow`的边。
+统计 Tag 为`player`的点和 Edge type 为`follow`的边。
 
 ```ngql
 nebula> LOOKUP ON player |\
@@ -259,4 +259,4 @@ nebula> LOOKUP ON follow | \
 
 !!! note
 
-    使用[`SHOW STATS`命令](./6.show/14.show-stats.md)也可以统计点和边。
+    使用 [`SHOW STATS`命令](./6.show/14.show-stats.md) 也可以统计点和边。
diff --git a/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/1.show-charset.md b/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/1.show-charset.md
index e920d34c41..f9291aba0f 100644
--- a/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/1.show-charset.md
+++ b/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/1.show-charset.md
@@ -2,7 +2,7 @@
 
 `SHOW CHARSET`语句显示当前的字符集。
 
-目前可用的字符集为`utf8`和`utf8mb4`。默认字符集为`utf8`。Nebula Graph扩展`uft8`支持四字节字符，因此`utf8`和`utf8mb4`是等价的。
+目前可用的字符集为`utf8`和`utf8mb4`。默认字符集为`utf8`。Nebula Graph 扩展`uft8`支持四字节字符，因此`utf8`和`utf8mb4`是等价的。
 
 ## 语法
 
diff --git a/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/10.show-roles.md b/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/10.show-roles.md
index 55624fc9f7..862a37eae3 100644
--- a/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/10.show-roles.md
+++ b/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/10.show-roles.md
@@ -10,7 +10,7 @@
 
 - 如果登录的用户角色没有权限访问该图空间，则返回权限错误。
 
-关于角色的详情请参见[内置角色权限](../../../7.data-security/1.authentication/3.role-list.md)。
+关于角色的详情请参见 [内置角色权限](../../../7.data-security/1.authentication/3.role-list.md)。
 
 ## 语法
 
diff --git a/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/11.show-snapshots.md b/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/11.show-snapshots.md
index 9c055dc4c7..6fc60082ab 100644
--- a/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/11.show-snapshots.md
+++ b/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/11.show-snapshots.md
@@ -2,7 +2,7 @@
 
 `SHOW SNAPSHOTS`语句显示所有快照信息。
 
-快照的使用方式请参见[管理快照](../../../7.data-security/3.manage-snapshot.md)。
+快照的使用方式请参见 [管理快照](../../../7.data-security/3.manage-snapshot.md)。
 
 ## 角色要求
 
diff --git a/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/12.show-spaces.md b/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/12.show-spaces.md
index a35afa834c..ae1ce2f54c 100644
--- a/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/12.show-spaces.md
+++ b/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/12.show-spaces.md
@@ -2,7 +2,7 @@
 
 `SHOW SPACES`语句显示现存的图空间。
 
-如何创建图空间，请参见[CREATE SPACE](./../../9.space-statements/1.create-space.md)。
+如何创建图空间，请参见 [CREATE SPACE](./../../9.space-statements/1.create-space.md)。
 
 ## 语法
 
diff --git a/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/14.show-stats.md b/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/14.show-stats.md
index 6494f56b54..0cc2ee16b8 100644
--- a/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/14.show-stats.md
+++ b/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/14.show-stats.md
@@ -6,12 +6,12 @@
 
 - 点的总数
 - 边的总数
-- 每个Tag关联的点的总数
-- 每个Edge type关联的边的总数
+- 每个 Tag 关联的点的总数
+- 每个 Edge type 关联的边的总数
 
 ## 前提条件
 
-在需要查看统计信息的图空间中执行`SUBMIT JOB STATS`。详情请参见[SUBMIT JOB STATS](../../18.operation-and-maintenance-statements/4.job-statements.md)。
+在需要查看统计信息的图空间中执行`SUBMIT JOB STATS`。详情请参见 [SUBMIT JOB STATS](../../18.operation-and-maintenance-statements/4.job-statements.md)。
 
 !!! caution
 
@@ -29,7 +29,7 @@ SHOW STATS;
 # 选择图空间。
 nebula> USE basketballplayer;
 
-# 执行SUBMIT JOB STATS。
+# 执行 SUBMIT JOB STATS。
 nebula> SUBMIT JOB STATS;
 +------------+
 | New Job Id |
diff --git a/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/15.show-tags-edges.md b/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/15.show-tags-edges.md
index b0c00e3184..3be597d307 100644
--- a/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/15.show-tags-edges.md
+++ b/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/15.show-tags-edges.md
@@ -1,8 +1,8 @@
 # SHOW TAGS/EDGES
 
-`SHOW TAGS`语句显示当前图空间内的所有Tag。
+`SHOW TAGS`语句显示当前图空间内的所有 Tag。
 
-`SHOW EDGES`语句显示当前图空间内的所有Edge type。
+`SHOW EDGES`语句显示当前图空间内的所有 Edge type。
 
 ## 语法
 
diff --git a/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/17.show-sessions.md b/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/17.show-sessions.md
index 3b42816c8f..be49d01360 100644
--- a/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/17.show-sessions.md
+++ b/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/17.show-sessions.md
@@ -1,14 +1,14 @@
 # SHOW SESSIONS
 
-`SHOW SESSIONS`语句显示所有会话信息，也可以指定会话ID进行查看。
+`SHOW SESSIONS`语句显示所有会话信息，也可以指定会话 ID 进行查看。
 
 ## 注意事项
 
-使用Nebula Console登录数据库时，会创建一个会话，操作结束执行`exit`退出登录时，客户端会调用API `release`，释放会话并清除会话信息。
+使用 Nebula Console 登录数据库时，会创建一个会话，操作结束执行`exit`退出登录时，客户端会调用 API `release`，释放会话并清除会话信息。
 
-如果没有正常退出，且没有在配置文件[nebula-graphd.conf](../../../5.configurations-and-logs/1.configurations/3.graph-config.md)设置空闲会话超时时间（`session_idle_timeout_secs`），会话不会自动释放。
+如果没有正常退出，且没有在配置文件 [nebula-graphd.conf](../../../5.configurations-and-logs/1.configurations/3.graph-config.md) 设置空闲会话超时时间（`session_idle_timeout_secs`），会话不会自动释放。
 
-对于未自动释放的会话，需要手动删除指定会话(TODO: coding)。
+对于未自动释放的会话，需要手动删除指定会话 (TODO: coding)。
 
 ## 语法
 
@@ -53,11 +53,11 @@ nebula> SHOW SESSION 1635254859271703;
 
 |参数|说明|
 |:---|:---|
-|`SessionId`|会话ID，唯一标识一个会话。|
+|`SessionId`|会话 ID，唯一标识一个会话。|
 |`UserName`|会话的登录用户名称。|
 |`SpaceName`|用户当前所使用的图空间。刚登录时为空（`""`）。|
 |`CreateTime`|会话的创建时间，即用户认证登录的时间。时区为配置文件中`timezone_name`指定的时区。|
 |`UpdateTime`|用户有执行操作时，会更新此时间。时区为配置文件中`timezone_name`指定的时区。|
-|`GraphAddr`|会话的Graph服务地址和端口。|
+|`GraphAddr`|会话的 Graph 服务地址和端口。|
 |`Timezone`|保留参数，暂无意义。|
-|`ClientIp`|会话的客户端IP地址。|
+|`ClientIp`|会话的客户端 IP 地址。|
diff --git a/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/18.show-queries.md b/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/18.show-queries.md
index 934dd306e6..4a357aae77 100644
--- a/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/18.show-queries.md
+++ b/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/18.show-queries.md
@@ -1,16 +1,16 @@
 # SHOW QUERIES
 
-`SHOW QUERIES`语句可以查看当前Session中正在执行的查询请求信息。
+`SHOW QUERIES`语句可以查看当前 Session 中正在执行的查询请求信息。
 
 !!! note
 
-    如果需要终止查询，请参见[终止查询](../../18.operation-and-maintenance-statements/6.kill-query.md)。
+    如果需要终止查询，请参见 [终止查询](../../18.operation-and-maintenance-statements/6.kill-query.md)。
 
 ## 注意事项
 
-- `SHOW QUERIES`从本地缓存获取当前Session中查询的状态，几乎没有延迟。
+- `SHOW QUERIES`从本地缓存获取当前 Session 中查询的状态，几乎没有延迟。
 
-- `SHOW ALL QUERIES`从Meta服务获取所有Session中的查询信息。这些信息会根据参数`session_reclaim_interval_secs`定义的周期同步到Meta服务，因此在客户端获取到的信息可能属于上个同步周期。
+- `SHOW ALL QUERIES`从 Meta 服务获取所有 Session 中的查询信息。这些信息会根据参数`session_reclaim_interval_secs`定义的周期同步到 Meta 服务，因此在客户端获取到的信息可能属于上个同步周期。
 
 ## 语法
 
@@ -35,7 +35,7 @@ nebula> SHOW ALL QUERIES;
 | 1625456037718757 | 54              | "user1" | ""192.168.x.x":9669" | 2021-07-05T05:51:08.691318 | 1504502        | "RUNNING" | "MATCH p=(v:player)-[*1..4]-(v2) RETURN v2 AS Friends;" |
 +------------------+-----------------+---------+----------------------+----------------------------+----------------+-----------+---------------------------------------------------------+
 
-# 返回耗时TOP 10的查询。
+# 返回耗时 TOP 10 的查询。
 nebula> SHOW ALL QUERIES | ORDER BY $-.DurationInUSec DESC | LIMIT 10;
 +------------------+-----------------+---------+----------------------+----------------------------+----------------+-----------+-------------------------------------------------------+
 | SessionID        | ExecutionPlanID | User    | Host                 | StartTime                  | DurationInUSec | Status    | Query                                                 |
@@ -49,8 +49,8 @@ nebula> SHOW ALL QUERIES | ORDER BY $-.DurationInUSec DESC | LIMIT 10;
 
 |参数|说明|
 |:---|:---|
-| `SessionID` | 会话ID。  |
-| `ExecutionPlanID` |  执行计划ID。 |
+| `SessionID` | 会话 ID。  |
+| `ExecutionPlanID` |  执行计划 ID。 |
 | `User` | 执行查询的用户名。  |
 | `Host` | 用户连接的服务器地址和端口。  |
 | `StartTime` | 执行查询的开始时间。  |
diff --git a/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/19.show-meta-leader.md b/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/19.show-meta-leader.md
index d38ec1cd19..24afa3481d 100644
--- a/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/19.show-meta-leader.md
+++ b/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/19.show-meta-leader.md
@@ -1,8 +1,8 @@
 # SHOW META LEADER
 
-`SHOW META LEADER`语句显示当前Meta集群的leader信息。
+`SHOW META LEADER`语句显示当前 Meta 集群的 leader 信息。
 
-关于Meta服务的详细说明请参见[Meta 服务](../../../1.introduction/3.nebula-graph-architecture/2.meta-service.md)。
+关于 Meta 服务的详细说明请参见 [Meta 服务](../../../1.introduction/3.nebula-graph-architecture/2.meta-service.md)。
 
 ## 语法
 
@@ -23,5 +23,5 @@ nebula> SHOW META LEADER;
 
 |参数|说明|
 |:---|:---|
-|`Meta Leader`|Meta集群的leader信息，包括leader所在服务器的IP地址和端口。|
+|`Meta Leader`|Meta 集群的 leader 信息，包括 leader 所在服务器的 IP 地址和端口。|
 |`secs from last heart beat`|距离上次心跳的时间间隔。单位：秒。|
diff --git a/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/4.show-create-space.md b/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/4.show-create-space.md
index 4fb7c5b2c0..859938dfd3 100644
--- a/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/4.show-create-space.md
+++ b/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/4.show-create-space.md
@@ -2,7 +2,7 @@
 
 `SHOW CREATE SPACE`语句显示指定图空间的创建语句。
 
-图空间的更多详细信息，请参见[CREATE SPACE](../../9.space-statements/1.create-space.md)。
+图空间的更多详细信息，请参见 [CREATE SPACE](../../9.space-statements/1.create-space.md)。
 
 ## 语法
 
diff --git a/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/5.show-create-tag-edge.md b/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/5.show-create-tag-edge.md
index c01b3ffec7..4f84245cb4 100644
--- a/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/5.show-create-tag-edge.md
+++ b/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/5.show-create-tag-edge.md
@@ -1,8 +1,8 @@
 # SHOW CREATE TAG/EDGE
 
-`SHOW CREATE TAG`语句显示指定Tag的基本信息。Tag的更多详细信息，请参见[CREATE TAG](../../10.tag-statements/1.create-tag.md)。
+`SHOW CREATE TAG`语句显示指定 Tag 的基本信息。Tag 的更多详细信息，请参见 [CREATE TAG](../../10.tag-statements/1.create-tag.md)。
 
-`SHOW CREATE EDGE`语句显示指定Edge type的基本信息。Edge type的更多详细信息，请参见[CREATE EDGE](../../11.edge-type-statements/1.create-edge.md)。
+`SHOW CREATE EDGE`语句显示指定 Edge type 的基本信息。Edge type 的更多详细信息，请参见 [CREATE EDGE](../../11.edge-type-statements/1.create-edge.md)。
 
 ## 语法
 
diff --git a/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/6.show-hosts.md b/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/6.show-hosts.md
index 88f4a0caeb..3bfd2b05ce 100644
--- a/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/6.show-hosts.md
+++ b/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/6.show-hosts.md
@@ -1,6 +1,6 @@
 # SHOW HOSTS
 
-`SHOW HOSTS`语句可以显示Graph、Storage、Meta服务主机信息、版本信息。
+`SHOW HOSTS`语句可以显示 Graph、Storage、Meta 服务主机信息、版本信息。
 
 ## 语法
 
@@ -9,10 +9,8 @@ SHOW HOSTS [GRAPH | STORAGE | META];
 ```
 
 !!! note
-    - 不添加服务名，直接使用`SHOW HOSTS`时，会显示Storage服务主机信息，以及leader总数、leader分布和分片分布。
-    - 对于使用源码安装的Nebula Graph，执行添加了服务名的命令后，输出的信息中不显示版本信息。
-
-
+    - 不添加服务名，直接使用`SHOW HOSTS`时，会显示 Storage 服务主机信息，以及 leader 总数、leader 分布和分片分布。
+    - 对于使用源码安装的 Nebula Graph，执行添加了服务名的命令后，输出的信息中不显示版本信息。
 
 ## 示例
 
diff --git a/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/8.show-indexes.md b/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/8.show-indexes.md
index a2734488b8..51b5532a08 100644
--- a/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/8.show-indexes.md
+++ b/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/8.show-indexes.md
@@ -1,6 +1,6 @@
 # SHOW INDEXES
 
-`SHOW INDEXES`语句可以列出当前图空间内的所有Tag和Edge type（包括属性）的索引。
+`SHOW INDEXES`语句可以列出当前图空间内的所有 Tag 和 Edge type（包括属性）的索引。
 
 ## 语法
 
@@ -29,7 +29,6 @@ nebula> SHOW EDGE INDEXES;
 +----------------+----------+---------+
 ```
 
-
 !!! Compatibility "历史版本兼容性"
 
-    Nebula Graph 2.0.1中， `SHOW TAG/EDGE INDEXES` 语句仅返回 `Names`。
+    Nebula Graph 2.0.1 中， `SHOW TAG/EDGE INDEXES` 语句仅返回 `Names`。
diff --git a/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/9.show-parts.md b/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/9.show-parts.md
index 524f472cba..6a14a6e57e 100644
--- a/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/9.show-parts.md
+++ b/docs-2.0/3.ngql-guide/7.general-query-statements/6.show/9.show-parts.md
@@ -39,7 +39,7 @@ nebula> SHOW PARTS 1;
 
 | 参数 | 说明 |
 | - | - |
-| `Partition ID` | 存储分片的ID |
-| `Leader` | 分片对应的Raft leader副本的信息，包括IP地址与服务端口 |
-| `Peers` | 分片对应的所有副本（leader与follower）的信息，包括IP地址与服务端口 |
-| `Losts` | 分片对应的处于离线状态的副本信息，包括IP地址和服务端口 |
+| `Partition ID` | 存储分片的 ID |
+| `Leader` | 分片对应的 Raft leader 副本的信息，包括 IP 地址与服务端口 |
+| `Peers` | 分片对应的所有副本（leader 与 follower）的信息，包括 IP 地址与服务端口 |
+| `Losts` | 分片对应的处于离线状态的副本信息，包括 IP 地址和服务端口 |
diff --git a/docs-2.0/3.ngql-guide/7.general-query-statements/7.unwind.md b/docs-2.0/3.ngql-guide/7.general-query-statements/7.unwind.md
index 70671579a9..2f2c2268e7 100644
--- a/docs-2.0/3.ngql-guide/7.general-query-statements/7.unwind.md
+++ b/docs-2.0/3.ngql-guide/7.general-query-statements/7.unwind.md
@@ -27,7 +27,7 @@ nebula> UNWIND [1,2,3] AS n RETURN n;
 
 在`UNWIND`语句中使用`WITH DISTINCT`可以将列表中的重复项忽略，返回去重后的结果。
 
-### 示例1
+### 示例 1
 
 1. 拆分列表`[1,1,2,2,3,3]`。
 2. 删除重复行。
@@ -47,7 +47,7 @@ nebula> WITH [1,1,2,2,3,3] AS n \
 +------------+
 ```
 
-### 示例2
+### 示例 2
 
 1. 将匹配路径上的顶点输出到列表中。
 2. 拆分列表。
diff --git a/docs-2.0/3.ngql-guide/8.clauses-and-options/group-by.md b/docs-2.0/3.ngql-guide/8.clauses-and-options/group-by.md
index 691c00cd87..d8b41afe4d 100644
--- a/docs-2.0/3.ngql-guide/8.clauses-and-options/group-by.md
+++ b/docs-2.0/3.ngql-guide/8.clauses-and-options/group-by.md
@@ -2,11 +2,11 @@
 
 `GROUP BY`子句可以用于聚合数据。
 
-## openCypher兼容性
+## openCypher 兼容性
 
-本文操作仅适用于原生nGQL。
+本文操作仅适用于原生 nGQL。
 
-用户也可以使用openCypher方式的[count()](../6.functions-and-expressions/7.count.md)函数聚合数据。
+用户也可以使用 openCypher 方式的 [count()](../6.functions-and-expressions/7.count.md) 函数聚合数据。
 
 ```ngql
 nebula>  MATCH (v:player)<-[:follow]-(:player) RETURN v.name AS Name, count(*) as cnt ORDER BY cnt DESC;
@@ -36,7 +36,7 @@ nebula>  MATCH (v:player)<-[:follow]-(:player) RETURN v.name AS Name, count(*) a
 ## 示例
 
 ```ngql
-# 查找所有连接到player100的点，并根据他们的姓名进行分组，返回姓名的出现次数。
+# 查找所有连接到 player100 的点，并根据他们的姓名进行分组，返回姓名的出现次数。
 nebula> GO FROM "player100" OVER follow BIDIRECT \
         YIELD properties($$).name as Name \
         | GROUP BY $-.Name \
@@ -60,7 +60,7 @@ nebula> GO FROM "player100" OVER follow BIDIRECT \
 ## 用函数进行分组和计算
 
 ```ngql
-# 查找所有连接到player100的点，并根据起始点进行分组，返回degree的总和。
+# 查找所有连接到 player100 的点，并根据起始点进行分组，返回 degree 的总和。
 nebula> GO FROM "player100" OVER follow \
         YIELD src(edge) AS player, properties(edge).degree AS degree \
         | GROUP BY $-.player \
@@ -72,4 +72,4 @@ nebula> GO FROM "player100" OVER follow \
 +----------------+
 ```
 
-`sum()`函数详情请参见[内置数学函数](../6.functions-and-expressions/1.math.md)。
+`sum()`函数详情请参见 [内置数学函数](../6.functions-and-expressions/1.math.md)。
diff --git a/docs-2.0/3.ngql-guide/8.clauses-and-options/limit.md b/docs-2.0/3.ngql-guide/8.clauses-and-options/limit.md
index f54e74f310..dc4962085c 100644
--- a/docs-2.0/3.ngql-guide/8.clauses-and-options/limit.md
+++ b/docs-2.0/3.ngql-guide/8.clauses-and-options/limit.md
@@ -1,26 +1,26 @@
 # LIMIT
 
-`LIMIT`子句限制输出结果的行数。`LIMIT`在原生nGQL语句和openCypher兼容语句中的用法有所不同。
+`LIMIT`子句限制输出结果的行数。`LIMIT`在原生 nGQL 语句和 openCypher 兼容语句中的用法有所不同。
 
-- 在原生nGQL语句中，一般需要在`LIMIT`子句前使用管道符，可以直接在LIMIT语句后设置或者省略偏移量参数。
+- 在原生 nGQL 语句中，一般需要在`LIMIT`子句前使用管道符，可以直接在 LIMIT 语句后设置或者省略偏移量参数。
 
-- 在openCypher兼容语句中，不允许在`LIMIT`子句前使用管道符，可以使用`SKIP`指明偏移量。
+- 在 openCypher 兼容语句中，不允许在`LIMIT`子句前使用管道符，可以使用`SKIP`指明偏移量。
 
   !!! Note
 
-        在原生nGQL或openCypher方式中使用`LIMIT`时，使用`ORDER BY`子句限制输出顺序非常重要，否则会输出一个不可预知的子集。
+        在原生 nGQL 或 openCypher 方式中使用`LIMIT`时，使用`ORDER BY`子句限制输出顺序非常重要，否则会输出一个不可预知的子集。
 
 !!! compatibility "历史版本兼容性"
 
-    Nebula Graph 2.6.0中，`GO`语句支持了新的`LIMIT`语法。部分`LIMIT`相关的算子支持计算下推。
+    Nebula Graph 2.6.0 中，`GO`语句支持了新的`LIMIT`语法。部分`LIMIT`相关的算子支持计算下推。
 
-## 原生nGQL语句中的LIMIT
+## 原生 nGQL 语句中的 LIMIT
 
-在原生nGQL中，`LIMIT`有通用语法和`GO`语句中的专属语法。
+在原生 nGQL 中，`LIMIT`有通用语法和`GO`语句中的专属语法。
 
-### 原生nGQL中的通用LIMIT语法
+### 原生 nGQL 中的通用 LIMIT 语法
 
-原生nGQL中的通用`LIMIT`语法与`SQL`中的`LIMIT`原理相同。`LIMIT`子句接收一个或两个参数，参数的值必须是非负整数，且必须用在管道符之后。语法和说明如下：
+原生 nGQL 中的通用`LIMIT`语法与`SQL`中的`LIMIT`原理相同。`LIMIT`子句接收一个或两个参数，参数的值必须是非负整数，且必须用在管道符之后。语法和说明如下：
 
 ```ngql
 ... | LIMIT [<offset>,] <number_rows>;
@@ -34,7 +34,7 @@
 示例：
 
 ```ngql
-# 从结果中返回最前面的3行数据。
+# 从结果中返回最前面的 3 行数据。
 nebula> LOOKUP ON player |\
         LIMIT 3;
 +-------------+
@@ -45,7 +45,7 @@ nebula> LOOKUP ON player |\
 | "player102" |
 +-------------+
 
-# 从排序后结果中返回第2行开始的3行数据。
+# 从排序后结果中返回第 2 行开始的 3 行数据。
 nebula> GO FROM "player100" OVER follow REVERSELY \
         YIELD properties($$).name AS Friend, properties($$).age AS Age \
         | ORDER BY $-.Age, $-.Friend \
@@ -59,9 +59,9 @@ nebula> GO FROM "player100" OVER follow REVERSELY \
 +-------------------+-----+
 ```
 
-### GO语句中的LIMIT
+### GO 语句中的 LIMIT
 
-`GO`语句中的`LIMIT`除了支持原生nGQL中的通用语法外，还支持根据边限制输出结果数量。
+`GO`语句中的`LIMIT`除了支持原生 nGQL 中的通用语法外，还支持根据边限制输出结果数量。
 
 语法：
 
@@ -71,13 +71,13 @@ nebula> GO FROM "player100" OVER follow REVERSELY \
 
 `limit_list`是一个列表，列表中的元素必须为自然数，且元素数量必须与`GO`语句中的`STEPS`的最大数相同。下文以`GO 1 TO 3 STEPS FROM "A" OVER * LIMIT <limit_list>`为例详细介绍`LIMIT`的这种用法。
 
-* 列表`limit_list`必须包含3个自然数元素，例如`GO 1 TO 3 STEPS FROM "A" OVER * LIMIT [1,2,4]`。
-* `LIMIT [1,2,4]`中的`1`表示系统在第一步时自动选择1条边继续遍历，`2`表示在第二步时选择2条边继续遍历，`4`表示在第三步时选择4条边继续遍历。
+* 列表`limit_list`必须包含 3 个自然数元素，例如`GO 1 TO 3 STEPS FROM "A" OVER * LIMIT [1,2,4]`。
+* `LIMIT [1,2,4]`中的`1`表示系统在第一步时自动选择 1 条边继续遍历，`2`表示在第二步时选择 2 条边继续遍历，`4`表示在第三步时选择 4 条边继续遍历。
 * 因为`GO 1 TO 3 STEPS`表示返回第一到第三步的所有遍历结果，因此下图中所有红色边和它们的原点与目的点都会被这条`GO`语句匹配上，而黄色边表示`GO`语句遍历时没有选择的路径。如果不是`GO 1 TO 3 STEPS`而是`GO 3 STEPS`，则只会匹配上第三步的红色边和它们两端的点。
 
 ![LIMIT in GO](limit_in_go_1.png)
 
-在basketballplayer数据集中的执行示例如下：
+在 basketballplayer 数据集中的执行示例如下：
 
 ```ngql
 nebula> GO 3 STEPS FROM "player100" \
@@ -104,9 +104,9 @@ nebula> GO 3 STEPS FROM "player102" \
 +------------+-------------+
 ```
 
-## openCypher兼容语句中的LIMIT
+## openCypher 兼容语句中的 LIMIT
 
-在`MATCH`等openCypher兼容语句中使用LIMIT不需要加管道符。语法和说明如下：
+在`MATCH`等 openCypher 兼容语句中使用 LIMIT 不需要加管道符。语法和说明如下：
 
 ```ngql
 ... [SKIP <offset>] [LIMIT <number_rows>];
@@ -121,9 +121,9 @@ nebula> GO 3 STEPS FROM "player102" \
 
 !!! Note
 
-    两个整数组成的分数表达式会自动向下取整。例如`8/6`向下取整为1。
+    两个整数组成的分数表达式会自动向下取整。例如`8/6`向下取整为 1。
 
-### 单独使用LIMIT
+### 单独使用 LIMIT
 
 `LIMIT`可以单独使用，返回指定数量的结果。
 
@@ -152,7 +152,7 @@ nebula> MATCH (v:player) RETURN v.name AS Name, v.age AS Age \
 +-------------------------+-----+
 ```
 
-### 单独使用SKIP
+### 单独使用 SKIP
 
 `SKIP`可以单独使用，用于设置偏移量，返回指定位置之后的数据。
 
@@ -177,7 +177,7 @@ nebula> MATCH (v:player{name:"Tim Duncan"}) --> (v2) \
 +---------------+-----+
 ```
 
-### 同时使用SKIP与LIMIT
+### 同时使用 SKIP 与 LIMIT
 
 同时使用`SKIP`与`LIMIT`可以返回从指定位置开始的指定数量的数据。
 
@@ -195,5 +195,5 @@ nebula> MATCH (v:player{name:"Tim Duncan"}) --> (v2) \
 <!--
 ## 性能提示
 
-Nebula Graph {{ nebula.release }} 未实现 `LIMIT` 语句的存储层下推优化, 类似 `MATCH (n:T) RETURN n LIMIT 10` 语句或者 `LOOKUP on i_T | LIMIT 10` 语句会发生 graphd 资源占用过大的问题：一个 graphd 会从所有的 storaged 获取全部T类型的点，然后返回 10 个。如果全部数据量很大，graphd 此时通常会消耗大量内存，甚至 OOM。
+Nebula Graph {{ nebula.release }} 未实现 `LIMIT` 语句的存储层下推优化，类似 `MATCH (n:T) RETURN n LIMIT 10` 语句或者 `LOOKUP on i_T | LIMIT 10` 语句会发生 graphd 资源占用过大的问题：一个 graphd 会从所有的 storaged 获取全部 T 类型的点，然后返回 10 个。如果全部数据量很大，graphd 此时通常会消耗大量内存，甚至 OOM。
 -->
diff --git a/docs-2.0/3.ngql-guide/8.clauses-and-options/order-by.md b/docs-2.0/3.ngql-guide/8.clauses-and-options/order-by.md
index 438c7d80e0..50e6bcff1f 100644
--- a/docs-2.0/3.ngql-guide/8.clauses-and-options/order-by.md
+++ b/docs-2.0/3.ngql-guide/8.clauses-and-options/order-by.md
@@ -2,16 +2,16 @@
 
 `ORDER BY`子句指定输出结果的排序规则。
 
-- 在原生nGQL中，必须在`YIELD`子句之后使用管道符（|）和`ORDER BY`子句。
+- 在原生 nGQL 中，必须在`YIELD`子句之后使用管道符（|）和`ORDER BY`子句。
 
-- 在openCypher方式中，不允许使用管道符。在`RETURN`子句之后使用`ORDER BY`子句。
+- 在 openCypher 方式中，不允许使用管道符。在`RETURN`子句之后使用`ORDER BY`子句。
 
 排序规则分为如下两种：
 
 - `ASC`（默认）: 升序。
 - `DESC`: 降序。
 
-## 原生nGQL语法
+## 原生 nGQL 语法
 
 ```ngql
 <YIELD clause>
@@ -20,7 +20,7 @@ ORDER BY <expression> [ASC | DESC] [, <expression> [ASC | DESC] ...];
 
 !!! compatibility
 
-    原生nGQL语法中，`ORDER BY`命令后必须使用引用符`$-.`。但在2.5.0之前的版本中不需要。
+    原生 nGQL 语法中，`ORDER BY`命令后必须使用引用符`$-.`。但在 2.5.0 之前的版本中不需要。
 
 ### 示例
 
@@ -48,7 +48,7 @@ nebula> $var = GO FROM "player100" OVER follow \
 +-------------+
 ```
 
-## OpenCypher方式语法
+## OpenCypher 方式语法
 
 ```ngql
 <RETURN clause>
@@ -85,9 +85,9 @@ nebula> MATCH (v:player) RETURN v.age AS Age, v.name AS Name  \
 ...
 ```
 
-## NULL值的排序
+## NULL 值的排序
 
-升序排列时，会在输出的最后列出NULL值，降序排列时，会在输出的开头列出NULL值。
+升序排列时，会在输出的最后列出 NULL 值，降序排列时，会在输出的开头列出 NULL 值。
 
 ```ngql
 nebula> MATCH (v:player{name:"Tim Duncan"}) --> (v2) \
diff --git a/docs-2.0/3.ngql-guide/8.clauses-and-options/return.md b/docs-2.0/3.ngql-guide/8.clauses-and-options/return.md
index 2f56761b50..cc2c373ea6 100644
--- a/docs-2.0/3.ngql-guide/8.clauses-and-options/return.md
+++ b/docs-2.0/3.ngql-guide/8.clauses-and-options/return.md
@@ -1,24 +1,24 @@
 # RETURN
 
-`RETURN`子句定义了nGQL查询的输出结果。如果需要返回多个字段，用英文逗号（,）分隔。
+`RETURN`子句定义了 nGQL 查询的输出结果。如果需要返回多个字段，用英文逗号（,）分隔。
 
 `RETURN`可以引导子句或语句：
 
-- `RETURN`子句可以用于nGQL中的openCypher方式语句中，例如`MATCH`或`UNWIND`。
+- `RETURN`子句可以用于 nGQL 中的 openCypher 方式语句中，例如`MATCH`或`UNWIND`。
 
 - `RETURN`可以单独使用，输出表达式的结果。
 
-## openCypher兼容性
+## openCypher 兼容性
 
-本文操作仅适用于nGQL中的openCypher方式。关于原生nGQL如何定义输出结果，请参见[`YIELD`](yield.md)。
+本文操作仅适用于 nGQL 中的 openCypher 方式。关于原生 nGQL 如何定义输出结果，请参见 [`YIELD`](yield.md)。
 
-`RETURN`不支持如下openCypher功能：
+`RETURN`不支持如下 openCypher 功能：
 
 - 使用不在英文字母表中的字符作为变量名。例如：
 
   ```ngql
-  MATCH (`点1`:player) \
-  RETURN `点1`;
+  MATCH (`点 1`:player) \
+  RETURN `点 1`;
   ```
 
 - 设置一个模式，并返回该模式匹配的所有元素。例如：
@@ -30,13 +30,13 @@
 
 ## 历史版本兼容性
 
-- 在nGQL 1.x中，`RETURN`适用于原生nGQL，语法为`RETURN <var_ref> IF <var_ref> IS NOT NULL`。
+- 在 nGQL 1.x 中，`RETURN`适用于原生 nGQL，语法为`RETURN <var_ref> IF <var_ref> IS NOT NULL`。
 
-- 在nGQL 2.0中，`RETURN`不适用于原生nGQL。
+- 在 nGQL 2.0 中，`RETURN`不适用于原生 nGQL。
 
-## Map顺序说明
+## Map 顺序说明
 
-`RETURN`返回Map时，Key的顺序是未定义的。
+`RETURN`返回 Map 时，Key 的顺序是未定义的。
 
 ```ngql
 nebula> RETURN {age: 32, name: "Marco Belinelli"};
@@ -208,7 +208,7 @@ nebula> RETURN 1+1, rand32(1, 5);
 使用`DISTINCT`可以删除结果集中的重复字段。
 
 ```ngql
-# 未使用DISTINCT。
+# 未使用 DISTINCT。
 nebula> MATCH (v:player{name:"Tony Parker"})--(v2:player) \
         RETURN v2.name, v2.age;
 +---------------------+--------+
@@ -224,7 +224,7 @@ nebula> MATCH (v:player{name:"Tony Parker"})--(v2:player) \
 | "Manu Ginobili"     | 41     |
 +---------------------+--------+
 
-# 使用DISTINCT。
+# 使用 DISTINCT。
 nebula> MATCH (v:player{name:"Tony Parker"})--(v2:player) \
         RETURN DISTINCT v2.name, v2.age;
 +---------------------+--------+
diff --git a/docs-2.0/3.ngql-guide/8.clauses-and-options/sample.md b/docs-2.0/3.ngql-guide/8.clauses-and-options/sample.md
index b04d0d21cb..06f0a535db 100644
--- a/docs-2.0/3.ngql-guide/8.clauses-and-options/sample.md
+++ b/docs-2.0/3.ngql-guide/8.clauses-and-options/sample.md
@@ -4,7 +4,7 @@
 
 !!! compatibility "历史版本兼容性"
 
-    `SAMPLE`是Nebula Graph 2.6.0 新增的子句。
+    `SAMPLE`是 Nebula Graph 2.6.0 新增的子句。
 
 `SAMPLE`仅能在`GO`语句中使用，语法如下：
 
@@ -14,13 +14,13 @@
 
 `sample_list`是一个列表，列表中的元素必须为自然数，且元素数量必须与`GO`语句中的`STEPS`的最大数相同。下文以`GO 1 TO 3 STEPS FROM "A" OVER * SAMPLE <sample_list>`为例详细介绍`SAMPLE`的用法。
 
-* 列表`sample_list`必须包含3个自然数元素，例如`GO 1 TO 3 STEPS FROM "A" OVER * SAMPLE [1,2,4]`。
-* `SAMPLE [1,2,4]`中的`1`表示系统在第一步时自动选择1条边继续遍历，`2`表示在第二步时选择2条边继续遍历，`4`表示在第三步时选择4条边继续遍历。如果某一步没有匹配的边或者匹配到的边数量小于指定数量，则按实际数量返回。
+* 列表`sample_list`必须包含 3 个自然数元素，例如`GO 1 TO 3 STEPS FROM "A" OVER * SAMPLE [1,2,4]`。
+* `SAMPLE [1,2,4]`中的`1`表示系统在第一步时自动选择 1 条边继续遍历，`2`表示在第二步时选择 2 条边继续遍历，`4`表示在第三步时选择 4 条边继续遍历。如果某一步没有匹配的边或者匹配到的边数量小于指定数量，则按实际数量返回。
 * 因为`GO 1 TO 3 STEPS`表示返回第一到第三步的所有遍历结果，因此下图中所有红色边和它们的原点与目的点都会被这条`GO`语句匹配上，而黄色边表示`GO`语句遍历时没有选择的路径。如果不是`GO 1 TO 3 STEPS`而是`GO 3 STEPS`，则只会匹配上第三步的红色边和它们两端的点。
 
 ![SAMPLE in GO](sample_in_go.png)
 
-在basketballplayer数据集中的执行示例如下：
+在 basketballplayer 数据集中的执行示例如下：
 
 ```ngql
 nebula> GO 3 STEPS FROM "player100" \
diff --git a/docs-2.0/3.ngql-guide/8.clauses-and-options/ttl-options.md b/docs-2.0/3.ngql-guide/8.clauses-and-options/ttl-options.md
index 38b49f86e5..26663968cf 100644
--- a/docs-2.0/3.ngql-guide/8.clauses-and-options/ttl-options.md
+++ b/docs-2.0/3.ngql-guide/8.clauses-and-options/ttl-options.md
@@ -2,19 +2,19 @@
 
 TTL（Time To Live）指定属性的存活时间，超时后，该属性就会过期。
 
-## openCypher兼容性
+## openCypher 兼容性
 
-本文操作仅适用于原生nGQL。
+本文操作仅适用于原生 nGQL。
 
 ## 注意事项
 
-- 不能修改带有TTL选项的属性的Schema。
+- 不能修改带有 TTL 选项的属性的 Schema。
 
-- TTL和INDEX共存问题：
+- TTL 和 INDEX 共存问题：
 
-    + 如果一个Tag的其中一属性已有INDEX，则不能为其设置TTL，也不能为该Tag的其他属性设置TTL。    
+    + 如果一个 Tag 的其中一属性已有 INDEX，则不能为其设置 TTL，也不能为该 Tag 的其他属性设置 TTL。    
 
-    + 如果已有TTL，可以再添加INDEX。
+    + 如果已有 TTL，可以再添加 INDEX。
 
 ## 属性过期
 
@@ -22,59 +22,59 @@ TTL（Time To Live）指定属性的存活时间，超时后，该属性就会
 
 点属性过期有如下影响：
 
-- 如果一个点仅有一个Tag，点上的一个属性过期，点也会过期。
+- 如果一个点仅有一个 Tag，点上的一个属性过期，点也会过期。
 
-- 如果一个点有多个Tag，点上的一个属性过期，和该属性相同Tag的其他属性也会过期，但是点不会过期，点上其他Tag的属性保持不变。
+- 如果一个点有多个 Tag，点上的一个属性过期，和该属性相同 Tag 的其他属性也会过期，但是点不会过期，点上其他 Tag 的属性保持不变。
 
 ### 边属性过期
 
-因为一条边仅有一个Edge type，边上的一个属性过期，边也会过期。
+因为一条边仅有一个 Edge type，边上的一个属性过期，边也会过期。
 
 ## 过期处理
 
 属性过期后，对应的过期数据仍然存储在硬盘上，但是查询时会过滤过期数据。
 
-Nebula Graph自动删除过期数据后，会在下一次[Compaction](../../8.service-tuning/compaction.md)过程中回收硬盘空间。
+Nebula Graph 自动删除过期数据后，会在下一次 [Compaction](../../8.service-tuning/compaction.md) 过程中回收硬盘空间。
 
 !!! Note
 
-    如果[关闭TTL选项](#ttl_1)，上一次Compaction之后的过期数据将可以被查询到。
+    如果 [关闭 TTL 选项](#ttl_1)，上一次 Compaction 之后的过期数据将可以被查询到。
 
-## TTL选项
+## TTL 选项
 
-nGQL支持的TTL选项如下。
+nGQL 支持的 TTL 选项如下。
 
 |选项|说明|
 |:---|:---|
 |`ttl_col`|指定要设置存活时间的属性。属性的数据类型必须是`int`或者`timestamp`。|
-|`ttl_duration`|指定时间戳差值，单位：秒。时间戳差值必须为64位非负整数。属性值和时间戳差值之和如果小于当前时间戳，属性就会过期。如果`ttl_duration`为`0`，属性永不过期。|
+|`ttl_duration`|指定时间戳差值，单位：秒。时间戳差值必须为 64 位非负整数。属性值和时间戳差值之和如果小于当前时间戳，属性就会过期。如果`ttl_duration`为`0`，属性永不过期。|
 
-## 使用TTL选项
+## 使用 TTL 选项
 
-### Tag或Edge type已存在
+### Tag 或 Edge type 已存在
 
-如果Tag和Edge type已经创建，请使用`ALTER`语句更新Tag或Edge type。
+如果 Tag 和 Edge type 已经创建，请使用`ALTER`语句更新 Tag 或 Edge type。
 
 ```ngql
-# 创建Tag。
+# 创建 Tag。
 nebula> CREATE TAG IF NOT EXISTS t1 (a timestamp);
 
-# ALTER修改Tag，添加TTL选项。
+# ALTER 修改 Tag，添加 TTL 选项。
 nebula> ALTER TAG t1 ttl_col = "a", ttl_duration = 5;
 
-# 插入点，插入后5秒过期。
+# 插入点，插入后 5 秒过期。
 nebula> INSERT VERTEX t1(a) values "101":(now());
 ```
 
-### Tag或Edge type不存在
+### Tag 或 Edge type 不存在
 
-创建Tag或Edge type时可以同时设置TTL选项。详情请参见[CREATE TAG](../10.tag-statements/1.create-tag.md)和[CREATE EDGE](../11.edge-type-statements/1.create-edge.md)。
+创建 Tag 或 Edge type 时可以同时设置 TTL 选项。详情请参见 [CREATE TAG](../10.tag-statements/1.create-tag.md) 和 [CREATE EDGE](../11.edge-type-statements/1.create-edge.md)。
 
 ```ngql
-# 创建Tag并设置TTL选项。
+# 创建 Tag 并设置 TTL 选项。
 nebula> CREATE TAG IF NOT EXISTS t2(a int, b int, c string) ttl_duration= 100, ttl_col = "a";
 
-# 插入点。过期时间戳为1612778164774（1612778164674 + 100）。
+# 插入点。过期时间戳为 1612778164774（1612778164674 + 100）。
 nebula> INSERT VERTEX t2(a, b, c) values "102":(1612778164674, 30, "Hello");
 ```
 
@@ -94,7 +94,7 @@ nebula> INSERT VERTEX t2(a, b, c) values "102":(1612778164674, 30, "Hello");
     nebula> ALTER TAG t1 ttl_col = "";
     ```
 
-- 设置`ttl_duration`为`0`。本操作可以保留TTL选项，属性永不过期，且属性的Schema无法修改。
+- 设置`ttl_duration`为`0`。本操作可以保留 TTL 选项，属性永不过期，且属性的 Schema 无法修改。
 
     ```ngql
     nebula> ALTER TAG t1 ttl_duration = 0;
diff --git a/docs-2.0/3.ngql-guide/8.clauses-and-options/where.md b/docs-2.0/3.ngql-guide/8.clauses-and-options/where.md
index f91003e4af..73c3d55d41 100644
--- a/docs-2.0/3.ngql-guide/8.clauses-and-options/where.md
+++ b/docs-2.0/3.ngql-guide/8.clauses-and-options/where.md
@@ -4,24 +4,24 @@
 
 `WHERE`子句通常用于如下查询：
 
-- 原生nGQL，例如`GO`和`LOOKUP`语句。
+- 原生 nGQL，例如`GO`和`LOOKUP`语句。
 
-- openCypher方式，例如`MATCH`和`WITH`语句。
+- openCypher 方式，例如`MATCH`和`WITH`语句。
 
-## openCypher兼容性
+## openCypher 兼容性
 
-- 不支持在`WHERE`子句中使用Pattern（TODO: planning），例如`WHERE (v)-->(v2)`。
+- 不支持在`WHERE`子句中使用 Pattern（TODO: planning），例如`WHERE (v)-->(v2)`。
 
-- [过滤Rank](#rank)是原生nGQL功能。如需在openCypher兼容语句中直接获取Rank值，可以使用rank()函数，例如`MATCH (:player)-[e:follow]->() RETURN rank(e);`。
+- [过滤 Rank](#rank) 是原生 nGQL 功能。如需在 openCypher 兼容语句中直接获取 Rank 值，可以使用 rank() 函数，例如`MATCH (:player)-[e:follow]->() RETURN rank(e);`。
 
 ## 基础用法
 
 !!! note
-    下文示例中的`$$`、`$^`等是引用符号，详情请参见[引用符](../5.operators/5.property-reference.md)。
+    下文示例中的`$$`、`$^`等是引用符号，详情请参见 [引用符](../5.operators/5.property-reference.md)。
 
 ### 用布尔运算符定义条件
 
-在`WHERE`子句中使用布尔运算符`NOT`、`AND`、`OR`和`XOR`定义条件。关于运算符的优先级，请参见[运算符优先级](../5.operators/9.precedence.md)。
+在`WHERE`子句中使用布尔运算符`NOT`、`AND`、`OR`和`XOR`定义条件。关于运算符的优先级，请参见 [运算符优先级](../5.operators/9.precedence.md)。
 
 ```ngql
 nebula> MATCH (v:player) \
@@ -144,9 +144,9 @@ nebula> MATCH (v:player) \
 ...
 ```
 
-### 过滤rank
+### 过滤 rank
 
-在nGQL中，如果多个边拥有相同的起始点、目的点和属性，则它们的唯一区别是rank值。在`WHERE`子句中可以使用rank过滤边。
+在 nGQL 中，如果多个边拥有相同的起始点、目的点和属性，则它们的唯一区别是 rank 值。在`WHERE`子句中可以使用 rank 过滤边。
 
 ```ngql
 # 创建测试数据。
@@ -164,7 +164,7 @@ nebula> INSERT EDGE e1(p1) VALUES "1"->"2"@4:(14);
 nebula> INSERT EDGE e1(p1) VALUES "1"->"2"@5:(15);
 nebula> INSERT EDGE e1(p1) VALUES "1"->"2"@6:(16);
 
-# 通过rank过滤边，查找rank大于2的边。
+# 通过 rank 过滤边，查找 rank 大于 2 的边。
 nebula> GO FROM "1" \
         OVER e1 \
         WHERE rank(edge) > 2 \
@@ -189,7 +189,7 @@ nebula> GO FROM "1" \
 `STARTS WITH`会从字符串的起始位置开始匹配。
 
 ```ngql
-# 查询姓名以T开头的player信息。
+# 查询姓名以 T 开头的 player 信息。
 nebula> MATCH (v:player) \
         WHERE v.name STARTS WITH "T" \
         RETURN v.name, v.age;
@@ -247,7 +247,7 @@ nebula> MATCH (v:player) \
 +---------------+-------+
 ```
 
-### 结合NOT使用
+### 结合 NOT 使用
 
 用户可以结合布尔运算符`NOT`一起使用，否定字符串匹配条件。
 
@@ -316,7 +316,7 @@ nebula> LOOKUP ON player \
 +-------------+-------------------------+------------------------+
 ```
 
-### 结合NOT使用
+### 结合 NOT 使用
 
 ```ngql
 nebula> MATCH (v:player) \
diff --git a/docs-2.0/3.ngql-guide/8.clauses-and-options/with.md b/docs-2.0/3.ngql-guide/8.clauses-and-options/with.md
index 993713df75..65de0dfcd4 100644
--- a/docs-2.0/3.ngql-guide/8.clauses-and-options/with.md
+++ b/docs-2.0/3.ngql-guide/8.clauses-and-options/with.md
@@ -2,19 +2,19 @@
 
 `WITH`子句可以获取并处理查询前半部分的结果，并将处理结果作为输入传递给查询的后半部分。
 
-## openCypher兼容性
+## openCypher 兼容性
 
-本文操作仅适用于openCypher方式。
+本文操作仅适用于 openCypher 方式。
 
 !!! Note
 
-    在原生nGQL中，有与`WITH`类似的[管道符](../5.operators/4.pipe.md)，但它们的工作方式不同。不要在openCypher方式中使用管道符，也不要在原生nGQL中使用`WITH`子句。
+    在原生 nGQL 中，有与`WITH`类似的 [管道符](../5.operators/4.pipe.md)，但它们的工作方式不同。不要在 openCypher 方式中使用管道符，也不要在原生 nGQL 中使用`WITH`子句。
 
 ## 组成复合查询
 
 使用`WITH`子句可以组合语句，将一条语句的输出转换为另一条语句的输入。
 
-### 示例1
+### 示例 1
 
 1. 匹配一个路径。
 2. 通过`nodes()`函数将路径上的所有点输出到一个列表。
@@ -44,10 +44,10 @@ nebula> MATCH p=(v:player{name:"Tim Duncan"})--() \
 +-----------------------------------------------------------+
 ```
 
-### 示例2
+### 示例 2
 
-1. 匹配点ID为`player100`的点。
-2. 通过`labels()`函数将点的所有Tag输出到一个列表。
+1. 匹配点 ID 为`player100`的点。
+2. 通过`labels()`函数将点的所有 Tag 输出到一个列表。
 3. 将列表拆分为行。
 4. 返回结果。
 
@@ -83,7 +83,7 @@ nebula> MATCH (v:player)-->(v2:player) \
 +----------------------+-----+
 ```
 
-## collect()之前处理输出
+## collect() 之前处理输出
 
 在`collect()`函数将输出结果转换为列表之前，可以使用`WITH`子句排序和限制输出结果。
 
@@ -100,7 +100,7 @@ nebula> MATCH (v:player) \
 +-----------------------------------------------+
 ```
 
-## 结合RETURN语句使用
+## 结合 RETURN 语句使用
 
 在`WITH`子句中设置别名，并通过`RETURN`子句输出结果。
 
diff --git a/docs-2.0/3.ngql-guide/8.clauses-and-options/yield.md b/docs-2.0/3.ngql-guide/8.clauses-and-options/yield.md
index 1936ba9f75..42cce2d250 100644
--- a/docs-2.0/3.ngql-guide/8.clauses-and-options/yield.md
+++ b/docs-2.0/3.ngql-guide/8.clauses-and-options/yield.md
@@ -1,31 +1,31 @@
 # YIELD
 
-`YIELD`定义nGQL查询的输出结果。
+`YIELD`定义 nGQL 查询的输出结果。
 
 `YIELD`可以引导子句或语句：
 
-- `YIELD`子句可以用于原生nGQL语句中，例如`GO`、`FETCH`或`LOOKUP`。
+- `YIELD`子句可以用于原生 nGQL 语句中，例如`GO`、`FETCH`或`LOOKUP`。
 
 - `YIELD`语句可以在独立查询或复合查询中使用。
 
-## openCypher兼容性
+## openCypher 兼容性
 
-本文操作仅适用于原生nGQL。关于openCypher方式如何定义输出结果，请参见[`RETURN`](return.md)。
+本文操作仅适用于原生 nGQL。关于 openCypher 方式如何定义输出结果，请参见 [`RETURN`](return.md)。
 
-`YIELD`在nGQL和openCypher中有不同的函数：
+`YIELD`在 nGQL 和 openCypher 中有不同的函数：
 
-- 在openCypher中，`YIELD`用于在`CALL[…YIELD]`子句中指定过程调用的输出。
+- 在 openCypher 中，`YIELD`用于在`CALL[…YIELD]`子句中指定过程调用的输出。
 
   !!! Note
 
-        nGQL不支持`CALL[…YIELD]`。
+        nGQL 不支持`CALL[…YIELD]`。
 
-- 在nGQL中，`YIELD`和openCypher中的`RETURN`类似。
+- 在 nGQL 中，`YIELD`和 openCypher 中的`RETURN`类似。
 
 !!! note
-    下文示例中的`$$`、`$-`等是引用符号，详情请参见[引用符](../5.operators/5.property-reference.md)。
+    下文示例中的`$$`、`$-`等是引用符号，详情请参见 [引用符](../5.operators/5.property-reference.md)。
 
-## YIELD子句
+## YIELD 子句
 
 ### 语法
 
@@ -39,7 +39,7 @@ YIELD [DISTINCT] <col> [AS <alias>] [, <col> [AS <alias>] ...];
 |`col`|要返回的字段。如果没有为字段设置别名，返回结果中的列名为`col`。|
 |`alias`|`col`的别名。使用关键字`AS`进行设置，设置后返回结果中的列名为该别名。|
 
-### 使用YIELD子句
+### 使用 YIELD 子句
 
 - `GO`语句中使用`YIELD`：
 
@@ -78,7 +78,7 @@ YIELD [DISTINCT] <col> [AS <alias>] [, <col> [AS <alias>] ...];
     +-------------+-------------------------+------------------------+
     ```
 
-## YIELD语句
+## YIELD 语句
 
 ### 语法
 
@@ -92,14 +92,14 @@ YIELD [DISTINCT] <col> [AS <alias>] [, <col> [AS <alias>] ...]
 |`DISTINCT`|聚合输出结果，返回去重后的结果集。|
 |`col`|要按返回的字段。如果没有为字段设置别名，返回结果中的列名为`col`。|
 |`alias`|`col`的别名。使用关键字`AS`进行设置，设置后返回结果中的列名为该别名。|
-|`conditions`|在`WHERE`子句中设置的过滤条件。详情请参见[`WHERE`](where.md)。|
+|`conditions`|在`WHERE`子句中设置的过滤条件。详情请参见 [`WHERE`](where.md)。|
 
-### 复合查询中使用YIELD语句
+### 复合查询中使用 YIELD 语句
 
-在[复合查询](../4.variable-and-composite-queries/1.composite-queries.md)中，`YIELD`语句可以接收、过滤、修改之前语句的结果集，然后输出。
+在 [复合查询](../4.variable-and-composite-queries/1.composite-queries.md) 中，`YIELD`语句可以接收、过滤、修改之前语句的结果集，然后输出。
 
 ```ngql
-# 查找player100关注的player，并计算他们的平均年龄。
+# 查找 player100 关注的 player，并计算他们的平均年龄。
 nebula> GO FROM "player100" OVER follow \
         YIELD dst(edge) AS ID \
         | FETCH PROP ON player $-.ID \
@@ -113,7 +113,7 @@ nebula> GO FROM "player100" OVER follow \
 ```
 
 ```ngql
-# 查找player101关注的player，返回degree大于90的player。
+# 查找 player101 关注的 player，返回 degree 大于 90 的 player。
 nebula> $var1 = GO FROM "player101" OVER follow \
         YIELD properties(edge).degree AS Degree, dst(edge) as ID; \
         YIELD $var1.ID AS ID WHERE $var1.Degree > 90;
@@ -125,7 +125,7 @@ nebula> $var1 = GO FROM "player101" OVER follow \
 +-------------+
 ```
 
-### 独立使用YIELD语句
+### 独立使用 YIELD 语句
 
 `YIELD`可以计算表达式并返回结果。