doc: SQL reference guide

4176b6b6 · gccgdb1234 · e13e80db · 4176b6b6 · 4176b6b6 · 4176b6b6
9 changed file
--- a/docs/zh/12-taos-sql/05-insert.md
+++ b/docs/zh/12-taos-sql/05-insert.md
@@ -5,7 +5,7 @@ title: 数据写入

 ## 写入语法

-```
+```sql
 INSERT INTO
    tb_name
        [USING stb_name [(tag1_name, ...)] TAGS (tag1_value, ...)]
@@ -18,46 +18,64 @@ INSERT INTO
    ...];
 ```

-## 插入一条或多条记录
+**关于时间戳**
+
+1. TDengine 要求插入的数据必须要有时间戳，插入数据的时间戳要注意以下几点：
+
+2. 时间戳不同的格式语法会有不同的精度影响。字符串格式的时间戳写法不受所在 DATABASE 的时间精度设置影响；而长整形格式的时间戳写法会受到所在 DATABASE 的时间精度设置影响。例如，时间戳"2021-07-13 16:16:48"的 UNIX 秒数为 1626164208。则其在毫秒精度下需要写作 1626164208000，在微秒精度设置下就需要写为 1626164208000000，纳秒精度设置下需要写为 1626164208000000000。
+
+3. 一次插入多行数据时，不要把首列的时间戳的值都写 NOW。否则会导致语句中的多条记录使用相同的时间戳，于是就可能出现相互覆盖以致这些数据行无法全部被正确保存。其原因在于，NOW 函数在执行中会被解析为所在 SQL 语句的客户端执行时间，出现在同一语句中的多个 NOW 标记也就会被替换为完全相同的时间戳取值。
+   允许插入的最老记录的时间戳，是相对于当前服务器时间，减去配置的 KEEP 值（数据保留的天数）。允许插入的最新记录的时间戳，是相对于当前服务器时间，加上配置的 DURATION 值（数据文件存储数据的时间跨度，单位为天）。KEEP 和 DURATION 都是可以在创建数据库时指定的，缺省值分别是 3650 天和 10 天。
+
+**语法说明**
+
+1. USING 子句是自动建表语法。如果用户在写数据时并不确定某个表是否存在，此时可以在写入数据时使用自动建表语法来创建不存在的表，若该表已存在则不会建立新表。自动建表时，要求必须以超级表为模板，并写明数据表的 TAGS 取值。可以只是指定部分 TAGS 列的取值，未被指定的 TAGS 列将置为 NULL。
+
+2. 可以指定要插入值的列，对于为指定的列数据库将自动填充为 NULL。
+
+3. VALUES 语法表示了要插入的一行或多行数据。
+
+4. FILE 语法表示数据来自于 CSV 文件（英文逗号分隔、英文单引号括住每个值），CSV 文件无需表头。
+
+5. 无论使用哪种语法，均可以在一条 INSERT 语句中同时向多个表插入数据。
+
+6. INSERT 语句是完整解析后再执行的，对如下语句，不会再出现数据错误但建表成功的情况：
+
+   ```sql
+   INSERT INTO d1001 USING meters TAGS('Beijing.Chaoyang', 2) VALUES('a');
+   ```
+
+7. 对于向多个子表插入数据的情况，依然会有部分数据写入失败，部分数据写入成功的情况。这是因为多个子表可能分布在不同的 VNODE 上，客户端将 INSERT 语句完整解析后，将数据发往各个涉及的 VNODE 上，每个 VNODE 独立进行写入操作。如果某个 VNODE 因为某些原因（比如网络问题或磁盘故障）导致写入失败，并不会影响其他 VNODE 节点的写入。
+
+## 插入一条记录

 指定已经创建好的数据子表的表名，并通过 VALUES 关键字提供一行或多行数据，即可向数据库写入这些数据。例如，执行如下语句可以写入一行记录：

-```
+```sql
 INSERT INTO d1001 VALUES (NOW, 10.2, 219, 0.32);
 ```

+## 插入多条记录
+
 或者，可以通过如下语句写入两行记录：

-```
+```sql
 INSERT INTO d1001 VALUES ('2021-07-13 14:06:32.272', 10.2, 219, 0.32) (1626164208000, 10.15, 217, 0.33);
 ```

-:::note
-
-1. 在第二个例子中，两行记录的首列时间戳使用了不同格式的写法。其中字符串格式的时间戳写法不受所在 DATABASE 的时间精度设置影响；而长整形格式的时间戳写法会受到所在 DATABASE 的时间精度设置影响——例子中的时间戳在毫秒精度下可以写作 1626164208000，而如果是在微秒精度设置下就需要写为 1626164208000000，纳秒精度设置下需要写为 1626164208000000000。
-2. 在使用“插入多条记录”方式写入数据时，不能把第一列的时间戳取值都设为 NOW，否则会导致语句中的多条记录使用相同的时间戳，于是就可能出现相互覆盖以致这些数据行无法全部被正确保存。其原因在于，NOW 函数在执行中会被解析为所在 SQL 语句的实际执行时间，出现在同一语句中的多个 NOW 标记也就会被替换为完全相同的时间戳取值。
-3. 允许插入的最老记录的时间戳，是相对于当前服务器时间，减去配置的 keep 值（数据保留的天数）；允许插入的最新记录的时间戳，是相对于当前服务器时间，加上配置的 days 值（数据文件存储数据的时间跨度，单位为天）。keep 和 days 都是可以在创建数据库时指定的，缺省值分别是 3650 天和 10 天。
-
-:::
-
-## 插入记录，数据对应到指定的列
+## 指定列插入

 向数据子表中插入记录时，无论插入一行还是多行，都可以让数据对应到指定的列。对于 SQL 语句中没有出现的列，数据库将自动填充为 NULL。主键（时间戳）不能为 NULL。例如：

-```
+```sql
 INSERT INTO d1001 (ts, current, phase) VALUES ('2021-07-13 14:06:33.196', 10.27, 0.31);
 ```

-:::info
-如果不指定列，也即使用全列模式——那么在 VALUES 部分提供的数据，必须为数据表的每个列都显式地提供数据。全列模式写入速度会远快于指定列，因此建议尽可能采用全列写入方式，此时空列可以填入 NULL。
-
-:::
-
 ## 向多个表插入记录

 可以在一条语句中，分别向多个表插入一条或多条记录，并且也可以在插入过程中指定列。例如：

