vesoft-inc
diff --git a/‎docs-2.0/1.introduction/3.nebula-graph-architecture/2.meta-service.md
+2-4 b/‎docs-2.0/1.introduction/3.nebula-graph-architecture/2.meta-service.md
+2-4
diff --git a/‎docs-2.0/2.quick-start/4.nebula-graph-crud.md
+58-102 b/‎docs-2.0/2.quick-start/4.nebula-graph-crud.md
+58-102
@@ -45,11 +45,9 @@ The Meta Service stores the schema information. Besides, it performs the additio
 
 For more information on Nebula Graph schema, see [Data model](../2.data-model.md).
 
-### Manages TTL-based data eviction
+### Manages TTL information
 
-The Meta Service provides automatic data eviction and space reclamation based on TTL (time to live) options for Nebula Graph.
-
-For more information on TTL, see [TTL options](../../3.ngql-guide/8.clauses-and-options/ttl-options.md).
+The Meta Service stores the definition of TTL (Time to Live) options which are used to control data expiration. The Storage Service takes care of the expiring and evicting processes. For more information, see [TTL](../../3.ngql-guide/8.clauses-and-options/ttl-options.md).
 
 ### Manages jobs
 
 
@@ -23,7 +23,7 @@ For more information, see [Data modeling](../1.introduction/2.data-model.md).
 
 In this topic, we will use the following dataset to demonstrate basic CRUD operations.
 
