Docs/sangshuduo/td 13571 remove outdated (#10497)

* remove out-dated links

* refine taostools section

* adjst descriptions

* fix typo

documentation20/cn/01.evaluation/docs.md

@@ -16,7 +16,7 @@ TDengine 是一款高性能、分布式、支持 SQL 的时序数据库。而且
 
 - **零学习成本**：采用 SQL 查询语言，支持 Python, Java, C/C++, Go, Rust, Node.js 等多种编程语言,与 MySQL 相似，零学习成本。
 
-- **无缝集成**：不用一行代码，即可与 Telegraf, Grafana, EMQ X, Prometheus, StatsD, collectd, Matlab, R 等第三方工具无缝集成。
+- **无缝集成**：不用一行代码，即可与 Telegraf, Grafana, EMQX, Prometheus, StatsD, collectd, Matlab, R 等第三方工具无缝集成。
 
 - **互动 Console**: 通过命令行 console，不用编程，执行 SQL 语句就能做即席查询、各种数据库的操作、管理以及集群的维护.
 

documentation20/cn/02.getting-started/02.taosdemo/docs.md

@@ -228,7 +228,7 @@ taosBenchmark 的参数是为了满足数据模拟的需求来设计的。下面
 ```
 -t, --tables=NUMBER           The number of tables. Default is 10000.
 -n, --records=NUMBER          The number of records per table. Default is 10000.
--M, --random                  The value of records generated are totally random. The default is to simulate power equipment senario.
+-M, --random                  The value of records generated are totally random. The default is to simulate power equipment scenario.
 ```
 
 前面提到 taosBenchmark 默认创建 10000 个表，每个表写入 10000 条记录。可以通过 -t 和 -n 设置表的数量和每个表的记录的数量。默认无参数生成的数据为模拟真实场景，模拟生成的数据为电流电压相位值增加一定的抖动，可以更真实表现 TDengine 高效的数据压缩能力。如果需要模拟生成完全随机数据，可以通过 -M 参数。
@@ -253,7 +253,7 @@ taosBenchmark 的参数是为了满足数据模拟的需求来设计的。下面
 如果对 taosBenchmark 写入数据过程感兴趣或者数据写入结果不符合预期，可以使用 -g 参数使 taosBenchmark 打印执行过程中间调试信息到屏幕上，或通过 Linux 重定向命令导入到另外一个文件，方便找到发生问题的原因。另外 taosBenchmark 在执行失败后也会把相应执行的语句和调试原因输出到屏幕。可以搜索 reason 来找到 TDengine 服务端返回的错误原因信息。
 
 ```
--x, --aggr-func               Test aggregation funtions after insertion.
+-x, --aggr-func               Test aggregation functions after insertion.
 ```
 
 TDengine 不仅仅是插入性能非常强大，由于其先进的数据库引擎设计使查询性能也异常强大。taosBenchmark 提供一个 -x 函数，可以在插入数据结束后进行常用查询操作并输出查询消耗时间。以下为在前述服务器上进行插入一亿条记录后进行常用查询的结果。
@@ -399,7 +399,7 @@ taosBenchmark 不仅仅可以进行数据写入，也可以执行查询和订阅
 
 ```
 "query_times": 每种查询类型的查询次数
-"query_mode": 查询数据接口，"taosc"：调用TDengine的c接口；“resetful”：使用restfule接口。可选项。缺省是“taosc”。
+"query_mode": 查询数据接口，"taosc"：调用TDengine的c接口；“restful”：使用 RESTful 接口。可选项。缺省是“taosc”。
 "specified_table_query": { 指定表的查询
 "query_interval": 执行sqls的间隔，单位是秒。可选项，缺省是0。
 "concurrent": 并发执行sqls的线程数，可选项，缺省是1。每个线程都执行所有的sqls。
@@ -468,7 +468,7 @@ taosBenchmark 不仅仅可以进行数据写入，也可以执行查询和订阅
 
 ## 结语
 
-TDengine是涛思数据专为物联网、车联网、工业互联网、IT运维等设计和优化的大数据平台。TDengine 由于数据库内核中创新的数据存储和查询引擎设计，展现出远超同类产品的高效性能。并且由于支持 SQL 语法和多种编程语言的连接器（目前支持 Java, Python, Go, C#, NodeJS, Rust 等），易用性极强，学习成本为零。为了便于运维需求，我们还提供数据迁移和监控功能等相关生态工具软件。
+TDengine是涛思数据专为物联网、车联网、工业互联网、IT运维等设计和优化的大数据平台。TDengine 由于数据库内核中创新的数据存储和查询引擎设计，展现出远超同类产品的高效性能。并且由于支持 SQL 语法和多种编程语言的连接器（目前支持 Java, Python, Go, C#, Node.js, Rust 等），易用性极强，学习成本为零。为了便于运维需求，我们还提供数据迁移和监控功能等相关生态工具软件。
 
 为了刚接触 TDengine 的使用者方便进行技术评估和压力测试，我们为 taosBenchmark 开发了丰富的特性。本文即为对 taosBenchmark 的一个简单介绍，随着 TDengine 新功能的不断增加，taosBenchmark 也会继续演化和改进。taosBenchmark 的代码做为 TDengine 的一部分在 GitHub 上完全开源。欢迎就 taosBenchmark 或 TDengine 的使用或实现在 GitHub 或者涛思数据的用户群提出建议或批评。
 
@@ -601,7 +601,7 @@ taosBenchmark支持3种功能的测试，包括插入、查询、订阅。但一
             "start_timestamp": "2020-10-01 00:00:00.000",
             "sample_format": "csv",
             "sample_file": "./sample.csv",
-               "use_sameple_ts": "no",
+               "use_sample_ts": "no",
             "tags_file": "",
             "columns": [{"type": "INT"}, {"type": "DOUBLE", "count":10}, {"type": "BINARY", "len": 16, "count":3}, {"type": "BINARY", "len": 32, "count":6}],
             "tags": [{"type": "TINYINT", "count":2}, {"type": "BINARY", "len": 16, "count":5}]
@@ -684,7 +684,7 @@ taosBenchmark支持3种功能的测试，包括插入、查询、订阅。但一
 
 "data_source": 插入数据来源，"rand"：实例随机生成；“sample”：从样例文件中读取。可选项。缺省是“rand”。
 
-"insert_mode": 插入数据接口，"taosc"：调用TDengine的c接口；“rest”：使用restful接口；“stmt”：使用 stmt （参数绑定）接口 （目前仅在 develop 分支代码中）。可选项。缺省是“taosc”。
+"insert_mode": 插入数据接口，"taosc"：调用TDengine的c接口；“rest”：使用 RESTful 接口；“stmt”：使用 stmt （参数绑定）接口 （目前仅在 develop 分支代码中）。可选项。缺省是“taosc”。
 
 "insert_rows": 插入记录数，0：一直插入，永不退出；>0：每个子表插入记录数，完成后实例退出。可选项，缺省是0。
 
@@ -794,7 +794,7 @@ taosBenchmark支持3种功能的测试，包括插入、查询、订阅。但一
 
 "query_times": 每种查询类型的查询次数
 
-"query_mode": 查询数据接口，"taosc"：调用TDengine的c接口；“resetful”：使用restfule接口。可选项。缺省是“taosc”。
+"query_mode": 查询数据接口，"taosc"：调用TDengine的c接口；“restful”：使用 RESTful 接口。可选项。缺省是“taosc”。
 
 "specified_table_query": { 指定表的查询
 

documentation20/cn/02.getting-started/docs.md

@@ -17,7 +17,7 @@ docker run -d -p 6030-6049:6030-6049 -p 6030-6049:6030-6049/udp tdengine/tdengin
 
 注：暂时不建议生产环境采用 Docker 来部署 TDengine 的客户端或服务端，但在开发环境下或初次尝试时，使用 Docker 方式部署是十分方便的。特别是，利用 Docker，可以方便地在 macOS 和 Windows 环境下尝试 TDengine。
 
-从 2.4.0.10 开始，除taosd以外，docker镜像还包含：taos、taosAdapter、taosdump、taosBenchmark、TDinsight安装脚本和示例代码。启动docker容器时，将同时启动taosAdapter和taosd，实现对restful的支持。
+从 2.4.0.10 开始，除 taosd 以外，docker 镜像还包含：taos、taosAdapter、taosdump、taosBenchmark、TDinsight 安装脚本和示例代码。启动 docker 容器时，将同时启动 taosAdapter 和 taosd，实现对 RESTful 的支持。
 
 
 ### <a class="anchor" id="package-install"></a>通过安装包安装

documentation20/cn/05.insert/docs.md

@@ -315,7 +315,7 @@ taosAdapter 相关配置参数请参考 taosadapter --help 命令输出以及相
 
 ## <a class="anchor" id="emq"></a>EMQ Broker 直接写入
 
-MQTT 是流行的物联网数据传输协议，[EMQ](https://github.com/emqx/emqx) 是一开源的 MQTT Broker 软件，无需任何代码，只需要在 EMQ Dashboard 里使用“规则”做简单配置，即可将 MQTT 的数据直接写入 TDengine。EMQ X 支持通过 发送到 Web 服务的方式保存数据到 TDengine，也在企业版上提供原生的 TDengine 驱动实现直接保存。详细使用方法请参考 [EMQ 官方文档](https://docs.emqx.com/zh/enterprise/v4.4/rule/backend_tdengine.html#%E4%BF%9D%E5%AD%98%E6%95%B0%E6%8D%AE%E5%88%B0-tdengine)。
+MQTT 是流行的物联网数据传输协议，[EMQX](https://github.com/emqx/emqx) 是一开源的 MQTT Broker 软件，无需任何代码，只需要在 EMQ Dashboard 里使用“规则”做简单配置，即可将 MQTT 的数据直接写入 TDengine。EMQX 支持通过 发送到 Web 服务的方式保存数据到 TDengine，也在企业版上提供原生的 TDengine 驱动实现直接保存。详细使用方法请参考 [EMQ 官方文档](https://docs.emqx.com/zh/enterprise/v4.4/rule/backend_tdengine.html#%E4%BF%9D%E5%AD%98%E6%95%B0%E6%8D%AE%E5%88%B0-tdengine)。
 
 ## <a class="anchor" id="hivemq"></a>HiveMQ Broker 直接写入
 

documentation20/cn/08.connector/01.java/docs.md

@@ -23,7 +23,7 @@ TDengine 的 JDBC 驱动实现尽可能与关系型数据库驱动保持一致
 <tr align="center"><th>对比项</th><th>JDBC-JNI</th><th>JDBC-RESTful</th></tr>
 <tr align="center">
   <td>支持的操作系统</td>
-  <td>linux、windows</td>
+  <td>Linux、Windows</td>
   <td>全平台</td>
 </tr>
 <tr align="center">

documentation20/cn/08.connector/docs.md

@@ -55,14 +55,14 @@ TDengine 提供了丰富的应用程序开发接口，其中包括 C/C++、Java
 ​    *install_client.sh*：安装脚本，用于应用驱动程序
 ​    *taos.tar.gz*：应用驱动安装包
 ​    *driver*：TDengine应用驱动driver
-​    *connector*: 各种编程语言连接器（go/nodejs/python/JDBC）
-​    *examples*: 各种编程语言的示例程序(c/C#/go/JDBC/MATLAB/python/R)
+​    *connector*: 各种编程语言连接器（Go/Node.js/Python/JDBC）
+​    *examples*: 各种编程语言的示例程序（c/C#/Go/JDBC/MATLAB/Python/R）
 
 运行install_client.sh进行安装。
 
 **4.   配置taos.cfg**
 
-编辑 taos.cfg 文件(默认路径/etc/taos/taos.cfg)，将 firstEP 修改为 TDengine 服务器的 End Point，例如：h1.taos.com:6030
+编辑 taos.cfg 文件（默认路径/etc/taos/taos.cfg），将 firstEP 修改为 TDengine 服务器的 End Point，例如：h1.taos.com:6030
 
 **提示：**
 
@@ -1099,7 +1099,7 @@ HTTP 请求 URL 采用 `sqlutc` 时，返回结果集的时间戳将采用 UTC
 
 ### 安装验证
 
-需要先安装 .Net SDK
+需要先安装 .NET SDK
 
 ```cmd
 cd {client_install_directory}/examples/C#/C#Checker
@@ -1141,7 +1141,7 @@ using TDengineDriver;
 
 ### 第三方驱动
 
-Maikebing.Data.Taos 是一个 TDengine 的 ADO.Net 提供器，支持 linux，windows。该开发包由热心贡献者`麦壳饼@@maikebing`提供，具体请参考
+Maikebing.Data.Taos 是一个 TDengine 的 ADO.NET 提供器，支持 Linux，Windows。该开发包由热心贡献者`麦壳饼@@maikebing`提供，具体请参考
 
 ```
 //接口下载
@@ -1380,7 +1380,7 @@ Node.js 连接器的使用参见[视频教程](https://www.taosdata.com/blog/202
 npm install td2.0-connector
 ```
 
-我们建议用户使用 npm 安装 Node.js 连接器。如果您没有安装 npm，可以将 *src/connector/nodejs/* 拷贝到您的 nodejs 项目目录下。
+我们建议用户使用 npm 安装 Node.js 连接器。如果您没有安装 npm，可以将 *src/connector/nodejs/* 拷贝到您的 Node.js 项目目录下。
 
 我们使用 [node-gyp](https://github.com/nodejs/node-gyp) 和 TDengine 服务端进行交互。安装 Node.js 连接器之前，还需要根据具体操作系统来安装下文提到的一些依赖工具。
 
@@ -1418,7 +1418,7 @@ Node-example-raw.js
 
 ### 安装验证
 
-在安装好 TDengine 客户端后，使用 nodejsChecker.js 程序能够验证当前环境是否支持 nodejs 方式访问 TDengine。
+在安装好 TDengine 客户端后，使用 nodejsChecker.js 程序能够验证当前环境是否支持 Node.js 方式访问 TDengine。
 
 验证方法：
 
@@ -1432,7 +1432,7 @@ npm install td2.0-connector
 node nodejsChecker.js host=localhost
 ```
 
-3. 执行以上步骤后，在命令行会输出 nodejs 连接 TDengine 实例，并执行简答插入和查询的结果。
+3. 执行以上步骤后，在命令行会输出 Node.js 连接 TDengine 实例，并执行简答插入和查询的结果。
 
 ### Node.js连接器的使用
 
@@ -1530,6 +1530,6 @@ promise2.then(function(result) {
 
 ### 示例
 
-[node-example.js](https://github.com/taosdata/TDengine/blob/master/examples/nodejs/node-example.js) 提供了一个使用NodeJS 连接器建表，插入天气数据并查询插入的数据的代码示例。
+[node-example.js](https://github.com/taosdata/TDengine/blob/master/examples/nodejs/node-example.js) 提供了一个使用 Node.js 连接器建表，插入天气数据并查询插入的数据的代码示例。
 
-[node-example-raw.js](https://github.com/taosdata/TDengine/blob/master/examples/nodejs/node-example-raw.js) 同样是一个使用 NodeJS 连接器建表，插入天气数据并查询插入的数据的代码示例，但和上面不同的是，该示例只使用 `cursor`。
+[node-example-raw.js](https://github.com/taosdata/TDengine/blob/master/examples/nodejs/node-example-raw.js) 同样是一个使用 Node.js 连接器建表，插入天气数据并查询插入的数据的代码示例，但和上面不同的是，该示例只使用 `cursor`。

documentation20/en/00.index/docs.md

@@ -38,7 +38,7 @@ TDengine is a highly efficient platform to store, query, and analyze time-series
 - [Data Writing via Schemaless](/insert#schemaless): write one or multiple records with automatic table creation and adaptive table structure maintenance
 - [Data Writing via Prometheus](/insert#prometheus): Configure Prometheus to write data directly without any code
 - [Data Writing via Telegraf](/insert#telegraf): Configure Telegraf to write collected data directly without any code
-- [Data Writing via EMQ X](/insert#emq): Configure EMQ X to write MQTT data directly without any code
+- [Data Writing via EMQX](/insert#emq): Configure EMQX to write MQTT data directly without any code
 - [Data Writing via HiveMQ Broker](/insert#hivemq): Configure HiveMQ to write MQTT data directly without any code
 
 ## [Efficient Data Querying](/queries)

documentation20/en/01.evaluation/docs.md

@@ -12,7 +12,7 @@ TDengine is a high-performance, scalable time-series database with SQL support.
 
 - **All in One**: TDengine has built-in caching, stream processing and data subscription functions. It is no longer necessary to integrate Kafka/Redis/HBase/Spark or other software in some scenarios. It makes the system architecture much simpler, cost-effective and easier to maintain.
 
-- **Seamless Integration**: Without a single line of code, TDengine provide seamless, configurable integration with third-party tools such as Telegraf, Grafana, EMQ X, Prometheus, StatsD, collectd, etc. More third-party tools are being integrated.
+- **Seamless Integration**: Without a single line of code, TDengine provide seamless, configurable integration with third-party tools such as Telegraf, Grafana, EMQX, Prometheus, StatsD, collectd, etc. More third-party tools are being integrated.
 
 - **Zero Management**: Installation and cluster setup can be done in seconds. Data partitioning and sharding are executed automatically. TDengine’s running status can be monitored via Grafana or other DevOps tools.
 

documentation20/en/02.getting-started/02.taosdemo/docs.md

@@ -69,7 +69,7 @@ taos> describe test.meters;
 Query OK, 6 row(s) in set (0.002972s)
 ```
 
-After pressing any key taosBenchmark will create the database test and super table meters and generate 10,000 sub-tables representing 10,000 individule meter devices that report data. That means they independently using the super table meters as a template according to TDengine data modeling best practices.
+After pressing any key taosBenchmark will create the database test and super table meters and generate 10,000 sub-tables representing 10,000 individual meter devices that report data. That means they independently using the super table meters as a template according to TDengine data modeling best practices.
 
 ```
 taos> use test;
@@ -151,7 +151,7 @@ Spent 6.0257 seconds to insert rows: 100000000, affected rows: 100000000 with 16
 insert delay, avg:       8.31ms, max:     860.12ms, min:       2.00ms
 ```
 
-It shows that taosBenchmark inserted 100 million records in 6 seconds, with a much more higher insertion performance, 1,659,590 records wer inserted per second.
+It shows that taosBenchmark inserted 100 million records in 6 seconds, with a much more higher insertion performance, 1,659,590 records was inserted per second.
 
 Because taosBenchmark is so easy to use, so we have extended it with more features to support more complex parameter settings for sample data preparation and validation for rapid prototyping.
 
@@ -224,7 +224,7 @@ The -T parameter sets how many threads taosBenchmark uses to synchronize data wr
 -l, --columns=COLUMNS         The number of columns per record. Demo mode by default is 3 (float, int, float). Max values is 4095
 ```
 
-As mentioned earlier, tadosdemo creates a typical meter data reporting scenario by default, with each device containing three columns. They are current, voltage and phases. TDengine supports BOOL, TINYINT, SMALLINT, INT, BIGINT, FLOAT, DOUBLE, BINARY, NCHAR, TIMESTAMP data types. By using -b with a list of types allows you to specify the column list with customized data type. Using -w to specify the width of the columns of the BINARY and NCHAR data types (default is 64). The -l parameter can be added to the columns of the data type specified by the -b parameter with the total number of columns of the INT type, which reduces the manual input process in case of a particularly large number of columns, up to 4095 columns.
+As mentioned earlier, taosdemo creates a typical meter data reporting scenario by default, with each device containing three columns. They are current, voltage and phases. TDengine supports BOOL, TINYINT, SMALLINT, INT, BIGINT, FLOAT, DOUBLE, BINARY, NCHAR, TIMESTAMP data types. By using -b with a list of types allows you to specify the column list with customized data type. Using -w to specify the width of the columns of the BINARY and NCHAR data types (default is 64). The -l parameter can be added to the columns of the data type specified by the -b parameter with the total number of columns of the INT type, which reduces the manual input process in case of a particularly large number of columns, up to 4095 columns.
 
 ```
 -r, --rec-per-req=NUMBER      The number of records per request. Default is 30000.
@@ -251,7 +251,7 @@ As we can see above, taosBenchmark outputs a list of parameters for the upcoming
 -R, --disorder-range=NUMBER   Out of order data's range, ms, default is 1000.
 ```
 
-In some scenarios, the received data does not arrive in exact order, but contains a certain percentage of out-of-order data, which TDengine can also handle very well. In order to simulate the writing of out-of-order data, tadosdemo provides -O and -R parameters to be set. The -O parameter is the same as the -O parameter for fully ordered data writes. 1 to 50 is the percentage of data that contains out-of-order data. The -R parameter is the range of the timestamp offset of the out-of-order data, default is 1000 milliseconds. Also note that temporal data is uniquely identified by a timestamp, so garbled data may generate the exact same timestamp as previously written data, and such data may either be discarded (update 0) or overwrite existing data (update 1 or 2) depending on the update value created by the database, and the total number of data entries may not match the expected number of entries.
+In some scenarios, the received data does not arrive in exact order, but contains a certain percentage of out-of-order data, which TDengine can also handle very well. In order to simulate the writing of out-of-order data, taosdemo provides -O and -R parameters to be set. The -O parameter is the same as the -O parameter for fully ordered data writes. 1 to 50 is the percentage of data that contains out-of-order data. The -R parameter is the range of the timestamp offset of the out-of-order data, default is 1000 milliseconds. Also note that temporal data is uniquely identified by a timestamp, so garbled data may generate the exact same timestamp as previously written data, and such data may either be discarded (update 0) or overwrite existing data (update 1 or 2) depending on the update value created by the database, and the total number of data entries may not match the expected number of entries.
 
 ```
  -g, --debug                   Print debug info.
@@ -260,10 +260,10 @@ In some scenarios, the received data does not arrive in exact order, but contain
 If you are interested in the taosBenchmark insertion process or if the data insertion result is not as expected, you can use the -g parameter to make taosBenchmark print the debugging information in the process of the execution to the screen or import it to another file with the Linux redirect command to easily find the cause of the problem. In addition, taosBenchmark will also output the corresponding executed statements and debugging reasons to the screen after the execution fails. You can search the word "reason" to find the error reason information returned by the TDengine server.
 
 ```
--x, --aggr-func               Test aggregation funtions after insertion.
+-x, --aggr-func               Test aggregation functions after insertion.
 ```
 
-TDengine is not only very powerful in insertion performance, but also in query performance due to its advanced database engine design. tadosdemo provides a -x function that performs the usual query operations and outputs the query consumption time after the insertion of data. The following is the result of a common query after inserting 100 million rows on the aforementioned server.
+TDengine is not only very powerful in insertion performance, but also in query performance due to its advanced database engine design. taosdemo provides a -x function that performs the usual query operations and outputs the query consumption time after the insertion of data. The following is the result of a common query after inserting 100 million rows on the aforementioned server.
 
 You can see that the select * fetch 100 million rows (not output to the screen) operation consumes only 1.26 seconds. The most of normal aggregation function for 100 million records usually takes only about 20 milliseconds, and even the longest count function takes less than 40 milliseconds.
 
@@ -406,7 +406,7 @@ The following parameters are specific to the query in the JSON file.
 
 ```
 "query_times": the number of queries per query type
-"query_mode": query data interface, "tosc": call TDengine's c interface; "resetful": use restfule interface. Options are available. Default is "taosc".
+"query_mode": query data interface, "taosc": call TDengine's c interface; "restful": use RESTful interface. Options are available. Default is "taosc".
 "specified_table_query": { query for the specified table
 "query_interval": interval to execute sqls, in seconds. Optional, default is 0.
 "concurrent": the number of threads to execute sqls concurrently, optional, default is 1. Each thread executes all sqls.
@@ -475,9 +475,9 @@ The following are the meanings of the parameters specific to the subscription fu
 
 # Conclusion
 
-TDengine is a big data platform designed and optimized for IoT, Telematics, Industrial Internet, DevOps, etc. TDengine shows a high performance that far exceeds similar products due to the innovative data storage and query engine design in the database kernel. And withSQL syntax support and connectors for multiple programming languages (currently Java, Python, Go, C#, NodeJS, Rust, etc. are supported), it is extremely easy to use and has zero learning cost. To facilitate the operation and maintenance needs, we also provide data migration and monitoring functions and other related ecological tools and software.
+TDengine is a big data platform designed and optimized for IoT, Telemetric, Industrial Internet, DevOps, etc. TDengine shows a high performance that far exceeds similar products due to the innovative data storage and query engine design in the database kernel. And with SQL syntax support and connectors for multiple programming languages (currently Java, Python, Go, C#, Node.js, Rust, etc. are supported), it is extremely easy to use and has zero learning cost. To facilitate the operation and maintenance needs, we also provide data migration and monitoring functions and other related ecological tools and software.
 
 For users who are new to TDengine, we have developed rich features for taosBenchmark to facilitate technical evaluation and stress testing. This article is a brief introduction to taosBenchmark, which will continue to evolve and improve as new features are added to TDengine.
 
- As part of TDengine, taosBenchmark's source code is fully open on the GitHub. Suggestions or advices about the use or implementation of taosBenchmark or TDengine are welcomed on GitHub or in the Taos Data user group.
+ As part of TDengine, taosBenchmark's source code is fully open on the GitHub. Suggestions or advice about the use or implementation of taosBenchmark or TDengine are welcomed on GitHub or in the Taos Data user group.
 

documentation20/en/02.getting-started/03.install/docs.md

@@ -138,7 +138,7 @@ To start TDengine     : sudo systemctl start taosd
 To access TDengine    : use taos -h shuduo-1804 in shell OR from http://127.0.0.1:6060
 
 TDengine is updated successfully!
-Install taoskeeper as a stand-alone service
+Install taoskeeper as a standalone service
 taoskeeper is installed, enable it by `systemctl enable taoskeeper`
 ```
 

documentation20/en/05.insert/docs.md

@@ -306,7 +306,7 @@ Please find taosAdapter configuration and usage from `taosadapter --help` output
 
 ## <a class="anchor" id="emq"></a> Data Writing via EMQ Broker
 
-[EMQ](https://github.com/emqx/emqx) is an open source MQTT Broker software, with no need of coding, only to use "rules" in EMQ Dashboard for simple configuration, and MQTT data can be directly written into TDengine. EMQ X supports storing data to the TDengine by sending it to a Web service, and also provides a native TDengine driver on Enterprise Edition for direct data store. Please refer to [EMQ official documents](https://docs.emqx.io/broker/latest/cn/rule/rule-example.html#%E4%BF%9D%E5%AD%98%E6%95%B0%E6%8D%AE%E5%88%B0-tdengine) for more details.
+[EMQ](https://github.com/emqx/emqx) is an open source MQTT Broker software, with no need of coding, only to use "rules" in EMQ Dashboard for simple configuration, and MQTT data can be directly written into TDengine. EMQX supports storing data to the TDengine by sending it to a Web service, and also provides a native TDengine driver on Enterprise Edition for direct data store. Please refer to [EMQ official documents](https://docs.emqx.io/broker/latest/cn/rule/rule-example.html#%E4%BF%9D%E5%AD%98%E6%95%B0%E6%8D%AE%E5%88%B0-tdengine) for more details.
 
 ## <a class="anchor" id="hivemq"></a> Data Writing via HiveMQ Broker
 

documentation20/en/08.connector/01.java/docs.md

@@ -23,7 +23,7 @@ In terms of implementation, the JDBC driver of TDengine is as consistent as poss
 <tr align="center"><th>Difference</th><th>JDBC-JNI</th><th>JDBC-RESTful</th></tr>
 <tr align="center">
   <td>Supported OS</td>
-  <td>linux、windows</td>
+  <td>Linux, Windows</td>
   <td>all platform</td>
 </tr>
 <tr align="center">
@@ -83,6 +83,7 @@ The TDengine supports the following data types and Java data types:
 | NCHAR             | java.lang.String                   | java.lang.String                    |
 | JSON              | -                                  | java.lang.String                    |
 **Note**: JSON type can only be used in tag.
+
 ## Install Java connector
 
 ### Runtime Requirements
@@ -102,7 +103,7 @@ To run TDengine's Java connector, the following requirements shall be met:
 
 ### Obtain JDBC driver by maven
 
-To Java delevopers, TDengine provides `taos-jdbcdriver` according to the JDBC(3.0) API. Users can find and download it through [Sonatype Repository](https://search.maven.org/artifact/com.taosdata.jdbc/taos-jdbcdriver). Add the following dependencies in pom.xml for your maven projects.
+To Java developers, TDengine provides `taos-jdbcdriver` according to the JDBC(3.0) API. Users can find and download it through [Sonatype Repository](https://search.maven.org/artifact/com.taosdata.jdbc/taos-jdbcdriver). Add the following dependencies in pom.xml for your maven projects.
 
 ```xml
 <dependencies>
@@ -172,7 +173,7 @@ The configuration parameters in the URL are as follows:
 * charset: character set used by the client. The default value is the system character set.
 * locale: client locale. The default value is the current system locale.
 * timezone: timezone used by the client. The default value is the current timezone of the system.
-* batchfetch: only valid for JDBC-JNI. True if batch ResultSet fetching is enabled; false if row-by-row ResultSet fetching is enabled. Default value is flase.
+* batchfetch: only valid for JDBC-JNI. True if batch ResultSet fetching is enabled; false if row-by-row ResultSet fetching is enabled. Default value is false.
 * timestampFormat: only valid for JDBC-RESTful. 'TIMESTAMP' if you want to get a long value in a ResultSet; 'UTC' if you want to get a string in UTC date-time format in a ResultSet; 'STRING' if you want to get a local date-time format string in ResultSet. Default value is 'STRING'.
 * batchErrorIgnore: true if you want to continue executing the rest of the SQL when error happens during execute the executeBatch method in Statement; false, false if the remaining SQL statements are not executed. Default value is false.
 
@@ -203,7 +204,7 @@ The configuration parameters in properties are as follows:
 * TSDBDriver.PROPERTY_KEY_CHARSET: character set used by the client. The default value is the system character set.
 * TSDBDriver.PROPERTY_KEY_LOCALE: client locale. The default value is the current system locale.
 * TSDBDriver.PROPERTY_KEY_TIME_ZONE: timezone used by the client. The default value is the current timezone of the system.
-* TSDBDriver.PROPERTY_KEY_BATCH_LOAD: only valid for JDBC-JNI. True if batch ResultSet fetching is enabled; false if row-by-row ResultSet fetching is enabled. Default value is flase.
+* TSDBDriver.PROPERTY_KEY_BATCH_LOAD: only valid for JDBC-JNI. True if batch ResultSet fetching is enabled; false if row-by-row ResultSet fetching is enabled. Default value is false.
 * TSDBDriver.PROPERTY_KEY_TIMESTAMP_FORMAT: only valid for JDBC-RESTful. 'TIMESTAMP' if you want to get a long value in a ResultSet; 'UTC' if you want to get a string in UTC date-time format in a ResultSet; 'STRING' if you want to get a local date-time format string in ResultSet. Default value is 'STRING'.
 * TSDBDriver.PROPERTY_KEY_BATCH_ERROR_IGNORE: true if you want to continue executing the rest of the SQL when error happens during execute the executeBatch method in Statement; false, false if the remaining SQL statements are not executed. Default value is false.
 
@@ -307,19 +308,20 @@ try (Statement statement = connection.createStatement()) {
 
 The Java connector may report three types of error codes: JDBC Driver (error codes ranging from 0x2301 to 0x2350), JNI method (error codes ranging from 0x2351 to 0x2400), and TDengine Error. For details about the error code, see:
 
-- https://github.com/taosdata/TDengine/blob/develop/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBErrorNumbers.java
-- https://github.com/taosdata/TDengine/blob/develop/src/inc/taoserror.h
+- `https://github.com/taosdata/TDengine/blob/develop/src/connector/jdbc/src/main/java/com/taosdata/jdbc/TSDBErrorNumbers.java`
+- `https://github.com/taosdata/TDengine/blob/develop/src/inc/taoserror.h`
 
 ### Write data through parameter binding
+
 Starting with version 2.1.2.0, TDengine's JDBC-JNI implementation significantly improves support for data write (INSERT) scenarios with Parameter-Binding. When writing data in this way, you can avoid the resource consumption of SQL parsing, which can significantly improve write performance in many cases.
 
 **Note**:
-* Jdbc-restful implementations do not provide Parameter-Binding
+
+* JDBC-RESTful implementations do not provide Parameter-Binding
 * The following sample code is based on taos-jdbcdriver-2.0.36
 * use setString to bind BINARY data, and use setNString to bind NCHAR data
 * Both setString and setNString require the user to declare the column width of the corresponding column in the table definition in the size parameter
 
-
 Sample Code:
 
 ```java
@@ -584,7 +586,8 @@ public void setNString(int columnIndex, ArrayList<String> list, int size) throws
 Starting with version 2.2.0.0, TDengine supports schemaless function. schemaless writing protocol is compatible with InfluxDB's Line Protocol, OpenTSDB's telnet and JSON format protocols, Please see [Schemaless Writing](https://www.taosdata.com/docs/en/v2.0/insert#schemaless)
 
 **Note**:
-* Jdbc-restful implementations do not provide Schemaless-Writing
+
+* JDBC-RESTful implementations do not provide Schemaless-Writing
 * The following sample code is based on taos-jdbcdriver-2.0.36
 
 Sample Code:
@@ -623,6 +626,7 @@ public class SchemalessInsertTest {
 Starting with TDengine-2.3.5.0, JDBC Driver supports setting TDengine client parameters on the first connection of a Java application. The Driver supports jdbcUrl and Properties to set client parameters in JDBC-JNI mode.
 
 **Note**:
+
 * JDBC-RESTful does not support setting client parameters.
 * The client parameters set in the java application are process-level. To update the client parameters, the application needs to be restarted. This is because these client parameters are global that take effect the first time the application is set up.
 * The following sample code is based on taos-jdbcdriver-2.0.36.
@@ -679,10 +683,9 @@ public class ClientParameterSetting {
 }
 ```
 
-
 ## Data Subscription
 
-#### Subscribe
+### Subscribe
 
 ```java
 TSDBSubscribe sub = ((TSDBConnection)conn).subscribe("topic", "select * from meters", false);
@@ -696,7 +699,7 @@ parameters:
 
 In the example above, a subscription named 'topic' is created which use the SQL statement 'select * from meters'. If the subscription already exists, it will continue with the previous query progress, rather than consuming all the data from scratch.
 
-#### Consume
+### Consume
 
 ```java
 int total = 0;
@@ -714,7 +717,7 @@ while(true) {
 
 The consume method returns a result set containing all the new data so far since the last consume. Make sure to call consume as often as you need (like Thread.sleep(1000) in the example), otherwise you will put unnecessary stress on the server.
 
-#### Close
+### Close
 
 ```java
 sub.close(true);
@@ -803,6 +806,7 @@ Query OK, 1 row(s) in set (0.000141s)
 you see sample code here: [JDBC example](https://github.com/taosdata/TDengine/tree/develop/examples/JDBC)
 
 ## FAQ
+
 - Why does not addBatch and executeBatch provide a performance benefit for executing "batch writes/updates"?
   **Cause**:In TDengine's JDBC implementation, SQL statements submitted through the addBatch method are executed in the order in which they are added. This method does not reduce the number of interactions with the server and does not improve performance.
   **Answer**：1. Concatenate multiple values in an INSERT statement; 2. Use multi-threaded concurrent insertion; 3. Use the parameter-binding to write

documentation20/en/08.connector/docs.md

@@ -56,9 +56,9 @@ After extracting the package, you will see the following files (directories) in
 
 *driver*: TDengine application driver
 
-*connector*: Connectors for various programming languages (go/grafanaplugin/nodejs/python/JDBC)
+*connector*: Connectors for various programming languages (Go/grafanaplugin/Node.js/Python/JDBC)
 
-*Examples*: Sample programs for various programming languages (C/C #/go/JDBC/MATLAB/python/R)
+*Examples*: Sample programs for various programming languages (C/C#/Go/JDBC/MATLAB/Python/R)
 
 Run install_client.sh to install.
 
@@ -900,7 +900,7 @@ you can find sample code under follow directions:
 
 Run {client_install_directory}/examples/C#/C#Checker/C#Checker.cs
 
-Need install .Net SDK first
+Need install .NET SDK first
 
 ```cmd
 cd {client_install_directory}/examples/C#/C#Checker
@@ -944,7 +944,7 @@ using TDengineDriver;
 
 ### Third-party Driver
 
-Maikebing.Data.Taos is an ADO.Net provider for TDengine that supports Linux, Windows. This development package is provided by enthusiastic contributor 麦壳饼@@maikebing. For more details:
+Maikebing.Data.Taos is an ADO.NET provider for TDengine that supports Linux, Windows. This development package is provided by enthusiastic contributor 麦壳饼@@maikebing. For more details:
 
 ```
 // Download
@@ -1036,7 +1036,7 @@ First, install the Node.js connector through [npm](https://www.npmjs.com/).
 npm install td2.0-connector
 ```
 
-We recommend that use npm to install the Node.js connector. If you do not have npm installed, you can copy src/connector/nodejs/ to your nodejs project directory.
+We recommend that use npm to install the Node.js connector. If you do not have npm installed, you can copy src/connector/nodejs/ to your Node.js project directory.
 
 We use [node-gyp](https://github.com/nodejs/node-gyp) to interact with the TDengine server. Before installing the Node.js connector, you also need to install the following software:
 
@@ -1087,11 +1087,11 @@ Steps:
    node nodejsChecker.js host=localhost
    ```
 
-3. After performing the above steps, the nodejs connection TDengine instance will be outputted on the command line, and the short-answer of insertion and query will be executed.
+3. After performing the above steps, the Node.js connection TDengine instance will be outputted on the command line, and the short-answer of insertion and query will be executed.
 
 ### How to use Node.js
 
-The following are some basic uses of Node.js connector. Please refer to [TDengine Node.js connector](https://github.com/taosdata/TDengine/tree/develop/src/connector/nodejs)for details.
+The following are some basic uses of Node.js connector. Please refer to [TDengine Node.js connector](https://github.com/taosdata/TDengine/tree/develop/src/connector/nodejs) for details.
 
 ### Create connection