-```
+```sql
 INSERT INTO d1001 VALUES ('2021-07-13 14:06:34.630', 10.2, 219, 0.32) ('2021-07-13 14:06:35.779', 10.15, 217, 0.33)
            d1002 (ts, current, phase) VALUES ('2021-07-13 14:06:34.255', 10.27, 0.31）;
 ```
@@ -66,28 +84,24 @@ INSERT INTO d1001 VALUES ('2021-07-13 14:06:34.630', 10.2, 219, 0.32) ('2021-07-

 如果用户在写数据时并不确定某个表是否存在，此时可以在写入数据时使用自动建表语法来创建不存在的表，若该表已存在则不会建立新表。自动建表时，要求必须以超级表为模板，并写明数据表的 TAGS 取值。例如：

-```
+```sql
 INSERT INTO d21001 USING meters TAGS ('California.SanFrancisco', 2) VALUES ('2021-07-13 14:06:32.272', 10.2, 219, 0.32);
 ```

 也可以在自动建表时，只是指定部分 TAGS 列的取值，未被指定的 TAGS 列将置为 NULL。例如：

-```
+```sql
 INSERT INTO d21001 USING meters (groupId) TAGS (2) VALUES ('2021-07-13 14:06:33.196', 10.15, 217, 0.33);
 ```

 自动建表语法也支持在一条语句中向多个表插入记录。例如：

-```
+```sql
 INSERT INTO d21001 USING meters TAGS ('California.SanFrancisco', 2) VALUES ('2021-07-13 14:06:34.630', 10.2, 219, 0.32) ('2021-07-13 14:06:35.779', 10.15, 217, 0.33)
            d21002 USING meters (groupId) TAGS (2) VALUES ('2021-07-13 14:06:34.255', 10.15, 217, 0.33)
            d21003 USING meters (groupId) TAGS (2) (ts, current, phase) VALUES ('2021-07-13 14:06:34.255', 10.27, 0.31);
 ```

-:::info
-在 2.0.20.5 版本之前，在使用自动建表语法并指定列时，子表的列名必须紧跟在子表名称后面，而不能如例子里那样放在 TAGS 和 VALUES 之间。从 2.0.20.5 版本开始，两种写法都可以，但不能在一条 SQL 语句中混用，否则会报语法错误。
-:::
-
 ## 插入来自文件的数据记录

 除了使用 VALUES 关键字插入一行或多行数据外，也可以把要写入的数据放在 CSV 文件中（英文逗号分隔、英文单引号括住每个值）供 SQL 指令读取。其中 CSV 文件无需表头。例如，如果 /tmp/csvfile.csv 文件的内容为：
@@ -99,51 +113,19 @@ INSERT INTO d21001 USING meters TAGS ('California.SanFrancisco', 2) VALUES ('202

 那么通过如下指令可以把这个文件中的数据写入子表中：

-```
+```sql
 INSERT INTO d1001 FILE '/tmp/csvfile.csv';
 ```

 ## 插入来自文件的数据记录，并自动建表

-从 2.1.5.0 版本开始，支持在插入来自 CSV 文件的数据时，以超级表为模板来自动创建不存在的数据表。例如：
-
-```
+```sql
 INSERT INTO d21001 USING meters TAGS ('California.SanFrancisco', 2) FILE '/tmp/csvfile.csv';
 ```

 也可以在一条语句中向多个表以自动建表的方式插入记录。例如：

-```
+```sql
 INSERT INTO d21001 USING meters TAGS ('California.SanFrancisco', 2) FILE '/tmp/csvfile_21001.csv'
            d21002 USING meters (groupId) TAGS (2) FILE '/tmp/csvfile_21002.csv';
 ```
-
-## 历史记录写入
-
-可使用 IMPORT 或者 INSERT 命令，IMPORT 的语法，功能与 INSERT 完全一样。
-
-针对 insert 类型的 SQL 语句，我们采用的流式解析策略，在发现后面的错误之前，前面正确的部分 SQL 仍会执行。下面的 SQL 中，INSERT 语句是无效的，但是 d1001 仍会被创建。
-
-```
-taos> CREATE TABLE meters(ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS(location BINARY(30), groupId INT);
-Query OK, 0 row(s) affected (0.008245s)
-
-taos> SHOW STABLES;
-              name              |      created_time       | columns |  tags  |   tables    |
-============================================================================================
- meters                         | 2020-08-06 17:50:27.831 |       4 |      2 |           0 |
-Query OK, 1 row(s) in set (0.001029s)
-
-taos> SHOW TABLES;
-Query OK, 0 row(s) in set (0.000946s)
-
-taos> INSERT INTO d1001 USING meters TAGS('California.SanFrancisco', 2) VALUES('a');
-
-DB error: invalid SQL: 'a' (invalid timestamp) (0.039494s)
-
-taos> SHOW TABLES;
-           table_name           |      created_time       | columns |          stable_name           |
-======================================================================================================
- d1001                          | 2020-08-06 17:52:02.097 |       4 | meters                         |
-Query OK, 1 row(s) in set (0.001091s)
-```
--- a/docs/zh/12-taos-sql/06-select.md
+++ b/docs/zh/12-taos-sql/06-select.md
@@ -5,121 +5,118 @@ title: 数据查询

 ## 查询语法

-```
-SELECT select_expr [, select_expr ...]
-    FROM {tb_name_list}
-    [WHERE where_condition]
-    [SESSION(ts_col, tol_val)]
-    [STATE_WINDOW(col)]
-    [INTERVAL(interval_val [, interval_offset]) [SLIDING sliding_val]]
-    [FILL(fill_mod_and_val)]
-    [GROUP BY col_list]
-    [ORDER BY col_list { DESC | ASC }]
+```sql
+SELECT {DATABASE() | CLIENT_VERSION() | SERVER_VERSION() | SERVER_STATUS() | NOW() | TODAY() | TIMEZONE()}
+
+SELECT [DISTINCT] select_list
+    from_clause
+    [WHERE condition]
+    [PARTITION BY tag_list]
+    [window_clause]
+    [group_by_clause]
+    [order_by_clasue]
    [SLIMIT limit_val [SOFFSET offset_val]]
    [LIMIT limit_val [OFFSET offset_val]]
-    [>> export_file];
-```
+    [>> export_file]

-## 通配符
+select_list:
+    select_expr [, select_expr] ...

-通配符 \* 可以用于代指全部列。对于普通表，结果中只有普通列。
+select_expr: {
+    *
+  | query_name.*
+  | [schema_name.] {table_name | view_name} .*
+  | t_alias.*
+  | expr [[AS] c_alias]
+}

-```
-taos> SELECT * FROM d1001;
-           ts            |       current        |   voltage   |        phase         |
-======================================================================================
- 2018-10-03 14:38:05.000 |             10.30000 |         219 |              0.31000 |
- 2018-10-03 14:38:15.000 |             12.60000 |         218 |              0.33000 |
- 2018-10-03 14:38:16.800 |             12.30000 |         221 |              0.31000 |
-Query OK, 3 row(s) in set (0.001165s)
-```
+from_clause: {
+    table_reference [, table_reference] ...
+  | join_clause [, join_clause] ...
+}
+
+table_reference:
+    table_expr t_alias
+
+table_expr: {
+    table_name
+  | view_name
+  | ( subquery )
+}

-在针对超级表，通配符包含 _标签列_ 。
+join_clause:
+    table_reference [INNER] JOIN table_reference ON condition

+window_clause: {
+    SESSION(ts_col, tol_val)
+  | STATE_WINDOW(col)
+  | INTERVAL(interval_val [, interval_offset]) [SLIDING (sliding_val)] [WATERMARK(watermark_val)] [FILL(fill_mod_and_val)]
+
+changes_option: {
+    DURATION duration_val
+  | ROWS rows_val
+}
+
+group_by_clause:
+    GROUP BY expr [, expr] ... HAVING condition
+
+order_by_clasue:
+    ORDER BY order_expr [, order_expr] ...
+
+order_expr:
+    {expr | position | c_alias} [DESC | ASC] [NULLS FIRST | NULLS LAST]
 ```
-taos> SELECT * FROM meters;
-           ts            |       current        |   voltage   |        phase         |            location            |   groupid   |
-=====================================================================================================================================
- 2018-10-03 14:38:05.500 |             11.80000 |         221 |              0.28000 | California.LosAngeles                |           2 |
- 2018-10-03 14:38:16.600 |             13.40000 |         223 |              0.29000 | California.LosAngeles                |           2 |
- 2018-10-03 14:38:05.000 |             10.80000 |         223 |              0.29000 | California.LosAngeles                |           3 |
- 2018-10-03 14:38:06.500 |             11.50000 |         221 |              0.35000 | California.LosAngeles                |           3 |
- 2018-10-03 14:38:04.000 |             10.20000 |         220 |              0.23000 | California.SanFrancisco               |           3 |
- 2018-10-03 14:38:16.650 |             10.30000 |         218 |              0.25000 | California.SanFrancisco               |           3 |
- 2018-10-03 14:38:05.000 |             10.30000 |         219 |              0.31000 | California.SanFrancisco               |           2 |
- 2018-10-03 14:38:15.000 |             12.60000 |         218 |              0.33000 | California.SanFrancisco               |           2 |
- 2018-10-03 14:38:16.800 |             12.30000 |         221 |              0.31000 | California.SanFrancisco               |           2 |
-Query OK, 9 row(s) in set (0.002022s)
+
+## 列表
+
+查询语句可以指定部分或全部列作为返回结果。数据列和标签列都可以出现在列表中。
+
+### 通配符
+
+通配符 \* 可以用于代指全部列。对于普通表，结果中只有普通列。对于超级表和子表，还包含了 TAG 列。
+
+```sql
+SELECT * FROM d1001;
 ```

 通配符支持表名前缀，以下两个 SQL 语句均为返回全部的列：

-```
+```sql
 SELECT * FROM d1001;
 SELECT d1001.* FROM d1001;
 ```

-在 JOIN 查询中，带前缀的\*和不带前缀\*返回的结果有差别， \*返回全部表的所有列数据（不包含标签），带前缀的通配符，则只返回该表的列数据。
+在 JOIN 查询中，带表名前缀的\*和不带前缀\*返回的结果有差别， \*返回全部表的所有列数据（不包含标签），而带表名前缀的通配符，则只返回该表的列数据。

-```
-taos> SELECT * FROM d1001, d1003 WHERE d1001.ts=d1003.ts;
-           ts            | current |   voltage   |    phase     |           ts            | current |   voltage   |    phase     |
-==================================================================================================================================
- 2018-10-03 14:38:05.000 | 10.30000|         219 |      0.31000 | 2018-10-03 14:38:05.000 | 10.80000|         223 |      0.29000 |
-Query OK, 1 row(s) in set (0.017385s)
+```sql
+SELECT * FROM d1001, d1003 WHERE d1001.ts=d1003.ts;
+SELECT d1001.* FROM d1001,d1003 WHERE d1001.ts = d1003.ts;
 ```

-```
-taos> SELECT d1001.* FROM d1001,d1003 WHERE d1001.ts = d1003.ts;
-           ts            |       current        |   voltage   |        phase         |
-======================================================================================
- 2018-10-03 14:38:05.000 |             10.30000 |         219 |              0.31000 |
-Query OK, 1 row(s) in set (0.020443s)
-```
+上面的查询语句中，前者返回 d1001 和 d1003 的全部列，而后者仅返回 d1001 的全部列。

 在使用 SQL 函数来进行查询的过程中，部分 SQL 函数支持通配符操作。其中的区别在于：
 `count(*)`函数只返回一列。`first`、`last`、`last_row`函数则是返回全部列。

-```
-taos> SELECT COUNT(*) FROM d1001;
-       count(*)        |
-========================
-                     3 |
-Query OK, 1 row(s) in set (0.001035s)
-```
-
-```
-taos> SELECT FIRST(*) FROM d1001;
-        first(ts)        |    first(current)    | first(voltage) |     first(phase)     |
-=========================================================================================
- 2018-10-03 14:38:05.000 |             10.30000 |            219 |              0.31000 |
-Query OK, 1 row(s) in set (0.000849s)
-```
-
-## 标签列
+### 标签列

-从 2.0.14 版本开始，支持在普通表的查询中指定 _标签列_，且标签列的值会与普通列的数据一起返回。
+在超级表和子表的查询中可以指定 _标签列_，且标签列的值会与普通列的数据一起返回。

-```
-taos> SELECT location, groupid, current FROM d1001 LIMIT 2;
-            location            |   groupid   |       current        |
-======================================================================
- California.SanFrancisco               |           2 |             10.30000 |
- California.SanFrancisco               |           2 |             12.60000 |
-Query OK, 2 row(s) in set (0.003112s)
+```sql
+ELECT location, groupid, current FROM d1001 LIMIT 2;
 ```

-注意：普通表的通配符 \* 中并不包含 _标签列_。
+### 结果去重

-## 获取标签列或普通列的去重取值
+`DISINTCT` 关键字可以对结果集中的一列或多列进行去重，去除的列既可以是标签列也可以是数据列。

-从 2.0.15.0 版本开始，支持在超级表查询标签列时，指定 DISTINCT 关键字，这样将返回指定标签列的所有不重复取值。注意，在 2.1.6.0 版本之前，DISTINCT 只支持处理单个标签列，而从 2.1.6.0 版本开始，DISTINCT 可以对多个标签列进行处理，输出这些标签列取值不重复的组合。
+对标签列去重：

 ```sql
 SELECT DISTINCT tag_name [, tag_name ...] FROM stb_name;
 ```

-从 2.1.7.0 版本开始，DISTINCT 也支持对数据子表或普通表进行处理，也即支持获取单个普通列的不重复取值，或多个普通列取值的不重复组合。
+对数据列去重：

 ```sql
 SELECT DISTINCT col_name [, col_name ...] FROM tb_name;
@@ -133,210 +130,178 @@ SELECT DISTINCT col_name [, col_name ...] FROM tb_name;

 :::

-## 结果集列名
+### 结果集列名

 `SELECT`子句中，如果不指定返回结果集合的列名，结果集列名称默认使用`SELECT`子句中的表达式名称作为列名称。此外，用户可使用`AS`来重命名返回结果集合中列的名称。例如：

-```
+```sql
 taos> SELECT ts, ts AS primary_key_ts FROM d1001;
-           ts            |     primary_key_ts      |
-====================================================
- 2018-10-03 14:38:05.000 | 2018-10-03 14:38:05.000 |
- 2018-10-03 14:38:15.000 | 2018-10-03 14:38:15.000 |
- 2018-10-03 14:38:16.800 | 2018-10-03 14:38:16.800 |
-Query OK, 3 row(s) in set (0.001191s)
 ```

 但是针对`first(*)`、`last(*)`、`last_row(*)`不支持针对单列的重命名。

-## 隐式结果列
+### 隐式结果列

 `Select_exprs`可以是表所属列的列名，也可以是基于列的函数表达式或计算式，数量的上限 256 个。当用户使用了`interval`或`group by tags`的子句以后，在最后返回结果中会强制返回时间戳列（第一列）和 group by 子句中的标签列。后续的版本中可以支持关闭 group by 子句中隐式列的输出，列输出完全由 select 子句控制。

-## 表（超级表）列表
+### 伪列

-FROM 关键字后面可以是若干个表（超级表）列表，也可以是子查询的结果。
-如果没有指定用户的当前数据库，可以在表名称之前使用数据库的名称来指定表所属的数据库。例如：`power.d1001` 方式来跨库使用表。
+**TBNAME**
+`TBNAME` 可以视为超级表中一个特殊的标签，代表子表的表名。

+获取一个超级表所有的子表名及相关的标签信息：
+
+```mysql
+SELECT TBNAME, location FROM meters;
 ```
-SELECT * FROM power.d1001;
------------------------------
-USE power;
-SELECT * FROM d1001;
+
+统计超级表下辖子表数量：
+
+```mysql
+SELECT COUNT(*) FROM (SELECT DISTINCT TBNAME FROM meters);
 ```

-## 特殊功能
+以上两个查询均只支持在 WHERE 条件子句中添加针对标签（TAGS）的过滤条件。例如：

-部分特殊的查询功能可以不使用 FROM 子句执行。获取当前所在的数据库 database()：
+**\_QSTART/\_QEND**

-```
-taos> SELECT DATABASE();
-           database()           |
-=================================
- power                          |
-Query OK, 1 row(s) in set (0.000079s)
-```
+\_qstart 和\_qend 表示用户输入的查询时间范围，即 WHERE 子句中主键时间戳条件所限定的时间范围。如果 WHERE 子句中没有有效的主键时间戳条件，则时间范围为[-2^63, 2^63-1]。

-如果登录的时候没有指定默认数据库，且没有使用`USE`命令切换数据，则返回 NULL。
+\_qstart 和\_qend 不能用于 WHERE 子句中。

-```
-taos> SELECT DATABASE();
-           database()           |
-=================================
- NULL                           |
-Query OK, 1 row(s) in set (0.000184s)
-```
+**\_WSTART/\_WEND/\_WDURATION**
+\_wstart 伪列、\_wend 伪列和\_wduration 伪列
+\_wstart 表示窗口起始时间戳，\_wend 表示窗口结束时间戳，\_wduration 表示窗口持续时长。

-获取服务器和客户端版本号：
+这三个伪列只能用于时间窗口的窗口切分查询之中，且要在窗口切分子句之后出现。

-```
-taos> SELECT CLIENT_VERSION();
- client_version() |
-===================
- 2.0.0.0          |
-Query OK, 1 row(s) in set (0.000070s)
+### \_c0/\_ROWTS
+
+TDengine 中，所有表的第一列都必须是时间戳类型，且为其主键，\_rowts 伪列和\_c0 伪列均代表了此列的值。相比实际的主键时间戳列，使用伪列更加灵活，语义也更加标准。例如，可以和 max\min 等函数一起使用。

-taos> SELECT SERVER_VERSION();
- server_version() |
-===================
- 2.0.0.0          |
-Query OK, 1 row(s) in set (0.000077s)
+```sql
+select _rowts, max(current) from meters;
 ```

-服务器状态检测语句。如果服务器正常，返回一个数字（例如 1）。如果服务器异常，返回 error code。该 SQL 语法能兼容连接池对于 TDengine 状态的检查及第三方工具对于数据库服务器状态的检查。并可以避免出现使用了错误的心跳检测 SQL 语句导致的连接池连接丢失的问题。
+## GROUP BY

-```
-taos> SELECT SERVER_STATUS();
- server_status() |
-==================
-               1 |
-Query OK, 1 row(s) in set (0.000074s)
+如果在语句中同时指定了 GROUP BY 子句，那么 SELECT 列表只能包含如下表达式：

-taos> SELECT SERVER_STATUS() AS status;
-   status    |
-==============
-           1 |
-Query OK, 1 row(s) in set (0.000081s)
-```
+1. 常量
+2. 聚集函数
+3. 与 GROUP BY 后表达式相同的表达式。
+4. 包含前面表达式的表达式
+
+GROUP BY 子句对每行数据按 GROUP BY 后的表达式的值进行分组，并为每个组返回一行汇总信息。
+
+GROUP BY 子句中的表达式可以包含表或视图中的任何列，这些列不需要出现在 SELECT 列表中。
+
+该子句对行进行分组，但不保证结果集的顺序。若要对分组进行排序，请使用 ORDER BY 子句
+
+## 查询对象
+
+FROM 关键字后面可以是若干个表（超级表）列表，也可以是子查询的结果。
+如果没有指定用户的当前数据库，可以在表名称之前使用数据库的名称来指定表所属的数据库。例如：`power.d1001` 方式来跨库使用表。
+
+TDengine 支持基于时间戳主键的 INNER JOIN，规则如下：
+
+1. 支持 FROM 表列表和显式的 JOIN 子句两种语法。
+2. 对于普通表和子表，ON 条件必须有且只有时间戳主键的等值条件。
+3. 对于超级表，ON 条件在时间戳主键的等值条件之外，还要求有可以一一对应的标签列等值条件，不支持 OR 条件。
+4. 参与 JOIN 计算的表只能是同一种类型，即只能都是超级表，或都是子表，或都是普通表。
+5. JOIN 两侧均支持子查询。
+6. 参与 JOIN 的表个数上限为 10 个。
+7. 不支持与 FILL 子句混合使用。
+
+## PARTITON BY

-## \_block_dist 函数
+PARTITION BY 子句是 TDengine 特色语法，按 part_list 对数据进行切分，在每个切分的分片中进行计算。

-**功能说明**: 用于获得指定的（超级）表的数据块分布信息
+详见 [TDengine 特色查询](taos-sql/distinguished)
+
+## ORDER BY
+
+ORDER BY 子句对结果集排序。如果没有指定 ORDER BY，无法保证同一语句多次查询的结果集返回顺序一致。
+
+ORDER BY 后可以使用位置语法，位置标识为正整数，从 1 开始，表示使用 SELECT 列表的第几个表达式进行排序。
+
+ASC 表示升序，DESC 表示降序。
+
+NULLS 语法用来指定 NULL 值在排序中输出的位置。NULLS LAST 是升序的默认值，NULLS FIRST 是降序的默认值。
+
+## LIMIT
+
+LIMIT 控制输出条数，OFFSET 指定从第几条之后开始输出。LIMIT/OFFSET 对结果集的执行顺序在 ORDER BY 之后。LIMIT 5 OFFSET 2 可以简写为 LIMIT 2, 5，都输出第 3 行到第 7 行数据。
+
+在有 PARTITION BY 子句时，LIMIT 控制的是每个切分的分片中的输出，而不是总的结果集输出。
+
+## SLIMIT
+
+SLIMIT 和 PARTITION BY 子句一起使用，用来控制输出的分片的数量。SLIMIT 5 SOFFSET 2 可以简写为 SLIMIT 2, 5，都表示输出第 3 个到第 7 个分片。
+
+需要注意，如果有 ORDER BY 子句，则输出只有一个分片。
+
+## 特殊功能

-```txt title="语法"
-SELECT _block_dist() FROM { tb_name | stb_name }
+部分特殊的查询功能可以不使用 FROM 子句执行。
+
+### 获取当前数据库
+
+下面的命令可以获取当前所在的数据库 database()，如果登录的时候没有指定默认数据库，且没有使用`USE`命令切换数据，则返回 NULL。
+
+```sql
+SELECT DATABASE();
 ```

-**返回结果类型**：字符串。
+### 获取服务器和客户端版本号

-**适用数据类型**：不能输入任何参数。
+```sql
+SELECT CLIENT_VERSION();
+SELECT SERVER_VERSION();
+```

-**嵌套子查询支持**：不支持子查询或嵌套查询。
+### 获取服务器状态

-**返回结果**:
+服务器状态检测语句。如果服务器正常，返回一个数字（例如 1）。如果服务器异常，返回 error code。该 SQL 语法能兼容连接池对于 TDengine 状态的检查及第三方工具对于数据库服务器状态的检查。并可以避免出现使用了错误的心跳检测 SQL 语句导致的连接池连接丢失的问题。

- 返回 FROM 子句中输入的表或超级表的数据块分布情况。不支持查询条件。
- 返回的结果是该表或超级表的数据块所包含的行数的数据分布直方图。
+```sql
+SELECT SERVER_STATUS();
+```
+
+### 获取当前时间

-```txt title="返回结果"
-summary:
-5th=[392], 10th=[392], 20th=[392], 30th=[392], 40th=[792], 50th=[792] 60th=[792], 70th=[792], 80th=[792], 90th=[792], 95th=[792], 99th=[792] Min=[392(Rows)] Max=[800(Rows)] Avg=[666(Rows)] Stddev=[2.17] Rows=[2000], Blocks=[3], Size=[5.440(Kb)] Comp=[0.23] RowsInMem=[0] SeekHeaderTime=[1(us)]
+```sql
+SELECT NOW();
 ```

-**上述信息的说明如下**:
+### 获取当前日期

- 查询的（超级）表所包含的存储在文件中的数据块（data block）中所包含的数据行的数量分布直方图信息：5%， 10%， 20%， 30%， 40%， 50%， 60%， 70%， 80%， 90%， 95%， 99% 的数值；
- 所有数据块中，包含行数最少的数据块所包含的行数量， 其中的 Min 指标 392 行。
- 所有数据块中，包含行数最多的数据块所包含的行数量， 其中的 Max 指标 800 行。
- 所有数据块行数的算数平均值 666 行（其中的 Avg 项）。
- 所有数据块中行数分布的均方差为 2.17 ( stddev ）。
- 数据块包含的行的总数为 2000 行（Rows）。
- 数据块总数是 3 个数据块 （Blocks）。
- 数据块占用磁盘空间大小 5.44 Kb （size）。
- 压缩后的数据块的大小除以原始数据的所获得的压缩比例： 23%（Comp），及压缩后的数据规模是原始数据规模的 23%。
- 内存中存在的数据行数是 0，表示内存中没有数据缓存。
- 获取数据块信息的过程中读取头文件的时间开销 1 微秒（SeekHeaderTime）。
+```sql
+SELECT TODAY();
+```

-**支持版本**：指定计算算法的功能从 2.1.0.x 版本开始，2.1.0.0 之前的版本不支持指定使用算法的功能。
+### 获取当前时区
+
+```sql
+SELECT TIMEZONE();
+```

 ## TAOS SQL 中特殊关键词

 - `TBNAME`： 在超级表查询中可视为一个特殊的标签，代表查询涉及的子表名
 - `_c0`: 表示表（超级表）的第一列

-## 小技巧
-
 获取一个超级表所有的子表名及相关的标签信息：

-```
+```sql
 SELECT TBNAME, location FROM meters;
 ```

 统计超级表下辖子表数量：

+```sql
+SELECT COUNT(*) FROM (SELECT DISTINCT TBNAMEFROM meters);
 ```
-SELECT COUNT(TBNAME) FROM meters;
-```
-
-以上两个查询均只支持在 WHERE 条件子句中添加针对标签（TAGS）的过滤条件。例如：
-
-```
-taos> SELECT TBNAME, location FROM meters;
-             tbname             |            location            |
-==================================================================
- d1004                          | California.LosAngeles                |
- d1003                          | California.LosAngeles                |
- d1002                          | California.SanFrancisco               |
- d1001                          | California.SanFrancisco               |
-Query OK, 4 row(s) in set (0.000881s)
-
-taos> SELECT COUNT(tbname) FROM meters WHERE groupId > 2;
-     count(tbname)     |
-========================
-                     2 |
-Query OK, 1 row(s) in set (0.001091s)
-```
-
- 可以使用 \* 返回所有列，或指定列名。可以对数字列进行四则运算，可以给输出的列取列名。
-  - 暂不支持含列名的四则运算表达式用于条件过滤算子（例如，不支持 `where a*2>6;`，但可以写 `where a>6/2;`）。
-  - 暂不支持含列名的四则运算表达式作为 SQL 函数的应用对象（例如，不支持 `select min(2*a) from t;`，但可以写 `select 2*min(a) from t;`）。
- WHERE 语句可以使用各种逻辑判断来过滤数字值，或使用通配符来过滤字符串。
- 输出结果缺省按首列时间戳升序排序，但可以指定按降序排序( \_c0 指首列时间戳)。使用 ORDER BY 对其他字段进行排序,排序结果顺序不确定。
- 参数 LIMIT 控制输出条数，OFFSET 指定从第几条开始输出。LIMIT/OFFSET 对结果集的执行顺序在 ORDER BY 之后。且 `LIMIT 5 OFFSET 2` 可以简写为 `LIMIT 2, 5`。
-  - 在有 GROUP BY 子句的情况下，LIMIT 参数控制的是每个分组中至多允许输出的条数。
- 参数 SLIMIT 控制由 GROUP BY 指令划分的分组中，至多允许输出几个分组的数据。且 `SLIMIT 5 SOFFSET 2` 可以简写为 `SLIMIT 2, 5`。
- 通过 “>>” 输出结果可以导出到指定文件。
-
-## 条件过滤操作
-
-| **Operation** | **Note**                 | **Applicable Data Types**                 |
-| ------------- | ------------------------ | ----------------------------------------- |
-| >             | larger than              | all types except bool                     |
-| <             | smaller than             | all types except bool                     |
-| >=            | larger than or equal to  | all types except bool                     |
-| <=            | smaller than or equal to | all types except bool                     |
-| =             | equal to                 | all types                                 |
-| <\>           | not equal to             | all types                                 |
-| is [not] null | is null or is not null   | all types                                 |
-| between and   | within a certain range   | all types except bool                     |
-| in            | match any value in a set | all types except first column `timestamp` |
-| like          | match a wildcard string  | **`binary`** **`nchar`**                  |
-| match/nmatch  | filter regex             | **`binary`** **`nchar`**                  |
-
-**使用说明**:
-
- <\> 算子也可以写为 != ，请注意，这个算子不能用于数据表第一列的 timestamp 字段。
- like 算子使用通配符字符串进行匹配检查。
-  - 在通配符字符串中：'%'（百分号）匹配 0 到任意个字符；'\_'（下划线）匹配单个任意 ASCII 字符。
-  - 如果希望匹配字符串中原本就带有的 \_（下划线）字符，那么可以在通配符字符串中写作 `\_`，也即加一个反斜线来进行转义。（从 2.2.0.0 版本开始支持）
-  - 通配符字符串最长不能超过 20 字节。（从 2.1.6.1 版本开始，通配符字符串的长度放宽到了 100 字节，并可以通过 taos.cfg 中的 maxWildCardsLength 参数来配置这一长度限制。但不建议使用太长的通配符字符串，将有可能严重影响 LIKE 操作的执行性能。）
- 同时进行多个字段的范围过滤，需要使用关键词 AND 来连接不同的查询条件，暂不支持 OR 连接的不同列之间的查询过滤条件。
-  - 从 2.3.0.0 版本开始，已支持完整的同一列和/或不同列间的 AND/OR 运算。
- 针对单一字段的过滤，如果是时间过滤条件，则一条语句中只支持设定一个；但针对其他的（普通）列或标签列，则可以使用 `OR` 关键字进行组合条件的查询过滤。例如： `((value > 20 AND value < 30) OR (value < 12))`。
-  - 从 2.3.0.0 版本开始，允许使用多个时间过滤条件，但首列时间戳的过滤运算结果只能包含一个区间。
- 从 2.0.17.0 版本开始，条件过滤开始支持 BETWEEN AND 语法，例如 `WHERE col2 BETWEEN 1.5 AND 3.25` 表示查询条件为“1.5 ≤ col2 ≤ 3.25”。
- 从 2.1.4.0 版本开始，条件过滤开始支持 IN 算子，例如 `WHERE city IN ('California.SanFrancisco', 'California.SanDieo')`。说明：BOOL 类型写作 `{true, false}` 或 `{0, 1}` 均可，但不能写作 0、1 之外的整数；FLOAT 和 DOUBLE 类型会受到浮点数精度影响，集合内的值在精度范围内认为和数据行的值完全相等才能匹配成功；TIMESTAMP 类型支持非主键的列。
- 从 2.3.0.0 版本开始，条件过滤开始支持正则表达式，关键字 match/nmatch，不区分大小写。

 ## 正则表达式过滤

@@ -358,7 +323,7 @@ WHERE (column|tbname) **match/MATCH/nmatch/NMATCH** _regex_

 ## JOIN 子句

-从 2.2.0.0 版本开始，TDengine 对内连接（INNER JOIN）中的自然连接（Natural join）操作实现了完整的支持。也即支持“普通表与普通表之间”、“超级表与超级表之间”、“子查询与子查询之间”进行自然连接。自然连接与内连接的主要区别是，自然连接要求参与连接的字段在不同的表/超级表中必须是同名字段。也即，TDengine 在连接关系的表达中，要求必须使用同名数据列/标签列的相等关系。
+TDengine 支持“普通表与普通表之间”、“超级表与超级表之间”、“子查询与子查询之间” 进行自然连接。自然连接与内连接的主要区别是，自然连接要求参与连接的字段在不同的表/超级表中必须是同名字段。也即，TDengine 在连接关系的表达中，要求必须使用同名数据列/标签列的相等关系。

 在普通表与普通表之间的 JOIN 操作中，只能使用主键时间戳之间的相等关系。例如：


--- a/docs/zh/12-taos-sql/08-delete-data.mdx
+++ b/docs/zh/12-taos-sql/08-delete-data.mdx
@@ -5,8 +5,6 @@ title: "删除数据"
 ---

 删除数据是 TDengine 提供的根据指定时间段删除指定表或超级表中数据记录的功能，方便用户清理由于设备故障等原因产生的异常数据。
-注意：本功能只在企业版 2.6.0.0 及以后的版本中提供，如需此功能请点击下面的链接访问[企业版产品](https://www.taosdata.com/products#enterprise-edition-link)
-

 **语法：**

@@ -20,7 +18,7 @@ DELETE FROM [ db_name. ] tb_name [WHERE condition];

 - `db_name` ： 可选参数，指定要删除表所在的数据库名，不填写则在当前数据库中
 - `tb_name` ： 必填参数，指定要删除数据的表名，可以是普通表、子表，也可以是超级表。
- `condition`： 可选参数，指定删除数据的过滤条件，不指定过滤条件则为表中所有数据，请慎重使用。特别说明，这里的where 条件中只支持对第一列时间列的过滤，如果是超级表，支持对 tag 列过滤。
+- `condition`： 可选参数，指定删除数据的过滤条件，不指定过滤条件则为表中所有数据，请慎重使用。特别说明，这里的 where 条件中只支持对第一列时间列的过滤。

 **特别说明：**

@@ -28,10 +26,10 @@ DELETE FROM [ db_name. ] tb_name [WHERE condition];

 **示例：**

-`meters` 是一个超级表，`groupid` 是 int 类型的 tag 列，现在要删除 `meters` 表中时间小于 2021-10-01 10:40:00.100 且 tag 列 `groupid` 值为 1 的所有数据，sql 如下：
+`meters` 是一个超级表，`groupid` 是 int 类型的 tag 列，现在要删除 `meters` 表中时间小于 2021-10-01 10:40:00.100 的所有数据，sql 如下：

 ```sql
-delete from meters where ts < '2021-10-01 10:40:00.100' and groupid=1 ;
+delete from meters where ts < '2021-10-01 10:40:00.100' ;
 ```

 执行后显示结果为：

--- a/docs/zh/12-taos-sql/12-interval.md
+++ b/docs/zh/12-taos-sql/12-interval.md
@@ -12,16 +12,16 @@ TDengine 提供的特色查询包括标签切分查询和窗口切分查询。
 超级表查询中，当需要针对标签进行数据切分然后在切分出的数据空间内再进行一系列的计算时使用标签切分子句，标签切分的语句如下：

 ```sql
-PARTITION BY tag_list
+PARTITION BY part_list
 ```

-其中 `tag_list` 是标签列的列表，还可以包括 tbname 伪列。
+part_list 可以是任意的标量表达式，包括列、常量、标量函数和它们的组合。

-TDengine 按如下方式处理标签切分子句：
+当 PARTITION BY 和标签一起使用时，TDengine 按如下方式处理标签切分子句：

-标签切分子句位于 `WHERE` 子句之后，且不能和 `JOIN` 子句一起使用。
-标签切分子句将超级表数据按指定的标签组合进行切分，然后对每个切分的分片进行指定的计算。计算由之后的子句定义（窗口子句、`GROUP BY` 子句或`SELECT` 子句）。
-标签切分子句可以和窗口切分子句（或 `GROUP BY` 子句）一起使用，此时后面的子句作用在每个切分的分片上。例如，下面的示例将数据按标签 `location` 进行分组，并对每个组按 10 分钟进行降采样，取其最大值。
+- 标签切分子句位于 WHERE 子句之后，且不能和 JOIN 子句一起使用。
+- 标签切分子句将超级表数据按指定的标签组合进行切分，每个切分的分片进行指定的计算。计算由之后的子句定义（窗口子句、GROUP BY 子句或 SELECT 子句）。
+- 标签切分子句可以和窗口切分子句（或 GROUP BY 子句）一起使用，此时后面的子句作用在每个切分的分片上。例如，将数据按标签 location 进行分组，并对每个组按 10 分钟进行降采样，取其最大值。

 ```sql
 select max(current) from meters partition by location interval(10m)

--- a/docs/zh/12-taos-sql/14-stream.md
+++ b/docs/zh/12-taos-sql/14-stream.md
+---
+sidebar_label: 流式计算
+title: 流式计算
+---
+
+在时序数据的处理中，经常要对原始数据进行清洗、预处理，再使用时序数据库进行长久的储存。用户通常需要在时序数据库之外再搭建 Kafka、Flink、Spark 等流计算处理引擎，增加了用户的开发成本和维护成本。
+
+使用 TDengine 3.0 的流式计算引擎能够最大限度的减少对这些额外中间件的依赖，真正将数据的写入、预处理、长期存储、复杂分析、实时计算、实时报警触发等功能融为一体，并且，所有这些任务只需要使用 SQL 完成，极大降低了用户的学习成本、使用成本。
+
+## 创建流式计算
+
+```sql
+CREATE STREAM [IF NOT EXISTS] stream_name [stream_options] INTO stb_name AS subquery
+stream_options: {
+ TRIGGER    [AT_ONCE | WINDOW_CLOSE | MAX_DELAY time]
+ WATERMARK   time
+}
+
+```
+
+其中 subquery 是 select 普通查询语法的子集:
+
+```sql
+subquery: SELECT [DISTINCT] select_list
+    from_clause
+    [WHERE condition]
+    [PARTITION BY tag_list]
+    [window_clause]
+    [group_by_clause]
+```
+
+不支持 order_by，limit，slimit，fill 语句
+
+例如，如下语句创建流式计算，同时自动创建名为 avg_vol 的超级表，此流计算以一分钟为时间窗口、30 秒为前向增量统计这些电表的平均电压，并将来自 meters 表的数据的计算结果写入 avg_vol 表，不同 partition 的数据会分别创建子表并写入不同子表。
+
+```sql
+CREATE STREAM avg_vol_s INTO avg_vol AS
+SELECT _wstartts, count(*), avg(voltage) FROM meters PARTITION BY tbname INTERVAL(1m) SLIDING(30s);
+```
+
+## 删除流式计算
+
+```sql
+DROP STREAM [IF NOT EXISTS] stream_name
+```
+
+仅删除流式计算任务，由流式计算写入的数据不会被删除。
+
+## 展示流式计算
+
+```sql
+SHOW STREAMS;
+```
+
+## 流式计算的触发模式
+
+在创建流时，可以通过 TRIGGER 指令指定流式计算的触发模式。
+
+对于非窗口计算，流式计算的触发是实时的；对于窗口计算，目前提供 3 种触发模式：
+
+1. AT_ONCE：写入立即触发
+
+2. WINDOW_CLOSE：窗口关闭时触发（窗口关闭由事件时间决定，可配合 watermark 使用，详见《流式计算的乱序数据容忍策略》）
+
+3. MAX_DELAY time：若窗口关闭，则触发计算。若窗口未关闭，且未关闭时长超过 max delay 指定的时间，则触发计算。
+
+由于窗口关闭是由事件时间决定的，如事件流中断、或持续延迟，则事件时间无法更新，可能导致无法得到最新的计算结果。
+
+因此，流式计算提供了以事件时间结合处理时间计算的 MAX_DELAY 触发模式。
+
+MAX_DELAY 模式在窗口关闭时会立即触发计算。此外，当数据写入后，计算触发的时间超过 max delay 指定的时间，则立即触发计算
+
+## 流式计算的乱序数据容忍策略
+
+在创建流时，可以在 stream_option 中指定 watermark。
+
+流式计算通过 watermark 来度量对乱序数据的容忍程度，watermark 默认为 0。
+
+T = 最新事件时间 - watermark
+
+每批到来的数据都会以上述公式更新窗口关闭时间，并将窗口结束时间 < T 的所有打开的窗口关闭，若触发模式为 WINDOW_CLOSE 或 MAX_DELAY，则推送窗口聚合结果。
+
+流式计算的过期数据处理策略
+对于已关闭的窗口，再次落入该窗口中的数据被标记为过期数据，对于过期数据，流式计算提供两种处理方式：
+
+1. 直接丢弃：这是常见流式计算引擎提供的默认（甚至是唯一）计算模式
+
+2. 重新计算：从 TSDB 中重新查找对应窗口的所有数据并重新计算得到最新结果
+
+无论在哪种模式下，watermark 都应该被妥善设置，来得到正确结果（直接丢弃模式）或避免频繁触发重算带来的性能开销（重新计算模式）。
+
+## 流式计算的数据填充策略
+
+TODO
+
+## 流式计算与会话窗口（session window）
+
+```sql
+window_clause: {
+    SESSION(ts_col, tol_val)
+  | STATE_WINDOW(col)
+  | INTERVAL(interval_val [, interval_offset]) [SLIDING (sliding_val)] [FILL(fill_mod_and_val)]
+}
+```
+
+其中，SESSION 是会话窗口，tol_val 是时间间隔的最大范围。在 tol_val 时间间隔范围内的数据都属于同一个窗口，如果连续的两条数据的时间超过 tol_val，则自动开启下一个窗口。
+
+## 流式计算的监控与流任务分布查询
+
+TODO
+
+## 流式计算的内存控制与存算分离
+
+TODO
+
+## 流式计算的暂停与恢复
+
+```sql
+STOP STREAM stream_name;
+
+RESUME STREAM stream_name;
+```
--- a/docs/zh/12-taos-sql/20-keywords.md
+++ b/docs/zh/12-taos-sql/20-keywords.md
@@ -265,55 +265,12 @@ title: TDengine 保留关键字
 - WAL
 - WHERE

-### _
-
- _C0
- _QSTART
- _QSTOP
- _QDURATION
- _WSTART
- _WSTOP
- _WDURATION
-
-
-## 特殊说明
-### TBNAME
-`TBNAME` 可以视为超级表中一个特殊的标签，代表子表的表名。
-
-获取一个超级表所有的子表名及相关的标签信息：
-
-```mysql
-SELECT TBNAME, location FROM meters;
-```
-
-统计超级表下辖子表数量：
-
-```mysql
-SELECT COUNT(TBNAME) FROM meters;
-```
-
-以上两个查询均只支持在WHERE条件子句中添加针对标签（TAGS）的过滤条件。例如：
-```mysql
-taos> SELECT TBNAME, location FROM meters;
-             tbname             |            location            |
-==================================================================
- d1004                          | California.SanFrancisco        |
- d1003                          | California.SanFrancisco        |
- d1002                          | California.LosAngeles          |
- d1001                          | California.LosAngeles          |
-Query OK, 4 row(s) in set (0.000881s)
-
-taos> SELECT COUNT(tbname) FROM meters WHERE groupId > 2;
-     count(tbname)     |
-========================
-                     2 |
-Query OK, 1 row(s) in set (0.001091s)
-```
-### _QSTART/_QSTOP/_QDURATION
-表示查询过滤窗口的起始，结束以及持续时间。
-
-### _WSTART/_WSTOP/_WDURATION
-窗口切分聚合查询（例如 interval/session window/state window）中表示每个切分窗口的起始，结束以及持续时间。
-
-### _c0/_ROWTS
-_c0 _ROWTS 等价，表示表或超级表的第一列
+### \_
+
+- \_C0
+- \_QSTART
+- \_QSTOP
+- \_QDURATION
+- \_WSTART
+- \_WSTOP
+- \_WDURATION
--- a/docs/zh/12-taos-sql/22-information.md
+++ b/docs/zh/12-taos-sql/22-information.md
---
-sidebar_label: Information内置数据库
-title: Information内置数据库
---
-
--- a/docs/zh/12-taos-sql/22-meta.md
+++ b/docs/zh/12-taos-sql/22-meta.md
+---
+sidebar_label: 元数据库
+title: 元数据库
+---
+
+TDengine 内置了一个名为 `INFORMATION_SCHEMA` 的数据库，提供对数据库元数据、数据库系统信息和状态的访问，例如数据库或表的名称，当前执行的 SQL 语句等。
+
+`INFORMATION_SCHEMA` 是 TDengine 启动时自动创建的数据库，该数据库存储有关 TDengine 维护的所有其他数据库的信息。它包含多个只读表。实际上，这些表都是视图，而不是基表，因此没有与它们关联的文件。所以对这些表只能查询，不能进行 INSERT 等写入操作。
+
+可以使用 USE 语句将 INFORMATION_SCHEMA 设为默认数据库。
+
+INFORMATION_SCHEMA 旨在以一种更一致的方式来提供对 TDengine 支持的各种 SHOW 语句（如 SHOW TABLES、SHOW DATABASES）提供的信息的访问。与 SHOW 语句相比，使用 SELECT ... FROM INFORMATION_SCHEMA.tablename 具有以下优点：
+
+您可以使用 SELECT 语句熟悉的语法，只需要学习一些表名和列名。
+
+您可以对查询结果进行筛选、排序等操作，事实上，您可以使用任意 TDengine 支持的 SELECT 语句对 INFORMATION_SCHEMA 中的表进行查询。
+TDengine 在后续演进中可以灵活的添加已有 INFORMATION_SCHEMA 中表的列，而不用担心对既有业务系统造成影响。
+
+此技术与其他数据库系统更具互操作性。例如，Oracle 数据库用户熟悉查询 Oracle 数据字典中的表。
+
+由于 SHOW 语句已经被开发者熟悉的和广泛使用，所以它们仍然是可用的。
+
+本章将详细介绍 `INFORMATION_SCHEMA` 这个内置元数据库中的表和表结构。
+
+## DNODES
+
+提供 dnode 的相关信息。也可以使用 SHOW DNODES 来查询这些信息。
+
+| #   |    **列名**    | **数据类型** | **说明**              |
+| --- | :------------: | ------------ | --------------------- |
+| 1   |     vnodes     | SMALLINT     | dnode 中的 vnode 个数 |
+| 2   | support_vnodes | SMALLINT     | 支持的 vnode 个数     |
+| 3   |     status     | BINARY(10)   | 当前状态              |
+| 4   |      note      | BINARY(256)  | 离线原因等信息        |
+| 5   |       id       | SMALLINT     | dnode id              |
+| 6   |    endpoint    | BINARY(134)  | dnode 的地址          |
+| 7   |     create     | TIMESTAMP    | 创建时间              |
+
+## MNODES
+
+提供 mnode 的相关信息。也可以使用 SHOW MNODES 来查询这些信息。
+
+| #   |  **列名**   | **数据类型** | **说明**           |
+| --- | :---------: | ------------ | ------------------ |
+| 1   |     id      | SMALLINT     | mnode id           |
+| 2   |  endpoint   | BINARY(134)  | mnode 的地址       |
+| 3   |    role     | BINARY(10)   | 当前角色           |
+| 4   |  role_time  | TIMESTAMP    | 成为当前角色的时间 |
+| 5   | create_time | TIMESTAMP    | 创建时间           |
+
+## MODULES
+
+提供组件的相关信息。也可以使用 SHOW MODULES 来查询这些信息
+
+| #   | **列名** | **数据类型** | **说明**   |
+| --- | :------: | ------------ | ---------- |
+| 1   |    id    | SMALLINT     | module id  |
+| 2   | endpoint | BINARY(134)  | 组件的地址 |
+| 3   |  module  | BINARY(10)   | 组件状态   |
+
+## QNODES
+
+当前系统中 QNODE 的信息。也可以使用 SHOW QNODES 来查询这些信息。
+
+| #   |  **列名**   | **数据类型** | **说明**     |
+| --- | :---------: | ------------ | ------------ |
+| 1   |     id      | SMALLINT     | module id    |
+| 2   |  endpoint   | BINARY(134)  | qnode 的地址 |
+| 3   | create_time | TIMESTAMP    | 创建时间     |
+
+## USER_DATABASES
+
+提供用户创建的数据库对象的相关信息。也可以使用 SHOW DATABASES 来查询这些信息。
+
+TODO
+
+| #   |  **列名**   | **数据类型** | **说明**                                         |
+| --- | :---------: | ------------ | ------------------------------------------------ |
+| 1   |    name     | BINARY(32)   | 数据库名                                         |
+| 2   | create_time | TIMESTAMP    | 创建时间                                         |
+| 3   |   ntables   | INT          | 数据库中表的数量，包含子表和普通表但不包含超级表 |
+| 4   |   vgroups   | INT          | 数据库中有多少个 vgroup                          |
+| 5   |   replica   | INT          | 副本数                                           |
+| 6   |   quorum    | INT          | 写成功的确认数                                   |
+| 7   |    days     | INT          | 单文件存储数据的时间跨度                         |
+| 8   |    keep     | INT          | 数据保留时长                                     |
+| 9   |   buffer    | INT          | 每个 vnode 写缓存的内存块大小，单位 MB           |
+| 10  |   minrows   | INT          | 文件块中记录的最大条数                           |
+| 11  |   maxrows   | INT          | 文件块中记录的最小条数                           |
+| 12  |  wallevel   | INT          | WAL 级别                                         |
+| 13  |    fsync    | INT          | 数据落盘周期                                     |
+| 14  |    comp     | INT          | 数据压缩方式                                     |
+| 15  |  precision  | BINARY(2)    | 时间分辨率                                       |
+| 16  |   status    | BINARY(10)   | 数据库状态                                       |
+
+## USER_FUNCTIONS
+
+TODO
+
+## USER_INDEXES
+
+提供用户创建的索引的相关信息。也可以使用 SHOW INDEX 来查询这些信息。
+
+| #   |     **列名**     | **数据类型** | **说明**                                                                           |
+| --- | :--------------: | ------------ | ---------------------------------------------------------------------------------- |
+| 1   |     db_name      | BINARY(32)   | 包含此索引的表所在的数据库名                                                       |
+| 2   |    table_name    | BINARY(192)  | 包含此索引的表的名称                                                               |
+| 3   |    index_name    | BINARY(192)  | 索引名                                                                             |
+| 4   |   column_name    | BINARY(64)   | 建索引的列的列名                                                                   |
+| 5   |    index_type    | BINARY(10)   | 目前有 SMA 和 FULLTEXT                                                             |
+| 6   | index_extensions | BINARY(256)  | 索引的额外信息。对 SMA 类型的索引，是函数名的列表。对 FULLTEXT 类型的索引为 NULL。 |
+
+## USER_STABLES
+
+提供用户创建的超级表的相关信息。
+
+| #   |   **列名**    | **数据类型** | **说明**                 |
+| --- | :-----------: | ------------ | ------------------------ |
+| 1   |  stable_name  | BINARY(192)  | 超级表表名               |
+| 2   |    db_name    | BINARY(64)   | 超级表所在的数据库的名称 |
+| 3   |  create_time  | TIMESTAMP    | 创建时间                 |
+| 4   |    columns    | INT          | 列数目                   |
+| 5   |     tags      | INT          | 标签数目                 |
+| 6   |  last_update  | TIMESTAMP    | 最后更新时间             |
+| 7   | table_comment | BINARY(1024) | 表注释                   |
+| 8   |   watermark   | BINARY(64)   | 窗口的关闭时间           |
+| 9   |   max_delay   | BINARY(64)   | 推送计算结果的最大延迟   |
+| 10  |    rollup     | BINARY(128)  | rollup 聚合函数          |
+
+## USER_STREAMS
+
+提供用户创建的流计算的相关信息。
+
+| #   |  **列名**   | **数据类型** | **说明**                    |
+| --- | :---------: | ------------ | --------------------------- |
+| 1   | stream_name | BINARY(192)  | 流计算名称                  |
+| 2   |  user_name  | BINARY(23)   | 创建流计算的用户            |
+| 3   | dest_table  | BINARY(192)  | 流计算写入的目标表          |
+| 4   | create_time | TIMESTAMP    | 创建时间                    |
+| 5   |     sql     | BLOB         | 创建流计算时提供的 SQL 语句 |
+
+## USER_TABLES
+
+提供用户创建的普通表和子表的相关信息
+
+| #   |   **列名**    | **数据类型** | **说明**         |
+| --- | :-----------: | ------------ | ---------------- |
+| 1   |  table_name   | BINARY(192)  | 表名             |
+| 2   |    db_name    | BINARY(64)   | 数据库名         |
+| 3   |  create_time  | TIMESTAMP    | 创建时间         |
+| 4   |    columns    | INT          | 列数目           |
+| 5   |  stable_name  | BINARY(192)  | 所属的超级表表名 |
+| 6   |      uid      | BIGINT       | 表 id            |
+| 7   |   vgroup_id   | INT          | vgroup id        |
+| 8   |      ttl      | INT          | 表的生命周期     |
+| 9   | table_comment | BINARY(1024) | 表注释           |
+| 10  |     type      | BINARY(20)   | 表类型           |
+
+## USER_USERS
+
+提供系统中创建的用户的相关信息。
+
+| #   |  **列名**   | **数据类型** | **说明** |
+| --- | :---------: | ------------ | -------- |
+| 1   |  user_name  | BINARY(23)   | 用户名   |
+| 2   |  privilege  | BINARY(256)  | 权限     |
+| 3   | create_time | TIMESTAMP    | 创建时间 |
+
+## VGROUPS
+
+系统中所有 vgroups 的信息。
+
+| #   |  **列名**  | **数据类型** | **说明**                     |
+| --- | :--------: | ------------ | ---------------------------- |
+| 1   |   vg_id    | INT          | vgroup id                    |
+| 2   |  db_name   | BINARY(32)   | 数据库名                     |
+| 3   |   tables   | INT          | 此 vgroup 内有多少表         |
+| 4   |   status   | BINARY(10)   | 此 vgroup 的状态             |
+| 5   |  onlines   | INT          | 在线的成员数目               |
+| 6   |  v1_dnode  | INT          | 第一个成员所在的 dnode 的 id |
+| 7   | v1_status  | BINARY(10)   | 第一个成员的状态             |
+| 8   |  v2_dnode  | INT          | 第二个成员所在的 dnode 的 id |
+| 9   | v2_status  | BINARY(10)   | 第二个成员的状态             |
+| 10  |  v3_dnode  | INT          | 第三个成员所在的 dnode 的 id |
+| 11  | v3_status  | BINARY(10)   | 第三个成员的状态             |
+| 12  | compacting | INT          | compact 状态                 |
--- a/docs/zh/12-taos-sql/23-show.md
+++ b/docs/zh/12-taos-sql/23-show.md
+---
+sidebar_label: SHOW 命令
+title: 使用 SHOW 命令查看系统元数据
+---
+
+除了使用 `select` 语句查询 `INFORMATION_SCHEMA` 数据库中的表获得系统中的各种元数据、系统信息和状态之外，也可以用 `SHOW` 命令来实现同样的目的。
+
+## SHOW ACCOUNTS
+
+```sql
+SHOW ACCOUNTS;
+```
+
+显示当前系统中所有租户的信息。
+
+注：企业版独有
+
+## SHOW APPS
+
+```sql
+SHOW APPS;
+```
+
+显示接入集群的应用（客户端）信息。
+
+## SHOW BNODES
+
+```sql
+SHOW BNODES;
+```
+
+显示当前系统中存在的 BNODE (backup node, 即备份节点）的信息。
+
+## SHOW CLUSTER
+
+```sql
+SHOW CLUSTER;
+```
+
+显示当前集群的信息
+
+## SHOW CONNECTIONS
+
+```sql
+SHOW CONNECTIONS;
+```
+
+显示当前系统中存在的连接的信息。
+
+## SHOW CONSUMERS
+
+```sql
+SHOW CONSUMERS;
+```
+
+显示当前数据库下所有活跃的消费者的信息。
+
+## SHOW CREATE DATABASE
+
+```sql
+SHOW CREATE DATABASE db_name;
+```
+
+显示 db_name 指定的数据库的创建语句。
+
+## SHOW CREATE STABLE
+
+```sql
+SHOW CREATE STABLE [db_name.]stb_name;
+```
+
+显示 tb_name 指定的超级表的创建语句
+
+## SHOW CREATE TABLE
+
+```sql
+SHOW CREATE TABLE [db_name.]tb_name
+```
+
+显示 tb_name 指定的表的创建语句。支持普通表、超级表和子表。
+
+## SHOW DATABASES
+
+```sql
+SHOW DATABASES;
+```
+
+显示用户定义的所有数据库。
+
+## SHOW DNODES
+
+```sql
+SHOW DNODES;
+```
+
+显示当前系统中 DNODE 的信息。
+
+## SHOW FUNCTIONS
+
+```sql
+SHOW FUNCTIONS;
+```
+
+显示用户定义的自定义函数。
+
+## SHOW LICENSE
+
+```sql
+SHOW LICENSE;
+SHOW GRANTS;
+```
+
+显示企业版许可授权的信息。
+
+注：企业版独有
+
+## SHOW INDEXES
+
+```sql
+SHOW INDEXES FROM tbl_name [FROM db_name];
+```
+
+显示已创建的索引。
+
+## SHOW LOCAL VARIABLES
+
+```sql
+SHOW LOCAL VARIABLES;
+```
+
+显示当前客户端配置参数的运行值。
+
+## SHOW MNODES
+
+```sql
+SHOW MNODES;
+```
+
+显示当前系统中 MNODE 的信息。
+
+## SHOW MODULES
+
+```sql
+SHOW MODULES;
+```
+
+显示当前系统中所安装的组件的信息。
+
+## SHOW QNODES
+
+```sql
+SHOW QNODES;
+```
+
+显示当前系统中 QNODE （查询节点）的信息。
+
+## SHOW SCORES
+
+```sql
+SHOW SCORES;
+```
+
+显示系统被许可授权的容量的信息。
+
+注：企业版独有
+
+## SHOW SNODES
+
+```sql
+SHOW SNODES;
+```
+
+显示当前系统中 SNODE （流计算节点）的信息。
+
+## SHOW STABLES
+
+```sql
+SHOW [db_name.]STABLES [LIKE 'pattern'];
+```
+
+显示当前数据库下的所有超级表的信息。可以使用 LIKE 对表名进行模糊匹配。
+
+## SHOW STREAMS
+
+```sql
+SHOW STREAMS;
+```
+
+显示当前系统内所有流计算的信息。
+
+## SHOW SUBSCRIPTIONS
+
+```sql
+SHOW SUBSCRIPTIONS;
+```
+
+显示当前数据库下的所有的订阅关系
+
+## SHOW TABLES
+
+```sql
+SHOW [db_name.]TABLES [LIKE 'pattern'];
+```
+
+显示当前数据库下的所有普通表和子表的信息。可以使用 LIKE 对表名进行模糊匹配。
+
+## SHOW TABLE DISTRIBUTED
+
+```sql
+SHOW TABLE DISTRIBUTED table_name;
+```
+
+显示表的数据分布信息。
+
+## SHOW TAGS
+
+```sql
+SHOW TAGS FROM child_table_name [FROM db_name];
+```
+
+显示子表的标签信息。
+
+## SHOW TOPICS
+
+```sql
+SHOW TOPICS;
+```
+
+显示当前数据库下的所有主题的信息。
+
+## SHOW TRANSACTIONS
+
+```sql
+SHOW TRANSACTIONS;
+```
+
+显示当前系统中正在执行的事务的信息
+
+## SHOW USERS
+
+```sql
+SHOW USERS;
+```
+
+显示当前系统中所有用户的信息。包括用户自定义的用户和系统默认用户。
+
+## SHOW VARIABLES
+
+```sql
+SHOW VARIABLES;
+SHOW DNODE dnode_id VARIABLES;
+```
+
+显示当前系统中各节点需要相同的配置参数的运行值，也可以指定 DNODE 来查看其的配置参数。
+
+## SHOW VGROUPS
+
+```sql
+SHOW [db_name.]VGROUPS;
+```
+
+显示当前系统中所有 VGROUP 或某个 db 的 VGROUPS 的信息。
+
+## SHOW VNODES
+
+```sql
+SHOW VNODES [dnode_name];
+```
+
+显示当前系统中所有 VNODE 或某个 DNODE 的 VNODE 的信息。