go sample code (#11141)

* go sql insert example

* fix go doc bug

* adjust cluster part; change mysql to sql

* add go connect example using af

* go stmt example

* go influxdb line example

* go telnet line insert example

* reduce sample data

* go json insert example

* go query example

docs-cn/03-get-started/03-get-started.md

@@ -108,7 +108,7 @@ taos>
 
 在 TDengine 客户端中，用户可以通过 SQL 命令来创建/删除数据库、表等，并进行插入查询操作。在终端中运行的 SQL 语句需要以分号结束来运行。示例：
 
-```mysql
+```sql
 create database demo;
 use demo;
 create table t (ts timestamp, speed int);
@@ -145,7 +145,7 @@ taos -h h1.taos.com -s "use db; show tables;"
 
 TDengine 终端可以通过 `source` 命令来运行 SQL 命令脚本。
 
-```mysql
+```sql
 taos> source <filename>;
 ```
 
@@ -182,30 +182,30 @@ taosBenchmark 详细使用方法请参照 [如何使用 taosBenchmark 对 TDengi
 
 查询超级表下记录总条数：
 
-```mysql
+```sql
 taos> select count(*) from test.meters;
 ```
 
 查询 1 亿条记录的平均值、最大值、最小值等：
 
-```mysql
+```sql
 taos> select avg(current), max(voltage), min(phase) from test.meters;
 ```
 
 查询 location="beijing" 的记录总条数：
 
-```mysql
+```sql
 taos> select count(*) from test.meters where location="beijing";
 ```
 
 查询 groupId=10 的所有记录的平均值、最大值、最小值等：
 
-```mysql
+```sql
 taos> select avg(current), max(voltage), min(phase) from test.meters where groupId=10;
 ```
 
 对表 d10 按 10s 进行平均值、最大值和最小值聚合统计：
 
-```mysql
+```sql
 taos> select avg(current), max(voltage), min(phase) from test.d10 interval(10s);
 ```

docs-cn/04-connect/_connect_go_native.mdx

@@ -11,6 +11,12 @@ go 1.17
 require github.com/taosdata/driver-go/v2 develop
 ```
 
-```go
+```go title="使用 database/sql 包建立连接"
 {{#include docs-examples/go/connect/cgoexample/main.go}}
 ```
+
+也可以使用 driver-go 的 af 包建立连接。这个模块封装了 TDengine 的高级功能, 如：动态绑定、订阅等。
+
+```go title="使用 af 包建立连接"
+{{#include docs-examples/go/connect/afconn/main.go}}
+```

docs-cn/06-insert-data/03-opentsdb-telnet.mdx

@@ -39,3 +39,26 @@ import CTelnet from "./_c_opts_telnet.mdx";
     <CTelnet />
   </TabItem>
 </Tabs>
+
+以上示例代码会自动创建 2 个超级表， 每个超级表有 4 条数据。
+
+```cmd
+taos> use test;
+Database changed.
+
+taos> show stables;
+              name              |      created_time       | columns |  tags  |   tables    |
+============================================================================================
+ meters.current                 | 2022-03-30 17:04:10.877 |       2 |      2 |           2 |
+ meters.voltage                 | 2022-03-30 17:04:10.882 |       2 |      2 |           2 |
+Query OK, 2 row(s) in set (0.002544s)
+
+taos> select tbname, * from `meters.current`;
+             tbname             |           ts            |           value           | groupid |            location            |
+==================================================================================================================================
+ t_0e7bcfa21a02331c06764f275... | 2022-03-28 09:56:51.249 |              10.800000000 | 3       | Beijing.Haidian                |
+ t_0e7bcfa21a02331c06764f275... | 2022-03-28 09:56:51.250 |              11.300000000 | 3       | Beijing.Haidian                |
+ t_7e7b26dd860280242c6492a16... | 2022-03-28 09:56:51.249 |              10.300000000 | 2       | Beijing.Chaoyang               |
+ t_7e7b26dd860280242c6492a16... | 2022-03-28 09:56:51.250 |              12.600000000 | 2       | Beijing.Chaoyang               |
+Query OK, 4 row(s) in set (0.005399s)
+```

docs-cn/06-insert-data/_go_line.mdx

+```go
+{{#include docs-examples/go/insert/line/main.go}}
+```

docs-cn/06-insert-data/_go_opts_json.mdx

+```go
+{{#include docs-examples/go/insert/json/main.go}}
+```

docs-cn/06-insert-data/_go_opts_telnet.mdx

+```go
+{{#include docs-examples/go/insert/telnet/main.go}}
+```

docs-cn/06-insert-data/_go_sql.mdx

+```go
+{{#include docs-examples/go/insert/sql/main.go}}
+```

docs-cn/06-insert-data/_go_stmt.mdx

+```go
+{{#include docs-examples/go/insert/stmt/main.go}}
+```
+
+:::tip
+driver-go 的模块 `github.com/taosdata/driver-go/v2/wrapper` 是 C 接口的底层封装。使用这个模块也可以实现动态绑定写入。
+
+:::

docs-cn/07-query-data/_go.mdx

+```go
+{{#include docs-examples/go/query/sync/main.go}}
+```

docs-cn/07-query-data/_go_async.mdx

+```go
+{{#include docs-examples/go/query/async/main.go}}
+```

docs-cn/07-query-data/index.mdx

@@ -32,7 +32,7 @@ TDengine 采用 SQL 作为查询语言。应用程序可以通过 C/C++, Java, G
 
 例如：在 TAOS Shell 中，从表 d1001 中查询出 voltage > 215 的记录，按时间降序排列，仅仅输出 2 条。
 
-```mysql
+```sql
 taos> select * from d1001 where voltage > 215 order by ts desc limit 2;
            ts            |       current        |   voltage   |        phase         |
 ======================================================================================
@@ -121,6 +121,8 @@ Query OK, 5 row(s) in set (0.001521s)
 
 ### 查询数据
 
+在 [SQL 写入](/insert-data/sql-writing) 一章，我们创建了 power 数据库，并向 meters 表写入了一些数据，以下示例代码展示如何查询这个表的数据。
+
 <Tabs defaultValue="java" groupId="lang">
   <TabItem label="Java" value="java">
     <JavaQuery />

docs-cn/08-advance-feature/01-continuous-query.mdx

@@ -45,7 +45,7 @@ create table avg_vol as select avg(voltage) from meters interval(1m) sliding(30s
 
 会自动创建一个名为 `avg_vol` 的新表，然后每隔 30 秒，TDengine 会增量执行 `as` 后面的 SQL 语句，并将查询结果写入这个表中，用户程序后续只要从 `avg_vol` 中查询数据即可。例如：
 
-```mysql
+```sql
 taos> select * from avg_vol;
             ts           |        avg_voltage_    |
 ===================================================
@@ -59,7 +59,7 @@ taos> select * from avg_vol;
 
 此外，TDengine 还支持用户指定连续查询的起止时间。如果不输入开始时间，连续查询将从第一条原始数据所在的时间窗口开始；如果没有输入结束时间，连续查询将永久运行；如果用户指定了结束时间，连续查询在系统时间达到指定的时间以后停止运行。比如使用下面的 SQL 创建的连续查询将运行一小时，之后会自动停止。
 
-```mysql
+```sql
 create table avg_vol as select avg(voltage) from meters where ts > now and ts <= now + 1h interval(1m) sliding(30s);
 ```
 
@@ -68,4 +68,3 @@ create table avg_vol as select avg(voltage) from meters where ts > now and ts <=
 ## 管理连续查询
 
 用户可在控制台中通过 `show streams` 命令来查看系统中全部运行的连续查询，并可以通过 `kill stream` 命令杀掉对应的连续查询。后续版本会提供更细粒度和便捷的连续查询管理命令。
-

docs-cn/08-advance-feature/03-cache.md

@@ -14,7 +14,7 @@ TDengine 将内存池按块划分进行管理，数据在内存块里是以行
 
 你可以通过函数 last_row() 快速获取一张表或一张超级表的最后一条记录，这样很便于在大屏显示各设备的实时状态或采集值。例如：
 
-```mysql
+```sql
 select last_row(voltage) from meters where location='Beijing.Chaoyang';
 ```
 

docs-cn/10-cluster/01-prerequisites.md → docs-cn/10-cluster/01-deploy.md

-# 准备工作
-## 第零步
+# 集群部署
+
+## 准备工作
+
+### 第零步
 
 规划集群所有物理节点的 FQDN，将规划好的 FQDN 分别添加到每个物理节点的/etc/hostname；修改每个物理节点的/etc/hosts，将所有集群物理节点的 IP 与 FQDN 的对应添加好。【如部署了 DNS，请联系网络管理员在 DNS 上做好相关配置】
 
-## 第一步
+### 第一步
 
 如果搭建集群的物理节点中，存有之前的测试数据、装过 1.X 的版本，或者装过其他版本的 TDengine，请先将其删除，并清空所有数据（如果需要保留原有数据，请联系涛思交付团队进行旧版本升级、数据迁移），具体步骤请参考博客《TDengine 多种安装包的安装和卸载》。
 
 :::note
-因为 FQDN 的信息会写进文件，如果之前没有配置或者更改 FQDN，且启动了 TDengine。请一定在确保数据无用或者备份的前提下，清理一下之前的数据（rm -rf /var/lib/taos/*）；
+因为 FQDN 的信息会写进文件，如果之前没有配置或者更改 FQDN，且启动了 TDengine。请一定在确保数据无用或者备份的前提下，清理一下之前的数据（rm -rf /var/lib/taos/\*）；
 :::
 
 :::note
 客户端也需要配置，确保它可以正确解析每个节点的 FQDN 配置，不管是通过 DNS 服务，还是修改 hosts 文件。
 :::
 
-
-## 第二步
+### 第二步
 
 建议关闭所有物理节点的防火墙，至少保证端口：6030 - 6042 的 TCP 和 UDP 端口都是开放的。强烈建议先关闭防火墙，集群搭建完毕之后，再来配置端口；
 
-## 第三步
+### 第三步
 
 在所有物理节点安装 TDengine，且版本必须是一致的，但不要启动 taosd。安装时，提示输入是否要加入一个已经存在的 TDengine 集群时，第一个物理节点直接回车创建新集群，后续物理节点则输入该集群任何一个在线的物理节点的 FQDN:端口号(默认 6030)；
 
-## 第四步
+### 第四步
 
 检查所有数据节点，以及应用程序所在物理节点的网络设置：
 
-每个物理节点上执行命令hostname -f，查看和确认所有节点的 hostname 是不相同的(应用驱动所在节点无需做此项检查)；
+每个物理节点上执行命令 hostname -f，查看和确认所有节点的 hostname 是不相同的(应用驱动所在节点无需做此项检查)；
 
-每个物理节点上执行ping host，其中 host 是其他物理节点的 hostname，看能否 ping 通其它物理节点；如果不能 ping 通，需要检查网络设置，或/etc/hosts 文件(Windows 系统默认路径为 C:\Windows\system32\drivers\etc\hosts)，或 DNS 的配置。如果无法 ping 通，是无法组成集群的；
+每个物理节点上执行 ping host，其中 host 是其他物理节点的 hostname，看能否 ping 通其它物理节点；如果不能 ping 通，需要检查网络设置，或/etc/hosts 文件(Windows 系统默认路径为 C:\Windows\system32\drivers\etc\hosts)，或 DNS 的配置。如果无法 ping 通，是无法组成集群的；
 
 从应用运行的物理节点，ping taosd 运行的数据节点，如果无法 ping 通，应用是无法连接 taosd 的，请检查应用所在物理节点的 DNS 设置或 hosts 文件；
 
-每个数据节点的 End Point 就是输出的 hostname 外加端口号，比如h1.taosdata.com:6030。
+每个数据节点的 End Point 就是输出的 hostname 外加端口号，比如 h1.taosdata.com:6030。
 
-## 第五步
+### 第五步
 
 修改 TDengine 的配置文件（所有节点的文件/etc/taos/taos.cfg 都需要修改）。假设准备启动的第一个数据节点 End Point 为 h1.taosdata.com:6030，其与集群配置相关参数如下：
 
@@ -53,6 +55,7 @@ serverPort            6030
 // 副本数为偶数的时候，需要配置，请参考《Arbitrator的使用》的部分
 arbitrator            ha.taosdata.com:6042
 ```
+
 一定要修改的参数是 firstEp 和 fqdn。在每个数据节点，firstEp 需全部配置成一样，但 fqdn 一定要配置成其所在数据节点的值。其他参数可不做任何修改，除非你很清楚为什么要修改。
 
 加入到集群中的数据节点 dnode，涉及集群相关的下表 9 项参数必须完全相同，否则不能成功加入到集群中。
@@ -72,3 +75,62 @@ arbitrator            ha.taosdata.com:6042
 :::note
 在 2.0.19.0 及更早的版本中，除以上 9 项参数外，dnode 加入集群时，还会要求 locale 和 charset 参数的取值也一致。
 :::
+
+## 启动集群
+
+### 启动第一个数据节点
+
+按照《立即开始》里的指示，启动第一个数据节点，例如 h1.taosdata.com，然后执行 taos, 启动 taos shell，从 shell 里执行命令"show dnodes;"，如下所示：
+
+```
+
+Welcome to the TDengine shell from Linux, Client Version:2.0.0.0
+
+
+Copyright (c) 2017 by TAOS Data, Inc. All rights reserved.
+
+taos> show dnodes;
+ id |       end_point    | vnodes | cores | status | role |      create_time        |
+=====================================================================================
+  1 |  h1.taos.com:6030  |      0 |     2 |  ready |  any | 2020-07-31 03:49:29.202 |
+Query OK, 1 row(s) in set (0.006385s)
+
+taos>
+```
+
+上述命令里，可以看到这个刚启动的这个数据节点的 End Point 是：h1.taos.com:6030，就是这个新集群的 firstEp。
+
+### 启动后续数据节点
+
+将后续的数据节点添加到现有集群，具体有以下几步：
+
+按照《立即开始》一章的方法在每个物理节点启动 taosd；（注意：每个物理节点都需要在 taos.cfg 文件中将 firstEp 参数配置为新集群首个节点的 End Point——在本例中是 h1.taos.com:6030）
+
+在第一个数据节点，使用 CLI 程序 taos，登录进 TDengine 系统，执行命令：
+
+```sql
+CREATE DNODE "h2.taos.com:6030";
+```
+
+将新数据节点的 End Point (准备工作中第四步获知的) 添加进集群的 EP 列表。"fqdn:port"需要用双引号引起来，否则出错。请注意将示例的“h2.taos.com:6030" 替换为这个新数据节点的 End Point。
+
+然后执行命令
+
+```sql
+SHOW DNODES;
+```
+
+查看新节点是否被成功加入。如果该被加入的数据节点处于离线状态，请做两个检查：
+
+查看该数据节点的 taosd 是否正常工作，如果没有正常运行，需要先检查为什么
+查看该数据节点 taosd 日志文件 taosdlog.0 里前面几行日志(一般在/var/log/taos 目录)，看日志里输出的该数据节点 fqdn 以及端口号是否为刚添加的 End Point。如果不一致，需要将正确的 End Point 添加进去。
+按照上述步骤可以源源不断的将新的数据节点加入到集群。
+
+:::tip
+
+任何已经加入集群在线的数据节点，都可以作为后续待加入节点的 firstEp。
+firstEp 这个参数仅仅在该数据节点首次加入集群时有作用，加入集群后，该数据节点会保存最新的 mnode 的 End Point 列表，不再依赖这个参数。
+接下来，配置文件中的 firstEp 参数就主要在客户端连接的时候使用了，例如 taos shell 如果不加参数，会默认连接由 firstEp 指定的节点。
+两个没有配置 firstEp 参数的数据节点 dnode 启动后，会独立运行起来。这个时候，无法将其中一个数据节点加入到另外一个数据节点，形成集群。无法将两个独立的集群合并成为新的集群。
+
+:::

docs-cn/10-cluster/02-cluster-mgmt.md

-# 集群部署
-## 启动第一个数据节点
-按照《立即开始》里的指示，启动第一个数据节点，例如 h1.taosdata.com，然后执行 taos, 启动 taos shell，从 shell 里执行命令"show dnodes;"，如下所示：
-```
-
-Welcome to the TDengine shell from Linux, Client Version:2.0.0.0
-
-
-Copyright (c) 2017 by TAOS Data, Inc. All rights reserved.
-
-taos> show dnodes;
- id |       end_point    | vnodes | cores | status | role |      create_time        |
-=====================================================================================
-  1 |  h1.taos.com:6030  |      0 |     2 |  ready |  any | 2020-07-31 03:49:29.202 |
-Query OK, 1 row(s) in set (0.006385s)
-
-taos>
-```
-上述命令里，可以看到这个刚启动的这个数据节点的 End Point 是：h1.taos.com:6030，就是这个新集群的 firstEp。
-
-## 启动后续数据节点
-将后续的数据节点添加到现有集群，具体有以下几步：
-
-按照《立即开始》一章的方法在每个物理节点启动 taosd；（注意：每个物理节点都需要在 taos.cfg 文件中将 firstEp 参数配置为新集群首个节点的 End Point——在本例中是 h1.taos.com:6030）
-
-在第一个数据节点，使用 CLI 程序 taos，登录进 TDengine 系统，执行命令：
-
-```mysql
-CREATE DNODE "h2.taos.com:6030";
-```
-将新数据节点的 End Point (准备工作中第四步获知的) 添加进集群的 EP 列表。"fqdn:port"需要用双引号引起来，否则出错。请注意将示例的“h2.taos.com:6030" 替换为这个新数据节点的 End Point。
-
-然后执行命令
-```mysql
-SHOW DNODES;
-```
-查看新节点是否被成功加入。如果该被加入的数据节点处于离线状态，请做两个检查：
-
-查看该数据节点的 taosd 是否正常工作，如果没有正常运行，需要先检查为什么
-查看该数据节点 taosd 日志文件 taosdlog.0 里前面几行日志(一般在/var/log/taos 目录)，看日志里输出的该数据节点 fqdn 以及端口号是否为刚添加的 End Point。如果不一致，需要将正确的 End Point 添加进去。
-按照上述步骤可以源源不断的将新的数据节点加入到集群。
-
-:::tip
-
-任何已经加入集群在线的数据节点，都可以作为后续待加入节点的 firstEp。
-firstEp 这个参数仅仅在该数据节点首次加入集群时有作用，加入集群后，该数据节点会保存最新的 mnode 的 End Point 列表，不再依赖这个参数。
-接下来，配置文件中的 firstEp 参数就主要在客户端连接的时候使用了，例如 taos shell 如果不加参数，会默认连接由 firstEp 指定的节点。
-两个没有配置 firstEp 参数的数据节点 dnode 启动后，会独立运行起来。这个时候，无法将其中一个数据节点加入到另外一个数据节点，形成集群。无法将两个独立的集群合并成为新的集群。
-
-:::
+# 集群管理
 
 ## 数据节点管理
+
 上面已经介绍如何从零开始搭建集群。集群组建完后，还可以随时添加新的数据节点进行扩容，或删除数据节点，并检查集群当前状态。
 
 提示：
@@ -58,17 +10,20 @@ firstEp 这个参数仅仅在该数据节点首次加入集群时有作用，加
 添加数据节点
 执行 CLI 程序 taos，执行：
 
-```mysql
+```sql
 CREATE DNODE "fqdn:port";
 ```
+
 将新数据节点的 End Point 添加进集群的 EP 列表。"fqdn:port"需要用双引号引起来，否则出错。一个数据节点对外服务的 fqdn 和 port 可以通过配置文件 taos.cfg 进行配置，缺省是自动获取。【强烈不建议用自动获取方式来配置 FQDN，可能导致生成的数据节点的 End Point 不是所期望的】
 
 ## 删除数据节点
+
 执行 CLI 程序 taos，执行：
 
-```mysql
+```sql
 DROP DNODE "fqdn:port | dnodeID";
 ```
+
 通过"fqdn:port"或"dnodeID"来指定一个具体的节点都是可以的。其中 fqdn 是被删除的节点的 FQDN，port 是其对外服务器的端口号；dnodeID 可以通过 SHOW DNODES 获得。
 
 :::warning
@@ -81,13 +36,15 @@ dnodeID 是集群自动分配的，不得人工指定。它在生成时是递增
 :::
 
 ## 手动迁移数据节点
+
 手动将某个 vnode 迁移到指定的 dnode。
 
 执行 CLI 程序 taos，执行：
 
-```mysql
+```sql
 ALTER DNODE <source-dnodeId> BALANCE "VNODE:<vgId>-DNODE:<dest-dnodeId>";
 ```
+
 其中：source-dnodeId 是源 dnodeId，也就是待迁移的 vnode 所在的 dnodeID；vgId 可以通过 SHOW VGROUPS 获得，列表的第一列；dest-dnodeId 是目标 dnodeId。
 
 :::warning
@@ -99,19 +56,22 @@ ALTER DNODE <source-dnodeId> BALANCE "VNODE:<vgId>-DNODE:<dest-dnodeId>";
 :::
 
 ## 查看数据节点
+
 执行 CLI 程序 taos，执行：
 
-```mysql
+```sql
 SHOW DNODES;
 ```
+
 它将列出集群中所有的 dnode，每个 dnode 的 ID，end_point(fqdn:port)，状态(ready, offline 等），vnode 数目，还未使用的 vnode 数目等信息。在添加或删除一个数据节点后，可以使用该命令查看。
 
 ## 查看虚拟节点组
+
 为充分利用多核技术，并提供 scalability，数据需要分片处理。因此 TDengine 会将一个 DB 的数据切分成多份，存放在多个 vnode 里。这些 vnode 可能分布在多个数据节点 dnode 里，这样就实现了水平扩展。一个 vnode 仅仅属于一个 DB，但一个 DB 可以有多个 vnode。vnode 的是 mnode 根据当前系统资源的情况，自动进行分配的，无需任何人工干预。
 
 执行 CLI 程序 taos，执行：
 
- ```mysql
+```sql
 USE SOME_DATABASE;
 SHOW VGROUPS;
- ```
+```

docs-cn/10-cluster/03-ha-and-lb.md

 # 高可用与负载均衡
+
 ## vnode 的高可用性
+
 TDengine 通过多副本的机制来提供系统的高可用性，包括 vnode 和 mnode 的高可用性。
 
 vnode 的副本数是与 DB 关联的，一个集群里可以有多个 DB，根据运营的需求，每个 DB 可以配置不同的副本数。创建数据库时，通过参数 replica 指定副本数（缺省为 1）。如果副本数为 1，系统的可靠性无法保证，只要数据所在的节点宕机，就将无法提供服务。集群的节点数必须大于等于副本数，否则创建表时将返回错误"more dnodes are needed"。比如下面的命令将创建副本数为 3 的数据库 demo：
 
-```mysql
+```sql
 CREATE DATABASE demo replica 3;
 ```
+
 一个 DB 里的数据会被切片分到多个 vnode group，vnode group 里的 vnode 数目就是 DB 的副本数，同一个 vnode group 里各 vnode 的数据是完全一致的。为保证高可用性，vnode group 里的 vnode 一定要分布在不同的数据节点 dnode 里（实际部署时，需要在不同的物理机上），只要一个 vgroup 里超过半数的 vnode 处于工作状态，这个 vgroup 就能正常的对外服务。
 
 一个数据节点 dnode 里可能有多个 DB 的数据，因此一个 dnode 离线时，可能会影响到多个 DB。如果一个 vnode group 里的一半或一半以上的 vnode 不工作，那么该 vnode group 就无法对外服务，无法插入或读取数据，这样会影响到它所属的 DB 的一部分表的读写操作。
@@ -14,13 +17,15 @@ CREATE DATABASE demo replica 3;
 因为 vnode 的引入，无法简单地给出结论：“集群中过半数据节点 dnode 工作，集群就应该工作”。但是对于简单的情形，很好下结论。比如副本数为 3，只有三个 dnode，那如果仅有一个节点不工作，整个集群还是可以正常工作的，但如果有两个数据节点不工作，那整个集群就无法正常工作了。
 
 ## Mnode 的高可用性
+
 TDengine 集群是由 mnode (taosd 的一个模块，管理节点) 负责管理的，为保证 mnode 的高可用，可以配置多个 mnode 副本，副本数由系统配置参数 numOfMnodes 决定，有效范围为 1-3。为保证元数据的强一致性，mnode 副本之间是通过同步的方式进行数据复制的。
 
 一个集群有多个数据节点 dnode，但一个 dnode 至多运行一个 mnode 实例。多个 dnode 情况下，哪个 dnode 可以作为 mnode 呢？这是完全由系统根据整个系统资源情况，自动指定的。用户可通过 CLI 程序 taos，在 TDengine 的 console 里，执行如下命令：
 
-```mysql
+```sql
 SHOW MNODES;
 ```
+
 来查看 mnode 列表，该列表将列出 mnode 所处的 dnode 的 End Point 和角色(master, slave, unsynced 或 offline)。当集群中第一个数据节点启动时，该数据节点一定会运行一个 mnode 实例，否则该数据节点 dnode 无法正常工作，因为一个系统是必须有至少一个 mnode 的。如果 numOfMnodes 配置为 2，启动第二个 dnode 时，该 dnode 也将运行一个 mnode 实例。
 
 为保证 mnode 服务的高可用性，numOfMnodes 必须设置为 2 或更大。因为 mnode 保存的元数据必须是强一致的，如果 numOfMnodes 大于 2，复制参数 quorum 自动设为 2，也就是说，至少要保证有两个副本写入数据成功，才通知客户端应用写入成功。
@@ -31,6 +36,7 @@ SHOW MNODES;
 :::
 
 ## 负载均衡
+
 有三种情况，将触发负载均衡，而且都无需人工干预。
 
 当一个新数据节点添加进集群时，系统将自动触发负载均衡，一些节点上的数据将被自动转移到新数据节点上，无需任何人工干预。
@@ -39,11 +45,12 @@ SHOW MNODES;
 当上述三种情况发生时，系统将启动各个数据节点的负载计算，从而决定如何挪动。
 
 :::tip
-负载均衡由参数 balance 控制，它决定是否启动自动负载均衡， 0 表示禁用， 1 表示启用自动负载均衡。** 
+负载均衡由参数 balance 控制，它决定是否启动自动负载均衡， 0 表示禁用， 1 表示启用自动负载均衡。\*\*
 
 :::
 
 ## 数据节点离线处理
+
 如果一个数据节点离线，TDengine 集群将自动检测到。有如下两种情况：
 
 该数据节点离线超过一定时间（taos.cfg 里配置参数 offlineThreshold 控制时长)，系统将自动把该数据节点删除，产生系统报警信息，触发负载均衡流程。如果该被删除的数据节点重新上线时，它将无法加入集群，需要系统管理员重新将其添加进集群才会开始工作。
@@ -56,6 +63,7 @@ SHOW MNODES;
 :::
 
 ## Arbitrator 的使用
+
 如果副本数为偶数，当一个 vnode group 里一半或超过一半的 vnode 不工作时，是无法从中选出 master 的。同理，一半或超过一半的 mnode 不工作时，是无法选出 mnode 的 master 的，因为存在“split brain”问题。
 
 为解决这个问题，TDengine 引入了 Arbitrator 的概念。Arbitrator 模拟一个 vnode 或 mnode 在工作，但只简单的负责网络连接，不处理任何数据插入或访问。只要包含 Arbitrator 在内，超过半数的 vnode 或 mnode 工作，那么该 vnode group 或 mnode 组就可以正常的提供数据插入或查询服务。比如对于副本数为 2 的情形，如果一个节点 A 离线，但另外一个节点 B 正常，而且能连接到 Arbitrator，那么节点 B 就能正常工作。
@@ -72,6 +80,6 @@ Arbitrator 的执行程序名为 tarbitrator。该程序对系统资源几乎没
 在配置文件中配置了的 Arbitrator，会出现在 SHOW DNODES; 指令的返回结果中，对应的 role 列的值会是“arb”。
 查看集群 Arbitrator 的状态【2.0.14.0 以后支持】
 
-```mysql
+```sql
 SHOW DNODES;
 ```

docs-cn/11-operation/06-admin.md

@@ -28,7 +28,7 @@ ALTER USER <user_name> PRIVILEGE <write|read>;
 
 说明：系统内共有 super/write/read 三种权限级别，但目前不允许通过 alter 指令把 super 权限赋予用户。
 
-```mysql
+```sql
 SHOW USERS;
 ```
 

docs-cn/11-operation/07-import.md

@@ -10,7 +10,7 @@ TDengine 的 shell 支持 source filename 命令，用于批量运行文件中
 
 TDengine 也支持在 shell 对已存在的表从 CSV 文件中进行数据导入。CSV 文件只属于一张表且 CSV 文件中的数据格式需与要导入表的结构相同，在导入的时候，其语法如下：
 
-```mysql
+```sql
 insert into tb1 file 'path/data.csv';
 ```
 
@@ -21,7 +21,7 @@ insert into tb1 file 'path/data.csv';
 
 例如，现在存在一个子表 d1001, 其表结构如下：
 
-```mysql
+```sql
 taos> DESCRIBE d1001
              Field              |        Type        |   Length    |    Note    |
 =================================================================================
@@ -49,7 +49,7 @@ taos> DESCRIBE d1001
 
 那么可以用如下命令导入数据：
 
-```mysql
+```sql
 taos> insert into d1001 file '~/data.csv';
 Query OK, 9 row(s) affected (0.004763s)
 ```

docs-cn/11-operation/08-export.md

@@ -6,7 +6,7 @@
 
 如果用户需要导出一个表或一个 STable 中的数据，可在 taos shell 中运行：
 
-```mysql
+```sql
 select * from <tb_name> >> data.csv;
 ```
 

docs-cn/11-operation/09-status.md

@@ -2,37 +2,37 @@
 
 系统管理员可以从 CLI 查询系统的连接、正在进行的查询、流式计算，并且可以关闭连接、停止正在进行的查询和流式计算。CLI 里 SQL 语法如下：
 
-```mysql
+```sql
 SHOW CONNECTIONS;
 ```
 
 显示数据库的连接，其中一列显示 ip:port, 为连接的 IP 地址和端口号。
 
-```mysql
+```sql
 KILL CONNECTION <connection-id>;
 ```
 
 强制关闭数据库连接，其中的 connection-id 是 SHOW CONNECTIONS 中显示的第一列的数字。
 
-```mysql
+```sql
 SHOW QUERIES;
 ```
 
 显示数据查询，其中第一列显示的以冒号隔开的两个数字为 query-id，为发起该 query 应用连接的 connection-id 和查询次数。
 
-```mysql
+```sql
 KILL QUERY <query-id>;
 ```
 
 强制关闭数据查询，其中 query-id 是 SHOW QUERIES 中显示的 connection-id:query-no 字串，如“105:2”，拷贝粘贴即可。
 
-```mysql
+```sql
 SHOW STREAMS;
 ```
 
 显示流式计算，其中第一列显示的以冒号隔开的两个数字为 stream-id, 为启动该 stream 应用连接的 connection-id 和发起 stream 的次数。
 
-```mysql
+```sql
 KILL STREAM <stream-id>;
 ```
 

docs-cn/11-operation/11-optimize.md

@@ -2,7 +2,7 @@
 
 因数据行 [update](https://www.taosdata.com/cn/documentation/faq#update)、表删除、数据过期等原因，TDengine 的磁盘存储文件有可能出现数据碎片，影响查询操作的性能表现。从 2.1.3.0 版本开始，新增 SQL 指令 COMPACT 来启动碎片重整过程：
 
-```mysql
+```sql
 COMPACT VNODES IN (vg_id1, vg_id2, ...)
 ```
 
@@ -10,7 +10,6 @@ COMPACT 命令对指定的一个或多个 VGroup 启动碎片重整，系统会
 
 需要注意的是，碎片重整操作会大幅消耗磁盘 I/O。因此在重整进行期间，有可能会影响节点的写入和查询性能，甚至在极端情况下导致短时间的阻写。
 
-
 ## 存储参数优化
 
 不同应用场景的数据往往具有不同的数据特征，比如保留天数、副本数、采集频次、记录大小、采集点的数量、压缩等都可完全不同。为获得在存储上的最高效率，TDengine 提供如下存储相关的系统配置参数（既可以作为 create database 指令的参数，也可以写在 taos.cfg 配置文件中用来设定创建新数据库时所采用的默认值）：
@@ -34,7 +33,7 @@ COMPACT 命令对指定的一个或多个 VGroup 启动碎片重整，系统会
 
 对于一个应用场景，可能有多种数据特征的数据并存，最佳的设计是将具有相同数据特征的表放在一个库里，这样一个应用有多个库，而每个库可以配置不同的存储参数，从而保证系统有最优的性能。TDengine 允许应用在创建库时指定上述存储参数，如果指定，该参数就将覆盖对应的系统配置参数。举例，有下述 SQL：
 
-```mysql
+```sql
  CREATE DATABASE demo DAYS 10 CACHE 32 BLOCKS 8 REPLICA 3 UPDATE 1;
 ```
 
@@ -83,7 +82,7 @@ TDengine 集群中加入一个新的 dnode 时，涉及集群相关的一些参
 
 为方便调试，可通过 SQL 语句临时调整每个 dnode 的日志配置，系统重启后会失效：
 
-```mysql
+```sql
 ALTER DNODE <dnode_id> <config>
 ```
 
@@ -97,4 +96,3 @@ ALTER DNODE <dnode_id> <config>
 ```
 alter dnode 1 debugFlag 135;
 ```
-

docs-cn/14-reference/01-taos-sql/07-function.md

@@ -179,11 +179,12 @@ Query OK, 1 row(s) in set (0.000921s)
 ```
 SELECT MODE(field_name) FROM tb_name [WHERE clause];
 ```
+
 - **功能说明**：返回出现频率最高的值，若存在多个频率相同的最高值，输出空。不能匹配标签、时间戳输出。
 - **返回数据类型**：同应用的字段。
 - **应用字段**：适合于除时间主列外的任何类型字段。
-- **说明**：由于返回数据量未知，考虑到内存因素，为了函数可以正常返回结果，建议不重复的数据量在10万级别，否则会报错。
-- **支持的版本**：2.6开始的版本。
+- **说明**：由于返回数据量未知，考虑到内存因素，为了函数可以正常返回结果，建议不重复的数据量在 10 万级别，否则会报错。
+- **支持的版本**：2.6 开始的版本。
 
 示例：
 
@@ -205,15 +206,17 @@ Query OK, 1 row(s) in set (0.019393s)
 ```
 
 ### HYPERLOGLOG
+
 ```
 SELECT HYPERLOGLOG(field_name) FROM { tb_name | stb_name } [WHERE clause];
 ```
+
 - **功能说明**：
-    - 采用hyperloglog算法，返回某列的基数。该算法在数据量很大的情况下，可以明显降低内存的占用，但是求出来的基数是个估算值，标准误差（标准误差是多次实验，每次的平均数的标准差，不是与真实结果的误差）为0.81%。
-    - 在数据量较少的时候该算法不是很准确，可以使用select count(data) from (select unique(col) as data from table) 的方法。
+  - 采用 hyperloglog 算法，返回某列的基数。该算法在数据量很大的情况下，可以明显降低内存的占用，但是求出来的基数是个估算值，标准误差（标准误差是多次实验，每次的平均数的标准差，不是与真实结果的误差）为 0.81%。
+  - 在数据量较少的时候该算法不是很准确，可以使用 select count(data) from (select unique(col) as data from table) 的方法。
 - **返回结果类型**：整形。
 - **应用字段**：适合于任何类型字段。
-- **支持的版本**：2.6开始的版本。
+- **支持的版本**：2.6 开始的版本。
 
 示例：
 
@@ -236,7 +239,7 @@ taos> select hyperloglog(dbig) from shll;
 ========================
        4           |
 Query OK, 1 row(s) in set (0.008388s)
- ```
+```
 
 ## 选择函数
 
@@ -674,10 +677,12 @@ SELECT INTERP(field_name) FROM { tb_name | stb_name } WHERE ts='timestamp' [FILL
 ```
 
 ### TAIL
+
 ```
 SELECT TAIL(field_name, k, offset_val) FROM {tb_name | stb_name} [WHERE clause];
 ```
-**功能说明**：返回跳过最后 offset_value个，然后取连续 k 个记录，不忽略 NULL 值。offset_val 可以不输入。此时返回最后的 k 个记录。当有 offset_val 输入的情况下，该函数功能等效于order by ts desc LIMIT  k OFFSET offset_val。
+
+**功能说明**：返回跳过最后 offset_value 个，然后取连续 k 个记录，不忽略 NULL 值。offset_val 可以不输入。此时返回最后的 k 个记录。当有 offset_val 输入的情况下，该函数功能等效于 order by ts desc LIMIT k OFFSET offset_val。
 
 **参数范围**：k: [1,100] offset_val: [0,100]。
 
@@ -688,6 +693,7 @@ SELECT TAIL(field_name, k, offset_val) FROM {tb_name | stb_name} [WHERE clause];
 **支持版本**：2.6 开始的版本。
 
 示例：
+
 ```
 taos> select ts,dbig from tail2;
        ts            |         dbig          |
@@ -709,9 +715,11 @@ Query OK, 2 row(s) in set (0.002307s)
 ```
 
 ### UNIQUE
+
 ```
 SELECT UNIQUE(field_name) FROM {tb_name | stb_name} [WHERE clause];
 ```
+
 **功能说明**：返回该列的数值首次出现的值。该函数功能与 distinct 相似，但是可以匹配标签和时间戳信息。可以针对除时间列以外的字段进行查询，可以匹配标签和时间戳，其中的标签和时间戳是第一次出现时刻的标签和时间戳。
 
 **返回结果数据类型**：同应用的字段。
@@ -721,10 +729,12 @@ SELECT UNIQUE(field_name) FROM {tb_name | stb_name} [WHERE clause];
 **支持版本**：2.6 开始的版本。
 
 **说明**：
-  - 该函数可以应用在普通表和超级表上。不能和窗口操作一起使用，例如 interval/state_window/session_window 。
-  - 由于返回数据量未知，考虑到内存因素，为了函数可以正常返回结果，建议不重复的数据量在10万级别，否则会报错。
+
+- 该函数可以应用在普通表和超级表上。不能和窗口操作一起使用，例如 interval/state_window/session_window 。
+- 由于返回数据量未知，考虑到内存因素，为了函数可以正常返回结果，建议不重复的数据量在 10 万级别，否则会报错。
 
 示例：
+
 ```
 taos> select ts,voltage from unique1;
        ts            |        voltage        |
@@ -753,21 +763,24 @@ Query OK, 5 row(s) in set (0.108458s)
 ## 计算函数
 
 - **DIFF**
-    ```mysql
+
+  ```sql
   SELECT {DIFF(field_name, ignore_negative) | DIFF(field_name)} FROM tb_name [WHERE clause];
   ```
-    功能说明：统计表中某列的值与前一行对应值的差。 ignore_negative 取值为 0|1 , 可以不填，默认值为 0. 不忽略负值。ignore_negative为1时表示忽略负数。
+
+  功能说明：统计表中某列的值与前一行对应值的差。 ignore_negative 取值为 0|1 , 可以不填，默认值为 0. 不忽略负值。ignore_negative 为 1 时表示忽略负数。
 
   返回结果数据类型：同应用字段。
 
-    应用字段：不能应用在timestamp、binary、nchar、bool类型字段。
+  应用字段：不能应用在 timestamp、binary、nchar、bool 类型字段。
 
   适用于：**表、（超级表）**。
 
-    说明：输出结果行数是范围内总行数减一，第一行没有结果输出。从 2.1.3.0 版本开始，DIFF 函数可以在由 GROUP BY 划分出单独时间线的情况下用于超级表（也即 GROUP BY tbname）。从2.6.0开始，DIFF函数支持ignore_negative参数
+  说明：输出结果行数是范围内总行数减一，第一行没有结果输出。从 2.1.3.0 版本开始，DIFF 函数可以在由 GROUP BY 划分出单独时间线的情况下用于超级表（也即 GROUP BY tbname）。从 2.6.0 开始，DIFF 函数支持 ignore_negative 参数
 
   示例：
-    ```mysql
+
+  ```sql
   taos> SELECT DIFF(current) FROM d1001;
           ts            |    diff(current)     |
   =================================================
@@ -876,12 +889,14 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
  其他使用说明参见 CEIL 函数描述。
 
 - **ASIN**
-    ```mysql
+
+  ```sql
   SELECT ASIN(field_name) FROM { tb_name | stb_name } [WHERE clause]
   ```
+
   功能说明：获得指定列的反正弦结果
 
-    返回结果类型：DOUBLE。如果输入值为NULL，输出值也为NULL
+  返回结果类型：DOUBLE。如果输入值为 NULL，输出值也为 NULL
 
   适用数据类型：不能应用在 timestamp、binary、nchar、bool 类型字段上；在超级表查询中使用时，不能应用在 tag 列
 
@@ -894,12 +909,14 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
       该函数可以应用在普通表和超级表上。
 
 - **ACOS**
-    ```mysql
+
+  ```sql
   SELECT ACOS(field_name) FROM { tb_name | stb_name } [WHERE clause]
   ```
+
   功能说明：获得指定列的反余弦结果
 
-    返回结果类型：DOUBLE。如果输入值为NULL，输出值也为NULL
+  返回结果类型：DOUBLE。如果输入值为 NULL，输出值也为 NULL
 
   适用数据类型：不能应用在 timestamp、binary、nchar、bool 类型字段上；在超级表查询中使用时，不能应用在 tag 列
 
@@ -912,12 +929,14 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
       该函数可以应用在普通表和超级表上。
 
 - **ATAN**
-    ```mysql
+
+  ```sql
   SELECT ATAN(field_name) FROM { tb_name | stb_name } [WHERE clause]
   ```
+
   功能说明：获得指定列的反正切结果
 
-    返回结果类型：DOUBLE。如果输入值为NULL，输出值也为NULL
+  返回结果类型：DOUBLE。如果输入值为 NULL，输出值也为 NULL
 
   适用数据类型：不能应用在 timestamp、binary、nchar、bool 类型字段上；在超级表查询中使用时，不能应用在 tag 列
 
@@ -932,12 +951,14 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
       版本2.6.0.x后支持
 
 - **SIN**
-    ```mysql
+
+  ```sql
   SELECT SIN(field_name) FROM { tb_name | stb_name } [WHERE clause]
   ```
+
   功能说明：获得指定列的正弦结果
 
-    返回结果类型：DOUBLE。如果输入值为NULL，输出值也为NULL
+  返回结果类型：DOUBLE。如果输入值为 NULL，输出值也为 NULL
 
   适用数据类型：不能应用在 timestamp、binary、nchar、bool 类型字段上；在超级表查询中使用时，不能应用在 tag 列
 
@@ -952,12 +973,14 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
       版本2.6.0.x后支持
 
 - **COS**
-    ```mysql
+
+  ```sql
   SELECT COS(field_name) FROM { tb_name | stb_name } [WHERE clause]
   ```
+
   功能说明：获得指定列的余弦结果
 
-    返回结果类型：DOUBLE。如果输入值为NULL，输出值也为NULL
+  返回结果类型：DOUBLE。如果输入值为 NULL，输出值也为 NULL
 
   适用数据类型：不能应用在 timestamp、binary、nchar、bool 类型字段上；在超级表查询中使用时，不能应用在 tag 列
 
@@ -972,12 +995,14 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
       版本2.6.0.x后支持
 
 - **TAN**
-    ```mysql
+
+  ```sql
   SELECT TAN(field_name) FROM { tb_name | stb_name } [WHERE clause]
   ```
+
   功能说明：获得指定列的正切结果
 
-    返回结果类型：DOUBLE。如果输入值为NULL，输出值也为NULL
+  返回结果类型：DOUBLE。如果输入值为 NULL，输出值也为 NULL
 
   适用数据类型：不能应用在 timestamp、binary、nchar、bool 类型字段上；在超级表查询中使用时，不能应用在 tag 列
 
@@ -992,12 +1017,14 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
       版本2.6.0.x后支持
 
 - **POW**
-    ```mysql
+
+  ```sql
   SELECT POW(field_name, power) FROM { tb_name | stb_name } [WHERE clause]
   ```
-    功能说明：获得指定列的指数为power的幂
 
-    返回结果类型：DOUBLE。如果输入值为NULL，输出值也为NULL
+  功能说明：获得指定列的指数为 power 的幂
+
+  返回结果类型：DOUBLE。如果输入值为 NULL，输出值也为 NULL
 
   适用数据类型：不能应用在 timestamp、binary、nchar、bool 类型字段上；在超级表查询中使用时，不能应用在 tag 列
 
@@ -1012,12 +1039,14 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
       版本2.6.0.x后支持
 
 - **LOG**
-    ```mysql
+
+  ```sql
   SELECT LOG(field_name, base) FROM { tb_name | stb_name } [WHERE clause]
   ```
-    功能说明：获得指定列对于底数base的对数
 
-    返回结果类型：DOUBLE。如果输入值为NULL，输出值也为NULL
+  功能说明：获得指定列对于底数 base 的对数
+
+  返回结果类型：DOUBLE。如果输入值为 NULL，输出值也为 NULL
 
   适用数据类型：不能应用在 timestamp、binary、nchar、bool 类型字段上；在超级表查询中使用时，不能应用在 tag 列
 
@@ -1032,12 +1061,14 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
       版本2.6.0.x后支持
 
 - **ABS**
-    ```mysql
+
+  ```sql
   SELECT ABS(field_name) FROM { tb_name | stb_name } [WHERE clause]
   ```
+
   功能说明：获得指定列的绝对值
 
-    返回结果类型：如果输入值为整数，输出值是UBIGINT类型。如果输入值是FLOAT/DOUBLE数据类型，输出值是DOUBLE数据类型。
+  返回结果类型：如果输入值为整数，输出值是 UBIGINT 类型。如果输入值是 FLOAT/DOUBLE 数据类型，输出值是 DOUBLE 数据类型。
 
   适用数据类型：不能应用在 timestamp、binary、nchar、bool 类型字段上；在超级表查询中使用时，不能应用在 tag 列
 
@@ -1052,12 +1083,14 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
       版本2.6.0.x后支持
 
 - **SQRT**
-    ```mysql
+
+  ```sql
   SELECT SQRT(field_name) FROM { tb_name | stb_name } [WHERE clause]
   ```
+
   功能说明：获得指定列的平方根
 
-    返回结果类型：DOUBLE。如果输入值为NULL，输出值也为NULL
+  返回结果类型：DOUBLE。如果输入值为 NULL，输出值也为 NULL
 
   适用数据类型：不能应用在 timestamp、binary、nchar、bool 类型字段上；在超级表查询中使用时，不能应用在 tag 列
 
@@ -1072,14 +1105,16 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
       版本2.6.0.x后支持
 
 - **CAST**
-    ```mysql
+
+  ```sql
   SELECT CAST(expression AS type_name) FROM { tb_name | stb_name } [WHERE clause]
   ```
-    功能说明：数据类型转换函数，输入参数expression支持普通列、常量、标量函数及它们之间的四则运算，不支持tag列，只适用于select子句中。
 
-    返回结果类型：CAST中指定的类型（type_name）。
+  功能说明：数据类型转换函数，输入参数 expression 支持普通列、常量、标量函数及它们之间的四则运算，不支持 tag 列，只适用于 select 子句中。
 
-    适用数据类型：输入参数expression的类型可以是除JSON外目前所有类型字段（BOOL/TINYINT/SMALLINT/INT/BIGINT/FLOAT/DOUBLE/BINARY(M)/TIMESTAMP/NCHAR(M)/TINYINT UNSIGNED/SMALLINT UNSIGNED/INT UNSIGNED/BIGINT UNSIGNED）; 输出目标类型只支持BIGINT/BINARY(N)/TIMESTAMP/NCHAR(N)/BIGINT UNSIGNED。
+  返回结果类型：CAST 中指定的类型（type_name）。
+
+  适用数据类型：输入参数 expression 的类型可以是除 JSON 外目前所有类型字段（BOOL/TINYINT/SMALLINT/INT/BIGINT/FLOAT/DOUBLE/BINARY(M)/TIMESTAMP/NCHAR(M)/TINYINT UNSIGNED/SMALLINT UNSIGNED/INT UNSIGNED/BIGINT UNSIGNED）; 输出目标类型只支持 BIGINT/BINARY(N)/TIMESTAMP/NCHAR(N)/BIGINT UNSIGNED。
 
   说明：
 
@@ -1095,14 +1130,16 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
       版本2.6.0.x后支持
 
 - **CONCAT**
-    ```mysql
+
+  ```sql
   SELECT CONCAT(str1|column1, str2|column2, ...) FROM { tb_name | stb_name } [WHERE clause]
   ```
+
   功能说明：字符串连接函数。
 
-    返回结果类型：同输入参数类型，BINARY或者NCHAR。
+  返回结果类型：同输入参数类型，BINARY 或者 NCHAR。
 
-    适用数据类型：输入参数或者全部是BINARY格式的字符串或者列，或者全部是NCHAR格式的字符串或者列。不能应用在TAG列。
+  适用数据类型：输入参数或者全部是 BINARY 格式的字符串或者列，或者全部是 NCHAR 格式的字符串或者列。不能应用在 TAG 列。
 
   说明：
 
@@ -1113,14 +1150,16 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
       版本2.6.0.x后支持
 
 - **CONCAT_WS**
+
   ```
   SELECT CONCAT_WS(separator, str1|column1, str2|column2, ...) FROM { tb_name | stb_name } [WHERE clause]
   ```
+
   功能说明：带分隔符的字符串连接函数。
 
-    返回结果类型：同输入参数类型，BINARY或者NCHAR。
+  返回结果类型：同输入参数类型，BINARY 或者 NCHAR。
 
-    适用数据类型：输入参数或者全部是BINARY格式的字符串或者列，或者全部是NCHAR格式的字符串或者列。不能应用在TAG列。
+  适用数据类型：输入参数或者全部是 BINARY 格式的字符串或者列，或者全部是 NCHAR 格式的字符串或者列。不能应用在 TAG 列。
 
   说明：
 
@@ -1131,14 +1170,16 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
       版本2.6.0.x后支持
 
 - **LENGTH**
+
   ```
   SELECT LENGTH(str|column) FROM { tb_name | stb_name } [WHERE clause]
   ```
+
   功能说明：以字节计数的字符串长度。
 
   返回结果类型：INT。
 
-    适用数据类型：输入参数是BINARY类型或者NCHAR类型的字符串或者列。不能应用在TAG列。
+  适用数据类型：输入参数是 BINARY 类型或者 NCHAR 类型的字符串或者列。不能应用在 TAG 列。
 
   说明：
 
@@ -1148,14 +1189,16 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
       版本2.6.0.x后支持
 
 - **CHAR_LENGTH**
+
   ```
   SELECT CHAR_LENGTH(str|column) FROM { tb_name | stb_name } [WHERE clause]
   ```
+
   功能说明：以字符计数的字符串长度。
 
   返回结果类型：INT。
 
-    适用数据类型：输入参数是BINARY类型或者NCHAR类型的字符串或者列。不能应用在TAG列。
+  适用数据类型：输入参数是 BINARY 类型或者 NCHAR 类型的字符串或者列。不能应用在 TAG 列。
 
   说明：
 
@@ -1165,14 +1208,16 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
       版本2.6.0.x后支持
 
 - **LOWER**
+
   ```
   SELECT LOWER(str|column) FROM { tb_name | stb_name } [WHERE clause]
   ```
+
   功能说明：将字符串参数值转换为全小写字母。
 
   返回结果类型：同输入类型。
 
-    适用数据类型：输入参数是BINARY类型或者NCHAR类型的字符串或者列。不能应用在TAG列。
+  适用数据类型：输入参数是 BINARY 类型或者 NCHAR 类型的字符串或者列。不能应用在 TAG 列。
 
   说明：
 
@@ -1182,14 +1227,16 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
       版本2.6.0.x后支持
 
 - **UPPER**
+
   ```
   SELECT UPPER(str|column) FROM { tb_name | stb_name } [WHERE clause]
   ```
+
   功能说明：将字符串参数值转换为全大写字母。
 
   返回结果类型：同输入类型。
 
-    适用数据类型：输入参数是BINARY类型或者NCHAR类型的字符串或者列。不能应用在TAG列。
+  适用数据类型：输入参数是 BINARY 类型或者 NCHAR 类型的字符串或者列。不能应用在 TAG 列。
 
   说明：
 
@@ -1199,14 +1246,16 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
       版本2.6.0.x后支持
 
 - **LTRIM**
+
   ```
   SELECT LTRIM(str|column) FROM { tb_name | stb_name } [WHERE clause]
   ```
+
   功能说明：返回清除左边空格后的字符串。
 
   返回结果类型：同输入类型。
 
-    适用数据类型：输入参数是BINARY类型或者NCHAR类型的字符串或者列。不能应用在TAG列。
+  适用数据类型：输入参数是 BINARY 类型或者 NCHAR 类型的字符串或者列。不能应用在 TAG 列。
 
   说明：
 
@@ -1216,14 +1265,16 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
       版本2.6.0.x后支持
 
 - **RTRIM**
+
   ```
   SELECT RTRIM(str|column) FROM { tb_name | stb_name } [WHERE clause]
   ```
+
   功能说明：返回清除右边空格后的字符串。
 
   返回结果类型：同输入类型。
 
-    适用数据类型：输入参数是BINARY类型或者NCHAR类型的字符串或者列。不能应用在TAG列。
+  适用数据类型：输入参数是 BINARY 类型或者 NCHAR 类型的字符串或者列。不能应用在 TAG 列。
 
   说明：
 
@@ -1233,14 +1284,16 @@ SELECT ROUND(field_name) FROM { tb_name | stb_name } [WHERE clause];
       版本2.6.0.x后支持
 
 - **SUBSTR**
+
   ```
   SELECT SUBSTR(str,pos[,len]) FROM { tb_name | stb_name } [WHERE clause]
   ```
-    功能说明：从源字符串str中的指定位置pos开始取一个长度为len的子串并返回。
+
+  功能说明：从源字符串 str 中的指定位置 pos 开始取一个长度为 len 的子串并返回。
 
   返回结果类型：同输入类型。
 
-    适用数据类型：输入参数是BINARY类型或者NCHAR类型的字符串或者列。不能应用在TAG列。
+  适用数据类型：输入参数是 BINARY 类型或者 NCHAR 类型的字符串或者列。不能应用在 TAG 列。
 
   说明：
 
@@ -1281,12 +1334,15 @@ Query OK, 3 row(s) in set (0.001046s)
 ```
 
 ### STATECOUNT
+
 ```
 SELECT STATECOUNT(field_name, oper, val) FROM { tb_name | stb_name } [WHERE clause];
 ```
-**功能说明**：返回满足某个条件的连续记录的个数，结果作为新的一列追加在每行后面。条件根据参数计算，如果条件为true则加1，条件为false则重置为-1，如果数据为NULL，跳过该条数据。
+
+**功能说明**：返回满足某个条件的连续记录的个数，结果作为新的一列追加在每行后面。条件根据参数计算，如果条件为 true 则加 1，条件为 false 则重置为-1，如果数据为 NULL，跳过该条数据。
 
 **参数范围**：
+
 - oper : LT (小于)、GT（大于）、LE（小于等于）、GE（大于等于）、NE（不等于）、EQ（等于），不区分大小写。
 - val : 数值型
 
@@ -1302,9 +1358,10 @@ SELECT STATECOUNT(field_name, oper, val) FROM { tb_name | stb_name } [WHERE clau
 
 - 该函数可以应用在普通表上，在由 GROUP BY 划分出单独时间线的情况下用于超级表（也即 GROUP BY tbname）
 
-- 不能和窗口操作一起使用，例如interval/state_window/session_window。
+- 不能和窗口操作一起使用，例如 interval/state_window/session_window。
 
 示例：
+
 ```
 taos> select ts,dbig from statef2;
           ts               |         dbig          |
@@ -1330,15 +1387,18 @@ Query OK, 6 row(s) in set (0.002791s)
 ```
 
 ### STATEDURATION
+
 ```
 SELECT stateDuration(field_name, oper, val, unit) FROM { tb_name | stb_name } [WHERE clause];
 ```
-**功能说明**：返回满足某个条件的连续记录的时间长度，结果作为新的一列追加在每行后面。条件根据参数计算，如果条件为true则加上两个记录之间的时间长度（第一个满足条件的记录时间长度记为0），条件为false则重置为-1，如果数据为NULL，跳过该条数据。
+
+**功能说明**：返回满足某个条件的连续记录的时间长度，结果作为新的一列追加在每行后面。条件根据参数计算，如果条件为 true 则加上两个记录之间的时间长度（第一个满足条件的记录时间长度记为 0），条件为 false 则重置为-1，如果数据为 NULL，跳过该条数据。
 
 **参数范围**：
+
 - oper : LT (小于)、GT（大于）、LE（小于等于）、GE（大于等于）、NE（不等于）、EQ（等于），不区分大小写。
 - val : 数值型
-- unit : 时间长度的单位，范围[1s、1m、1h ]，不足一个单位舍去。默认为1s。
+- unit : 时间长度的单位，范围[1s、1m、1h ]，不足一个单位舍去。默认为 1s。
 
 **返回结果类型**：整形。
 
@@ -1352,9 +1412,10 @@ SELECT stateDuration(field_name, oper, val, unit) FROM { tb_name | stb_name } [W
 
 - 该函数可以应用在普通表上，在由 GROUP BY 划分出单独时间线的情况下用于超级表（也即 GROUP BY tbname）
 
-- 不能和窗口操作一起使用，例如interval/state_window/session_window。
+- 不能和窗口操作一起使用，例如 interval/state_window/session_window。
 
 示例：
+
 ```
 taos> select ts,dbig from statef2;
           ts               |         dbig          |
@@ -1381,10 +1442,11 @@ Query OK, 6 row(s) in set (0.002613s)
 
 ### 时间函数
 
-从 2.6.0.0 版本开始，TDengine查询引擎支持以下时间相关函数：
+从 2.6.0.0 版本开始，TDengine 查询引擎支持以下时间相关函数：
 
 ### NOW
-```mysql
+
+```sql
 SELECT NOW() FROM { tb_name | stb_name } [WHERE clause];
 SELECT select_expr FROM { tb_name | stb_name } WHERE ts_col cond_operatior NOW();
 INSERT INTO tb_name VALUES (NOW(), ...);
@@ -1394,17 +1456,18 @@ INSERT INTO tb_name VALUES (NOW(), ...);
 
 **返回结果数据类型**：TIMESTAMP 时间戳类型。
 
-**应用字段**：在 WHERE 或 INSERT 语句中使用时只能作用于TIMESTAMP类型的字段。
+**应用字段**：在 WHERE 或 INSERT 语句中使用时只能作用于 TIMESTAMP 类型的字段。
 
 **适用于**：表、超级表。
 
 **说明**：
-  1）支持时间加减操作，如NOW() + 1s, 支持的时间单位如下：
-     b(纳秒)、u(微秒)、a(毫秒)、s(秒)、m(分)、h(小时)、d(天)、w(周)。
-  2）返回的时间戳精度与当前 DATABASE 设置的时间精度一致。
+1）支持时间加减操作，如 NOW() + 1s, 支持的时间单位如下：
+b(纳秒)、u(微秒)、a(毫秒)、s(秒)、m(分)、h(小时)、d(天)、w(周)。
+2）返回的时间戳精度与当前 DATABASE 设置的时间精度一致。
 
 示例：
-```mysql
+
+```sql
 taos> SELECT NOW() FROM meters;
           now()          |
 ==========================
@@ -1428,11 +1491,13 @@ Query OK, 1 of 1 row(s) in database (0.002210s)
 ```
 
 ## TODAY
-```mysql
+
+```sql
 SELECT TODAY() FROM { tb_name | stb_name } [WHERE clause];
 SELECT select_expr FROM { tb_name | stb_name } WHERE ts_col cond_operatior TODAY()];
 INSERT INTO tb_name VALUES (TODAY(), ...);
 ```
+
 **功能说明**：返回客户端当日零时的系统时间。
 
 **返回结果数据类型**：TIMESTAMP 时间戳类型。
@@ -1442,12 +1507,13 @@ INSERT INTO tb_name VALUES (TODAY(), ...);
 **适用于**：表、超级表。
 
 **说明**：
-  1）支持时间加减操作，如TODAY() + 1s, 支持的时间单位如下：
-     b(纳秒)，u(微秒)，a(毫秒)，s(秒)，m(分)，h(小时)，d(天)，w(周)。
-  2）返回的时间戳精度与当前 DATABASE 设置的时间精度一致。
+1）支持时间加减操作，如 TODAY() + 1s, 支持的时间单位如下：
+b(纳秒)，u(微秒)，a(毫秒)，s(秒)，m(分)，h(小时)，d(天)，w(周)。
+2）返回的时间戳精度与当前 DATABASE 设置的时间精度一致。
 
 示例：
-```mysql
+
+```sql
 taos> SELECT TODAY() FROM meters;
          today()          |
 ==========================
@@ -1471,9 +1537,11 @@ Query OK, 1 of 1 row(s) in database (0.002210s)
 ```
 
 ## TIMEZONE
-```mysql
+
+```sql
 SELECT TIMEZONE() FROM { tb_name | stb_name } [WHERE clause];
 ```
+
 **功能说明**：返回客户端当前时区信息。
 
 **返回结果数据类型**：BINARY 类型。
@@ -1483,7 +1551,8 @@ SELECT TIMEZONE() FROM { tb_name | stb_name } [WHERE clause];
 **适用于**：表、超级表。
 
 示例：
-```mysql
+
+```sql
 taos> SELECT TIMEZONE() FROM meters;
            timezone()           |
 =================================
@@ -1492,9 +1561,11 @@ Query OK, 1 row(s) in set (0.002093s)
 ```
 
 ## TO_ISO8601
-```mysql
+
+```sql
 SELECT TO_ISO8601(ts_val | ts_col) FROM { tb_name | stb_name } [WHERE clause];
 ```
+
 **功能说明**：将 UNIX 时间戳转换成为 ISO8601 标准的日期时间格式，并附加客户端时区信息。
 
 **返回结果数据类型**：BINARY 类型。
@@ -1506,7 +1577,8 @@ SELECT TO_ISO8601(ts_val | ts_col) FROM { tb_name | stb_name } [WHERE clause];
 **说明**：如果输入是 UNIX 时间戳常量，返回格式精度由时间戳的位数决定，如果输入是 TIMSTAMP 类型的列，返回格式的时间戳精度与当前 DATABASE 设置的时间精度一致。
 
 示例：
-```mysql
+
+```sql
 taos> SELECT TO_ISO8601(1643738400) FROM meters;
    to_iso8601(1643738400)    |
 ==============================
@@ -1521,23 +1593,26 @@ taos> SELECT TO_ISO8601(ts) FROM meters;
 ```
 
 ## TO_UNIXTIMESTAMP
-```mysql
+
+```sql
 SELECT TO_UNIXTIMESTAMP(datetime_string | ts_col) FROM { tb_name | stb_name } [WHERE clause];
 ```
+
 **功能说明**：将日期时间格式的字符串转换成为 UNIX 时间戳。
 
-**返回结果数据类型**：长整型INT64。
+**返回结果数据类型**：长整型 INT64。
 
 **应用字段**：字符串常量或是 BINARY/NCHAR 类型的列。
 
 **适用于**：表、超级表。
 
 说明：
-1）输入的日期时间字符串须符合 ISO8601/RFC3339 标准，无法转换的字符串格式将返回0。
+1）输入的日期时间字符串须符合 ISO8601/RFC3339 标准，无法转换的字符串格式将返回 0。
 2）返回的时间戳精度与当前 DATABASE 设置的时间精度一致。
 
 示例：
-```mysql
+
+```sql
 taos> SELECT TO_UNIXTIMESTAMP("2022-02-02T02:00:00.000Z") FROM meters;
 to_unixtimestamp("2022-02-02T02:00:00.000Z") |
 ==============================================
@@ -1552,9 +1627,11 @@ taos> SELECT TO_UNIXTIMESTAMP(col_binary) FROM meters;
 ```
 
 ## TIMETRUNCATE
-```mysql
+
+```sql
 SELECT TIMETRUNCATE(ts_val | datetime_string | ts_col, time_unit) FROM { tb_name | stb_name } [WHERE clause];
 ```
+
 **功能说明**：将时间戳按照指定时间单位 time_unit 进行截断。
 
 **返回结果数据类型**：TIMESTAMP 时间戳类型。
@@ -1565,11 +1642,12 @@ SELECT TIMETRUNCATE(ts_val | datetime_string | ts_col, time_unit) FROM { tb_name
 
 说明：
 1）支持的时间单位 time_unit 如下：
-     1u(微秒)，1a(毫秒)，1s(秒)，1m(分)，1h(小时)，1d(天)。
+1u(微秒)，1a(毫秒)，1s(秒)，1m(分)，1h(小时)，1d(天)。
 2）返回的时间戳精度与当前 DATABASE 设置的时间精度一致。
 
 示例：
-```mysql
+
+```sql
 taos> SELECT TIMETRUNCATE(1643738522000, 1h) FROM meters;
   timetruncate(1643738522000, 1h) |
 ===================================
@@ -1592,12 +1670,14 @@ Query OK, 3 row(s) in set (0.003903s)
 ```
 
 ## TIMEDIFF
-```mysql
+
+```sql
 SELECT TIMEDIFF(ts_val1 | datetime_string1 | ts_col1, ts_val2 | datetime_string2 | ts_col2 [, time_unit]) FROM { tb_name | stb_name } [WHERE clause];
 ```
+
 **功能说明**：计算两个时间戳之间的差值，并近似到时间单位 time_unit 指定的精度。
 
-**返回结果数据类型**：长整型INT64。
+**返回结果数据类型**：长整型 INT64。
 
 **应用字段**：UNIX 时间戳，日期时间格式的字符串，或者 TIMESTAMP 类型的列。
 
@@ -1605,11 +1685,12 @@ SELECT TIMEDIFF(ts_val1 | datetime_string1 | ts_col1, ts_val2 | datetime_string2
 
 说明：
 1）支持的时间单位 time_unit 如下：
-     1u(微秒)，1a(毫秒)，1s(秒)，1m(分)，1h(小时)，1d(天)。
+1u(微秒)，1a(毫秒)，1s(秒)，1m(分)，1h(小时)，1d(天)。
 2）如果时间单位 time_unit 未指定， 返回的时间差值精度与当前 DATABASE 设置的时间精度一致。
 
 示例：
-```mysql
+
+```sql
 taos> SELECT TIMEDIFF(1643738400000, 1643742000000) FROM meters;
  timediff(1643738400000, 1643742000000) |
 =========================================

docs-cn/14-reference/03-connector/_varify_linux.mdx

 在 Linux shell 下直接执行 taos，应该就能正常连接到 TDegine 服务，进入到 taos shell 界面，示例如下：
 
-```mysql
+```sql
 $ taos
 Welcome to the TDengine shell from Linux, Client  Version:2.0.5.0
 Copyright (c) 2017 by TAOS Data, Inc. All rights  reserved.

docs-cn/14-reference/03-connector/_varify_windows.mdx

 在 cmd 下进入到 c:\TDengine 目录下直接执行 taos.exe，应该就能正常链接到 tdegine 服务，进入到 taos shell 界面，示例如下：
 
-```mysql
+```sql
   C:\TDengine>taos
   Welcome to the TDengine  shell from Linux, Client Version:2.0.5.0
   Copyright (c) 2017 by  TAOS Data, Inc. All rights reserved.

docs-cn/14-reference/03-connector/go.mdx

@@ -17,7 +17,7 @@ Go 连接器支持的系统有：
 
 ## 示例程序
 
-使用 Go 连接器的示例代码请参考 `https://github.com/taosdata/TDengine/tree/develop/examples/go` 以及[视频教程](https://www.taosdata.com/blog/2020/11/11/1951.html)。
+使用 Go 连接器的示例代码请参考 [https://github.com/taosdata/TDengine/tree/develop/examples/go](https://github.com/taosdata/TDengine/tree/develop/examples/go) 以及[视频教程](https://www.taosdata.com/blog/2020/11/11/1951.html)。
 
 示例程序源码也位于安装目录下的 examples/go/taosdemo.go 文件中。
 

docs-cn/17-train-fqa/01-faq.md

@@ -158,7 +158,7 @@ TDengine 是根据 hostname 唯一标志一台机器的，在数据文件从机
 
 为了调试方便，从 2.0.16 版本开始，命令行程序 taos 新增了与日志记录相关的两条指令：
 
-```mysql
+```sql
 ALTER LOCAL flag_name flag_value;
 ```
 
@@ -167,7 +167,7 @@ ALTER LOCAL flag_name flag_value;
 - flag_name 的取值可以是：debugFlag，cDebugFlag，tmrDebugFlag，uDebugFlag，rpcDebugFlag
 - flag_value 的取值可以是：131（输出错误和警告日志），135（ 输出错误、警告和调试日志），143（ 输出错误、警告、调试和跟踪日志）
 
-```mysql
+```sql
 ALTER LOCAL RESETLOG;
 ```
 

docs-examples/go/.gitignore

 .idea
 .vscode
+tmp/
\ No newline at end of file

docs-examples/go/connect/afconn/main.go

+package main
+
+import (
+	"fmt"
+
+	"github.com/taosdata/driver-go/v2/af"
+)
+
+func main() {
+	conn, err := af.Open("localhost", "root", "taosdata", "", 6030)
+	defer conn.Close()
+	if err != nil {
+		fmt.Println("failed to connect, err:", err)
+	} else {
+		fmt.Println("connected")
+	}
+}

docs-examples/go/connect/restexample/main.go

@@ -8,7 +8,7 @@ import (
 )
 
 func main() {
-	var taosDSN = "root:taosdata@http(localhost:6041)"
+	var taosDSN = "root:taosdata@http(localhost:6041)/"
 	taos, err := sql.Open("taosRestful", taosDSN)
 	if err != nil {
 		fmt.Println("failed to connect TDengine, err:", err)

docs-examples/go/connect/wrapper/main.go

+package main
+
+import (
+	"fmt"
+
+	"github.com/taosdata/driver-go/v2/wrapper"
+)
+
+func main() {
+	conn, err := wrapper.TaosConnect("localhost", "root", "taosdata", "", 6030)
+	defer wrapper.TaosClose(conn)
+	if err != nil {
+		fmt.Println("fail to connect, err:", err)
+	} else {
+		fmt.Println("connected")
+	}
+}

docs-examples/go/insert/json/main.go

+package main
+
+import (
+	"fmt"
+
+	"github.com/taosdata/driver-go/v2/af"
+)
+
+func prepareDatabase(conn *af.Connector) {
+	_, err := conn.Exec("CREATE DATABASE test")
+	if err != nil {
+		panic(err)
+	}
+	_, err = conn.Exec("use test")
+	if err != nil {
+		panic(err)
+	}
+}
+
+func main() {
+	conn, err := af.Open("localhost", "root", "taosdata", "", 6030)
+	if err != nil {
+		fmt.Println("fail to connect, err:", err)
+	}
+	defer conn.Close()
+	prepareDatabase(conn)
+
+	payload := `[{"metric": "meters.current", "timestamp": 1648432611249, "value": 10.3, "tags": {"location": "Beijing.Chaoyang", "groupid": 2}},
+				{"metric": "meters.voltage", "timestamp": 1648432611249, "value": 219, "tags": {"location": "Beijing.Haidian", "groupid": 1}},
+				{"metric": "meters.current", "timestamp": 1648432611250, "value": 12.6, "tags": {"location": "Beijing.Chaoyang", "groupid": 2}},
+				{"metric": "meters.voltage", "timestamp": 1648432611250, "value": 221, "tags": {"location": "Beijing.Haidian", "groupid": 1}}]`
+
+	err = conn.OpenTSDBInsertJsonPayload(payload)
+	if err != nil {
+		fmt.Println("insert error:", err)
+	}
+}

docs-examples/go/insert/line/main.go

+package main
+
+import (
+	"fmt"
+
+	"github.com/taosdata/driver-go/v2/af"
+)
+
+func prepareDatabase(conn *af.Connector) {
+	_, err := conn.Exec("CREATE DATABASE test")
+	if err != nil {
+		panic(err)
+	}
+	_, err = conn.Exec("use test")
+	if err != nil {
+		panic(err)
+	}
+}
+
+func main() {
+	conn, err := af.Open("localhost", "root", "taosdata", "", 6030)
+	if err != nil {
+		fmt.Println("fail to connect, err:", err)
+	}
+	defer conn.Close()
+	prepareDatabase(conn)
+	var lines = []string{
+		"meters,location=Beijing.Haidian,groupid=2 current=11.8,voltage=221,phase=0.28 1648432611249",
+		"meters,location=Beijing.Haidian,groupid=2 current=13.4,voltage=223,phase=0.29 1648432611250",
+		"meters,location=Beijing.Haidian,groupid=3 current=10.8,voltage=223,phase=0.29 1648432611249",
+		"meters,location=Beijing.Haidian,groupid=3 current=11.3,voltage=221,phase=0.35 1648432611250",
+	}
+
+	err = conn.InfluxDBInsertLines(lines, "ms")
+	if err != nil {
+		fmt.Println("insert error:", err)
+	}
+}

docs-examples/go/insert/sql/main.go

+package main
+
+import (
+	"database/sql"
+	"fmt"
+
+	_ "github.com/taosdata/driver-go/v2/taosRestful"
+)
+
+func createStable(taos *sql.DB) {
+	_, err := taos.Exec("CREATE DATABASE power")
+	if err != nil {
+		fmt.Println("failed to create database, err:", err)
+	}
+	_, err = taos.Exec("CREATE STABLE power.meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS (location BINARY(64), groupId INT)")
+	if err != nil {
+		fmt.Println("failed to create stable, err:", err)
+	}
+}
+
+func insertData(taos *sql.DB) {
+	sql := `INSERT INTO power.d1001 USING power.meters TAGS(Beijing.Chaoyang, 2) VALUES ('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)
+	power.d1002 USING power.meters TAGS(Beijing.Chaoyang, 3) VALUES ('2018-10-03 14:38:16.650', 10.30000, 218, 0.25000)
+	power.d1003 USING power.meters TAGS(Beijing.Haidian, 2) VALUES ('2018-10-03 14:38:05.500', 11.80000, 221, 0.28000) ('2018-10-03 14:38:16.600', 13.40000, 223, 0.29000)
+	power.d1004 USING power.meters TAGS(Beijing.Haidian, 3) VALUES ('2018-10-03 14:38:05.000', 10.80000, 223, 0.29000) ('2018-10-03 14:38:06.500', 11.50000, 221, 0.35000)`
+	result, err := taos.Exec(sql)
+	if err != nil {
+		fmt.Println("failed to insert, err:", err)
+		return
+	}
+	rowsAffected, err := result.RowsAffected()
+	if err != nil {
+		fmt.Println("failed to get affected rows, err:", err)
+		return
+	}
+	fmt.Println("RowsAffected", rowsAffected)
+}
+
+func main() {
+	var taosDSN = "root:taosdata@http(localhost:6041)/"
+	taos, err := sql.Open("taosRestful", taosDSN)
+	if err != nil {
+		fmt.Println("failed to connect TDengine, err:", err)
+		return
+	}
+	defer taos.Close()
+	createStable(taos)
+	insertData(taos)
+}

docs-examples/go/insert/stmt/main.go

+package main
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/taosdata/driver-go/v2/af"
+	"github.com/taosdata/driver-go/v2/af/param"
+	"github.com/taosdata/driver-go/v2/common"
+)
+
+func checkErr(err error, prompt string) {
+	if err != nil {
+		fmt.Printf("%s\n", prompt)
+		panic(err)
+	}
+}
+
+func prepareStable(conn *af.Connector) {
+	_, err := conn.Exec("CREATE DATABASE power")
+	checkErr(err, "failed to create database")
+	_, err = conn.Exec("CREATE STABLE power.meters (ts TIMESTAMP, current FLOAT, voltage INT, phase FLOAT) TAGS (location BINARY(64), groupId INT)")
+	checkErr(err, "failed to create stable")
+	_, err = conn.Exec("USE power")
+	checkErr(err, "failed to change database")
+}
+
+func main() {
+	conn, err := af.Open("localhost", "root", "taosdata", "", 6030)
+	checkErr(err, "fail to connect")
+	defer conn.Close()
+	prepareStable(conn)
+	// create stmt
+	stmt := conn.InsertStmt()
+	defer stmt.Close()
+	err = stmt.Prepare("INSERT INTO ? USING meters TAGS(?, ?) VALUES(?, ?, ?, ?)")
+	checkErr(err, "failed to create prepare statement")
+
+	// bind table name and tags
+	tagParams := param.NewParam(2).AddBinary([]byte("Beijing.Chaoyang")).AddInt(2)
+	err = stmt.SetTableNameWithTags("d1001", tagParams)
+	checkErr(err, "failed to execute SetTableNameWithTags")
+
+	// specify ColumnType
+	var bindType *param.ColumnType = param.NewColumnType(4).AddTimestamp().AddFloat().AddInt().AddFloat()
+
+	// bind values. note: can only bind one row each time.
+	valueParams := []*param.Param{
+		param.NewParam(1).AddTimestamp(time.Unix(1648432611, 249300000), common.PrecisionMilliSecond),
+		param.NewParam(1).AddFloat(10.3),
+		param.NewParam(1).AddInt(219),
+		param.NewParam(1).AddFloat(0.31),
+	}
+	err = stmt.BindParam(valueParams, bindType)
+	checkErr(err, "BindParam error")
+	err = stmt.AddBatch()
+	checkErr(err, "AddBatch error")
+
+	// bind one more row
+	valueParams = []*param.Param{
+		param.NewParam(1).AddTimestamp(time.Unix(1648432611, 749300000), common.PrecisionMilliSecond),
+		param.NewParam(1).AddFloat(12.6),
+		param.NewParam(1).AddInt(218),
+		param.NewParam(1).AddFloat(0.33),
+	}
+	err = stmt.BindParam(valueParams, bindType)
+	checkErr(err, "BindParam error")
+	err = stmt.AddBatch()
+	checkErr(err, "AddBatch error")
+	// execute
+	err = stmt.Execute()
+	checkErr(err, "Execute batch error")
+}

docs-examples/go/insert/telnet/main.go

+package main
+
+import (
+	"fmt"
+
+	"github.com/taosdata/driver-go/v2/af"
+)
+
+func prepareDatabase(conn *af.Connector) {
+	_, err := conn.Exec("CREATE DATABASE test")
+	if err != nil {
+		panic(err)
+	}
+	_, err = conn.Exec("use test")
+	if err != nil {
+		panic(err)
+	}
+}
+
+func main() {
+	conn, err := af.Open("localhost", "root", "taosdata", "", 6030)
+	if err != nil {
+		fmt.Println("fail to connect, err:", err)
+	}
+	defer conn.Close()
+	prepareDatabase(conn)
+	var lines = []string{
+		"meters.current 1648432611249 10.3 location=Beijing.Chaoyang groupid=2",
+		"meters.current 1648432611250 12.6 location=Beijing.Chaoyang groupid=2",
+		"meters.current 1648432611249 10.8 location=Beijing.Haidian groupid=3",
+		"meters.current 1648432611250 11.3 location=Beijing.Haidian groupid=3",
+		"meters.voltage 1648432611249 219 location=Beijing.Chaoyang groupid=2",
+		"meters.voltage 1648432611250 218 location=Beijing.Chaoyang groupid=2",
+		"meters.voltage 1648432611249 221 location=Beijing.Haidian groupid=3",
+		"meters.voltage 1648432611250 217 location=Beijing.Haidian groupid=3",
+	}
+
+	err = conn.OpenTSDBInsertTelnetLines(lines)
+	if err != nil {
+		fmt.Println("insert error:", err)
+	}
+}

docs-examples/go/query/async/main.go

+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println("hello world!")
+}

docs-examples/go/query/sync/main.go

+package main
+
+import (
+	"database/sql"
+	"fmt"
+	"time"
+
+	_ "github.com/taosdata/driver-go/v2/taosRestful"
+)
+
+func main() {
+	var taosDSN = "root:taosdata@http(localhost:6041)/power"
+	taos, err := sql.Open("taosRestful", taosDSN)
+	if err != nil {
+		fmt.Println("failed to connect TDengine, err:", err)
+		return
+	}
+	defer taos.Close()
+	rows, err := taos.Query("select ts, current from meters limit 2")
+	if err != nil {
+		fmt.Println("failed to select from table, err:", err)
+		return
+	}
+
+	defer rows.Close()
+	for rows.Next() {
+		var r struct {
+			ts      time.Time
+			current float32
+		}
+		err := rows.Scan(&r.ts, &r.current)
+		if err != nil {
+			fmt.Println("scan error:\n", err)
+			return
+		}
+		fmt.Println(r.ts, r.current)
+	}
+}

docs-examples/java/src/main/java/com/taos/example/LineProtocolExample.java

@@ -12,11 +12,7 @@ import java.sql.Statement;
 public class LineProtocolExample {
     // format: measurement,tag_set field_set timestamp
     private static String[] lines = {
-            "meters,location=Beijing.Chaoyang,groupid=2 current=10.3,voltage=219,phase=0.31 1648432611249300", // micro seconds
-            "meters,location=Beijing.Chaoyang,groupid=2 current=12.6,voltage=218,phase=0.33 1648432611249800",
-            "meters,location=Beijing.Chaoyang,groupid=2 current=12.3,voltage=221,phase=0.31 1648432611250300",
-            "meters,location=Beijing.Chaoyang,groupid=3 current=10.3,voltage=218,phase=0.25 1648432611249200",
-            "meters,location=Beijing.Haidian,groupid=2 current=11.8,voltage=221,phase=0.28 1648432611249000",
+            "meters,location=Beijing.Haidian,groupid=2 current=11.8,voltage=221,phase=0.28 1648432611249000", // micro seconds
             "meters,location=Beijing.Haidian,groupid=2 current=13.4,voltage=223,phase=0.29 1648432611249500",
             "meters,location=Beijing.Haidian,groupid=3 current=10.8,voltage=223,phase=0.29 1648432611249300",
             "meters,location=Beijing.Haidian,groupid=3 current=11.3,voltage=221,phase=0.35 1648432611249800",

docs-examples/python/line_protocol_example.py

 import taos
 from taos import SmlProtocol, SmlPrecision
 
-lines = ["meters,location=Beijing.Chaoyang,groupid=2 current=10.3,voltage=219,phase=0.31 1648432611249300",
-         "meters,location=Beijing.Chaoyang,groupid=2 current=12.6,voltage=218,phase=0.33 1648432611249800",
-         "meters,location=Beijing.Chaoyang,groupid=2 current=12.3,voltage=221,phase=0.31 1648432611250300",
-         "meters,location=Beijing.Chaoyang,groupid=3 current=10.3,voltage=218,phase=0.25 1648432611249200",
-         "meters,location=Beijing.Haidian,groupid=2 current=11.8,voltage=221,phase=0.28 1648432611249000",
+lines = ["meters,location=Beijing.Haidian,groupid=2 current=11.8,voltage=221,phase=0.28 1648432611249000",
          "meters,location=Beijing.Haidian,groupid=2 current=13.4,voltage=223,phase=0.29 1648432611249500",
          "meters,location=Beijing.Haidian,groupid=3 current=10.8,voltage=223,phase=0.29 1648432611249300",
          "meters,location=Beijing.Haidian,groupid=3 current=11.3,voltage=221,phase=0.35 1648432611249800",