-![The demo dataset](https://docs-cdn.nebula-graph.com.cn/docs-2.0/2.quick-start/dataset-for-crud.png)
+![The demo dataset](dataset-for-crud.png)
 
 ## Check the machine status in the Nebula Graph cluster
 
@@ -41,7 +41,6 @@ nebula> SHOW HOSTS;
 | "storaged2" | 9779      | "ONLINE"  | 0            | "No valid partition" | "No valid partition"   |
 | "Total"     | __EMPTY__ | __EMPTY__ | 0            | __EMPTY__            | __EMPTY__              |
 +-------------+-----------+-----------+--------------+----------------------+------------------------+
-Got 4 rows (time spent 1061/2251 us)
 ```
 
 From the **Status** column of the table in the return results, you can see that all the Storage services are online.
@@ -110,7 +109,6 @@ To make sure the follow-up operations work as expected, take one of the followin
 
     ```ngql
     nebula> CREATE SPACE basketballplayer(partition_num=15, replica_factor=1, vid_type=fixed_string(30));
-    Execution succeeded (time spent 2817/3280 us)
     ```
 
 2. Check the partition distribution with `SHOW HOSTS` to make sure that the partitions are distributed in a balanced way.
@@ -125,7 +123,6 @@ To make sure the follow-up operations work as expected, take one of the followin
     | "storaged2" | 9779      | "ONLINE"  | 5            | "basketballplayer:5"             | "basketballplayer:5"   |
     | "Total"     |           |           | 15           | "basketballplayer:15"            | "basketballplayer:15"  |
     +-------------+-----------+-----------+--------------+----------------------------------+------------------------+
-    Got 4 rows (time spent 1633/2867 us)
     ```
 
     If the **Leader distribution** is uneven, use `BALANCE LEADER` to redistribute the partitions. For more information, see [BALANCE](../8.service-tuning/load-balance.md).
@@ -134,7 +131,6 @@ To make sure the follow-up operations work as expected, take one of the followin
 
     ```ngql
     nebula[(none)]> USE basketballplayer;
-    Execution succeeded (time spent 1229/2318 us)
     ```
 
     You can use `SHOW SPACES` to check the graph space you created.
@@ -146,7 +142,6 @@ To make sure the follow-up operations work as expected, take one of the followin
     +--------------------+
     | "basketballplayer" |
     +--------------------+
-    Got 1 rows (time spent 977/2000 us)
     ```
 
 ## Create tags and edge types
@@ -174,16 +169,12 @@ Create tags `player` and `team`, edge types `follow` and `serve`. Descriptions a
 
 ```ngql
 nebula> CREATE TAG player(name string, age int);
-Execution succeeded (time spent 20708/22071 us)
 
 nebula> CREATE TAG team(name string);
-Execution succeeded (time spent 5643/6810 us)
 
 nebula> CREATE EDGE follow(degree int);
-Execution succeeded (time spent 12665/13934 us)
 
 nebula> CREATE EDGE serve(start_year int, end_year int);
-Execution succeeded (time spent 5858/6870 us)
 ```
 
 ## Insert vertices and edges
@@ -219,32 +210,24 @@ Users can use the `INSERT` statement to insert vertices or edges based on existi
 
     ```ngql
     nebula> INSERT VERTEX player(name, age) VALUES "player100":("Tim Duncan", 42);
-    Execution succeeded (time spent 28196/30896 us)
-
+    
     nebula> INSERT VERTEX player(name, age) VALUES "player101":("Tony Parker", 36);
-    Execution succeeded (time spent 2708/3834 us)
-
+    
     nebula> INSERT VERTEX player(name, age) VALUES "player102":("LaMarcus Aldridge", 33);
-    Execution succeeded (time spent 1945/3294 us)
-
-    nebula> INSERT VERTEX team(name) VALUES "team200":("Warriors"), "team201":("Nuggets");
-    Execution succeeded (time spent 2269/3310 us)
+    
+    nebula> INSERT VERTEX team(name) VALUES "team203":("Trail Blazers"), "team204":("Spurs");
     ```
 
 * Insert edges representing the relations between basketball players and teams:
 
     ```ngql
-    nebula> INSERT EDGE follow(degree) VALUES "player100" -> "player101":(95);
-    Execution succeeded (time spent 3362/4542 us)
-
-    nebula> INSERT EDGE follow(degree) VALUES "player100" -> "player102":(90);
-    Execution succeeded (time spent 2974/4274 us)
-
-    nebula> INSERT EDGE follow(degree) VALUES "player102" -> "player101":(75);
-    Execution succeeded (time spent 1891/3096 us)
-
-    nebula> INSERT EDGE serve(start_year, end_year) VALUES "player100" -> "team200":(1997, 2016), "player101" -> "team201":(1999,  2018);
-    Execution succeeded (time spent 6064/7104 us)
+    nebula> INSERT EDGE follow(degree) VALUES "player101" -> "player100":(95);
+    
+    nebula> INSERT EDGE follow(degree) VALUES "player101" -> "player102":(90);
+    
+    nebula> INSERT EDGE follow(degree) VALUES "player102" -> "player100":(75);
+    
+    nebula> INSERT EDGE serve(start_year, end_year) VALUES "player101" -> "team204":(1999, 2018),"player102" -> "team203":(2006,  2015);
     ```
 
 ## Read data
@@ -305,30 +288,28 @@ Users can use the `INSERT` statement to insert vertices or edges based on existi
 
 ### Examples of `GO` statement
 
-* Search for the players that the player with VID `player100` follows.
+* Search for the players that the player with VID `player101` follows.
 
     ```ngql
-    nebula> GO FROM "player100" OVER follow;
+    nebula> GO FROM "player101" OVER follow;
     +-------------+
     | follow._dst |
     +-------------+
-    | "player101" |
+    | "player100" |
     | "player102" |
     +-------------+
-    Got 2 rows (time spent 12097/14220 us)
     ```
 
-* Filter the players that the player with VID `player100` follows whose age is equal to or greater than 35. Rename the corresponding columns in the results with `Teammate` and `Age`.
+* Filter the players that the player with VID `player101` follows whose age is equal to or greater than 35. Rename the corresponding columns in the results with `Teammate` and `Age`.
 
     ```ngql
-    nebula> GO FROM "player100" OVER follow WHERE properties($$).age >= 35 \
+    nebula> GO FROM "player101" OVER follow WHERE properties($$).age >= 35 \
             YIELD properties($$).name AS Teammate, properties($$).age AS Age;
-    +-----------------+-----+
-    | Teammate        | Age |
-    +-----------------+-----+
-    | "Tony Parker"   | 36  |
-    | "Manu Ginobili" | 41  |
-    +-----------------+-----+
+    +--------------+-----+
+    | Teammate     | Age |
+    +--------------+-----+
+    | "Tim Duncan" | 42  |
+    +--------------+-----+
     ```
 
     | Clause/Sign | Description                                                         |
@@ -337,21 +318,19 @@ Users can use the `INSERT` statement to insert vertices or edges based on existi
     | `$$`        | Represents the target vertices.                                     |
     | `\`         | A line-breaker.                                                     |
 
-* Search for the players that the player with VID `player100` follows. Then Retrieve the teams of the players that the player with VID `player100` follows. To combine the two queries, use a pipe or a temporary variable.
+* Search for the players that the player with VID `player101` follows. Then Retrieve the teams of the players that the player with VID `player100` follows. To combine the two queries, use a pipe or a temporary variable.
 
   * With a pipe:
 
     ```ngql
-    nebula> GO FROM "player100" OVER follow YIELD dst(edge) AS id | \
+    nebula> GO FROM "player101" OVER follow YIELD dst(edge) AS id | \
             GO FROM $-.id OVER serve YIELD properties($$).name AS Team, \
             properties($^).name AS Player;
-    +-----------+-----------------+
-    | Team      | Player          |
-    +-----------+-----------------+
-    | "Spurs"   | "Tony Parker"   |
-    | "Hornets" | "Tony Parker"   |
-    | "Spurs"   | "Manu Ginobili" |
-    +-----------+-----------------+
+    +-----------------+---------------------+
+    | Team            | Player              |
+    +-----------------+---------------------+
+    | "Trail Blazers" | "LaMarcus Aldridge" |
+    +-----------------+---------------------+
     ```
 
     |Clause/Sign|Description|
@@ -367,16 +346,14 @@ Users can use the `INSERT` statement to insert vertices or edges based on existi
         Once a composite statement is submitted to the server as a whole, the life cycle of the temporary variables in the statement ends.
 
     ```ngql
-    nebula> $var = GO FROM "player100" OVER follow YIELD dst(edge) AS id; \
+    nebula> $var = GO FROM "player101" OVER follow YIELD dst(edge) AS id; \
             GO FROM $var.id OVER serve YIELD properties($$).name AS Team, \
             properties($^).name AS Player;
-    +-----------+-----------------+
-    | Team      | Player          |
-    +-----------+-----------------+
-    | "Spurs"   | "Tony Parker"   |
-    | "Hornets" | "Tony Parker"   |
-    | "Spurs"   | "Manu Ginobili" |
-    +-----------+-----------------+
+    +-----------------+---------------------+
+    | Team            | Player              |
+    +-----------------+---------------------+
+    | "Trail Blazers" | "LaMarcus Aldridge" |
+    +-----------------+---------------------+
     ```
 
 ### Example of `FETCH` statement
@@ -435,49 +412,41 @@ Users can use the `UPDATE` or the `UPSERT` statements to update existing data.
 
     ```ngql
     nebula> UPDATE VERTEX "player100" SET player.name = "Tim";
-    Execution succeeded (time spent 3483/3914 us)
 
     nebula> FETCH PROP ON player "player100";
     +---------------------------------------------+
     | vertices_                                   |
     +---------------------------------------------+
     | ("player100" :player{age: 42, name: "Tim"}) |
     +---------------------------------------------+
-    Got 1 rows (time spent 2463/3042 us)
     ```
 
 * `UPDATE` the `degree` property of an edge and check the result with the `FETCH` statement.
 
     ```ngql
-    nebula> UPDATE EDGE "player100" -> "player101" OF follow SET degree = 96;
-    Execution succeeded (time spent 3932/4432 us)
+    nebula> UPDATE EDGE "player101" -> "player100" OF follow SET degree = 96;
 
-    nebula> FETCH PROP ON follow "player100" -> "player101";
+    nebula> FETCH PROP ON follow "player101" -> "player100";
     +----------------------------------------------------+
     | edges_                                             |
     +----------------------------------------------------+
-    | [:follow "player100"->"player101" @0 {degree: 96}] |
+    | [:follow "player101"->"player100" @0 {degree: 96}] |
     +----------------------------------------------------+
-    Got 1 rows (time spent 2205/2800 us)
     ```
 
 * Insert a vertex with VID `player111` and `UPSERT` it.
 
     ```ngql
-    nebula> INSERT VERTEX player(name, age) VALUES "player111":("Ben Simmons", 22);
-    Execution succeeded (time spent 2115/2900 us)
-
-    Wed, 21 Oct 2020 11:11:50 UTC
-
-    nebula> UPSERT VERTEX "player111" SET player.name = "Dwight Howard", player.age = $^.player.age + 11 \
-            WHEN $^.player.name == "Ben Simmons" AND $^.player.age > 20 \
+    nebula> INSERT VERTEX player(name,age) values "player111":("David West", 38);
+    
+    nebula> UPSERT VERTEX "player111" SET player.name = "David", player.age = $^.player.age + 11 \
+            WHEN $^.player.name == "David West" AND $^.player.age > 20 \
             YIELD $^.player.name AS Name, $^.player.age AS Age;
-    +---------------+-----+
-    | Name          | Age |
-    +---------------+-----+
-    | Dwight Howard | 33  |
-    +---------------+-----+
-    Got 1 rows (time spent 1815/2329 us)
+    +---------+-----+
+    | Name    | Age |
+    +---------+-----+
+    | "David" | 49  |
+    +---------+-----+
     ```
 
 ## Delete vertices and edges
@@ -502,15 +471,13 @@ Users can use the `UPDATE` or the `UPSERT` statements to update existing data.
 * Delete vertices:
 
     ```ngql
-    nebula> DELETE VERTEX "team1", "team2";
-    Execution succeeded (time spent 4337/4782 us)
+    nebula> DELETE VERTEX "player111", "team203";
     ```
 
 * Delete edges:
 
     ```ngql
-    nebula> DELETE EDGE follow "team1" -> "team2";
-    Execution succeeded (time spent 3700/4101 us)
+    nebula> DELETE EDGE follow "player101" -> "team204";
     ```
 
 ## About indexes
@@ -538,15 +505,6 @@ Users can add indexes to tags and edge types with the [CREATE INDEX](../3.ngql-g
     REBUILD {TAG | EDGE} INDEX <index_name>;
     ```
 
-### Examples
-
-Create and rebuild indexes for the `name` property on all vertices with the tag `player`.
-
-```ngql
-nebula> CREATE TAG INDEX player_index_0 on player(name(20));
-nebula> REBUILD TAG INDEX player_index_0;
-```
-
 !!! note
 
     Define the index length when creating an index for a variable-length property. In UTF-8 encoding, a non-ascii character occupies 3 bytes. You should set an appropriate index length according to the variable-length property. For example, the index should be 30 bytes for 10 non-ascii characters. For more information, see [CREATE INDEX](../3.ngql-guide/14.native-index-statements/1.create-native-index.md)
@@ -557,17 +515,16 @@ Make sure there is an [index](#about_indexes) for `LOOKUP` or `MATCH` to use. If
 
 Find the information of the vertex with the tag `player` and its value of the `name` property is `Tony Parker`.
 
-This example creates the index `player_name_0` on the player name property.
+This example creates the index `player_index_1` on the player name property.
 
 ```nGQL
-nebula> CREATE TAG INDEX player_name_0 on player(name(10));
-Execution succeeded (time spent 3465/4150 us)
+nebula> CREATE TAG INDEX player_index_1 ON player(name(20));
 ```
 
 This example rebuilds the index to make sure it takes effect on pre-existing data.
 
 ```nGQL
-nebula> REBUILD TAG INDEX player_name_0
+nebula> REBUILD TAG INDEX player_index_1
 +------------+
 | New Job Id |
 +------------+
@@ -580,12 +537,12 @@ This example uses the `LOOKUP` statement to retrieve the vertex property.
 
 ```nGQL
 nebula> LOOKUP ON player WHERE player.name == "Tony Parker" \
-        YIELD player.name, player.age;
-+-------------+---------------+------------+
-| VertexID    | player.name   | player.age |
-+-------------+---------------+------------+
-| "player101" | "Tony Parker" | 36         |
-+-------------+---------------+------------+
+        YIELD properties(vertex).name AS name, properties(vertex).age AS age;
++-------------+---------------+-----+
+| VertexID    | name          | age |
++-------------+---------------+-----+
+| "player101" | "Tony Parker" | 36  |
++-------------+---------------+-----+
 ```
 
 This example uses the `MATCH` statement to retrieve the vertex property.
@@ -597,5 +554,4 @@ nebula> MATCH (v:player{name:"Tony Parker"}) RETURN v;
 +-----------------------------------------------------+
 | ("player101" :player{age: 36, name: "Tony Parker"}) |
 +-----------------------------------------------------+
-Got 1 rows (time spent 5132/6246 us)
 ```