Merge branch 'develop' into feature/TD-11214

c019c5e5 · wmmhello · 7d607a1e · 9331c1b2 · c019c5e5 · c019c5e5
122 changed file
--- a/.gitmodules
+++ b/.gitmodules
@@ -23,4 +23,4 @@
 	branch = develop
 [submodule "examples/rust"]
 	path = examples/rust
-	url = https://github.com/songtianyi/tdengine-rust-bindings.git
\ No newline at end of file
+	url = https://github.com/songtianyi/tdengine-rust-bindings.git
--- a/Jenkinsfile2
+++ b/Jenkinsfile2
@@ -247,14 +247,14 @@ pipeline {
                }
            }
            parallel {
-                stage ('build worker06_arm64') {
-                    agent {label " worker06_arm64 "}
+                stage ('build worker08_arm32') {
+                    agent {label " worker08_arm32 "}
                    steps {
                        timeout(time: 20, unit: 'MINUTES') {
                            pre_test()
                            script {
                                sh '''
-                                    echo "worker06_arm64 build done"
+                                    echo "worker08_arm32 build done"
                                    date
                                '''
                            }

--- a/README-CN.md
+++ b/README-CN.md
@@ -11,22 +11,33 @@

 # TDengine 简介

-TDengine是涛思数据专为物联网、车联网、工业互联网、IT运维等设计和优化的大数据平台。除核心的快10倍以上的时序数据库功能外，还提供缓存、数据订阅、流式计算等功能，最大程度减少研发和运维的复杂度，且核心代码，包括集群功能全部开源（开源协议，AGPL v3.0）。
+TDengine 是一款高性能、分布式、支持 SQL 的时序数据库。而且除时序数据库功能外，它还提供缓存、数据订阅、流式计算等功能，最大程度减少研发和运维的复杂度，且核心代码，包括集群功能全部开源（开源协议，AGPL v3.0）。与其他时序数据数据库相比，TDengine 有以下特点：

- 10 倍以上性能提升。定义了创新的数据存储结构，单核每秒就能处理至少2万次请求，插入数百万个数据点，读出一千万以上数据点，比现有通用数据库快了十倍以上。
- 硬件或云服务成本降至1/5。由于超强性能，计算资源不到通用大数据方案的1/5；通过列式存储和先进的压缩算法，存储空间不到通用数据库的1/10。
- 全栈时序数据处理引擎。将数据库、消息队列、缓存、流式计算等功能融合一起，应用无需再集成Kafka/Redis/HBase/Spark等软件，大幅降低应用开发和维护成本。
- 强大的分析功能。无论是十年前还是一秒钟前的数据，指定时间范围即可查询。数据可在时间轴上或多个设备上进行聚合。即席查询可通过Shell/Python/R/Matlab随时进行。
- 与第三方工具无缝连接。不用一行代码，即可与Telegraf, Grafana, EMQ X, Prometheus, Matlab, R集成。后续还将支持MQTT, OPC, Hadoop，Spark等, BI工具也将无缝连接。
- 零运维成本、零学习成本。安装、集群一秒搞定，无需分库分表，实时备份。标准SQL，支持JDBC,RESTful，支持Python/Java/C/C++/Go/Node.JS, 与MySQL相似，零学习成本。
+- **高性能**：通过创新的存储引擎设计，无论是数据写入还是查询，TDengine 的性能比通用数据库快 10 倍以上，也远超其他时序数据库，而且存储空间也大为节省。
+
+- **分布式**：通过原生分布式的设计，TDengine 提供了水平扩展的能力，只需要增加节点就能获得更强的数据处理能力，同时通过多副本机制保证了系统的高可用。
+
+- **支持 SQL**：TDengine 采用 SQL 作为数据查询语言，减少学习和迁移成本，同时提供 SQL 扩展来处理时序数据特有的分析，而且支持方便灵活的 schemaless 数据写入。
+
+- **All in One**：将数据库、消息队列、缓存、流式计算等功能融合一起，应用无需再集成 Kafka/Redis/HBase/Spark 等软件，大幅降低应用开发和维护成本。
+
+- **零管理**：安装、集群几秒搞定，无任何依赖，不用分库分表，系统运行状态监测能与 Grafana 或其他运维工具无缝集成。
+
+- **零学习成本**：采用 SQL 查询语言，支持 Python, Java, C/C++, Go, Rust, Node.js 等多种编程语言,与 MySQL 相似，零学习成本。
+
+- **无缝集成**：不用一行代码，即可与 Telegraf, Grafana, EMQ X, Prometheus, StatsD, collectd, Matlab, R 等第三方工具无缝集成。
+
+- **互动 Console**: 通过命令行 console，不用编程，执行 SQL 语句就能做即席查询、各种数据库的操作、管理以及集群的维护.
+
+TDengine 可以广泛应用于物联网、工业互联网、车联网、IT 运维、能源、金融等领域, 让大量设备、数据采集器每天产生的高达 TB 甚至 PB 级的数据能得到高效实时的处理，对业务的运行状态进行实时的监测、预警，从大数据中挖掘出商业价值。

 # 文档

-TDengine是一个高效的存储、查询、分析时序大数据的平台，专为物联网、车联网、工业互联网、运维监测等优化而设计。您可以像使用关系型数据库MySQL一样来使用它，但建议您在使用前仔细阅读一遍下面的文档，特别是 [数据模型](https://www.taosdata.com/cn/documentation/architecture) 与 [数据建模](https://www.taosdata.com/cn/documentation/model)。除本文档之外，欢迎 [下载产品白皮书](https://www.taosdata.com/downloads/TDengine%20White%20Paper.pdf)。
+TDengine 采用传统的关系数据库模型，您可以像使用关系型数据库 MySQL 一样来使用它。但由于引入了超级表，一个采集点一张表的概念，建议您在使用前仔细阅读一遍下面的文档，特别是 [数据模型](https://www.taosdata.com/cn/documentation/architecture) 与 [数据建模](https://www.taosdata.com/cn/documentation/model)。除本文档之外，欢迎 [下载产品白皮书](https://www.taosdata.com/downloads/TDengine%20White%20Paper.pdf)。

 # 构建

-TDengine目前2.0版服务器仅能在Linux系统上安装和运行，后续会支持Windows、macOS等系统。客户端可以在Windows或Linux上安装和运行。任何OS的应用也可以选择RESTful接口连接服务器taosd。CPU支持X64/ARM64/MIPS64/Alpha64，后续会支持ARM32、RISC-V等CPU架构。用户可根据需求选择通过[源码](https://www.taosdata.com/cn/getting-started/#通过源码安装)或者[安装包](https://www.taosdata.com/cn/getting-started/#通过安装包安装)来安装。本快速指南仅适用于通过源码安装。
+TDengine 目前 2.0 版服务器仅能在 Linux 系统上安装和运行，后续会支持 Windows、macOS 等系统。客户端可以在 Windows 或 Linux 上安装和运行。任何 OS 的应用也可以选择 RESTful 接口连接服务器 taosd。CPU 支持 X64/ARM64/MIPS64/Alpha64，后续会支持 ARM32、RISC-V 等 CPU 架构。用户可根据需求选择通过[源码](https://www.taosdata.com/cn/getting-started/#通过源码安装)或者[安装包](https://www.taosdata.com/cn/getting-started/#通过安装包安装)来安装。本快速指南仅适用于通过源码安装。

 ## 安装工具

@@ -155,7 +166,7 @@ apt install autoconf
 cmake .. -DJEMALLOC_ENABLED=true
 ```

-在X86-64、X86、arm64、arm32 和 mips64 平台上，TDengine 生成脚本可以自动检测机器架构。也可以手动配置 CPUTYPE 参数来指定 CPU 类型，如 aarch64 或 aarch32 等。
+在 X86-64、X86、arm64、arm32 和 mips64 平台上，TDengine 生成脚本可以自动检测机器架构。也可以手动配置 CPUTYPE 参数来指定 CPU 类型，如 aarch64 或 aarch32 等。

 aarch64：

@@ -190,7 +201,7 @@ nmake

 如果你使用的是 Visual Studio 2019 或 2017 版本：

-打开cmd.exe，执行 vcvarsall.bat 时，为 64 位操作系统指定“x64”，为 32 位操作系统指定“x86”。
+打开 cmd.exe，执行 vcvarsall.bat 时，为 64 位操作系统指定“x64”，为 32 位操作系统指定“x86”。

 ```bash
 mkdir debug && cd debug
@@ -207,7 +218,7 @@ cmake .. -G "NMake Makefiles"
 nmake
 ```

-### Mac OS X 系统
+### macOS 系统

 安装 Xcode 命令行工具和 cmake. 在 Catalina 和 Big Sur 操作系统上，需要安装 XCode 11.4+ 版本。

@@ -258,7 +269,7 @@ taos

 # 体验 TDengine

-在TDengine终端中，用户可以通过SQL命令来创建/删除数据库、表等，并进行插入查询操作。
+在 TDengine 终端中，用户可以通过 SQL 命令来创建/删除数据库、表等，并进行插入查询操作。

 ```bash
 create database demo;
@@ -278,7 +289,7 @@ Query OK, 2 row(s) in set (0.001700s)

 ## 官方连接器

-TDengine 提供了丰富的应用程序开发接口，其中包括C/C++、Java、Python、Go、Node.js、C# 、RESTful 等，便于用户快速开发应用：
+TDengine 提供了丰富的应用程序开发接口，其中包括 C/C++、Java、Python、Go、Node.js、C# 、RESTful 等，便于用户快速开发应用：

 - [Java](https://www.taosdata.com/cn/documentation/connector/java)

@@ -300,13 +311,13 @@ TDengine 社区生态中也有一些非常友好的第三方连接器，可以

 - [Rust Bindings](https://github.com/songtianyi/tdengine-rust-bindings/tree/master/examples)
 - [.Net Core Connector](https://github.com/maikebing/Maikebing.EntityFrameworkCore.Taos)
- [Lua Connector](https://github.com/taosdata/TDengine/tree/develop/tests/examples/lua)
+- [Lua Connector](https://github.com/taosdata/TDengine/tree/develop/examples/lua)

 # 运行和添加测试例

 TDengine 的测试框架和所有测试例全部开源。

-点击 [这里](tests/How-To-Run-Test-And-How-To-Add-New-Test-Case.md)，了解如何运行测试例和添加新的测试例。
+点击 [这里](https://github.com/taosdata/tests/blob/develop/How-To-Run-Test-And-How-To-Add-New-Test-Case.md)，了解如何运行测试例和添加新的测试例。

 # 成为社区贡献者


--- a/README.md
+++ b/README.md
@@ -11,19 +11,25 @@ We are hiring, check [here](https://www.taosdata.com/en/careers/)

 # What is TDengine？

-TDengine is an open-sourced big data platform under [GNU AGPL v3.0](http://www.gnu.org/licenses/agpl-3.0.html), designed and optimized for the Internet of Things (IoT), Connected Cars, Industrial IoT, and IT Infrastructure and Application Monitoring. Besides the 10x faster time-series database, it provides caching, stream computing, message queuing and other functionalities to reduce the complexity and cost of development and operation.
+TDengine is a high-performance, scalable time-series database with SQL support. Its code including cluster feature is open source under [GNU AGPL v3.0](http://www.gnu.org/licenses/agpl-3.0.html). Besides the database, it provides caching, stream processing, data data subscription and other functionalities to reduce the complexity and cost of development and operation. TDengine differentiates itself from other TSDBs with the following advantages.

- **10x Faster on Insert/Query Speeds**: Through the innovative design on storage, on a single-core machine, over 20K requests can be processed, millions of data points can be ingested, and over 10 million data points can be retrieved in a second. It is 10 times faster than other databases.
+- **High Performance**: TDengine outperforms other time series databases in data ingestion and querying while significantly reducing storage cost and compute costs, with an innovatively designed and purpose-built storage engine.

- **1/5 Hardware/Cloud Service Costs**: Compared with typical big data solutions, less than 1/5 of computing resources are required. Via column-based storage and tuned compression algorithms for different data types, less than 1/10 of storage space is needed.
+- **Scalable**: TDengine provides out-of-box scalability and high-availability through its native distributed design. Nodes can be added through simple configuration to achieve greater data processing power. In addition, this feature is open source.

- **Full Stack for Time-Series Data**: By integrating a database with message queuing, caching, and stream computing features together, it is no longer necessary to integrate Kafka/Redis/HBase/Spark or other software. It makes the system architecture much simpler and more robust.
+- **SQL Support**: TDengine uses SQL as the query language, thereby reducing learning and migration costs, while adding SQL extensions to handle time-series data better, and supporting convenient and flexible schemaless data ingestion.

- **Powerful Data Analysis**: Whether it is 10 years or one minute ago, data can be queried just by specifying the time range. Data can be aggregated over time, multiple time streams or both. Ad Hoc queries or analyses can be executed via TDengine shell, Python, R or Matlab.
+- **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 and easy to maintain.

- **Seamless Integration with Other Tools**: Telegraf, Grafana, Matlab, R, and other tools can be integrated with TDengine without a line of code. MQTT, OPC, Hadoop, Spark, and many others will be integrated soon.
+- **Seamless Integration**: Without a single line of code, TDengine provide seamless integration with third-party tools such as Telegraf, Grafana, EMQ X, Prometheus, StatsD, collectd, etc. More will be integrated.

- **Zero Management, No Learning Curve**: It takes only seconds to download, install, and run it successfully; there are no other dependencies. Automatic partitioning on tables or DBs. Standard SQL is used, with C/C++, Python, JDBC, Go and RESTful connectors.
+- **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.
+
+- **Zero Learning Cost**: With SQL as the query language, support for ubiquitous tools like Python, Java, C/C++, Go, Rust, Node.js connectors, there is zero learning cost.
+
+- **Interactive Console**: TDengine provides convenient console access to the database to run ad hoc queries, maintain the database, or manage the cluster without any programming.
+
+TDengine can be widely applied to Internet of Things (IoT), Connected Vehicles, Industrial IoT, DevOps, energy, finance and many other scenarios.

 # Documentation

@@ -145,7 +151,7 @@ git clone https://github.com/taosdata/TDengine.git
 cd TDengine
 ```

-The connectors for go & grafana and some tools have been moved to separated repositories,
+The connectors for go & Grafana and some tools have been moved to separated repositories,
 so you should run this command in the TDengine directory to install them:

 ```bash
@@ -241,7 +247,7 @@ cmake .. -G "NMake Makefiles"
 nmake
 ```

-### On Mac OS X platform
+### On macOS platform

 Please install XCode command line tools and cmake. Verified with XCode 11.4+ on Catalina and Big Sur.

@@ -343,7 +349,7 @@ The TDengine community has also kindly built some of their own connectors! Follo
 # How to run the test cases and how to add a new test case

  TDengine's test framework and all test cases are fully open source.
-  Please refer to [this document](tests/How-To-Run-Test-And-How-To-Add-New-Test-Case.md) for how to run test and develop new test case.
+  Please refer to [this document](https://github.com/taosdata/tests/blob/develop/How-To-Run-Test-And-How-To-Add-New-Test-Case.md) for how to run test and develop new test case.

 # TDengine Roadmap


--- a/TDenginelogo.png
+++ b/TDenginelogo.png
--- a/cmake/install.inc
+++ b/cmake/install.inc
@@ -9,11 +9,12 @@ ELSEIF (TD_WINDOWS)
  INSTALL(DIRECTORY ${TD_COMMUNITY_DIR}/src/connector/nodejs DESTINATION connector)
  INSTALL(DIRECTORY ${TD_COMMUNITY_DIR}/src/connector/python DESTINATION connector)
  INSTALL(DIRECTORY ${TD_COMMUNITY_DIR}/src/connector/C\# DESTINATION connector)
-  INSTALL(DIRECTORY ${TD_COMMUNITY_DIR}/tests/examples DESTINATION .)
+  INSTALL(DIRECTORY ${TD_COMMUNITY_DIR}/examples DESTINATION .)
  INSTALL(FILES ${TD_COMMUNITY_DIR}/packaging/cfg/taos.cfg DESTINATION cfg)
  INSTALL(FILES ${TD_COMMUNITY_DIR}/src/inc/taos.h DESTINATION include)
  INSTALL(FILES ${TD_COMMUNITY_DIR}/src/inc/taoserror.h DESTINATION include)
  INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos.lib DESTINATION driver)
+  INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos_static.lib DESTINATION driver)
  INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos.exp DESTINATION driver)
  INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/taos.dll DESTINATION driver)
  INSTALL(FILES ${EXECUTABLE_OUTPUT_PATH}/taos.exe DESTINATION .)

--- a/documentation20/cn/00.index/docs.md
+++ b/documentation20/cn/00.index/docs.md
--- a/documentation20/cn/01.evaluation/docs.md
+++ b/documentation20/cn/01.evaluation/docs.md
@@ -2,17 +2,23 @@

 ## <a class="anchor" id="intro"></a>TDengine 简介

-TDengine 是涛思数据面对高速增长的物联网大数据市场和技术挑战推出的创新性的大数据处理产品，它不依赖任何第三方软件，也不是优化或包装了一个开源的数据库或流式计算产品，而是在吸取众多传统关系型数据库、NoSQL 数据库、流式计算引擎、消息队列等软件的优点之后自主开发的产品，TDengine 在时序空间大数据处理上，有着自己独到的优势。
+TDengine 是一款高性能、分布式、支持 SQL 的时序数据库。而且除时序数据库功能外，它还提供缓存、数据订阅、流式计算等功能，最大程度减少研发和运维的复杂度，且核心代码，包括集群功能全部开源（开源协议，AGPL v3.0）。与其他时序数据数据库相比，TDengine 有以下特点：

-TDengine 的模块之一是时序数据库。但除此之外，为减少研发的复杂度、系统维护的难度，TDengine 还提供缓存、消息队列、订阅、流式计算等功能，为物联网和工业互联网大数据的处理提供全栈的技术方案，是一个高效易用的物联网大数据平台。与 Hadoop 等典型的大数据平台相比，TDengine 具有如下鲜明的特点：
+- **高性能**：通过创新的存储引擎设计，无论是数据写入还是查询，TDengine 的性能比通用数据库快 10 倍以上，也远超其他时序数据库，而且存储空间也大为节省。

-* __10 倍以上的性能提升__：定义了创新的数据存储结构，单核每秒能处理至少 2 万次请求，插入数百万个数据点，读出一千万以上数据点，比现有通用数据库快十倍以上。
-* __硬件或云服务成本降至 1/5__：由于超强性能，计算资源不到通用大数据方案的 1/5；通过列式存储和先进的压缩算法，存储占用不到通用数据库的 1/10。
-* __全栈时序数据处理引擎__：将数据库、消息队列、缓存、流式计算等功能融为一体，应用无需再集成 Kafka/Redis/HBase/Spark/HDFS 等软件，大幅降低应用开发和维护的复杂度成本。 
-* __强大的分析功能__：无论是十年前还是一秒钟前的数据，指定时间范围即可查询。数据可在时间轴上或多个设备上进行聚合。即席查询可通过 Shell, Python, R, MATLAB 随时进行。
-* __高可用性和水平扩展__：通过分布式架构和一致性算法，通过多复制和集群特性，TDengine确保了高可用性和水平扩展性以支持关键任务应用程序。
-* __零运维成本、零学习成本__：安装集群简单快捷，无需分库分表，实时备份。类似标准 SQL，支持 RESTful，支持 Python/Java/C/C++/C#/Go/Node.js, 与 MySQL 相似，零学习成本。
-* __核心开源__：除了一些辅助功能外，TDengine的核心是开源的。企业再也不会被数据库绑定了。这使生态更加强大，产品更加稳定，开发者社区更加活跃。
+- **分布式**：通过原生分布式的设计，TDengine 提供了水平扩展的能力，只需要增加节点就能获得更强的数据处理能力，同时通过多副本机制保证了系统的高可用。
+
+- **支持 SQL**：TDengine 采用 SQL 作为数据查询语言，减少学习和迁移成本，同时提供 SQL 扩展来处理时序数据特有的分析，而且支持方便灵活的 schemaless 数据写入。
+
+- **All in One**：将数据库、消息队列、缓存、流式计算等功能融合一起，应用无需再集成 Kafka/Redis/HBase/Spark 等软件，大幅降低应用开发和维护成本。
+
+- **零管理**：安装、集群几秒搞定，无任何依赖，不用分库分表，系统运行状态监测能与 Grafana 或其他运维工具无缝集成。
+
+- **零学习成本**：采用 SQL 查询语言，支持 Python, Java, C/C++, Go, Rust, Node.js 等多种编程语言,与 MySQL 相似，零学习成本。
+
+- **无缝集成**：不用一行代码，即可与 Telegraf, Grafana, EMQ X, Prometheus, StatsD, collectd, Matlab, R 等第三方工具无缝集成。
+
+- **互动 Console**: 通过命令行 console，不用编程，执行 SQL 语句就能做即席查询、各种数据库的操作、管理以及集群的维护.

 采用 TDengine，可将典型的物联网、车联网、工业互联网大数据平台的总拥有成本大幅降低。但需要指出的是，因充分利用了物联网时序数据的特点，它无法用来处理网络爬虫、微博、微信、电商、ERP、CRM 等通用型数据。


--- a/documentation20/cn/02.getting-started/01.docker/docs.md
+++ b/documentation20/cn/02.getting-started/01.docker/docs.md
 # 通过 Docker 快速体验 TDengine

-虽然并不推荐在生产环境中通过 Docker 来部署 TDengine 服务，但 Docker 工具能够很好地屏蔽底层操作系统的环境差异，很适合在开发测试或初次体验时用于安装运行 TDengine 的工具集。特别是，借助 Docker，能够比较方便地在 Mac OSX 和 Windows 系统上尝试 TDengine，而无需安装虚拟机或额外租用 Linux 服务器。另外，从2.0.14.0版本开始，TDengine提供的镜像已经可以同时支持X86-64、X86、arm64、arm32平台，像NAS、树莓派、嵌入式开发板之类可以运行docker的非主流计算机也可以基于本文档轻松体验TDengine。
+虽然并不推荐在生产环境中通过 Docker 来部署 TDengine 服务，但 Docker 工具能够很好地屏蔽底层操作系统的环境差异，很适合在开发测试或初次体验时用于安装运行 TDengine 的工具集。特别是，借助 Docker，能够比较方便地在 macOS 和 Windows 系统上尝试 TDengine，而无需安装虚拟机或额外租用 Linux 服务器。另外，从2.0.14.0版本开始，TDengine提供的镜像已经可以同时支持X86-64、X86、arm64、arm32平台，像NAS、树莓派、嵌入式开发板之类可以运行docker的非主流计算机也可以基于本文档轻松体验TDengine。

 下文通过 Step by Step 风格的介绍，讲解如何通过 Docker 快速建立 TDengine 的单节点运行环境，以支持开发和测试。


--- a/documentation20/cn/02.getting-started/03.install/docs.md
+++ b/documentation20/cn/02.getting-started/03.install/docs.md
@@ -54,8 +54,8 @@ TDengine is removed successfully!

 ### 安装 rpm

-1、从官网下载获得rpm安装包，比如TDengine-server-2.0.0.0-Linux-x64.rpm；
-2、进入到TDengine-server-2.0.0.0-Linux-x64.rpm安装包所在目录，执行如下的安装命令：
+1、从官网下载获得 rpm 安装包，比如 TDengine-server-2.0.0.0-Linux-x64.rpm；
+2、进入到 TDengine-server-2.0.0.0-Linux-x64.rpm 安装包所在目录，执行如下的安装命令：

 ```
 $ sudo rpm -ivh TDengine-server-2.4.0.7-Linux-x64.rpm
@@ -94,8 +94,8 @@ TDengine is removed successfully!

 ### 安装 tar.gz 安装包

-1、从官网下载获得tar.gz安装包，比如TDengine-server-2.0.0.0-Linux-x64.tar.gz；
-2、进入到TDengine-server-2.0.0.0-Linux-x64.tar.gz安装包所在目录，先解压文件后，进入子目录，执行其中的install.sh安装脚本：
+1、从官网下载获得 tar.gz 安装包，比如 TDengine-server-2.4.0.7-Linux-x64.tar.gz；
+2、进入到 TDengine-server-2.4.0.7-Linux-x64.tar.gz 安装包所在目录，先解压文件后，进入子目录，执行其中的 install.sh 安装脚本：

 ```
 $ tar xvzf TDengine-enterprise-server-2.4.0.7-Linux-x64.tar.gz
@@ -141,7 +141,7 @@ Install taoskeeper as a standalone service
 taoskeeper is installed, enable it by `systemctl enable taoskeeper`
 ```

-说明：install.sh 安装脚本在执行过程中，会通过命令行交互界面询问一些配置信息。如果希望采取无交互安装方式，那么可以用 -e no 参数来执行 install.sh 脚本。运行 ./install.sh -h 指令可以查看所有参数的详细说明信息。
+说明：install.sh 安装脚本在执行过程中，会通过命令行交互界面询问一些配置信息。如果希望采取无交互安装方式，那么可以用 -e no 参数来执行 install.sh 脚本。运行 `./install.sh -h` 指令可以查看所有参数的详细说明信息。

 ### tar.gz 安装后的卸载

@@ -157,7 +157,7 @@ taosKeeper is removed successfully!

 ## 安装目录说明

-TDengine成功安装后，主安装目录是/usr/local/taos，目录内容如下：
+TDengine 成功安装后，主安装目录是 /usr/local/taos，目录内容如下：

 ```
 $ cd /usr/local/taos
@@ -176,24 +176,24 @@ lrwxrwxrwx  1 root root   13 Feb 22 09:34 log -> /var/log/taos/
 ```

 - 自动生成配置文件目录、数据库目录、日志目录。
- 配置文件缺省目录：/etc/taos/taos.cfg， 软链接到/usr/local/taos/cfg/taos.cfg；
- 数据库缺省目录：/var/lib/taos， 软链接到/usr/local/taos/data；
- 日志缺省目录：/var/log/taos， 软链接到/usr/local/taos/log；
- /usr/local/taos/bin目录下的可执行文件，会软链接到/usr/bin目录下；
- /usr/local/taos/driver目录下的动态库文件，会软链接到/usr/lib目录下；
- /usr/local/taos/include目录下的头文件，会软链接到到/usr/include目录下；
+- 配置文件缺省目录：/etc/taos/taos.cfg， 软链接到 /usr/local/taos/cfg/taos.cfg；
+- 数据库缺省目录：/var/lib/taos， 软链接到 /usr/local/taos/data；
+- 日志缺省目录：/var/log/taos， 软链接到 /usr/local/taos/log；
+- /usr/local/taos/bin 目录下的可执行文件，会软链接到 /usr/bin 目录下；
+- /usr/local/taos/driver 目录下的动态库文件，会软链接到 /usr/lib 目录下；
+- /usr/local/taos/include 目录下的头文件，会软链接到到 /usr/include 目录下；

 ## 卸载和更新文件说明

 卸载安装包的时候，将保留配置文件、数据库文件和日志文件，即 /etc/taos/taos.cfg 、 /var/lib/taos 、 /var/log/taos 。如果用户确认后不需保留，可以手工删除，但一定要慎重，因为删除后，数据将永久丢失，不可以恢复！

-如果是更新安装，当缺省配置文件（ /etc/taos/taos.cfg ）存在时，仍然使用已有的配置文件，安装包中携带的配置文件修改为taos.cfg.org保存在 /usr/local/taos/cfg/ 目录，可以作为设置配置参数的参考样例；如果不存在配置文件，就使用安装包中自带的配置文件。
+如果是更新安装，当缺省配置文件（ /etc/taos/taos.cfg ）存在时，仍然使用已有的配置文件，安装包中携带的配置文件修改为 taos.cfg.orig 保存在 /usr/local/taos/cfg/ 目录，可以作为设置配置参数的参考样例；如果不存在配置文件，就使用安装包中自带的配置文件。

 ## 注意事项

 - TDengine提供了多种安装包，但最好不要在一个系统上同时使用 tar.gz 安装包和 deb 或 rpm 安装包。否则会相互影响，导致在使用时出现问题。

- 对于deb包安装后，如果安装目录被手工误删了部分，出现卸载、或重新安装不能成功。此时，需要清除 tdengine 包的安装信息，执行如下命令：
+- 对于deb包安装后，如果安装目录被手工误删了部分，出现卸载、或重新安装不能成功。此时，需要清除 TDengine 包的安装信息，执行如下命令：

 ```
 $ sudo rm -f /var/lib/dpkg/info/tdengine*
@@ -201,7 +201,7 @@ $ sudo rm -f /var/lib/dpkg/info/tdengine*

 然后再重新进行安装就可以了。

- 对于rpm包安装后，如果安装目录被手工误删了部分，出现卸载、或重新安装不能成功。此时，需要清除tdengine包的安装信息，执行如下命令：
+- 对于 rpm 包安装后，如果安装目录被手工误删了部分，出现卸载、或重新安装不能成功。此时，需要清除 TDengine 包的安装信息，执行如下命令：

 ```
 $ sudo rpm -e --noscripts tdengine

--- a/documentation20/cn/02.getting-started/docs.md
+++ b/documentation20/cn/02.getting-started/docs.md
@@ -2,7 +2,8 @@

 ## <a class="anchor" id="install"></a>快捷安装

-TDengine 包括服务端、客户端和周边生态工具软件，目前 2.0 版服务端仅在 Linux 系统上安装和运行，后续将支持 Windows、Mac OS 等系统。客户端可以在 Windows 或 Linux 上安装和运行。在任何操作系统上的应用都可以使用 RESTful 接口连接服务端程序 taosd，其中 2.4 之后版本默认使用单独运行的独立组件 taosAdapter 提供 http 服务和更多数据写入方式。taosAdapter 需要手动启动。而之前版本 TDengine 使用内置 http 服务。
+TDengine 包括服务端、客户端和周边生态工具软件，目前 2.0 版服务端仅在 Linux 系统上安装和运行，后续将支持 Windows、macOS 等系统。客户端可以在 Windows 或 Linux 上安装和运行。在任何操作系统上的应用都可以使用 RESTful 接口连接服务端程序 taosd，其中 2.4 之后版本默认使用单独运行的独立组件 taosAdapter 提供 http 服务和更多数据写入方式。taosAdapter 需要手动启动。
+之前版本 TDengine 服务端，以及所有服务端lite版，均使用内置 http 服务。

 TDengine 支持 X64/ARM64/MIPS64/Alpha64 硬件平台，后续将支持 ARM32、RISC-V 等 CPU 架构。

@@ -14,11 +15,20 @@ docker run -d -p 6030-6049:6030-6049 -p 6030-6049:6030-6049/udp tdengine/tdengin

 详细操作方法请参照 [通过 Docker 快速体验 TDengine](https://www.taosdata.com/cn/documentation/getting-started/docker)。

-注：暂时不建议生产环境采用 Docker 来部署 TDengine 的客户端或服务端，但在开发环境下或初次尝试时，使用 Docker 方式部署是十分方便的。特别是，利用 Docker，可以方便地在 Mac OS X 和 Windows 环境下尝试 TDengine。
+注：暂时不建议生产环境采用 Docker 来部署 TDengine 的客户端或服务端，但在开发环境下或初次尝试时，使用 Docker 方式部署是十分方便的。特别是，利用 Docker，可以方便地在 macOS 和 Windows 环境下尝试 TDengine。
+
+从 2.4.0.10 开始，除taosd以外，docker镜像还包含：taos、taosAdapter、taosdump、taosBenchmark、TDinsight安装脚本和示例代码。启动docker容器时，将同时启动taosAdapter和taosd，实现对restful的支持。
+

 ### <a class="anchor" id="package-install"></a>通过安装包安装

-TDengine 的安装非常简单，从下载到安装成功仅仅只要几秒钟。为方便使用，标准的服务端安装包包含了客户端程序和示例代码；如果您只需要用到服务端程序和客户端连接的 C/C++ 语言支持，也可以仅下载 lite 版本的安装包。在安装包格式上，我们提供 rpm 和 deb 格式，也为企业客户提供 tar.gz 格式安装包，以方便在特定操作系统上使用。发布版本包括稳定版和 Beta 版，Beta版含有更多新功能。正式上线或测试建议安装稳定版。您可以根据需要选择下载：
+TDengine 的安装非常简单，从下载到安装成功仅仅只要几秒钟。
+
+为方便使用，从 2.4.0.10 开始，标准的服务端安装包包含了taos、taosd、taosAdapter、taosdump、taosBenchmark、TDinsight安装脚本和示例代码；如果您只需要用到服务端程序和客户端连接的 C/C++ 语言支持，也可以仅下载 lite 版本的安装包。
+
+在安装包格式上，我们提供tar.gz, rpm 和 deb 格式，为企业客户提供 tar.gz 格式安装包，以方便在特定操作系统上使用。需要注意的是，rpm和deb包不含taosdump、taosBenchmark和TDinsight安装脚本，这些工具需要通过安装taosTool包获得。
+
+发布版本包括稳定版和 Beta 版，Beta版含有更多新功能。正式上线或测试建议安装稳定版。您可以根据需要选择下载：

 <ul id="server-packageList" class="package-list"></ul>


--- a/documentation20/cn/05.insert/docs.md
+++ b/documentation20/cn/05.insert/docs.md
 # 高效写入数据

-TDengine支持多种接口写入数据，包括SQL，Prometheus，Telegraf，collectd，StatsD，EMQ MQTT Broker，HiveMQ Broker，CSV文件等，后续还将提供Kafka，OPC等接口。数据可以单条插入，也可以批量插入，可以插入一个数据采集点的数据，也可以同时插入多个数据采集点的数据。支持多线程插入，支持时间乱序数据插入，也支持历史数据插入。
+TDengine 支持多种接口写入数据，包括 SQL，Prometheus，Telegraf，collectd，StatsD，EMQ MQTT Broker，HiveMQ Broker，CSV 文件等，后续还将提供 Kafka，OPC 等接口。数据可以单条插入，也可以批量插入，可以插入一个数据采集点的数据，也可以同时插入多个数据采集点的数据。支持多线程插入，支持时间乱序数据插入，也支持历史数据插入。

 ## <a class="anchor" id="sql"></a>SQL 写入

-应用通过C/C++, Java, Go, C#, Python, Node.js 连接器执行SQL insert语句来插入数据，用户还可以通过TAOS Shell，手动输入SQL insert语句插入数据。比如下面这条insert 就将一条记录写入到表d1001中：
+应用通过 C/C++, Java, Go, C#, Python, Node.js 连接器执行 SQL insert 语句来插入数据，用户还可以通过 TAOS Shell，手动输入 SQL insert 语句插入数据。比如下面这条 insert 就将一条记录写入到表 d1001 中：

 ```mysql
 INSERT INTO d1001 VALUES (1538548685000, 10.3, 219, 0.31);
 ```

-TDengine支持一次写入多条记录，比如下面这条命令就将两条记录写入到表d1001中：
+TDengine 支持一次写入多条记录，比如下面这条命令就将两条记录写入到表 d1001 中：

 ```mysql
 INSERT INTO d1001 VALUES (1538548684000, 10.2, 220, 0.23) (1538548696650, 10.3, 218, 0.25);
 ```

-TDengine也支持一次向多个表写入数据，比如下面这条命令就向d1001写入两条记录，向d1002写入一条记录：
+TDengine 也支持一次向多个表写入数据，比如下面这条命令就向 d1001 写入两条记录，向 d1002 写入一条记录：

 ```mysql
 INSERT INTO d1001 VALUES (1538548685000, 10.3, 219, 0.31) (1538548695000, 12.6, 218, 0.33) d1002 VALUES (1538548696800, 12.3, 221, 0.31);
 ```

-详细的SQL INSERT语法规则请见 [TAOS SQL 的数据写入](https://www.taosdata.com/cn/documentation/taos-sql#insert) 章节。
+详细的 SQL INSERT 语法规则请见 [TAOS SQL 的数据写入](https://www.taosdata.com/cn/documentation/taos-sql#insert) 章节。

 **Tips:**

- 要提高写入效率，需要批量写入。一批写入的记录条数越多，插入效率就越高。但一条记录不能超过16K，一条SQL语句总长度不能超过1M 。
- TDengine支持多线程同时写入，要进一步提高写入速度，一个客户端需要打开20个以上的线程同时写。但线程数达到一定数量后，无法再提高，甚至还会下降，因为线程频繁切换，带来额外开销。
+- 要提高写入效率，需要批量写入。一批写入的记录条数越多，插入效率就越高。但一条记录不能超过 16K，一条 SQL 语句总长度不能超过 1M 。
+- TDengine 支持多线程同时写入，要进一步提高写入速度，一个客户端需要打开 20 个以上的线程同时写。但线程数达到一定数量后，无法再提高，甚至还会下降，因为线程频繁切换，带来额外开销。
 - 对同一张表，如果新插入记录的时间戳已经存在，默认情形下（UPDATE=0）新记录将被直接抛弃，也就是说，在一张表里，时间戳必须是唯一的。如果应用自动生成记录，很有可能生成的时间戳是一样的，这样，成功插入的记录条数会小于应用插入的记录条数。如果在创建数据库时使用了 UPDATE 1 选项，插入相同时间戳的新记录将覆盖原有记录。
- 写入的数据的时间戳必须大于当前时间减去配置参数keep的时间。如果keep配置为3650天，那么无法写入比3650天还早的数据。写入数据的时间戳也不能大于当前时间加配置参数days。如果days为2，那么无法写入比当前时间还晚2天的数据。
+- 写入的数据的时间戳必须大于当前时间减去配置参数 keep 的时间。如果 keep 配置为3650天，那么无法写入比 3650 天还早的数据。写入数据的时间戳也不能大于当前时间加配置参数 days。如果 days 为 2，那么无法写入比当前时间还晚2天的数据。

 ## <a class="anchor" id="schemaless"></a>无模式（Schemaless）写入

@@ -41,7 +41,7 @@ INSERT INTO d1001 VALUES (1538548685000, 10.3, 219, 0.31) (1538548695000, 12.6,
 **无模式写入行协议**
 <br/>TDengine 的无模式写入的行协议兼容 InfluxDB 的 行协议（Line Protocol）、OpenTSDB 的 telnet 行协议、OpenTSDB 的 JSON 格式协议。但是使用这三种协议的时候，需要在 API 中指定输入内容使用解析协议的标准。

-对于InfluxDB、OpenTSDB的标准写入协议请参考各自的文档。下面首先以 InfluxDB 的行协议为基础，介绍 TDengine 扩展的协议内容，允许用户采用更加精细的方式控制（超级表）模式。
+对于 InfluxDB、OpenTSDB 的标准写入协议请参考各自的文档。下面首先以 InfluxDB 的行协议为基础，介绍 TDengine 扩展的协议内容，允许用户采用更加精细的方式控制（超级表）模式。

 Schemaless 采用一个字符串来表达一个数据行（可以向写入 API 中一次传入多行字符串来实现多个数据行的批量写入），其格式约定如下：

@@ -59,7 +59,7 @@ measurement,tag_set field_set timestamp
 tag_set 中的所有的数据自动转化为 nchar 数据类型，并不需要使用双引号（")。
 <br/>在无模式写入数据行协议中，field_set 中的每个数据项都需要对自身的数据类型进行描述。具体来说：

-* 如果两边有英文双引号，表示 BIANRY(32) 类型。例如 `"abc"`。
+* 如果两边有英文双引号，表示 BINARY(32) 类型。例如 `"abc"`。
 * 如果两边有英文双引号而且带有 L 前缀，表示 NCHAR(32) 类型。例如 `L"报错信息"`。
 * 对空格、等号（=）、逗号（,）、双引号（"），前面需要使用反斜杠（\）进行转义。（都指的是英文半角符号）
 * 数值类型将通过后缀来区分数据类型：
@@ -86,13 +86,13 @@ st,t1=3,t2=4,t3=t3 c1=3i64,c3="passit",c2=false,c4=4f64 1626006833639000000
 ### 无模式写入的主要处理逻辑

 无模式写入按照如下原则来处理行数据：
-<br/>1. 将使用如下规则来生成子表名：首先将measurement 的名称和标签的 key 和 value 组合成为如下的字符串
+<br/>1. 将使用如下规则来生成子表名：首先将 measurement 的名称和标签的 key 和 value 组合成为如下的字符串

 ```json
 "measurement,tag_key1=tag_value1,tag_key2=tag_value2"
 ```

-需要注意的是，这里的tag_key1, tag_key2并不是用户输入的标签的原始顺序，而是使用了标签名称按照字符串升序排列后的结果。所以，tag_key1 并不是在行协议中输入的第一个标签。
+需要注意的是，这里的 tag_key1, tag_key2 并不是用户输入的标签的原始顺序，而是使用了标签名称按照字符串升序排列后的结果。所以，tag_key1 并不是在行协议中输入的第一个标签。
 排列完成以后计算该字符串的 MD5 散列值 "md5_val"。然后将计算的结果与字符串组合生成表名：“t_md5_val”。其中的 “t_” 是固定的前缀，每个通过该映射关系自动生成的表都具有该前缀。
 <br/>2. 如果解析行协议获得的超级表不存在，则会创建这个超级表。
 <br/>3. 如果解析行协议获得子表不存在，则 Schemaless 会按照步骤 1 或 2 确定的子表名来创建子表。
@@ -167,13 +167,13 @@ st,t1=3,t2=4,t3=t3 c1=3i64               1626006833639000000
 st,t1=3,t2=4,t3=t3 c1=3i64,c6="passit"   1626006833640000000
 ```

-第二行数据相对于第一行来说增加了一个列 c6，类型为binary(6)。那么此时会自动增加一个列 c6， 类型为  binary(6)。
+第二行数据相对于第一行来说增加了一个列 c6，类型为 binary(6)。那么此时会自动增加一个列 c6， 类型为 binary(6)。

 **写入完整性**
 <br/>TDengine 提供数据写入的幂等性保证，即您可以反复调用 API 进行出错数据的写入操作。但是不提供多行数据写入的原子性保证。即在多行数据一批次写入过程中，会出现部分数据写入成功，部分数据写入失败的情况。

 **错误码**
-<br/>如果是无模式写入过程中的数据本身错误，应用会得到 TSDB_CODE_TSC_LINE_SYNTAX_ERROR 错误信息，该错误信息表明错误发生在写入文本中。其他的错误码与原系统一致，可以通过 taos_errstr 获取具体的错误原因。
+<br/>如果是无模式写入过程中的数据本身错误，应用会得到 TSDB_CODE_TSC_LINE_SYNTAX_ERROR 错误信息，该错误信息表明错误发生在写入文本中。其他的错误码与原系统一致，可以通过 `taos_errstr()` 获取具体的错误原因。

 **后续升级计划**
 <br/>当前版本只提供了 C 版本的 API，后续将提供 其他高级语言的 API，例如 Java/Go/Python/C# 等。此外，在TDengine v2.3及后续版本中，您还可以通过 taosAdapter 采用 REST 的方式直接写入无模式数据。
@@ -306,7 +306,7 @@ taosAdapter 相关配置参数请参考 taosadapter --help 命令输出以及相

 ## <a class="anchor" id="tcollector"></a> TCollector 直接写入(通过 taosAdapter)

-TCollector 是一个在客户侧收集本地收集器并发送数据到 OpenTSDB 的进程，taosAdaapter 可以支持接收 TCollector 的数据并写入到 TDengine 中。
+TCollector 是一个在客户侧收集本地收集器并发送数据到 OpenTSDB 的进程，taosAdapter 可以支持接收 TCollector 的数据并写入到 TDengine 中。

 使能 taosAdapter 配置项 opentsdb_telnet.enable
 修改 TCollector 配置文件，修改 OpenTSDB 宿主机地址为 taosAdapter 被部署的地址，并修改端口号为 taosAdapter 使用的端口（默认6049）。
@@ -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.io/broker/latest/cn/rule/rule-example.html#%E4%BF%9D%E5%AD%98%E6%95%B0%E6%8D%AE%E5%88%B0-tdengine)。
+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)。

 ## <a class="anchor" id="hivemq"></a>HiveMQ Broker 直接写入


--- a/documentation20/cn/07.advanced-features/docs.md
+++ b/documentation20/cn/07.advanced-features/docs.md
--- a/documentation20/cn/08.connector/01.java/docs.md
+++ b/documentation20/cn/08.connector/01.java/docs.md
@@ -56,15 +56,15 @@ INSERT INTO test.t1 USING test.weather (ts, temperature) TAGS('beijing') VALUES(
 ## <a class="anchor" id="version"></a>TAOS-JDBCDriver 版本以及支持的 TDengine 版本和 JDK 版本

 | taos-jdbcdriver 版本 | TDengine 2.0.x.x 版本 | TDengine 2.2.x.x 版本 | TDengine 2.4.x.x 版本 | JDK 版本 |
-|---------------------| ----------------------| ----------------------| ----------------------| -------- |
-| 2.0.37              |            X          |            X          | 2.4.0.6 以上           | 1.8.x    |
-| 2.0.36              |            X          | 2.2.2.11 以上          | 2.4.0.0 - 2.4.0.5     | 1.8.x    |
-| 2.0.35              |            X          | 2.2.2.11 以上          | 2.3.0.0 - 2.4.0.5     | 1.8.x    |
-| 2.0.33 - 2.0.34     | 2.0.3.0 以上           | 2.2.0.0 以上           | 2.4.0.0 - 2.4.0.5     | 1.8.x    |
-| 2.0.31 - 2.0.32     | 2.1.3.0 - 2.1.7.7     |            X          |            X          | 1.8.x    |
-| 2.0.22 - 2.0.30     | 2.0.18.0 - 2.1.2.1    |            X          |            X          | 1.8.x    |
-| 2.0.12 - 2.0.21     | 2.0.8.0 - 2.0.17.4    |            X          |            X          | 1.8.x    |
-| 2.0.4 - 2.0.11      | 2.0.0.0 - 2.0.7.3     |            X          |            X          | 1.8.x    |
+| -------------------- | --------------------- | --------------------- | --------------------- | -------- |
+| 2.0.37               | X                     | X                     | 2.4.0.6 以上          | 1.8.x    |
+| 2.0.36               | X                     | 2.2.2.11 以上         | 2.4.0.0 - 2.4.0.5     | 1.8.x    |
+| 2.0.35               | X                     | 2.2.2.11 以上         | 2.3.0.0 - 2.4.0.5     | 1.8.x    |
+| 2.0.33 - 2.0.34      | 2.0.3.0 以上          | 2.2.0.0 以上          | 2.4.0.0 - 2.4.0.5     | 1.8.x    |
+| 2.0.31 - 2.0.32      | 2.1.3.0 - 2.1.7.7     | X                     | X                     | 1.8.x    |
+| 2.0.22 - 2.0.30      | 2.0.18.0 - 2.1.2.1    | X                     | X                     | 1.8.x    |
+| 2.0.12 - 2.0.21      | 2.0.8.0 - 2.0.17.4    | X                     | X                     | 1.8.x    |
+| 2.0.4 - 2.0.11       | 2.0.0.0 - 2.0.7.3     | X                     | X                     | 1.8.x    |


 ## TDengine DataType 和 Java DataType
@@ -72,18 +72,18 @@ INSERT INTO test.t1 USING test.weather (ts, temperature) TAGS('beijing') VALUES(
 TDengine 目前支持时间戳、数字、字符、布尔类型，与 Java 对应类型转换如下：

 | TDengine DataType | JDBCType （driver 版本 < 2.0.24） | JDBCType （driver 版本 >= 2.0.24） |
-|-------------------|-------------------------------| ------------------ |
-| TIMESTAMP         | java.lang.Long                | java.sql.Timestamp |
-| INT               | java.lang.Integer             | java.lang.Integer  |
-| BIGINT            | java.lang.Long                | java.lang.Long     |
-| FLOAT             | java.lang.Float               | java.lang.Float    |
-| DOUBLE            | java.lang.Double              | java.lang.Double   |
-| SMALLINT          | java.lang.Short               | java.lang.Short    |
-| TINYINT           | java.lang.Byte                | java.lang.Byte     |
-| BOOL              | java.lang.Boolean             | java.lang.Boolean  |
-| BINARY            | java.lang.String              | byte array         |
-| NCHAR             | java.lang.String              | java.lang.String   |
-| JSON              | -                             | java.lang.String   |
+| ----------------- | --------------------------------- | ---------------------------------- |
+| TIMESTAMP         | java.lang.Long                    | java.sql.Timestamp                 |
+| INT               | java.lang.Integer                 | java.lang.Integer                  |
+| BIGINT            | java.lang.Long                    | java.lang.Long                     |
+| FLOAT             | java.lang.Float                   | java.lang.Float                    |
+| DOUBLE            | java.lang.Double                  | java.lang.Double                   |
+| SMALLINT          | java.lang.Short                   | java.lang.Short                    |
+| TINYINT           | java.lang.Byte                    | java.lang.Byte                     |
+| BOOL              | java.lang.Boolean                 | java.lang.Boolean                  |
+| BINARY            | java.lang.String                  | byte array                         |
+| NCHAR             | java.lang.String                  | java.lang.String                   |
+| JSON              | -                                 | java.lang.String                   |

 注意：JSON类型仅在tag中支持。

@@ -177,7 +177,7 @@ url中的配置参数如下：
 * timezone：客户端使用的时区，默认值为系统当前时区。
 * batchfetch: 仅在使用JDBC-JNI时生效。true：在执行查询时批量拉取结果集；false：逐行拉取结果集。默认值为：false。
 * timestampFormat: 仅在使用JDBC-RESTful时生效. 'TIMESTAMP'：结果集中timestamp类型的字段为一个long值; 'UTC'：结果集中timestamp类型的字段为一个UTC时间格式的字符串; 'STRING'：结果集中timestamp类型的字段为一个本地时间格式的字符串。默认值为'STRING'。
-* batchErrorIgnore：true：在执行Statement的executeBatch时，如果中间有一条sql执行失败，继续执行下面的sq了。false：不再执行失败sql后的任何语句。默认值为：false。
+* batchErrorIgnore：true：在执行Statement的executeBatch时，如果中间有一条sql执行失败，继续执行下面的sql了。false：不再执行失败sql后的任何语句。默认值为：false。

 #### 指定URL和Properties获取连接

@@ -345,6 +345,7 @@ JDBC连接器可能报错的错误码包括3种：JDBC driver本身的报错（
 * setString 和 setNString 都要求用户在 size 参数里声明表定义中对应列的列宽

 示例代码：
+
 ```java
 public class ParameterBindingDemo {
 
@@ -572,6 +573,7 @@ public class ParameterBindingDemo {
 ```

 用于设定 TAGS 取值的方法总共有：
+
 ```java
 public void setTagNull(int index, int type)
 public void setTagBoolean(int index, boolean value)
@@ -587,6 +589,7 @@ public void setTagNString(int index, String value)
 ```

 用于设定 VALUES 数据列的取值的方法总共有：
+
 ```java
 public void setInt(int columnIndex, ArrayList<Integer> list) throws SQLException
 public void setFloat(int columnIndex, ArrayList<Float> list) throws SQLException
@@ -600,14 +603,56 @@ public void setString(int columnIndex, ArrayList<String> list, int size) throws
 public void setNString(int columnIndex, ArrayList<String> list, int size) throws SQLException
 ```

+### <a class="anchor" id="schemaless_java"></a>无模式写入
+
+从 2.2.0.0 版本开始，TDengine 增加了对无模式写入功能。无模式写入兼容 InfluxDB 的 行协议（Line Protocol）、OpenTSDB 的 telnet 行协议和 OpenTSDB 的 JSON 格式协议。详情请参见[无模式写入](https://www.taosdata.com/docs/cn/v2.0/insert#schemaless)。
+
+注意：
+* JDBC-RESTful 实现并不提供无模式写入这种使用方式
+* 以下示例代码基于taos-jdbcdriver-2.0.36
+
+示例代码：
+
+```java
+public class SchemalessInsertTest {
+    private static final String host = "127.0.0.1";
+    private static final String lineDemo = "st,t1=3i64,t2=4f64,t3=\"t3\" c1=3i64,c3=L\"passit\",c2=false,c4=4f64 1626006833639000000";
+    private static final String telnetDemo = "stb0_0 1626006833 4 host=host0 interface=eth0";
+    private static final String jsonDemo = "{\"metric\": \"meter_current\",\"timestamp\": 1346846400,\"value\": 10.3, \"tags\": {\"groupid\": 2, \"location\": \"Beijing\", \"id\": \"d1001\"}}";
+
+    public static void main(String[] args) throws SQLException {
+        final String url = "jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata";
+        try (Connection connection = DriverManager.getConnection(url)) {
+            init(connection);
+
+            SchemalessWriter writer = new SchemalessWriter(connection);
+            writer.write(lineDemo, SchemalessProtocolType.LINE, SchemalessTimestampType.NANO_SECONDS);
+            writer.write(telnetDemo, SchemalessProtocolType.TELNET, SchemalessTimestampType.MILLI_SECONDS);
+            writer.write(jsonDemo, SchemalessProtocolType.JSON, SchemalessTimestampType.NOT_CONFIGURED);
+        }
+    }
+
+    private static void init(Connection connection) throws SQLException {
+        try (Statement stmt = connection.createStatement()) {
+            stmt.executeUpdate("drop database if exists test_schemaless");
+            stmt.executeUpdate("create database if not exists test_schemaless");
+            stmt.executeUpdate("use test_schemaless");
+        }
+    }
+}
+```
+
 ### <a class="anchor" id="set-client-configuration"></a>设置客户端参数
+
 从TDengine-2.3.5.0版本开始，jdbc driver支持在应用的第一次连接中，设置TDengine的客户端参数。Driver支持JDBC-JNI方式中，通过jdbcUrl和properties两种方式设置client parameter。
+
 注意：
 * JDBC-RESTful不支持设置client parameter的功能。
 * 应用中设置的client parameter为进程级别的，即如果要更新client的参数，需要重启应用。这是因为client parameter是全局参数，仅在应用程序的第一次设置生效。
 * 以下示例代码基于taos-jdbcdriver-2.0.36。

 示例代码：
+
 ```java
 public class ClientParameterSetting {
    private static final String host = "127.0.0.1";

--- a/documentation20/cn/08.connector/docs.md
+++ b/documentation20/cn/08.connector/docs.md
--- a/documentation20/cn/09.connections/docs.md
+++ b/documentation20/cn/09.connections/docs.md
 # 与其他工具的连接

-
 ## <a class="anchor" id="grafana"></a>Grafana

-TDengine 能够与开源数据可视化系统 [Grafana](https://www.grafana.com/)快速集成搭建数据监测报警系统，整个过程无需任何代码开发，TDengine 中数据表中内容可以在仪表盘(DashBoard)上进行可视化展现。关于TDengine插件的使用您可以在[GitHub](https://github.com/taosdata/grafanaplugin/blob/master/README.md)中了解更多。
+TDengine 能够与开源数据可视化系统 [Grafana](https://www.grafana.com/) 快速集成搭建数据监测报警系统，整个过程无需任何代码开发，TDengine 中数据表中内容可以在仪表盘(DashBoard)上进行可视化展现。关于 TDengine 插件的使用您可以在 [GitHub](https://github.com/taosdata/grafanaplugin/blob/master/README.md) 中了解更多。

 ### 安装Grafana

@@ -11,7 +10,7 @@ TDengine 能够与开源数据可视化系统 [Grafana](https://www.grafana.com/

 ### 配置Grafana

-TDengine 的 Grafana 插件托管在GitHub，可从 <https://github.com/taosdata/grafanaplugin/releases/latest> 下载，当前最新版本为 3.1.3。
+TDengine 的 Grafana 插件托管在 GitHub，可从 <https://github.com/taosdata/grafanaplugin/releases/latest> 下载，当前最新版本为 3.1.3。

 推荐使用 [`grafana-cli` 命令行工具](https://grafana.com/docs/grafana/latest/administration/cli/) 进行插件安装。

@@ -41,7 +40,7 @@ Grafana 7.3+ / 8.x 版本会对插件进行签名检查，因此还需要在 gra
 allow_loading_unsigned_plugins = tdengine-datasource
 ```

-在Docker环境下，可以使用如下的环境变量设置自动安装并设置 TDengine 插件：
+在 Docker 环境下，可以使用如下的环境变量设置自动安装并设置 TDengine 插件：

 ```bash
 GF_INSTALL_PLUGINS=https://github.com/taosdata/grafanaplugin/releases/download/v3.1.3/tdengine-datasource-3.1.3.zip;tdengine-datasource
@@ -52,7 +51,7 @@ GF_PLUGINS_ALLOW_LOADING_UNSIGNED_PLUGINS=tdengine-datasource

 #### 配置数据源

-用户可以直接通过 http://localhost:3000 的网址，登录 Grafana 服务器（用户名/密码：admin/admin），通过左侧 `Configuration -> Data Sources` 可以添加数据源，如下图所示：
+用户可以直接通过 `http://localhost:3000` 的网址，登录 Grafana 服务器（用户名/密码：admin/admin），通过左侧 `Configuration -> Data Sources` 可以添加数据源，如下图所示：

 ![img](../images/connections/add_datasource1.jpg)

@@ -64,7 +63,7 @@ GF_PLUGINS_ALLOW_LOADING_UNSIGNED_PLUGINS=tdengine-datasource

 ![img](../images/connections/add_datasource3.jpg)

-* Host： TDengine 集群的中任意一台服务器的 IP 地址与 TDengine RESTful 接口的端口号(6041)，默认 http://localhost:6041。注意：从 2.4 版本开始 RESTful 服务默认使用独立组件 taosAdapter 提供，请参考相关文档配置部署。
+* Host： TDengine 集群的中任意一台服务器的 IP 地址与 TDengine RESTful 接口的端口号(6041)，默认 `http://localhost:6041`。注意：从 2.4 版本开始 RESTful 服务默认使用独立组件 taosAdapter 提供，请参考相关文档配置部署。
 * User：TDengine 用户名。
 * Password：TDengine 用户密码。

@@ -78,17 +77,17 @@ GF_PLUGINS_ALLOW_LOADING_UNSIGNED_PLUGINS=tdengine-datasource

 ![img](../images/connections/create_dashboard1.jpg)

-如上图所示，在 Query 中选中 `TDengine` 数据源，在下方查询框可输入相应 sql 进行查询，具体说明如下：
+如上图所示，在 Query 中选中 `TDengine` 数据源，在下方查询框可输入相应 SQL 进行查询，具体说明如下：

-* INPUT SQL：输入要查询的语句（该 SQL 语句的结果集应为两列多行），例如：`select avg(mem_system) from log.dn where  ts >= $from and ts < $to interval($interval)` ，其中，from、to 和 interval 为 TDengine插件的内置变量，表示从Grafana插件面板获取的查询范围和时间间隔。除了内置变量外，`也支持可以使用自定义模板变量`。
-* ALIAS BY：可设置当前查询别名。 
+* INPUT SQL：输入要查询的语句（该 SQL 语句的结果集应为两列多行），例如：`select avg(mem_system) from log.dn where  ts >= $from and ts < $to interval($interval)` ，其中，from、to 和 interval 为 TDengine 插件的内置变量，表示从 Grafana 插件面板获取的查询范围和时间间隔。除了内置变量外，`也支持可以使用自定义模板变量`。
+* ALIAS BY：可设置当前查询别名。
 * GENERATE SQL： 点击该按钮会自动替换相应变量，并生成最终执行的语句。
-  
+
 按照默认提示查询当前 TDengine 部署所在服务器指定间隔系统内存平均使用量如下：

 ![img](../images/connections/create_dashboard2.jpg)

-> 关于如何使用Grafana创建相应的监测界面以及更多有关使用Grafana的信息，请参考Grafana官方的[文档](https://grafana.com/docs/)。
+> 关于如何使用 Grafana 创建相应的监测界面以及更多有关使用 Grafana 的信息，请参考 Grafana 官方的[文档](https://grafana.com/docs/)。

 #### 导入 Dashboard


--- a/documentation20/cn/11.administrator/docs.md
+++ b/documentation20/cn/11.administrator/docs.md
--- a/documentation20/cn/12.taos-sql/docs.md
+++ b/documentation20/cn/12.taos-sql/docs.md
@@ -4,7 +4,7 @@

 TAOS SQL 是用户对 TDengine 进行数据写入和查询的主要工具。TAOS SQL 为了便于用户快速上手，在一定程度上提供类似于标准 SQL 类似的风格和模式。严格意义上，TAOS SQL 并不是也不试图提供 SQL 标准的语法。此外，由于 TDengine 针对的时序性结构化数据不提供删除功能，因此在 TAO SQL 中不提供数据删除的相关功能。

-TAOS SQL 不支持关键字的缩写，例如 DESCRIBE 不能缩写为 DESC。 
+TAOS SQL 目前仅支持 DESCRIBE 关键字的缩写，DESCRIBE 可以缩写为 DESC。

 本章节 SQL 语法遵循如下约定：

@@ -135,7 +135,7 @@ CREATE DATABASE db_name PRECISION 'ns';
    ```mysql
    ALTER DATABASE db_name BLOCKS 100;
    ```
-    BLOCKS 参数是每个 VNODE (TSDB) 中有多少 cache 大小的内存块，因此一个 VNODE 的用的内存大小粗略为（cache * blocks）。取值范围 [3, 1000]。
+    BLOCKS 参数是每个 VNODE (TSDB) 中有多少 cache 大小的内存块，因此一个 VNODE 的用的内存大小粗略为（cache * blocks）。取值范围 [3, 10000]。

    ```mysql
    ALTER DATABASE db_name CACHELAST 0;

--- a/documentation20/cn/14.devops/01.telegraf/docs.md
+++ b/documentation20/cn/14.devops/01.telegraf/docs.md
 # 使用 TDengine + Telegraf + Grafana 快速搭建 IT 运维展示系统

 ## 背景介绍
-TDengine是涛思数据专为物联网、车联网、工业互联网、IT运维等设计和优化的大数据平台。自从 2019年 7 月开源以来，凭借创新的数据建模设计、快捷的安装方式、易用的编程接口和强大的数据写入查询性能博得了大量时序数据开发者的青睐。
+
+TDengine 是涛思数据专为物联网、车联网、工业互联网、IT 运维等设计和优化的大数据平台。自从 2019年 7 月开源以来，凭借创新的数据建模设计、快捷的安装方式、易用的编程接口和强大的数据写入查询性能博得了大量时序数据开发者的青睐。

 IT 运维监测数据通常都是对时间特性比较敏感的数据，例如：
+
 - 系统资源指标：CPU、内存、IO、带宽等。
 - 软件系统指标：存活状态、连接数目、请求数目、超时数目、错误数目、响应时间、服务类型及其他与业务有关的指标。

@@ -13,23 +15,26 @@ IT 运维监测数据通常都是对时间特性比较敏感的数据，例如

 ![IT-DevOps-Solutions-Telegraf.png](../../images/IT-DevOps-Solutions-Telegraf.png)

-
 ## 安装步骤

 ### 安装 Telegraf，Grafana 和 TDengine
+
 安装 Telegraf、Grafana 和 TDengine 请参考相关官方文档。

 ### Telegraf
+
 请参考[官方文档](https://portal.influxdata.com/downloads/)。

 ### Grafana
+
 请参考[官方文档](https://grafana.com/grafana/download)。

 ### TDengine
-从涛思数据官网[下载](http://taosdata.com/cn/all-downloads/)页面下载最新 TDengine-server 2.3.0.0 或以上版本安装。

+从涛思数据官网[下载](http://taosdata.com/cn/all-downloads/)页面下载最新 TDengine-server 2.3.0.0 或以上版本安装。

 ## 数据链路设置
+
 ### 下载 TDengine 插件到 grafana 插件目录

 ```bash
@@ -40,8 +45,10 @@ IT 运维监测数据通常都是对时间特性比较敏感的数据，例如
 5. sudo systemctl restart grafana-server.service
 ```

-### 修改 /etc/telegraf/telegraf.conf 
+### 修改 /etc/telegraf/telegraf.conf
+
 配置方法，在 /etc/telegraf/telegraf.conf 增加如下文字，其中 database name 请填写希望在 TDengine 保存 Telegraf 数据的数据库名，TDengine server/cluster host、username和 password 填写 TDengine 实际值：
+
 ```
 [[outputs.http]]
  url = "http://<TDengine server/cluster host>:6041/influxdb/v1/write?db=<database name>"
@@ -54,20 +61,19 @@ IT 运维监测数据通常都是对时间特性比较敏感的数据，例如
 ```

 然后重启 telegraf：
-```
+
+```bash
 sudo systemctl start telegraf
 ```

-
 ### 导入 Dashboard

 使用 Web 浏览器访问 IP:3000 登录 Grafana 界面，系统初始用户名密码为 admin/admin。
 点击左侧齿轮图标并选择 Plugins，应该可以找到 TDengine data source 插件图标。
-点击左侧加号图标并选择 Import，从 https://github.com/taosdata/grafanaplugin/blob/master/examples/telegraf/grafana/dashboards/telegraf-dashboard-v0.1.0.json 下载 dashboard JSON 文件后导入。之后可以看到如下界面的仪表盘：
+点击左侧加号图标并选择 Import，从 `https://github.com/taosdata/grafanaplugin/blob/master/examples/telegraf/grafana/dashboards/telegraf-dashboard-v0.1.0.json` 下载 dashboard JSON 文件后导入。之后可以看到如下界面的仪表盘：

 ![IT-DevOps-Solutions-telegraf-dashboard.png](../../images/IT-DevOps-Solutions-telegraf-dashboard.png)

-
 ## 总结

 以上演示如何快速搭建一个完整的 IT 运维展示系统。得力于 TDengine 2.3.0.0 版本中新增的 schemaless 协议解析功能，以及强大的生态软件适配能力，用户可以短短数分钟就可以搭建一个高效易用的 IT 运维系统。TDengine 强大的数据写入查询性能和其他丰富功能请参考官方文档和产品落地案例。
--- a/documentation20/cn/14.devops/02.collectd/docs.md
+++ b/documentation20/cn/14.devops/02.collectd/docs.md
 # 使用 TDengine + collectd/StatsD + Grafana 快速搭建 IT 运维监控系统

 ## 背景介绍
+
 TDengine是涛思数据专为物联网、车联网、工业互联网、IT运维等设计和优化的大数据平台。自从 2019年 7 月开源以来，凭借创新的数据建模设计、快捷的安装方式、易用的编程接口和强大的数据写入查询性能博得了大量时序数据开发者的青睐。

 IT 运维监测数据通常都是对时间特性比较敏感的数据，例如：
+
 - 系统资源指标：CPU、内存、IO、带宽等。
 - 软件系统指标：存活状态、连接数目、请求数目、超时数目、错误数目、响应时间、服务类型及其他与业务有关的指标。

@@ -14,21 +16,27 @@ IT 运维监测数据通常都是对时间特性比较敏感的数据，例如
 ![IT-DevOps-Solutions-Collectd-StatsD.png](../../images/IT-DevOps-Solutions-Collectd-StatsD.png)

 ## 安装步骤
+
 安装 collectd， StatsD， Grafana 和 TDengine 请参考相关官方文档。

 ### 安装 collectd
+
 请参考[官方文档](https://collectd.org/documentation.shtml)。

 ### 安装 StatsD
+
 请参考[官方文档](https://github.com/statsd/statsd)。

 ### 安装 Grafana
+
 请参考[官方文档](https://grafana.com/grafana/download)。

 ### 安装 TDengine
+
 从涛思数据官网[下载](http://taosdata.com/cn/all-downloads/）页面下载最新 TDengine-server 2.3.0.0 或以上版本安装。

 ## 数据链路设置
+
 ### 复制 TDengine 插件到 grafana 插件目录

 ```bash
@@ -40,7 +48,9 @@ IT 运维监测数据通常都是对时间特性比较敏感的数据，例如
 ```

 ### 配置 collectd
+
 在 /etc/collectd/collectd.conf 文件中增加如下内容，其中 host 和 port 请填写 TDengine 和 taosAdapter 配置的实际值：
+
 ```
 LoadPlugin network
 <Plugin network>
@@ -51,7 +61,9 @@ sudo systemctl start collectd
 ```

 ### 配置 StatsD
+
 在 config.js 文件中增加如下内容后启动 StatsD，其中 host 和 port 请填写 TDengine 和 taosAdapter 配置的实际值：
+
 ```
 backends 部分添加 "./backends/repeater"
 repeater 部分添加 { host:'<TDengine server/cluster host>', port: <port for StatsD>}
@@ -74,6 +86,7 @@ repeater 部分添加 { host:'<TDengine server/cluster host>', port: <port for S
 ![IT-DevOps-Solutions-statsd-dashboard.png](../../images/IT-DevOps-Solutions-statsd-dashboard.png)

 ## 总结
+
 TDengine 作为新兴的时序大数据平台，具备极强的高性能、高可靠、易管理、易维护的优势。得力于 TDengine 2.3.0.0 版本中新增的 schemaless 协议解析功能，以及强大的生态软件适配能力，用户可以短短数分钟就可以搭建一个高效易用的 IT 运维系统或者适配一个已存在的系统。

 TDengine 强大的数据写入查询性能和其他丰富功能请参考官方文档和产品成功落地案例。
--- a/documentation20/cn/14.devops/03.immigrate/docs.md
+++ b/documentation20/cn/14.devops/03.immigrate/docs.md
--- a/documentation20/en/01.evaluation/docs.md
+++ b/documentation20/en/01.evaluation/docs.md
@@ -2,64 +2,71 @@

 ## <a class="anchor" id="intro"></a> About TDengine

-TDengine is an innovative Big Data processing product launched by TAOS Data in the face of the fast-growing Internet of Things (IoT) Big Data market and technical challenges. It does not rely on any third-party software, nor does it optimize or package any open-source database or stream computing product. Instead, it is a product independently developed after absorbing the advantages of many traditional relational databases, NoSQL databases, stream computing engines, message queues, and other software. TDengine has its own unique Big Data processing advantages in time-series space.
+TDengine is a high-performance, scalable time-series database with SQL support. Its code, including its cluster feature is open source under GNU AGPL v3.0. Besides the database engine, it provides caching, stream processing, data subscription and other functionalities to reduce the complexity and cost of development and operation. TDengine differentiates itself from other TSDBs with the following advantages.

-One of the modules of TDengine is the time-series database. However, in addition to this,  to reduce the complexity of research and development and the difficulty of system operation, TDengine also provides functions such as caching, message queuing, subscription, stream computing, etc. TDengine provides a full-stack technical solution for the processing of IoT and Industrial Internet BigData. It is an efficient and easy-to-use IoT Big Data platform. Compared with typical Big Data platforms such as Hadoop, TDengine has the following distinct characteristics:
+- **High Performance**: TDengine outperforms other time series databases in data ingestion and querying while significantly reducing storage cost and compute costs, with an innovatively designed and purpose-built storage engine.

- **Performance improvement over 10 times**: An innovative data storage structure is defined, with every single core that can process at least 20,000 requests per second, insert millions of data points, and read more than 10 million data points, which is more than 10 times faster than other existing general database.
- **Reduce the cost of hardware or cloud services to 1/5**: Due to its ultra-performance, TDengine’s computing resources consumption is less than 1/5 of other common Big Data solutions; through columnar storage and advanced compression algorithms, the storage consumption is less than 1/10 of other general databases.
- **Full-stack time-series data processing engine**: Integrate database, message queue, cache, stream computing, and other functions, and the applications do not need to integrate with software such as Kafka/Redis/HBase/Spark/HDFS, thus greatly reducing the complexity cost of application development and maintenance.
- **Highly Available and Horizontal Scalable**: With the distributed architecture and consistency algorithm, via multi-replication and clustering features, TDengine ensures high availability and horizontal scalability to support mission-critical applications.
- **Zero operation cost & zero learning cost**: Installing clusters is simple and quick, with real-time backup built-in, and no need to split libraries or tables. Similar to standard SQL, TDengine can support RESTful, Python/Java/C/C++/C#/Go/Node.js, and similar to MySQL with zero learning cost.
- **Core is Open Sourced:** Except for some auxiliary features, the core of TDengine is open-sourced. Enterprise won't be locked by the database anymore. The ecosystem is more strong, products are more stable, and developer communities are more active. 
+- **Scalable**: TDengine provides out-of-box scalability and high-availability through its native distributed design. Nodes can be added through simple configuration to achieve greater data processing power. In addition, this feature is open source.

-With TDengine, the total cost of ownership of typical IoT, Internet of Vehicles, and Industrial Internet Big Data platforms can be greatly reduced. However, since it makes full use of the characteristics of IoT time-series data, TDengine cannot be used to process general data from web crawlers, microblogs, WeChat, e-commerce, ERP, CRM, and other sources.
+- **SQL Support**: TDengine uses SQL as the query language, thereby reducing learning and migration costs, while adding SQL extensions to handle time-series data better, and supporting convenient and flexible schemaless data ingestion.
+
+- **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.
+
+- **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.
+
+- **Zero Learning Cost**: With SQL as the query language, support for ubiquitous tools like Python, Java, C/C++, Go, Rust, Node.js connectors, there is zero learning cost.
+
+- **Interactive Console**: TDengine provides convenient console access to the database to run ad hoc queries, maintain the database, or manage the cluster without any programming.
+
+With TDengine, the total cost of ownership of typical IoT, Connected Vehicles, Industrial Internet, Energy, Financial, DevOps and other Big Data applications can be greatly reduced. Note that because TDengine makes full use of the characteristics of IoT time-series data and is highly optimized for it, TDengine cannot be used as a general purpose database engine to process general data from web crawlers, microblogs, WeChat, e-commerce, ERP, CRM, and other sources.

 ![TDengine Technology Ecosystem](../images/eco_system.png)
+<center>Figure 1. TDengine Ecosystem</center>

-<center>Figure 1. TDengine Technology Ecosystem</center>

 ## <a class="anchor" id="scenes"></a>Overall Scenarios of TDengine

-As an IoT Big Data platform, the typical application scenarios of TDengine are mainly presented in the IoT category, with users having a certain amount of data. The following sections of this document are mainly aimed at  IoT-relevant systems. Other systems, such as CRM, ERP, etc., are beyond the scope of this article.
+As an IoT time-series Big Data platform, TDengine is optimal for application scenarios with the requirements described below. Therefore the following sections of this document are mainly aimed at IoT-relevant systems. Other systems, such as CRM, ERP, etc., are beyond the scope of this article.

 ### Characteristics and Requirements of Data Sources

-From the perspective of data sources, designers can analyze the applicability of TDengine in target application systems as following.
+From the perspective of data sources, designers can analyze the applicability of TDengine in target application systems as follows.

 | **Data Source Characteristics and Requirements**         | **Not Applicable** | **Might Be Applicable** | **Very Applicable** | **Description**                                              |
 | -------------------------------------------------------- | ------------------ | ----------------------- | ------------------- | :----------------------------------------------------------- |
-| A huge amount of total data                              |                    |                         | √                   | TDengine provides excellent scale-out functions in terms of capacity, and has a storage structure matching high compression ratio to achieve the best storage efficiency in the industry. |
-| Data input velocity is occasionally or continuously huge |                    |                         | √                   | TDengine's performance is much higher than other similar products. It can continuously process a large amount of input data in the same hardware environment, and provide a performance evaluation tool that can easily run in the user environment. |
-| A huge amount of data sources                            |                    |                         | √                   | TDengine is designed to include optimizations specifically for a huge amount of data sources, such as data writing and querying, which is especially suitable for efficiently processing massive (tens of millions or more) data sources. |
+| A massive amount of total data                              |                    |                         | √                   | TDengine provides excellent scale-out functions in terms of capacity, and has a storage structure with matching high compression ratio to achieve the best storage efficiency in the industry.|
+| Data input velocity is extremely high |                    |                         | √                   | TDengine's performance is much higher than that of other similar products. It can continuously process larger amounts of input data in the same hardware environment, and provides a performance evaluation tool that can easily run in the user environment. |
+| A huge number of data sources                            |                    |                         | √                   | TDengine is optimized specifically for a huge number of data sources. It is especially suitable for efficiently ingesting, writing and querying data from billions of data sources. |

 ### System Architecture Requirements

 | **System Architecture Requirements**              | **Not Applicable** | **Might Be Applicable** | **Very Applicable** | **Description**                                              |
 | ------------------------------------------------- | ------------------ | ----------------------- | ------------------- | ------------------------------------------------------------ |
-| Require a simple and reliable system architecture |                    |                         | √                   | TDengine's system architecture is very simple and reliable, with its own message queue, cache, stream computing, monitoring and other functions, and no need to integrate any additional third-party products. |
-| Require fault-tolerance and high-reliability      |                    |                         | √                   | TDengine has cluster functions to automatically provide high-reliability functions such as fault tolerance and disaster recovery. |
-| Standardization specifications                    |                    |                         | √                   | TDengine uses standard SQL language to provide main functions and follow standardization specifications. |
+| A simple and reliable system architecture |                    |                         | √                   | TDengine's system architecture is very simple and reliable, with its own message queue, cache, stream computing, monitoring and other functions. There is no need to integrate any additional third-party products. |
+| Fault-tolerance and high-reliability      |                    |                         | √                   | TDengine has cluster functions to automatically provide high-reliability and high-availability functions such as fault tolerance and disaster recovery. |
+| Standardization support                    |                    |                         | √                   | TDengine supports standard SQL and also provides extensions specifically to analyze time-series data. |

 ### System Function Requirements

-| **System Architecture Requirements**              | **Not Applicable** | **Might Be Applicable** | **Very Applicable** | **Description**                                              |
+| **System Function Requirements**              | **Not Applicable** | **Might Be Applicable** | **Very Applicable** | **Description**                                              |
 | ------------------------------------------------- | ------------------ | ----------------------- | ------------------- | ------------------------------------------------------------ |
-| Require completed data processing algorithms built-in |                    | √                    |                     | TDengine implements various general data processing algorithms, but has not properly handled all requirements of different industries, so special types of processing shall be processed at the application level. |
-| Require a huge amount of crosstab queries             |                    | √                    |                     | This type of processing should be handled more by relational database systems, or TDengine and relational database systems should fit together to implement system functions. |
+| Complete data processing algorithms built-in |                    | √                    |                     | While TDengine implements various general data processing algorithms, industry specific algorithms and special types of processing will need to be implemented at the application level.|
+| A large number of crosstab queries             |                    | √                    |                     | This type of processing is better handled by general purpose relational database systems but TDengine can work in concert with relational database systems to provide more complete solutions. |

 ### System Performance Requirements

-| **System Architecture Requirements**              | **Not Applicable** | **Might Be Applicable** | **Very Applicable** | **Description**                                              |
+| **System Performance Requirements**              | **Not Applicable** | **Might Be Applicable** | **Very Applicable** | **Description**                                              |
 | ------------------------------------------------- | ------------------ | ----------------------- | ------------------- | ------------------------------------------------------------ |
-| Require larger total processing capacity     |                    |                      | √                   | TDengine’s cluster functions can easily improve processing capacity via multi-server-cooperating. |
-| Require high-speed data processing           |                    |                      | √                   | TDengine’s storage and data processing are designed to be optimized for IoT, can generally improve the processing speed by multiple times than other similar products. |
-| Require fast processing of fine-grained data |                    |                      | √                   | TDengine has achieved the same level of performance with relational and NoSQL data processing systems. |
+| Very large total processing capacity     |                    |                      | √                   | TDengine’s cluster functions can easily improve processing capacity via multi-server coordination. |
+| Extremely high-speed data processing           |                    |                      | √                   | TDengine’s storage and data processing are optimized for IoT, and can process data many times faster than similar products.|
+| Extremely fast processing of fine-grained data |                    |                      | √                   | TDengine has achieved the same or better performance than other relational and NoSQL data processing systems. |

 ### System Maintenance Requirements

-| **System Architecture Requirements**              | **Not Applicable** | **Might Be Applicable** | **Very Applicable** | **Description**                                              |
+| **System Maintenance Requirements**              | **Not Applicable** | **Might Be Applicable** | **Very Applicable** | **Description**                                              |
 | ------------------------------------------------- | ------------------ | ----------------------- | ------------------- | ------------------------------------------------------------ |
-| Require system with high-reliability         |                    |                      | √                   | TDengine has a very robust and reliable system architecture to implement simple and convenient daily operation with streamlined experiences for operators, thus human errors and accidents are eliminated to the greatest extent. |
-| Require controllable operation learning cost |                    |                      | √                   | As above.                                                    |
-| Require abundant talent supply               | √                  |                      |                     | As a new-generation product, it’s still difficult to find talents with TDengine experiences from the market. However, the learning cost is low. As the vendor, we also provide extensive operation training and counseling services. |
+| Native high-reliability         |                    |                      | √                   | TDengine has a very robust, reliable and easily configurable system architecture to simplify routine operation. Human errors and accidents are eliminated to the greatest extent, with a streamlined experience for operators. |
+| Minimize learning and maintenance costs |                    |                      | √                   | In addition to being easily configurable, standard SQL support and the Taos shell for ad hoc queries makes maintenance simpler, allows reuse and reduces learning costs.|
+| Abundant talent supply               | √                  |                      |                     | Given the above, and given the extensive training and professional services provided by TDengine, it is easy to migrate from existing solutions or create a new and lasting solution based on TDengine.|
--- a/documentation20/en/02.getting-started/01.docker/docs.md
+++ b/documentation20/en/02.getting-started/01.docker/docs.md
 # Quickly Taste TDengine with Docker

-While it is not recommended to deploy TDengine services via Docker in a production environment, Docker tools do a good job of shielding the environmental differences in the underlying operating system and are well suited for use in development testing or first-time taste with the toolset for installing and running TDengine. In particular, Docker makes it relatively easy to try TDengine on Mac OSX and Windows systems without having to install a virtual machine or rent an additional Linux server. In addition, starting from version 2.0.14.0, TDengine provides images that support both X86-64, X86, arm64, and arm32 platforms, so non-mainstream computers that can run docker, such as NAS, Raspberry Pi, and embedded development boards, can also easily taste TDengine based on this document.
+While it is not recommended to deploy TDengine services via Docker in a production environment, Docker tools do a good job of shielding the environmental differences in the underlying operating system and are well suited for use in development testing or first-time taste with the toolset for installing and running TDengine. In particular, Docker makes it relatively easy to try TDengine on macOS and Windows systems without having to install a virtual machine or rent an additional Linux server. In addition, starting from version 2.0.14.0, TDengine provides images that support both X86-64, X86, arm64, and arm32 platforms, so non-mainstream computers that can run docker, such as NAS, Raspberry Pi, and embedded development boards, can also easily taste TDengine based on this document.

 The following article explains how to quickly build a single-node TDengine runtime environment via Docker to support development and testing through a Step by Step style introduction.

@@ -32,14 +32,14 @@ This command starts a docker container with TDengine server running and maps the
 - **tdengine/tdengine**: the official TDengine published application image that is pulled
 - **526aa188da767ae94b244226a2b2eec2b5f17dd8eff592893d9ec0cd0f3a1ccd**: The long character returned is the container ID, and we can also view the corresponding container by its container ID

-Further, you can also use the `docker run` command to start the docker container running TDengine server, and use the `--name` command line parameter to name the container tdengine, use `--hostname` to specify the hostname as tdengine-server, and use `-v` to mount the local directory (-v) to synchronize the data inside the host and the container to prevent data loss after the container is deleted.
+Further, you can also use the `docker run` command to start the docker container running TDengine server, and use the `--name` command line parameter to name the container TDengine, use `--hostname` to specify the hostname as TDengine-server, and use `-v` to mount the local directory (-v) to synchronize the data inside the host and the container to prevent data loss after the container is deleted.

 ```
 docker run -d --name tdengine --hostname="tdengine-server" -v ~/work/taos/log:/var/log/taos -v ~/work/taos/data:/var/lib/taos  -p 6030-6041:6030-6041 -p 6030-6041:6030-6041/udp tdengine/tdengine
 ```

 - **--name tdengine**: set the container name, we can access the corresponding container by container name
- **--hostnamename=tdengine-server**: set the hostname of the Linux system inside the container, we can map the hostname and IP to solve the problem that the container IP may change.
+- **--hostname=tdengine-server**: set the hostname of the Linux system inside the container, we can map the hostname and IP to solve the problem that the container IP may change.
 - **-v**: Set the host file directory to be mapped to the inner container directory to avoid data loss after the container is deleted.

 ### Use the `docker ps` command to verify that the container is running correctly
@@ -121,7 +121,7 @@ TDengine RESTful interface details can be found in the [official documentation](

 ### Running TDengine server and taosAdapter with a Docker container

-Docker containers of TDegnine version 2.4.0.0 and later include a component named `taosAdapter`, which supports data writing and querying capabilities to the TDengine server through the RESTful interface and provides the data ingestion interfaces compatible with InfluxDB/OpenTSDB. Allows seamless migration of InfluxDB/OpenTSDB applications to access TDengine.
+Docker containers of TDengine version 2.4.0.0 and later include a component named `taosAdapter`, which supports data writing and querying capabilities to the TDengine server through the RESTful interface and provides the data ingestion interfaces compatible with InfluxDB/OpenTSDB. Allows seamless migration of InfluxDB/OpenTSDB applications to access TDengine.

 Note: If taosAdapter is running inside the container, you need to add mapping to other additional ports as needed, please refer to [taosAdapter documentation](https://github.com/taosdata/taosadapter/blob/develop/README.md) for the default port number and modification methods for the specific purpose.

@@ -274,7 +274,7 @@ Query OK, 1 row(s) in set (0.003490s)

 ### Application Example: use data collection agent to write data into TDengine

-taosAdapter supports multiple data collection agents (e.g. Telegraf, StatsD, collectd, etc.), here only demonstrate how StasD is simulated to write data, and the command is executed from the host side as follows.
+taosAdapter supports multiple data collection agents (e.g. Telegraf, StatsD, collectd, etc.), here only demonstrate how StatsD is simulated to write data, and the command is executed from the host side as follows.

 ```
 echo "foo:1|c" | nc -u -w0 127.0.0.1 6044

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

-# How to install/uninstall TDengine with installtion package
+# How to install/uninstall TDengine with installation package

 TDengine open source version provides `deb` and `rpm` format installation packages. Our users can choose the appropriate installation package according to their own running environment. The `deb` supports Debian/Ubuntu etc. and the `rpm` supports CentOS/RHEL/SUSE etc. We also provide `tar.gz` format installers for enterprise users.

@@ -51,7 +51,7 @@ Removing tdengine (2.4.0.7) ...
 TDengine is removed successfully!
 ```

-## Install and unstall rpm package
+## Install and uninstall rpm package

 ### Install rpm

@@ -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 standalone service
+Install taoskeeper as a stand-alone service
 taoskeeper is installed, enable it by `systemctl enable taoskeeper`
 ```

@@ -177,9 +177,9 @@ lrwxrwxrwx  1 root root   13 Feb 22 09:34 log -> /var/log/taos/
 ```

 - Automatically generates the configuration file directory, database directory, and log directory.
- Configuration file default directory: /etc/taos/taos.cfg, softlinked to /usr/local/taos/cfg/taos.cfg.
- Database default directory: /var/lib/taos, softlinked to /usr/local/taos/data.
- Log default directory: /var/log/taos, softlinked to /usr/local/taos/log.
+- Configuration file default directory: /etc/taos/taos.cfg, soft-linked to /usr/local/taos/cfg/taos.cfg.
+- Database default directory: /var/lib/taos, soft-linked to /usr/local/taos/data.
+- Log default directory: /var/log/taos, soft-linked to /usr/local/taos/log.
 - executables in the /usr/local/taos/bin directory, which are soft-linked to the /usr/bin directory.
 - Dynamic library files in the /usr/local/taos/driver directory, which are soft-linked to the /usr/lib directory.
 - header files in the /usr/local/taos/include directory, which are soft-linked to the /usr/include directory.
@@ -188,14 +188,13 @@ lrwxrwxrwx  1 root root   13 Feb 22 09:34 log -> /var/log/taos/

 When uninstalling the installation package, the configuration files, database files and log files will be kept, i.e. /etc/taos/taos.cfg, /var/lib/taos, /var/log/taos. If users confirm that they do not need to keep them, they can delete them manually, but must be careful, because after deletion, the data will be permanently lost and cannot be recovered!

-If the installation is updated, when the default configuration file (/etc/taos/taos.cfg) exists, the existing configuration file is still used. The configuration file carried in the installation package is modified to taos.cfg.org and saved in the /usr/local/taos/cfg/ directory, which can be used as a reference sample for setting configuration parameters; if the configuration file does not exist, the Use the configuration file that comes with the installation package
-file that comes with the installation package.
+If the installation is updated, when the default configuration file (/etc/taos/taos.cfg) exists, the existing configuration file is still used. The configuration file carried in the installation package is modified to taos.cfg.orig and saved in the /usr/local/taos/cfg/ directory, which can be used as a reference sample for setting configuration parameters; if the configuration file does not exist, the use the configuration file that comes with the installation package file that comes with the installation package.

 ## Caution

 - TDengine provides several installers, but it is best not to use both the tar.gz installer and the deb or rpm installer on one system. Otherwise, they may affect each other and cause problems when using them.

- For deb package installation, if the installation directory is manually deleted by mistake, the uninstallation, or reinstallation cannot be successful. In this case, you need to clear the installation information of the tdengine package by executing the following command:
+- For deb package installation, if the installation directory is manually deleted by mistake, the uninstallation, or reinstallation cannot be successful. In this case, you need to clear the installation information of the TDengine package by executing the following command:

 ```
 $ sudo rm -f /var/lib/dpkg/info/tdengine*
@@ -203,7 +202,7 @@ $ sudo rm -f /var/lib/dpkg/info/tdengine*

 Then just reinstall it.

- For the rpm package after installation, if the installation directory is manually deleted by mistake part of the uninstallation, or reinstallation can not be successful. In this case, you need to clear the installation information of the tdengine package by executing the following command:
+- For the rpm package after installation, if the installation directory is manually deleted by mistake part of the uninstallation, or reinstallation can not be successful. In this case, you need to clear the installation information of the TDengine package by executing the following command:

 ```
 $ sudo rpm -e --noscripts tdengine

--- a/documentation20/en/02.getting-started/docs.md
+++ b/documentation20/en/02.getting-started/docs.md
@@ -2,7 +2,7 @@

 ## <a class="anchor" id="install"></a>Quick Install

-TDengine includes server, client, and ecological software and peripheral tools. Currently, version 2.0 of the server can only be installed and run on Linux and will support Windows, macOS, and other OSes in the future. The client can be installed and run on Windows or Linux. Applications on any operating system can use the RESTful interface to connect to the taosd server. After 2.4, TDengine includes taosAdapter to provide an easy-to-use and efficient way to ingest data including RESTful service. taosAdapter needs to be started manually as a stand-alone component. The early version uses an embedded HTTP component to provide the RESTful interface.
+TDengine includes server, client, and ecosystem software and peripheral tools. Currently, version 2.0 of the server can only be installed and run on Linux and will support Windows, macOS, and other OSes in the future. The client can be installed and run on Windows or Linux. Applications on any operating system can use the RESTful interface to connect to the taosd server. Starting with 2.4, TDengine includes taosAdapter to provide an easy-to-use and efficient way to ingest data and includes a RESTful service. taosAdapter needs to be started manually as a stand-alone component. The earlier version uses an embedded HTTP component to provide the RESTful interface.

 TDengine supports X64/ARM64/MIPS64/Alpha64 hardware platforms and will support ARM32, RISC-V, and other CPU architectures in the future.

@@ -14,11 +14,11 @@ docker run -d -p 6030-6049:6030-6049 -p 6030-6049:6030-6049/udp tdengine/tdengin

 Please refer to [Quickly Taste TDengine with Docker](https://www.taosdata.com/en/documentation/getting-started/docker) for the details.

-For the time being, using Docker to deploy the client or server of TDengine for production environments is not recommended. However it is a convenient way to deploy TDengine for development purposes. In particular, it is easy to try TDengine in Mac OS X and Windows environments with Docker.
+For the time being, we do not recommend using Docker to deploy the TDengine server or client in production environments. However it is a convenient way to deploy TDengine for development purposes. In particular, it is easy to try TDengine in macOS and Windows environments with Docker.

 ### <a class="anchor" id="package-install"></a>Install from Package

-TDengine is very easy to install, from download to successful installation in just a few seconds. For ease of use, the standard server installation package includes the client application and sample code; if you only need the server application and C/C++ language support for the client connection, you can also download the lite version of the installation package only. The installation packages are available in `rpm` and `deb` formats, as well as `tar.gz` format for enterprise customers who need to facilitate use on specific operating systems. Releases include both stable and beta releases. We recommend the stable release for production use or testing. The beta release may contain more new features. You can choose to download from the following as needed:
+TDengine is very easy to run; download to successful installation takes just a few seconds. For ease of use, the standard server installation package includes the client application and sample code. But if you only need the server application and C/C++ language support for the client connection, you can also download only the lite version of the installation package. The installation packages are available in `rpm` and `deb` formats, as well as `tar.gz` format for enterprise customers who need to facilitate use on specific operating systems. Releases include both stable and beta releases. We recommend the stable release for production use or testing. The beta release may contain more new features. You can choose to download from the following as needed:

 <ul id="server-packageList" class="package-list"></ul>

@@ -59,13 +59,13 @@ After installation, you can start the TDengine service by the `systemctl` comman
 systemctl start taosd
 ```

-Then check if the service is working now.
+Then check if the service is working.

 ```bash
 systemctl status taosd
 ```

-If the service is running successfully, you can play around through TDengine shell `taos`.
+If the service is running successfully, you can play around through the TDengine shell, `taos`.

 **Note:**

@@ -120,7 +120,7 @@ ts     |  speed  |
 Query OK, 2 row(s) in set (0.001700s)
 ```

-Besides the SQL commands, the system administrator can check system status, add or delete accounts, and manage the servers.
+Besides executing SQL commands, the system administrator can check system status, add or delete accounts, and manage the servers.

 ### Shell Command Line Parameters


--- a/documentation20/en/03.architecture/docs.md
+++ b/documentation20/en/03.architecture/docs.md
@@ -157,7 +157,7 @@ Logical structure diagram of TDengine distributed architecture as following:
 ![TDengine architecture diagram](../images/architecture/structure.png)
 <center> Figure 1: TDengine architecture diagram </center>

-A complete TDengine system runs on one or more physical nodes. Logically, it includes data node (dnode), TDEngine application driver (TAOSC) and application (app). There are one or more data nodes in the system, which form a cluster. The application interacts with the TDengine cluster through TAOSC's API. The following is a brief introduction to each logical unit.
+A complete TDengine system runs on one or more physical nodes. Logically, it includes data node (dnode), TDengine application driver (TAOSC) and application (app). There are one or more data nodes in the system, which form a cluster. The application interacts with the TDengine cluster through TAOSC's API. The following is a brief introduction to each logical unit.

 **Physical node (pnode)**: A pnode is a computer that runs independently and has its own computing, storage and network capabilities. It can be a physical machine, virtual machine, or Docker container installed with OS. The physical node is identified by its configured FQDN (Fully Qualified Domain Name). TDengine relies entirely on FQDN for network communication. If you don't know about FQDN, please read the blog post "[All about FQDN of TDengine](https://www.taosdata.com/blog/2020/09/11/1824.html)".


--- a/documentation20/en/05.insert/docs.md
+++ b/documentation20/en/05.insert/docs.md
@@ -36,7 +36,7 @@ For the SQL INSERT Grammar, please refer to  [Taos SQL insert](https://www.taosd
 **Introduction**
 <br/> In many IoT applications, data collection is often used in intelligent control, business analysis and device monitoring etc. As fast application upgrade and iteration, or hardware adjustment, data collection metrics can change rapidly over time. To provide solutions to such use cases, from version 2.2.0.0, TDengine supports writing data via Schemaless. When using Schemaless, action of pre-creating table before inserting data is no longer needed anymore. Tables, data columns and tags can be created automatically. Schemaless can also add additional data columns to tables if necessary, to make sure data can be properly stored into TDengine.

-<br/> TDengine C/C++ Connector provides Schemaless API. Please see [Schemaless data writting API](https://www.taosdata.com/en/documentation/connector#schemaless) for detailed data writing format.
+<br/> TDengine C/C++ Connector provides Schemaless API. Please see [Schemaless data writing API](https://www.taosdata.com/en/documentation/connector#schemaless) for detailed data writing format.
 <br/> Super table and corresponding child tables created via Schemaless are identical to the ones created via SQL, so inserting data into these tables via SQL is also supported. Note that child table names are generated via Schemaless are following special rules through tags mapping. Therefore, child table names are usually not meaningful in terms of readability.

 **Schemaless writing protocols**
@@ -115,7 +115,7 @@ After MD5 value "md5_val" calculated using the above string, prefix "t_" is prep
 | 3      | TSDB_SML_TIMESTAMP_MINUTES            |   minute       |
 | 4      | TSDB_SML_TIMESTAMP_SECONDS            |   second       |
 | 5      | TSDB_SML_TIMESTAMP_MILLI_SECONDS      |   millisecond  |
-| 6      | TSDB_SML_TIMESTAMP_MICRO_SECONDS      |   microsecon   |
+| 6      | TSDB_SML_TIMESTAMP_MICRO_SECONDS      |   microsecond  |
 | 7      | TSDB_SML_TIMESTAMP_NANO_SECONDS       |   nanosecond   |

 When SML_TELNET_PROTOCOL or SML_JSON_PROTOCOL used，timestamp precision is determined by how many digits used in timestamp（following OpenTSDB convention），precision from user input will be ignored。
@@ -136,7 +136,7 @@ create stable st (_ts timestamp, c1 bigint, c2 bool, c3 binary(6), c4 bigint) ta
 **Schemaless data alternation rules**
 <br/>This section describes several data alternation scenarios:

-When column with one line has certain type, and following lines attemp to change the data type of this column, an error will be reported by the API:
+When column with one line has certain type, and following lines attempt to change the data type of this column, an error will be reported by the API:

 ```json
 st,t1=3,t2=4,t3=t3 c1=3i64,c3="passit",c2=false,c4=4    1626006833639000000
@@ -255,7 +255,7 @@ sudo systemctl start collectd

 Please find taosAdapter configuration and usage from `taosadapter --help` output.

-## <a class="anchor" id="statsd"></a> Data Writting via StatsD and taosAdapter
+## <a class="anchor" id="statsd"></a> Data Writing via StatsD and taosAdapter

 Please refer to [official document](https://github.com/statsd/statsd) for StatsD installation.

@@ -278,7 +278,7 @@ port: 8125
 }
 ```

-## <a class="anchor" id="cinga2"></a> Data Writting via icinga2 and taosAdapter
+## <a class="anchor" id="cinga2"></a> Data Writing via icinga2 and taosAdapter

 Use icinga2 to collect check result metrics and performance data

@@ -295,7 +295,7 @@ object OpenTsdbWriter "opentsdb" {

 Please find taosAdapter configuration and usage from `taosadapter --help` output.

-## <a class="anchor" id="tcollector"></a> Data Writting via TCollector and taosAdapter
+## <a class="anchor" id="tcollector"></a> Data Writing via TCollector and taosAdapter

 TCollector is a client-side process that gathers data from local collectors and pushes the data to OpenTSDB. You run it on all your hosts, and it does the work of sending each host’s data to the TSD (OpenTSDB backend process).


--- a/documentation20/en/07.advanced-features/docs.md
+++ b/documentation20/en/07.advanced-features/docs.md
@@ -9,8 +9,8 @@ Continuous query of TDengine adopts time-driven mode, which can be defined direc
 The continuous query provided by TDengine differs from the time window calculation in ordinary stream computing in the following ways:

 - Unlike the real-time feedback calculated results of stream computing, continuous query only starts calculation after the time window is closed. For example, if the time period is 1 day, the results of that day will only be generated after 23:59:59.
- If a history record is written to the time interval that has been calculated, the continuous query will not re-calculate and will not push the new results to the user again. 
- TDengine server does not cache or save the client's status, nor does it provide Exactly-Once semantic guarantee. If the application crashes, the continuous query will be pull up again and starting time must be provided by the application. 
+- If a history record is written to the time interval that has been calculated, the continuous query will not re-calculate and will not push the new results to the user again.
+- TDengine server does not cache or save the client's status, nor does it provide Exactly-Once semantic guarantee. If the application crashes, the continuous query will be pull up again and starting time must be provided by the application.

 ### How to use continuous query

@@ -83,7 +83,7 @@ taos_consume
 taos_unsubscribe
 ```

-Please refer to the [C/C++ Connector](https://www.taosdata.com/cn/documentation/connector/) for the documentation of these APIs. The following is still a smart meter scenario as an example to introduce their specific usage (please refer to the previous section "Continuous Query" for the structure of STables and sub-tables). The complete sample code can be found [here](https://github.com/taosdata/TDengine/blob/master/tests/examples/c/subscribe.c).
+Please refer to the [C/C++ Connector](https://www.taosdata.com/cn/documentation/connector/) for the documentation of these APIs. The following is still a smart meter scenario as an example to introduce their specific usage (please refer to the previous section "Continuous Query" for the structure of STables and sub-tables). The complete sample code can be found [here](https://github.com/taosdata/TDengine/blob/master/examples/c/subscribe.c).

 If we want to be notified and do some process when the current of a smart meter exceeds a certain limit (e.g. 10A), there are two methods: one is to query each sub-table separately, record the timestamp of the last piece of data after each query, and then only query all data after this timestamp:

@@ -210,8 +210,8 @@ After introducing the code, let's take a look at the actual running effect. For
 You can compile and start the sample program by executing the following command in the directory where the sample code is located:

 ```shell
-$ make
-$ ./subscribe -sql='select * from meters where current > 10;'
+make
+./subscribe -sql='select * from meters where current > 10;'
 ```

 After the sample program starts, open another terminal window, and the shell that starts TDengine inserts a data with a current of 12A into **D1001**:
@@ -299,8 +299,8 @@ public class SubscribeDemo {
            try {
                if (null != subscribe)
                    subscribe.close(true); // Close the subscription
-                if (connection != null) 
-                    connection.close(); 
+                if (connection != null)
+                    connection.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
@@ -312,7 +312,7 @@ public class SubscribeDemo {
 Run the sample program. First, it consumes all the historical data that meets the query conditions:

 ```shell
-# java -jar subscribe.jar 
+# java -jar subscribe.jar

 ts: 1597464000000	current: 12.0	voltage: 220	phase: 1	location: Beijing.Chaoyang	groupid : 2
 ts: 1597464600000	current: 12.3	voltage: 220	phase: 2	location: Beijing.Chaoyang	groupid : 2
@@ -357,4 +357,4 @@ This SQL statement will obtain the last recorded voltage value of all smart mete

 In scenarios of TDengine, alarm monitoring is a common requirement. Conceptually, it requires the program to filter out data that meet certain conditions from the data of the latest period of time, and calculate a result according to a defined formula based on these data. When the result meets certain conditions and lasts for a certain period of time, it will notify the user in some form.

-In order to meet the needs of users for alarm monitoring, TDengine provides this function in the form of an independent module. For its installation and use, please refer to the blog [How to Use TDengine for Alarm Monitoring](https://www.taosdata.com/blog/2020/04/14/1438.html).
\ No newline at end of file
+In order to meet the needs of users for alarm monitoring, TDengine provides this function in the form of an independent module. For its installation and use, please refer to the blog [How to Use TDengine for Alarm Monitoring](https://www.taosdata.com/blog/2020/04/14/1438.html).
--- a/documentation20/en/08.connector/01.java/docs.md
+++ b/documentation20/en/08.connector/01.java/docs.md
@@ -54,25 +54,23 @@ INSERT INTO test.t1 USING test.weather (ts, temperature) TAGS('beijing') VALUES(

 ## JDBC driver version and supported TDengine and JDK versions

-| taos-jdbcdriver | TDengine           | JDK    |
-| --------------- |--------------------|--------|
-| 2.0.36          | 2.4.0 and above    | 1.8.x  |
-| 2.0.35          | 2.3.0 and above    | 1.8.x  |
-| 2.0.33 - 2.0.34 | 2.0.3.0 and above  | 1.8.x  |
-| 2.0.31 - 2.0.32 | 2.1.3.0 and above  | 1.8.x  |
-| 2.0.22 - 2.0.30 | 2.0.18.0 - 2.1.2.x | 1.8.x  |
-| 2.0.12 - 2.0.21 | 2.0.8.0 - 2.0.17.x | 1.8.x  |
-| 2.0.4 - 2.0.11  | 2.0.0.0 - 2.0.7.x  | 1.8.x  |
-| 1.0.3           | 1.6.1.x and above  | 1.8.x  |
-| 1.0.2           | 1.6.1.x and above  | 1.8.x  |
-| 1.0.1           | 1.6.1.x and above  | 1.8.x  |
+| taos-jdbcdriver version | TDengine 2.0.x.x version | TDengine 2.2.x.x version | TDengine 2.4.x.x version | JDK version |
+|---------------------| ----------------------| ----------------------| ----------------------| -------- |
+| 2.0.37              |            X          |            X          | 2.4.0.6 以上           | 1.8.x    |
+| 2.0.36              |            X          | 2.2.2.11 以上          | 2.4.0.0 - 2.4.0.5     | 1.8.x    |
+| 2.0.35              |            X          | 2.2.2.11 以上          | 2.3.0.0 - 2.4.0.5     | 1.8.x    |
+| 2.0.33 - 2.0.34     | 2.0.3.0 以上           | 2.2.0.0 以上           | 2.4.0.0 - 2.4.0.5     | 1.8.x    |
+| 2.0.31 - 2.0.32     | 2.1.3.0 - 2.1.7.7     |            X          |            X          | 1.8.x    |
+| 2.0.22 - 2.0.30     | 2.0.18.0 - 2.1.2.1    |            X          |            X          | 1.8.x    |
+| 2.0.12 - 2.0.21     | 2.0.8.0 - 2.0.17.4    |            X          |            X          | 1.8.x    |
+| 2.0.4 - 2.0.11      | 2.0.0.0 - 2.0.7.3     |            X          |            X          | 1.8.x    |

 ## DataType in TDengine and Java connector

 The TDengine supports the following data types and Java data types:

 | TDengine DataType | JDBCType (driver version < 2.0.24) | JDBCType (driver version >= 2.0.24) |
-|-------------------|------------------------------------| ----------------------------------- |
+| ----------------- | ---------------------------------- | ----------------------------------- |
 | TIMESTAMP         | java.lang.Long                     | java.sql.Timestamp                  |
 | INT               | java.lang.Integer                  | java.lang.Integer                   |
 | BIGINT            | java.lang.Long                     | java.lang.Long                      |
@@ -314,7 +312,8 @@ The Java connector may report three types of error codes: JDBC Driver (error cod

 ### 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:
+
+**Note**:
 * 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
@@ -322,6 +321,7 @@ Note:


 Sample Code:
+
 ```java
 public class ParameterBindingDemo {
 
@@ -578,15 +578,57 @@ public void setShort(int columnIndex, ArrayList<Short> list) throws SQLException
 public void setString(int columnIndex, ArrayList<String> list, int size) throws SQLException
 public void setNString(int columnIndex, ArrayList<String> list, int size) throws SQLException
 ```
+
+### Data Writing via Schemaless
+
+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
+* The following sample code is based on taos-jdbcdriver-2.0.36
+
+Sample Code:
+
+```java
+public class SchemalessInsertTest {
+    private static final String host = "127.0.0.1";
+    private static final String lineDemo = "st,t1=3i64,t2=4f64,t3=\"t3\" c1=3i64,c3=L\"passit\",c2=false,c4=4f64 1626006833639000000";
+    private static final String telnetDemo = "stb0_0 1626006833 4 host=host0 interface=eth0";
+    private static final String jsonDemo = "{\"metric\": \"meter_current\",\"timestamp\": 1346846400,\"value\": 10.3, \"tags\": {\"groupid\": 2, \"location\": \"Beijing\", \"id\": \"d1001\"}}";
+
+    public static void main(String[] args) throws SQLException {
+        final String url = "jdbc:TAOS://" + host + ":6030/?user=root&password=taosdata";
+        try (Connection connection = DriverManager.getConnection(url)) {
+            init(connection);
+
+            SchemalessWriter writer = new SchemalessWriter(connection);
+            writer.write(lineDemo, SchemalessProtocolType.LINE, SchemalessTimestampType.NANO_SECONDS);
+            writer.write(telnetDemo, SchemalessProtocolType.TELNET, SchemalessTimestampType.MILLI_SECONDS);
+            writer.write(jsonDemo, SchemalessProtocolType.JSON, SchemalessTimestampType.NOT_CONFIGURED);
+        }
+    }
+
+    private static void init(Connection connection) throws SQLException {
+        try (Statement stmt = connection.createStatement()) {
+            stmt.executeUpdate("drop database if exists test_schemaless");
+            stmt.executeUpdate("create database if not exists test_schemaless");
+            stmt.executeUpdate("use test_schemaless");
+        }
+    }
+}
+```
+
 ### Set client configuration in JDBC
-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:
+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.

 Sample Code:
+
 ```java
 public class ClientParameterSetting {
    private static final String host = "127.0.0.1";

--- a/documentation20/en/08.connector/docs.md
+++ b/documentation20/en/08.connector/docs.md
--- a/documentation20/en/09.connections/docs.md
+++ b/documentation20/en/09.connections/docs.md
--- a/documentation20/en/11.administrator/docs.md
+++ b/documentation20/en/11.administrator/docs.md
@@ -180,7 +180,7 @@ Client configuration parameters:

    The characters inputted by the client are all in the current default coding format of the operating system, mostly UTF-8 on Linux systems, and some Chinese system codes may be GB18030 or GBK, etc. The default encoding in the docker environment is POSIX. In the Chinese versions of Windows system, the code is CP936. The client needs to ensure that the character set it uses is correctly set, that is, the current encoded character set of the operating system running by the client, in order to ensure that the data in nchar is correctly converted into UCS4-LE encoding format.

-    The naming rules of locale in Linux are: < language > _ < region >. < character set coding >, such as: zh_CN.UTF-8, zh stands for Chinese, CN stands for mainland region, and UTF-8 stands for character set. Character set encoding provides a description of encoding transformations for clients to correctly parse local strings. Linux system and Mac OSX system can determine the character encoding of the system by setting locale. Because the locale used by Windows is not the POSIX standard locale format, another configuration parameter charset is needed to specify the character encoding under Windows. You can also use charset to specify character encoding in Linux systems.
+    The naming rules of locale in Linux are: < language > _ < region >. < character set coding >, such as: zh_CN.UTF-8, zh stands for Chinese, CN stands for mainland region, and UTF-8 stands for character set. Character set encoding provides a description of encoding transformations for clients to correctly parse local strings. Linux system and macOS system can determine the character encoding of the system by setting locale. Because the locale used by Windows is not the POSIX standard locale format, another configuration parameter charset is needed to specify the character encoding under Windows. You can also use charset to specify character encoding in Linux systems.

 - charset


--- a/documentation20/en/13.faq/docs.md
+++ b/documentation20/en/13.faq/docs.md
--- a/documentation20/en/14.devops/01.telegraf/docs.md
+++ b/documentation20/en/14.devops/01.telegraf/docs.md
--- a/documentation20/en/14.devops/02.collectd/docs.md
+++ b/documentation20/en/14.devops/02.collectd/docs.md
--- a/documentation20/en/14.devops/03.immigrate/docs.md
+++ b/documentation20/en/14.devops/03.immigrate/docs.md
--- a/importSampleData/.gitignore
+++ b/importSampleData/.gitignore
-# Binaries for programs and plugins
-*.exe
-*.exe~
-*.dll
-*.so
-*.dylib
-
-# Test binary, built with `go test -c`
-*.test
-
-# Output of the go coverage tool, specifically when used with LiteIDE
-*.out
-
-# Dependency directories (remove the comment below to include it)
-# vendor/
-.idea/
-.vscode/
\ No newline at end of file
--- a/importSampleData/LICENSE
+++ b/importSampleData/LICENSE
--- a/importSampleData/README.md
+++ b/importSampleData/README.md
--- a/importSampleData/app/main.go
+++ b/importSampleData/app/main.go
--- a/importSampleData/config/cfg.toml
+++ b/importSampleData/config/cfg.toml
--- a/importSampleData/dashboard/sensor_info.json
+++ b/importSampleData/dashboard/sensor_info.json
--- a/importSampleData/data/camera_detection.json
+++ b/importSampleData/data/camera_detection.json
--- a/importSampleData/data/sensor_info.csv
+++ b/importSampleData/data/sensor_info.csv
--- a/importSampleData/go.mod
+++ b/importSampleData/go.mod
-module github.com/taosdata/TDengine/importSampleData
-
-go 1.13
-
-require (
-	github.com/pelletier/go-toml v1.9.0
-	github.com/taosdata/driver-go v0.0.0-20210415143420-d99751356e28
-)
--- a/importSampleData/import/import_config.go
+++ b/importSampleData/import/import_config.go
--- a/packaging/cfg/jh_taos.cfg
+++ b/packaging/cfg/jh_taos.cfg
--- a/packaging/cfg/jh_taosd.service
+++ b/packaging/cfg/jh_taosd.service
--- a/packaging/cfg/khserver.service
+++ b/packaging/cfg/khserver.service
--- a/packaging/cfg/kinghistorian.cfg
+++ b/packaging/cfg/kinghistorian.cfg
--- a/packaging/cfg/power.cfg
+++ b/packaging/cfg/power.cfg
--- a/packaging/cfg/powerd.service
+++ b/packaging/cfg/powerd.service
--- a/packaging/cfg/prodb.cfg
+++ b/packaging/cfg/prodb.cfg
--- a/packaging/cfg/prodbs.service
+++ b/packaging/cfg/prodbs.service
--- a/packaging/cfg/tq.cfg
+++ b/packaging/cfg/tq.cfg
--- a/packaging/cfg/tqd.service
+++ b/packaging/cfg/tqd.service
--- a/packaging/docker/dockerbuild.sh
+++ b/packaging/docker/dockerbuild.sh
--- a/packaging/release.sh
+++ b/packaging/release.sh
--- a/packaging/sed_jh.bat
+++ b/packaging/sed_jh.bat
--- a/packaging/sed_jh.sh
+++ b/packaging/sed_jh.sh
--- a/packaging/sed_kh.bat
+++ b/packaging/sed_kh.bat
--- a/packaging/sed_kh.sh
+++ b/packaging/sed_kh.sh
--- a/packaging/sed_power.bat
+++ b/packaging/sed_power.bat
--- a/packaging/sed_power.sh
+++ b/packaging/sed_power.sh
--- a/packaging/sed_pro.bat
+++ b/packaging/sed_pro.bat
--- a/packaging/sed_pro.sh
+++ b/packaging/sed_pro.sh
--- a/packaging/sed_tq.bat
+++ b/packaging/sed_tq.bat
--- a/packaging/sed_tq.sh
+++ b/packaging/sed_tq.sh
--- a/packaging/tools/install.sh
+++ b/packaging/tools/install.sh
--- a/packaging/tools/makeclient.sh
+++ b/packaging/tools/makeclient.sh
--- a/packaging/tools/makepkg.sh
+++ b/packaging/tools/makepkg.sh
--- a/packaging/tools/remove.sh
+++ b/packaging/tools/remove.sh
--- a/src/client/src/tscLocal.c
+++ b/src/client/src/tscLocal.c
--- a/src/client/src/tscParseInsert.c
+++ b/src/client/src/tscParseInsert.c
--- a/src/client/src/tscParseLineProtocol.c
+++ b/src/client/src/tscParseLineProtocol.c
--- a/src/client/src/tscSQLParser.c
+++ b/src/client/src/tscSQLParser.c
--- a/src/client/src/tscSql.c
+++ b/src/client/src/tscSql.c
--- a/src/common/inc/texpr.h
+++ b/src/common/inc/texpr.h
--- a/src/common/src/tarithoperator.c
+++ b/src/common/src/tarithoperator.c
--- a/src/common/src/texpr.c
+++ b/src/common/src/texpr.c
--- a/src/common/src/tvariant.c
+++ b/src/common/src/tvariant.c
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulDriver.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/rs/RestfulDriver.java
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/utils/NullType.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/utils/NullType.java
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/ws/AbstractWSResultSet.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/ws/AbstractWSResultSet.java
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/ws/BlockResultSet.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/ws/BlockResultSet.java
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/ws/WSClient.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/ws/WSClient.java
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/ws/WSConnection.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/ws/WSConnection.java
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/ws/WSPreparedStatement.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/ws/WSPreparedStatement.java
--- a/src/connector/jdbc/src/main/java/com/taosdata/jdbc/ws/WSStatement.java
+++ b/src/connector/jdbc/src/main/java/com/taosdata/jdbc/ws/WSStatement.java
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulDatabaseMetaDataTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/rs/RestfulDatabaseMetaDataTest.java
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/ws/WSConnectionTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/ws/WSConnectionTest.java
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/ws/WSJsonTagTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/ws/WSJsonTagTest.java
--- a/src/connector/jdbc/src/test/java/com/taosdata/jdbc/ws/WSQueryTest.java
+++ b/src/connector/jdbc/src/test/java/com/taosdata/jdbc/ws/WSQueryTest.java
--- a/src/connector/nodejs/examples/stmtBindParamBatchSample.js
+++ b/src/connector/nodejs/examples/stmtBindParamBatchSample.js
--- a/src/connector/nodejs/examples/stmtBindParamSample.js
+++ b/src/connector/nodejs/examples/stmtBindParamSample.js
--- a/src/connector/nodejs/examples/stmtBindSingleParamBatchSample.js
+++ b/src/connector/nodejs/examples/stmtBindSingleParamBatchSample.js
--- a/src/connector/nodejs/examples/stmtUseResultSample.js
+++ b/src/connector/nodejs/examples/stmtUseResultSample.js
--- a/src/connector/nodejs/examples/taosBindParamSample.js
+++ b/src/connector/nodejs/examples/taosBindParamSample.js
--- a/src/connector/nodejs/nodetaos/taosMultiBind.js
+++ b/src/connector/nodejs/nodetaos/taosMultiBind.js
--- a/src/connector/nodejs/readme.md
+++ b/src/connector/nodejs/readme.md
--- a/src/connector/nodejs/test/cases/test.cases.js
+++ b/src/connector/nodejs/test/cases/test.cases.js
--- a/src/connector/nodejs/test/cases/test.stmt.js
+++ b/src/connector/nodejs/test/cases/test.stmt.js
--- a/src/inc/taosdef.h
+++ b/src/inc/taosdef.h
--- a/src/inc/ttokendef.h
+++ b/src/inc/ttokendef.h
--- a/src/inc/ttype.h
+++ b/src/inc/ttype.h
--- a/taos-tools @ 470ac848
+++ b/taos-tools @ 470ac848
--- a/src/mnode/inc/mnodeDnode.h
+++ b/src/mnode/inc/mnodeDnode.h
--- a/src/mnode/src/mnodeDb.c
+++ b/src/mnode/src/mnodeDb.c
--- a/src/mnode/src/mnodeDnode.c
+++ b/src/mnode/src/mnodeDnode.c
--- a/src/os/inc/osTime.h
+++ b/src/os/inc/osTime.h
--- a/src/os/src/detail/osTime.c
+++ b/src/os/src/detail/osTime.c
--- a/src/query/inc/sql.y
+++ b/src/query/inc/sql.y
--- a/src/query/src/qAggMain.c
+++ b/src/query/src/qAggMain.c
--- a/src/query/src/qExecutor.c
+++ b/src/query/src/qExecutor.c
--- a/src/query/src/qSqlParser.c
+++ b/src/query/src/qSqlParser.c
--- a/src/query/src/sql.c
+++ b/src/query/src/sql.c
--- a/src/query/tests/apercentileTest.cpp
+++ b/src/query/tests/apercentileTest.cpp
--- a/src/util/inc/hash.h
+++ b/src/util/inc/hash.h
--- a/src/util/inc/hashfunc.h
+++ b/src/util/inc/hashfunc.h
--- a/src/util/src/hash.c
+++ b/src/util/src/hash.c
--- a/src/util/src/ttokenizer.c
+++ b/src/util/src/ttokenizer.c
--- a/tests @ ce8ceea3
+++ b/tests @ ce8ceea3