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,23 +17,26 @@ 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，也就是说，至少要保证有两个副本写入数据成功，才通知客户端应用写入成功。
 
-:::note 
-一个 TDengine 高可用系统，无论是 vnode 还是 mnode, 都必须配置多个副本。 
+:::note
+一个 TDengine 高可用系统，无论是 vnode 还是 mnode, 都必须配置多个副本。
 
 :::
 
 ## 负载均衡
+
 有三种情况，将触发负载均衡，而且都无需人工干预。
 
 当一个新数据节点添加进集群时，系统将自动触发负载均衡，一些节点上的数据将被自动转移到新数据节点上，无需任何人工干预。
@@ -38,24 +44,26 @@ SHOW MNODES;
 如果一个数据节点过热（数据量过大），系统将自动进行负载均衡，将该数据节点的一些 vnode 自动挪到其他节点。
 当上述三种情况发生时，系统将启动各个数据节点的负载计算，从而决定如何挪动。
 
-:::tip 
-负载均衡由参数 balance 控制，它决定是否启动自动负载均衡， 0 表示禁用， 1 表示启用自动负载均衡。** 
+:::tip
+负载均衡由参数 balance 控制，它决定是否启动自动负载均衡， 0 表示禁用， 1 表示启用自动负载均衡。\*\*
 
 :::
 
 ## 数据节点离线处理
+
 如果一个数据节点离线，TDengine 集群将自动检测到。有如下两种情况：
 
 该数据节点离线超过一定时间（taos.cfg 里配置参数 offlineThreshold 控制时长)，系统将自动把该数据节点删除，产生系统报警信息，触发负载均衡流程。如果该被删除的数据节点重新上线时，它将无法加入集群，需要系统管理员重新将其添加进集群才会开始工作。
 
 离线后，在 offlineThreshold 的时长内重新上线，系统将自动启动数据恢复流程，等数据完全恢复后，该节点将开始正常工作。
 
-:::note 
-如果一个虚拟节点组（包括 mnode 组）里所归属的每个数据节点都处于离线或 unsynced 状态，必须等该虚拟节点组里的所有数据节点都上线、都能交换状态信息后，才能选出 Master，该虚拟节点组才能对外提供服务。比如整个集群有 3 个数据节点，副本数为 3，如果 3 个数据节点都宕机，然后 2 个数据节点重启，是无法工作的，只有等 3 个数据节点都重启成功，才能对外服务。 
+:::note
+如果一个虚拟节点组（包括 mnode 组）里所归属的每个数据节点都处于离线或 unsynced 状态，必须等该虚拟节点组里的所有数据节点都上线、都能交换状态信息后，才能选出 Master，该虚拟节点组才能对外提供服务。比如整个集群有 3 个数据节点，副本数为 3，如果 3 个数据节点都宕机，然后 2 个数据节点重启，是无法工作的，只有等 3 个数据节点都重启成功，才能对外服务。
 
 :::
 
 ## 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;
 ```
 
@@ -16,4 +16,4 @@ select * from <tb_name> >> data.csv;
 
 利用 taosdump，用户可以根据需要选择导出所有数据库、一个数据库或者数据库中的一张表，所有数据或一时间段的数据，甚至仅仅表的定义。
 
-具体使用方法，请参见博客：[TDengine DUMP 工具使用指南](https://www.taosdata.com/blog/2020/03/09/1334.html)。
\ No newline at end of file
+具体使用方法，请参见博客：[TDengine DUMP 工具使用指南](https://www.taosdata.com/blog/2020/03/09/1334.html)。

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/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.
@@ -11,4 +11,4 @@
   log        | 2020-10-12  09:08:21.651 |      4 |      1 |    1 |   1 |    10 | 30,30,30              |      1 |      3 |     100 |    4096 |    1 |    3000 |  2 | us    | ready    |
   Query OK, 2 row(s) in  set (0.045000s)
   taos>
-```
\ No newline at end of file
+```

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
\ No newline at end of file
+.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",